精华内容
下载资源
问答
  • web3.js
    千次阅读
    2022-06-06 19:52:50

    web3.js与ethers.js/hardhat-ethers介绍

    版本号:
    Web3.js v1.7.3
    Ethers.js v.5.6

    简单介绍web3.js

    web3.js是一个标准的以太坊JavaScript API库,该JS库由以太坊基金会开发维护,同时它也是最早且使用最广泛的一个ETH API库。由于Moonbeam完全兼容以太坊EVM,因此web3.js可以在Moonbeam上进行正常交互

    web3.js(v1.7.3)库官方使用文档:https://web3js.readthedocs.io/en/v1.7.3/index.html

    web3.js的安装与常用API介绍

    安装web3.js

    在命令终端输入npm install web3即可正常安装

    常用API介绍

    1. 签名交易web3.eth.accounts.signTransaction()

    web3.eth.accounts.signTransaction(tx, privateKey, [, callback]) => promise<object>
    

    第一个参数为tx,即定义该交易的细则,在其中可以定义的交易细则有gas,to,value,gasPrice等参数,其中gas是必须要设置的参数(其余用到的交易参数都是可选择的),gas参数规定了该交易将要花费的gas费用,to参数则说明了这笔交易的接受者,而value参数则规定了这笔交易中转移代币的数量
    第二个参数为privateKey,为发起交易人的私钥,该交易将由该私钥进行签署

    第三个参数为callback,该参数为一个可选参数,该回调函数返回的第一个参数为一个错误对象,第二个参数为结果对象

    该接口返回一个Promise对象,如果签署交易成功,将会返回该交易的一些具体信息,如messageHashrawTransactiontransactionHash等信息

    2. 部署合约contractInstance.deploy()

    new web3.eth.Contract(jsonInterface[, address][, options]) => promise<contract>
    

    该方法用于生产合约实例,只有通过合约实例才能进行部署操作。该函数只需要填写一个一个参数即可,jsonInterface即为该合约的abi,填入该参数即可完成合约实例的生成

    contractInstace.deploy(options) => promise<transaction>
    

    改方法用于部署合约,调用该函数将返回部署合约交易的具体信息
    其中的参数为options,其中里面可以写入两个部分,即data(String)与arguments(Array)两个参数,data参数为合约的bytecode;arguments参数为合约构造函数中的参数,因此该参数为可选的

    deploy函数会返回一个交易对象,该对象自带一个数组与4个函数,数组表示先前传入的构造函数的入参,四个函数分别为send()estimateGas()encodeABI()createAccessList()

    3. 调用合约方法methods.myMethod.call()

    myContract.methods.myMethod(param1[, param2[, ...]]).call(options [, defaultBlock] [, callback]) => returnValuesOfContract
    

    该方法用于调用一个“constant”方法并在不发起任何交易的同时在EVM执行智能合约的方法,使用此方法调用的智能合约方法均不会改变合约状态
    其中myMethod()括号中填入的参数为该方法的入参,call()中填入的options包含如下几个方面的值:from、gasPrice、gas,call()中还可以选择性的填入defaultBlock与callback,其中defaultBlock为默认区块设置,callback回调函数第一个参数为错误对象,第二个参数为合约方法结果

    该方法会返回调用函数的返回结果,如果返回结果为多个,则返回一个带有索引的对象

    4. 订阅监听事件web3.eth.subscribe()

    web3.eth.subscribe(type [, options] [, callback]) => subscriptionInstance
    

    该方法用于订阅监听智能合约中触发的事件
    其中订阅方法包含四种方法,分别为:pendingTransactions,newBlockHeaders,syncing,logs

    监听事件一般采用newBlockHeaders模式,该模式订阅监听传入的区块头,该特性可以作为计时器来检查区块链上的变化。callback参数与上述函数一样,第一个参数为错误对象,第二个参数为结果对象

    同时在该函数的返回内容中,有几个回调函数比较常见:on("connected"), on("data"), on("error"), on("changed")

    1. 一旦订阅成功连接则触发on("connected"),该函数返回订阅id;
    2. 当log有数据时触发on("data")
    3. 当订阅出错时触发on("error")
    4. 当有log被删除出区块链时触发on("changed")

    简单介绍Ethers.js

    Ethers.js与Web3.js一样,都是以太坊标准JavaScript API库,Ethers.js最初是为了ethers.io设计,后来拓展为一个开放的JS API库,与Web3.js相同的是,Ethers.js同样可以与Moonbeam进行正常交互,这得益于Moonbeam是一个完全兼容以太坊EVM的智能合约平台;而与Web3.js不同的是,Ethers.js在使用时不需要过多的回调函数,而且可以搭配Hardhat工具是的语法得到进一步的优化

    Ethers.js(Hardhat)的安装与常用API介绍

    Ethers.js(Hardhat)的安装

    Ethers.js的安装分为两种,一种为直接使用命令行安装,另一种为通过Hardhat间接安装(配合Hardhat使用),推荐第二种通过Hardhat👷的方式使用Ethers.js(安装Hardhat时通过hardhat-ethers插件安装经过包装后的Ethers.js)

    安装步骤如下:

    // command line
    npm install --save ethers
    
    // install Hardhat
    npm init
    npm install --save-dev hardhat
    npx hardhat
    

    常用API介绍

    Ethers.js库中的API主要由4大部分组成:ProvidersSignersContract InteractionUtilities

    1. Provider

    Provider是以太坊网络连接的抽象,其为标准以太坊节点功能提供简洁、一致的接口

    在Provider中比较常用的方法为JsonRpcProvider,该方法允许通过JSON-RPC的方式连接某一个节点网络

    // new ethers.providers.JsonRpcProvider([urlOrConnectionInfo[, networkish]])
    const provider = new ethers.providers.JsonRpcProvider(
            'https://rpc.api.moonbase.moonbeam.network',
            {
                chainId: 1287,
                name: 'moonbase-alpha'
            }
    );
    

    在上面的代码示例中,通过JsonRpcProvider的方式,连接到了Moonbase Alpha测试网中,在其中不止可以定义url参数,还可以定义该网络的chainId与name等信息

    2. Signers

    Signer是以太坊账户的抽象,可用于对消息和交易进行签名,并将签名过的交易发送到以太坊网络以执行状态更改操作

    在Signer中比较常用的方法为Wallet,只有Wallet可以使用私钥对交易和信息进行签名

    // new ethers.Wallet(privateKey[, provider])
    const alice = new ethers.Wallet(privateKeyAlice, provider);
    const bob = new ethers.Wallet(privateKeyBob, provider);
    
    const txReceipt = await alice.sendTransaction({
        to: bob.address,
        value: ethers.utils.parseEther('1.0')
    });
    await txReceipt.wait();
    

    在上面的代码示例中,使用Wallet定义了alice与bob两个Signer,接下来alice调用方法sendTransaction()方法向bob发起交易,转移了1 ether的token

    3. Contract Interaction

    部署合约与生成合约实例离不开下面介绍的两个方法:ContractFactory()与Contract,具体方法直接看下面的代码示例接口

    // deploy contract
    new ethers.ContractFactory(interface, bytecode[, signer])
    contractFactory.deploy(..args)
    contract.deployed()
    
    // generate contract instance
    new ethers.Contract(address, abi, signerOrProvider)
    

    其中ContracFactory中的interface参数代表合约的abi
    使用Hardhat编译过后的合约,其abi与bytecode等编译信息都存放在了项目根目录下的artifacts/contracts/CONTRACT_NAME.json文件中

    4. Utilities

    utilities下提供的各种方法更像是各种各样的工具,比较常用的有对BigNumber的操作,以太坊Token单位的直接转换以及将string于bytes32相互转化的工具等,以下列出几个常见方法

    // BigNumber
    BigNumber.toNumber() => number
    BigNumber.toHexString() => string<DataHexString>
    
    // Display Logic and Input
    ethers.utils.parseEther(string) => BigNumber
    ethers.utils.formatEther(value(BigNumber)) => string
    
    // Strings
    ethers.utils.parseBytes32String(aBytesLike) => string
    ethers.utils.formatBytes32String(text) => string<DataHexString<32>>
    
    1. BigNumber.toNumber():将BigNumber的值转换为JavaScript值

    2. BigNumber.toHexString():将BigNumber值转换为0x开头,16进制的值

    3. ethers.utils.parseEther(string):将一个整数转换为以ether为单位的大整数

    4. ethers.utils.formatEther(value(BigNumber)):将大整数转换为以ether为单位的整数

    5. ethers.utils.parseBytes32String(aBytesLike):返回一个bytes 32编码数据表示的解码字符串

    6. ethers.utils.formatBytes32String(text):返回文本的bytes 32字符串表示形式

    hardhat-ethers升级接口

    使用原生Ethers.js库进行与节点进行交互时,特别在部署合约方面的接口使用中,会发现原生接口的调用比较麻烦

    因此Hardhat在此方面做了优化,即Hardhat提供了一个hardhat-ethers插件,该插件会提供一个ethers对象,该对象与Ethers.js有着相同的API,同时还有一些Hardhat特别定义的接口

    其特别定义的接口主要体现在以下是三个方面:

    • 不需要额外定义provider,provider已经在执行npx hardhat --network NET run SCRIPT 命令时已自动连接到了选定网络中
    • getSigner() => Signer,该接口直接在hardhat配置中获取signer,不需要定义wallet,但需要提前将账户私钥信息填写到Hardhat配置文件中
    • getContracFactory(contractName[, signer]) => contractFactory,该接口简化了原生contractFactory()接口,使得只需要合约的名字即可产生contractFactory对象
      以部署一个ERC-20合约为例:
    // using hardhat-ethers API to deploy an ERC20 contract
    
    // get signer
    const alith = await ethers.getSigner(1);
    // deploy contract
    const Token = await ehters.getContractFactory('Token', alith);
    const token = await Token.deploy('MoonToken', 'MTK', 100);
    await token.deployed();
    
    // using raw ethers.js API to deploy the same ERC20 contract
    
    // get provider and signer
    const provider = new ethers.providers.JsonRpcProvider('http://localhost:9933');
    const alith = new ethers.Wallet(privateKeyAlith, provider);
    // deploy contract
    const Token = new ethers.ContractFactory(interface, bytecode, alith);
    const token = await Token.deploy('MoonToken', 'MTK', 100);
    await token.deployed();
    

    通过上面的代码示例可以很直观的发现,使用hardhat-ethers提供的API在部署合约时会更方便一些


    Web3.js与Ethers.js都属于以太坊标准JavaScript API库,二者各有特点,同样被广大的Web3开发者接受

    Web3.js属于比较老牌的API库,功能比较强大,但是使用过程中需要注意各种回调函数;而Ethers.js属于新兴起的API库,其最大的特点在于其接口调用简单方便,对于不是很熟悉JS的开发者来说比较友好。

    更多相关内容
  • $ yarn add @solana/web3.js npm $ npm install --save @solana/web3.js 浏览器捆绑 <!-- Development (un-minified) --> < script src =" https://unpkg.com/@solana/web3.js@0.92.0/lib/index.iife.js ...
  • Web3-基础Web3.js是一个与以太坊区块链连接的javascript库。 结帐库
  • 使用Web3.js和Infura的智能合约 Web3.js是一个库的集合,这些库使您可以使用HTTP或IPC连接与本地或远程以太坊节点进行交互。 在本练习中,我们将使用web3.js在以太坊Ropsten测试网上部署合约并进行使用。 我们将首先...
  • web3-示例使用Web3.js在BSC上发送事务
  • web3.js-以太坊JavaScript API 这是连接到规范的以太坊 。 您需要运行本地或远程节点才能使用此库。 请阅读以获取更多信息。 安装 节点 npm install web3 纱 yarn add web3 在浏览器中 使用预构建的dist/web3.min...
  • quarkchain-web3.js库没有提供修改web3源代码的功能,而是提供了一个接口( QuarkChain.injectWeb3(web3, ) )将QuarkChain功能注入到web3实例中。 注入后,QuarkChain函数将在web3.qkc中可用,并且它们与web3.eth...
  • Web3.js

    千次阅读 2022-04-23 18:39:10
    1 Web3.js基础 1.1 Web3.js 简介 Web3.js是一个库,使用它可以通过HTTP或IPC与本地或者以太坊远程节点交互 各种高级语言编写的程序可以使用web3 interface来与EVM交互,在此过程中使用是的JSON-RPC(一个无状态且轻...

    1 web3.js

    1.1 web3.js 简介

    Web3.js是一个库,它有很多函数,使用它可以在以太坊生态系统中通过HTTP或IPC与本地或者以太坊远程节点交互,如查看链上信息等

    各种高级语言编写的程序可以使用web3 interface来与EVM交互,在此过程中使用是的JSON-RPC(一个无状态且轻量级的远程过程调用(RPC)传送协议,其传递内容透过 JSON 为主)

    1.2 web3.js 安装

    1.先查看是否安装了node.js,node.js带了npm

    qinjianquan@MacBook-Pro-10 ~ % node -v 
    v10.24.1 
    

    Node.js发布于2009年5月,是一个基于Chrome V8引擎的JavaScript运行环境,使用了一个事件驱动、非阻塞式I/O模型, 让JavaScript 运行在服务端的开发平台,它让JavaScript成为与PHPPythonPerlRuby等服务端语言平起平坐的脚本语言

    而npm的全称是Node Package Manager,是一个NodeJS包管理和分发工具,已经成为了非官方的发布Node模块(包)的标准

    如果未安装,请先安装命令行工具homebrew 或者 去nodejs.org安装 node.js

    2.安装web3

    npm install web3
    

    此处使用web3命令和在geth控制台中使用web3命令原理上是一样的,具体方式上有所差别,如下是具体操作示范

    qinjianquan@MacBook-Pro-10 ~ % node //先启动node,node提供了js代码的运行环境,现在,可以使用web3.js了
    
    > var Web3 = require('web3') //先创建一个实例
    undefined
    
    > Web3 //查看Web3属性和功能
    
    [Function: Web3] {
      version: '1.7.3',
      utils: {
        _fireError: [Function: _fireError],
        _jsonInterfaceMethodToString: [Function: _jsonInterfaceMethodToString],
        _flattenTypes: [Function: _flattenTypes],
        randomHex: [Function: randomHex],
        BN: <ref *1> [Function: BN] {
          BN: [Circular *1],
          wordSize: 26,
          isBN: [Function: isBN],
          max: [Function: max],
          min: [Function: min],
          red: [Function: red],
          _prime: [Function: prime],
          mont: [Function: mont]
        },
        isBN: [Function: isBN],
        isBigNumber: [Function: isBigNumber],
        isHex: [Function: isHex],
        isHexStrict: [Function: isHexStrict],
        sha3: [Function: sha3] { _Hash: [Function: keccak256] },
        sha3Raw: [Function: sha3Raw],
        keccak256: [Function: sha3] { _Hash: [Function: keccak256] },
        soliditySha3: [Function: soliditySha3],
        soliditySha3Raw: [Function: soliditySha3Raw],
        encodePacked: [Function: encodePacked],
        isAddress: [Function: isAddress],
        checkAddressChecksum: [Function: checkAddressChecksum],
        toChecksumAddress: [Function: toChecksumAddress],
        toHex: [Function: toHex],
        toBN: [Function: toBN],
        bytesToHex: [Function: bytesToHex],
        hexToBytes: [Function: hexToBytes],
        hexToNumberString: [Function: hexToNumberString],
        hexToNumber: [Function: hexToNumber],
        toDecimal: [Function: hexToNumber],
        numberToHex: [Function: numberToHex],
        fromDecimal: [Function: numberToHex],
        hexToUtf8: [Function: hexToUtf8],
        hexToString: [Function: hexToUtf8],
        toUtf8: [Function: hexToUtf8],
        stripHexPrefix: [Function: stripHexPrefix],
        utf8ToHex: [Function: utf8ToHex],
        stringToHex: [Function: utf8ToHex],
        fromUtf8: [Function: utf8ToHex],
        hexToAscii: [Function: hexToAscii],
        toAscii: [Function: hexToAscii],
        asciiToHex: [Function: asciiToHex],
        fromAscii: [Function: asciiToHex],
        unitMap: {
          noether: '0',
          wei: '1',
          kwei: '1000',
          Kwei: '1000',
          babbage: '1000',
          femtoether: '1000',
          mwei: '1000000',
          Mwei: '1000000',
          lovelace: '1000000',
          picoether: '1000000',
          gwei: '1000000000',
          Gwei: '1000000000',
          shannon: '1000000000',
          nanoether: '1000000000',
          nano: '1000000000',
          szabo: '1000000000000',
          microether: '1000000000000',
          micro: '1000000000000',
          finney: '1000000000000000',
          milliether: '1000000000000000',
          milli: '1000000000000000',
          ether: '1000000000000000000',
          kether: '1000000000000000000000',
          grand: '1000000000000000000000',
          mether: '1000000000000000000000000',
          gether: '1000000000000000000000000000',
          tether: '1000000000000000000000000000000'
        },
        toWei: [Function: toWei],
        fromWei: [Function: fromWei],
        padLeft: [Function: leftPad],
        leftPad: [Function: leftPad],
        padRight: [Function: rightPad],
        rightPad: [Function: rightPad],
        toTwosComplement: [Function: toTwosComplement],
        isBloom: [Function: isBloom],
        isUserEthereumAddressInBloom: [Function: isUserEthereumAddressInBloom],
        isContractAddressInBloom: [Function: isContractAddressInBloom],
        isTopic: [Function: isTopic],
        isTopicInBloom: [Function: isTopicInBloom],
        isInBloom: [Function: isInBloom],
        compareBlockNumbers: [Function: compareBlockNumbers],
        toNumber: [Function: toNumber]
      },
      modules: {
        Eth: [Function: Eth] { givenProvider: null, providers: [Object] },
        Net: [Function: Net] { givenProvider: null, providers: [Object] },
        Personal: [Function: Personal] { givenProvider: null, providers: [Object] },
        Shh: [Function: Shh] { givenProvider: null, providers: [Object] },
        Bzz: [Function: Bzz] { givenProvider: null }
      },
      givenProvider: null,
      providers: {
        WebsocketProvider: [Function: WebsocketProvider],
        HttpProvider: [Function: HttpProvider],
        IpcProvider: [Function: IpcProvider]
      }
    }
    

    1.3 INFURA与Web3.js基本操作

    1.3.1 通过API与以太坊主网交互

    通过INFURA提供的API,可以实现与以太坊节点远程交互

    注意:以太坊是一个分布式的网络,这意味没有中心服务器,任何一个节点都可以当做服务器

    第一步,注册INFURA: https://infura.io,获取连接API

    https://mainnet.infura.io/v3/4adc822d926044efaa46a37fbd87fd0c 
    

    第二步,定义变量

    var url = 'https://mainnet.infura.io/v3/4adc822d926044efaa46a37fbd87fd0c' //定义变量url
    undefined
    
    > var web3 = new Web3(url) //定义变量web3
    undefined
    

    第三步,链上交互

    1. 找一个rich address,重定义为变量名
    > var address = '0xDA9dfA130Df4dE4673b89022EE50ff26f6EA73Cf'
    
    1. 查看账户余额
    web3.eth.getBalance(address,(err,bal) => {balance = bal}) //此处是调用函数而不是直接查看
    
    //此处有些语法源于智能合约语言Solidity,读者可以先了解一下Solidity
    Promise {
      <pending>,
      domain:
       Domain {
         domain: null,
         _events:
          [Object: null prototype] {
            removeListener: [Function: updateExceptionCapture],
            newListener: [Function: updateExceptionCapture],
            error: [Function: debugDomainError] },
         _eventsCount: 3,
         _maxListeners: undefined,
         members: [],
         [Symbol(kWeak)]: WeakReference {} } }
         
    > balance //查看余额,单位 Wei
    '2113030002434567800000000'
    
    > web3.utils.fromWei(balance,'ether') //转换为ether
    '2113030.0024345678'
    
    1. 创建账户

    以下账户只做演示,请不要使用

    > web3.eth.accounts.create()
    { address: '0xBC1Ee0f8474CC71288f1830Bb73E2aE5D60e5cd0',
      privateKey:
       '0xf4a4e1c0dd981bb1391fd30a5d3b5b94b80ba78f3c6baa31c1ef6ef2a3046f8e',
      signTransaction: [Function: signTransaction],
      sign: [Function: sign],
      encrypt: [Function: encrypt] }
    
    1. 补充内容

    eth是一个对象,它有很多功能,可以用于与以太坊交互,可以使用定义好的web3查看

    > web3
    Web3 {
      currentProvider: [Getter/Setter],
      _requestManager: RequestManager {
        provider: HttpProvider {
          withCredentials: false,
          timeout: 0,
          headers: undefined,
          agent: undefined,
          connected: true,
          host: 'https://mainnet.infura.io/v3/4adc822d926044efaa46a37fbd87fd0c',
          httpsAgent: [Agent]
        },
        providers: {
          WebsocketProvider: [Function: WebsocketProvider],
          HttpProvider: [Function: HttpProvider],
          IpcProvider: [Function: IpcProvider]
        },
        subscriptions: Map(0) {}
      },
      givenProvider: null,
      providers: {
        WebsocketProvider: [Function: WebsocketProvider],
        HttpProvider: [Function: HttpProvider],
        IpcProvider: [Function: IpcProvider]
      },
      _provider: HttpProvider {
        withCredentials: false,
        timeout: 0,
        headers: undefined,
        agent: undefined,
        connected: true,
        host: 'https://mainnet.infura.io/v3/4adc822d926044efaa46a37fbd87fd0c',
        httpsAgent: Agent {
          _events: [Object: null prototype],
          _eventsCount: 2,
          _maxListeners: undefined,
          defaultPort: 443,
          protocol: 'https:',
          options: [Object: null prototype],
          requests: [Object: null prototype] {},
          sockets: [Object: null prototype] {},
          freeSockets: [Object: null prototype],
          keepAliveMsecs: 1000,
          keepAlive: true,
          maxSockets: Infinity,
          maxFreeSockets: 256,
          scheduling: 'lifo',
          maxTotalSockets: Infinity,
          totalSocketCount: 1,
          maxCachedSessions: 100,
          _sessionCache: [Object],
          [Symbol(kCapture)]: false
        }
      },
      setProvider: [Function (anonymous)],
      setRequestManager: [Function (anonymous)],
      BatchRequest: [Function: bound Batch],
      extend: [Function: ex] {
        formatters: {
          inputDefaultBlockNumberFormatter: [Function: inputDefaultBlockNumberFormatter],
          inputBlockNumberFormatter: [Function: inputBlockNumberFormatter],
          inputCallFormatter: [Function: inputCallFormatter],
          inputTransactionFormatter: [Function: inputTransactionFormatter],
          inputAddressFormatter: [Function: inputAddressFormatter],
          inputPostFormatter: [Function: inputPostFormatter],
          inputLogFormatter: [Function: inputLogFormatter],
          inputSignFormatter: [Function: inputSignFormatter],
          inputStorageKeysFormatter: [Function: inputStorageKeysFormatter],
          outputProofFormatter: [Function: outputProofFormatter],
          outputBigNumberFormatter: [Function: outputBigNumberFormatter],
          outputTransactionFormatter: [Function: outputTransactionFormatter],
          outputTransactionReceiptFormatter: [Function: outputTransactionReceiptFormatter],
          outputBlockFormatter: [Function: outputBlockFormatter],
          outputLogFormatter: [Function: outputLogFormatter],
          outputPostFormatter: [Function: outputPostFormatter],
          outputSyncingFormatter: [Function: outputSyncingFormatter]
        },
        utils: {
          _fireError: [Function: _fireError],
          _jsonInterfaceMethodToString: [Function: _jsonInterfaceMethodToString],
          _flattenTypes: [Function: _flattenTypes],
          randomHex: [Function: randomHex],
          BN: [Function],
          isBN: [Function: isBN],
          isBigNumber: [Function: isBigNumber],
          isHex: [Function: isHex],
          isHexStrict: [Function: isHexStrict],
          sha3: [Function],
          sha3Raw: [Function: sha3Raw],
          keccak256: [Function],
          soliditySha3: [Function: soliditySha3],
          soliditySha3Raw: [Function: soliditySha3Raw],
          encodePacked: [Function: encodePacked],
          isAddress: [Function: isAddress],
          checkAddressChecksum: [Function: checkAddressChecksum],
          toChecksumAddress: [Function: toChecksumAddress],
          toHex: [Function: toHex],
          toBN: [Function: toBN],
          bytesToHex: [Function: bytesToHex],
          hexToBytes: [Function: hexToBytes],
          hexToNumberString: [Function: hexToNumberString],
          hexToNumber: [Function: hexToNumber],
          toDecimal: [Function: hexToNumber],
          numberToHex: [Function: numberToHex],
          fromDecimal: [Function: numberToHex],
          hexToUtf8: [Function: hexToUtf8],
          hexToString: [Function: hexToUtf8],
          toUtf8: [Function: hexToUtf8],
          stripHexPrefix: [Function: stripHexPrefix],
          utf8ToHex: [Function: utf8ToHex],
          stringToHex: [Function: utf8ToHex],
          fromUtf8: [Function: utf8ToHex],
          hexToAscii: [Function: hexToAscii],
          toAscii: [Function: hexToAscii],
          asciiToHex: [Function: asciiToHex],
          fromAscii: [Function: asciiToHex],
          unitMap: [Object],
          toWei: [Function: toWei],
          fromWei: [Function: fromWei],
          padLeft: [Function: leftPad],
          leftPad: [Function: leftPad],
          padRight: [Function: rightPad],
          rightPad: [Function: rightPad],
          toTwosComplement: [Function: toTwosComplement],
          isBloom: [Function: isBloom],
          isUserEthereumAddressInBloom: [Function: isUserEthereumAddressInBloom],
          isContractAddressInBloom: [Function: isContractAddressInBloom],
          isTopic: [Function: isTopic],
          isTopicInBloom: [Function: isTopicInBloom],
          isInBloom: [Function: isInBloom],
          compareBlockNumbers: [Function: compareBlockNumbers],
          toNumber: [Function: toNumber]
        },
        Method: [Function: Method]
      },
      version: '1.7.3',
      utils: {
        _fireError: [Function: _fireError],
        _jsonInterfaceMethodToString: [Function: _jsonInterfaceMethodToString],
        _flattenTypes: [Function: _flattenTypes],
        randomHex: [Function: randomHex],
        BN: <ref *1> [Function: BN] {
          BN: [Circular *1],
          wordSize: 26,
          isBN: [Function: isBN],
          max: [Function: max],
          min: [Function: min],
          red: [Function: red],
          _prime: [Function: prime],
          mont: [Function: mont]
        },
        isBN: [Function: isBN],
        isBigNumber: [Function: isBigNumber],
        isHex: [Function: isHex],
        isHexStrict: [Function: isHexStrict],
        sha3: [Function: sha3] { _Hash: [Function: keccak256] },
        sha3Raw: [Function: sha3Raw],
        keccak256: [Function: sha3] { _Hash: [Function: keccak256] },
        soliditySha3: [Function: soliditySha3],
        soliditySha3Raw: [Function: soliditySha3Raw],
        encodePacked: [Function: encodePacked],
        isAddress: [Function: isAddress],
        checkAddressChecksum: [Function: checkAddressChecksum],
        toChecksumAddress: [Function: toChecksumAddress],
        toHex: [Function: toHex],
        toBN: [Function: toBN],
        bytesToHex: [Function: bytesToHex],
        hexToBytes: [Function: hexToBytes],
        hexToNumberString: [Function: hexToNumberString],
        hexToNumber: [Function: hexToNumber],
        toDecimal: [Function: hexToNumber],
        numberToHex: [Function: numberToHex],
        fromDecimal: [Function: numberToHex],
        hexToUtf8: [Function: hexToUtf8],
        hexToString: [Function: hexToUtf8],
        toUtf8: [Function: hexToUtf8],
        stripHexPrefix: [Function: stripHexPrefix],
        utf8ToHex: [Function: utf8ToHex],
        stringToHex: [Function: utf8ToHex],
        fromUtf8: [Function: utf8ToHex],
        hexToAscii: [Function: hexToAscii],
        toAscii: [Function: hexToAscii],
        asciiToHex: [Function: asciiToHex],
        fromAscii: [Function: asciiToHex],
        unitMap: {
          noether: '0',
          wei: '1',
          kwei: '1000',
          Kwei: '1000',
          babbage: '1000',
          femtoether: '1000',
          mwei: '1000000',
          Mwei: '1000000',
          lovelace: '1000000',
          picoether: '1000000',
          gwei: '1000000000',
          Gwei: '1000000000',
          shannon: '1000000000',
          nanoether: '1000000000',
          nano: '1000000000',
          szabo: '1000000000000',
          microether: '1000000000000',
          micro: '1000000000000',
          finney: '1000000000000000',
          milliether: '1000000000000000',
          milli: '1000000000000000',
          ether: '1000000000000000000',
          kether: '1000000000000000000000',
          grand: '1000000000000000000000',
          mether: '1000000000000000000000000',
          gether: '1000000000000000000000000000',
          tether: '1000000000000000000000000000000'
        },
        toWei: [Function: toWei],
        fromWei: [Function: fromWei],
        padLeft: [Function: leftPad],
        leftPad: [Function: leftPad],
        padRight: [Function: rightPad],
        rightPad: [Function: rightPad],
        toTwosComplement: [Function: toTwosComplement],
        isBloom: [Function: isBloom],
        isUserEthereumAddressInBloom: [Function: isUserEthereumAddressInBloom],
        isContractAddressInBloom: [Function: isContractAddressInBloom],
        isTopic: [Function: isTopic],
        isTopicInBloom: [Function: isTopicInBloom],
        isInBloom: [Function: isInBloom],
        compareBlockNumbers: [Function: compareBlockNumbers],
        toNumber: [Function: toNumber]
      },
      eth: <ref *2> Eth {
        currentProvider: [Getter/Setter],
        _requestManager: RequestManager {
          provider: [HttpProvider],
          providers: [Object],
          subscriptions: Map(0) {}
        },
        givenProvider: null,
        providers: {
          WebsocketProvider: [Function: WebsocketProvider],
          HttpProvider: [Function: HttpProvider],
          IpcProvider: [Function: IpcProvider]
        },
        _provider: HttpProvider {
          withCredentials: false,
          timeout: 0,
          headers: undefined,
          agent: undefined,
          connected: true,
          host: 'https://mainnet.infura.io/v3/4adc822d926044efaa46a37fbd87fd0c',
          httpsAgent: [Agent]
        },
        setProvider: [Function (anonymous)],
        setRequestManager: [Function (anonymous)],
        BatchRequest: [Function: bound Batch],
        extend: [Function: ex] {
          formatters: [Object],
          utils: [Object],
          Method: [Function: Method]
        },
        handleRevert: [Getter/Setter],
        defaultCommon: [Getter/Setter],
        defaultHardfork: [Getter/Setter],
        defaultChain: [Getter/Setter],
        transactionPollingTimeout: [Getter/Setter],
        transactionPollingInterval: [Getter/Setter],
        transactionConfirmationBlocks: [Getter/Setter],
        transactionBlockTimeout: [Getter/Setter],
        blockHeaderTimeout: [Getter/Setter],
        defaultAccount: [Getter/Setter],
        defaultBlock: [Getter/Setter],
        maxListenersWarningThreshold: [Getter/Setter],
        clearSubscriptions: [Function: bound ],
        removeSubscriptionById: [Function: bound ],
        net: Net {
          currentProvider: [Getter/Setter],
          _requestManager: [RequestManager],
          givenProvider: null,
          providers: [Object],
          _provider: [HttpProvider],
          setProvider: [Function (anonymous)],
          setRequestManager: [Function (anonymous)],
          BatchRequest: [Function: bound Batch],
          extend: [Function],
          getId: [Function],
          isListening: [Function],
          getPeerCount: [Function],
          getNetworkType: [Function: bound getNetworkType]
        },
        accounts: Accounts {
          currentProvider: [Getter/Setter],
          _requestManager: [RequestManager],
          givenProvider: null,
          providers: [Object],
          _provider: [HttpProvider],
          setProvider: [Function (anonymous)],
          setRequestManager: [Function (anonymous)],
          _ethereumCall: [Object],
          wallet: [Wallet]
        },
        personal: Personal {
          currentProvider: [Getter/Setter],
          _requestManager: [RequestManager],
          givenProvider: null,
          providers: [Object],
          _provider: [HttpProvider],
          setProvider: [Function (anonymous)],
          setRequestManager: [Function (anonymous)],
          BatchRequest: [Function: bound Batch],
          extend: [Function],
          net: [Net],
          defaultAccount: [Getter/Setter],
          defaultBlock: [Getter/Setter],
          getAccounts: [Function],
          newAccount: [Function],
          unlockAccount: [Function],
          lockAccount: [Function],
          importRawKey: [Function],
          sendTransaction: [Function],
          signTransaction: [Function],
          sign: [Function],
          ecRecover: [Function]
        },
        Contract: [Function: Contract] {
          setProvider: [Function (anonymous)],
          defaultAccount: null,
          defaultBlock: 'latest',
          transactionBlockTimeout: 50,
          transactionConfirmationBlocks: 24,
          transactionPollingTimeout: 750,
          transactionPollingInterval: 1000,
          blockHeaderTimeout: 10,
          handleRevert: false,
          _requestManager: [RequestManager],
          _ethAccounts: [Accounts],
          currentProvider: [HttpProvider]
        },
        Iban: [class Iban],
        abi: ABICoder {},
        ens: ENS {
          eth: [Circular *2],
          _detectedAddress: null,
          _lastSyncCheck: null,
          registry: [Getter],
          resolverMethodHandler: [Getter],
          registryAddress: [Getter/Setter]
        },
        getNodeInfo: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'web3_clientVersion'
        },
        getProtocolVersion: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_protocolVersion'
        },
        getCoinbase: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_coinbase'
        },
        isMining: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_mining'
        },
        getHashrate: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_hashrate'
        },
        isSyncing: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_syncing'
        },
        getGasPrice: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_gasPrice'
        },
        getFeeHistory: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_feeHistory'
        },
        getAccounts: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_accounts'
        },
        getBlockNumber: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_blockNumber'
        },
        getBalance: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getBalance'
        },
        getStorageAt: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getStorageAt'
        },
        getCode: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getCode'
        },
        getBlock: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: [Function: blockCall]
        },
        getUncle: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: [Function: uncleCall]
        },
        getBlockTransactionCount: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: [Function: getBlockTransactionCountCall]
        },
        getBlockUncleCount: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: [Function: uncleCountCall]
        },
        getTransaction: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getTransactionByHash'
        },
        getTransactionFromBlock: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: [Function: transactionFromBlockCall]
        },
        getTransactionReceipt: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getTransactionReceipt'
        },
        getTransactionCount: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getTransactionCount'
        },
        sendSignedTransaction: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_sendRawTransaction'
        },
        signTransaction: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_signTransaction'
        },
        sendTransaction: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_sendTransaction'
        },
        sign: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_sign'
        },
        call: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_call'
        },
        estimateGas: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_estimateGas'
        },
        submitWork: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_submitWork'
        },
        getWork: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getWork'
        },
        getPastLogs: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getLogs'
        },
        getChainId: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_chainId'
        },
        requestAccounts: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_requestAccounts'
        },
        getProof: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_getProof'
        },
        getPendingTransactions: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_pendingTransactions'
        },
        createAccessList: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'eth_createAccessList'
        },
        subscribe: [Function (anonymous)]
      },
      shh: Shh {
        currentProvider: [Getter/Setter],
        _requestManager: RequestManager {
          provider: [HttpProvider],
          providers: [Object],
          subscriptions: Map(0) {}
        },
        givenProvider: null,
        providers: {
          WebsocketProvider: [Function: WebsocketProvider],
          HttpProvider: [Function: HttpProvider],
          IpcProvider: [Function: IpcProvider]
        },
        _provider: HttpProvider {
          withCredentials: false,
          timeout: 0,
          headers: undefined,
          agent: undefined,
          connected: true,
          host: 'https://mainnet.infura.io/v3/4adc822d926044efaa46a37fbd87fd0c',
          httpsAgent: [Agent]
        },
        setProvider: [Function (anonymous)],
        setRequestManager: [Function (anonymous)],
        BatchRequest: [Function: bound Batch],
        extend: [Function: ex] {
          formatters: [Object],
          utils: [Object],
          Method: [Function: Method]
        },
        net: Net {
          currentProvider: [Getter/Setter],
          _requestManager: [RequestManager],
          givenProvider: null,
          providers: [Object],
          _provider: [HttpProvider],
          setProvider: [Function (anonymous)],
          setRequestManager: [Function (anonymous)],
          BatchRequest: [Function: bound Batch],
          extend: [Function],
          getId: [Function],
          isListening: [Function],
          getPeerCount: [Function]
        },
        subscribe: [Function (anonymous)],
        getVersion: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_version'
        },
        getInfo: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_info'
        },
        setMaxMessageSize: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_setMaxMessageSize'
        },
        setMinPoW: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_setMinPoW'
        },
        markTrustedPeer: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_markTrustedPeer'
        },
        newKeyPair: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_newKeyPair'
        },
        addPrivateKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_addPrivateKey'
        },
        deleteKeyPair: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_deleteKeyPair'
        },
        hasKeyPair: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_hasKeyPair'
        },
        getPublicKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_getPublicKey'
        },
        getPrivateKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_getPrivateKey'
        },
        newSymKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_newSymKey'
        },
        addSymKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_addSymKey'
        },
        generateSymKeyFromPassword: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_generateSymKeyFromPassword'
        },
        hasSymKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_hasSymKey'
        },
        getSymKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_getSymKey'
        },
        deleteSymKey: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_deleteSymKey'
        },
        newMessageFilter: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_newMessageFilter'
        },
        getFilterMessages: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_getFilterMessages'
        },
        deleteMessageFilter: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_deleteMessageFilter'
        },
        post: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_post'
        },
        unsubscribe: [Function: send] {
          method: [Method],
          request: [Function: bound ],
          call: 'shh_unsubscribe'
        }
      },
      bzz: Bzz {
        givenProvider: null,
        currentProvider: null,
        isAvailable: [Function (anonymous)],
        upload: [Function (anonymous)],
        download: [Function (anonymous)]
      }
    }
    

    2. web3.js 命令

    web3.js 有很多函数和命令,更多内容,请读者参见参考文档:https://web3js.readthedocs.io/en/v1.2.0/index.html

    展开全文
  • 在您的项目中包括web3c.js ,在webpack项目中需要web3c,或将机密性扩展附加到您现有的Web3使用中。 $ npm install --save web3c 为了方便起见,我们在此处自动构建该库的最新版本: : 创建一个新的Web3c项目 您...
  • 目录标题web3.js介绍web3 模块加载异步回调(callback)回调 Promise 事件(v1.0.0)常用 API —— 基本信息查询查看 web3 版本查看 web3 连接到的节点版本(clientVersion)基本信息查询获取 network id获取节点的...

    web3.js介绍

    • Web3 JavaScript app API

    • web3.js 是一个JavaScript API库。要使DApp在以太坊上运行,我们可以使用web3.js库提供的web3对象

    • web3.js 通过RPC调用与本地节点通信,它可以用于任何暴露了RPC层的以太坊节点

    • web3 包含 eth 对象 - web3.eth(专门与以太坊区块链交互)和 shh 对象 - web3.shh(用于与 Whisper 交互)

    web3 模块加载

    • 首先需要将 web3 模块安装在项目中:npm install web3@0.20.1
    • 然后创建一个 web3 实例,设置一个“provider” • 为了保证我们的 MetaMask 设置好的 provider 不被覆盖掉,在引入 web3 之前我们一般要做当前环境检查(以v0.20.1为例):

    if (typeof web3 !== 'undefined') { 
    web3 = new Web3(web3.currentProvider); 
    } else {
    web3 = new Web3(new Web3.providers
    .HttpProvider("http://localhost:8545")); 
    }
    

    异步回调(callback)

    • web3js API 设计的最初目的,主要是为了和本地 RPC 节点共同使用,所以默认情况下发送的是同步 HTTP 请求

    • 如果要发送异步请求,可以在函数的最后一个参数位置上,传入一个回调函数。回调函数是可选(optioanl)的

    • 我们一般采用的回调风格是所谓的“错误优先”,例如:

    web3.eth.getBlock(48, function(error, result){ 
    if(!error) 
    console.log(JSON.stringify(result)); 
    else 
    console.error(error); 
    });
    

    回调 Promise 事件(v1.0.0)

    • 为了帮助 web3 集成到不同标准的所有类型项目中,1.0.0 版本提供了多种方式来处理异步函数。大多数的 web3 对象允许将一个回调函数作为最后一个函数参数传入,同时会返回一个promise 用于链式函数调用。

    • 以太坊作为一个区块链系统,一次请求具有不同的结束阶段。为了满足这样的要求,1.0.0 版本将这类函数调用的返回值包成一个“承诺事件”(promiEvent),这是一个 promise 和EventEmitter 的结合体。

    • PromiEvent 的用法就像 promise 一样,另外还加入了.on,.once 和.off方法

    web3.eth.sendTransaction({from: '0x123...', data: '0x432...'}) 
    .once('transactionHash', function(hash){ ... }) 
    .once('receipt', function(receipt){ ... }) 
    .on('confirmation', function(confNumber, receipt){ ... }) 
    .on('error', function(error){ ... }) 
    .then(function(receipt){ 
    // will be fired once the receipt is mined });
    

    应用二进制接口(ABI) • web3.js 通过以太坊智能合约的 json 接口(Application Binary Interface,ABI)创建一个 JavaScript 对象,用来在 js
    代码中描述

    • 函数(functions) • type:函数类型,默认“function”,也可能“constructor” • constant, payable, stateMutability:函数的状态可变性
    • inputs, outputs: 函数输入、输出参数描述列表
    • 事件(events) • type:类型,总是“event” • inputs:输入对象列表,包括name、type、indexed
    批处理请求(batch requests) • 批处理请求允许我们将请求排序,然后一起处理它们。

    • 注意:批量请求不会更快。实际上,在某些情况下,一次性地发出许多请求会更快,因为请求是异步处理的。

    • 批处理请求主要用于确保请求的顺序,并串行处理。

    var batch = web3.createBatch(); 
    batch.add(web3.eth.getBalance.request('0x0000000000000000
    000000000000000000000000', 'latest', callback)); 
    batch.add(web3.eth.contract(abi).at(address).balance.request(a
    ddress, callback2)); 
    batch.execute();
    

    常用 API —— 基本信息查询

    查看 web3 版本

    • v0.2x.x:web3.version.api
    • v1.0.0:web3.version

    查看 web3 连接到的节点版本(clientVersion)

    • 同步:web3.version.node
    • 异步:web3.version.getNode((error,result)=>{console.log(result)})
    • v1.0.0:web3.eth.getNodeInfo().then(console.log)

    基本信息查询

    获取 network id

    • 同步:web3.version.network
    • 异步:web3.version.getNetwork((err, res)=>{console.log(res)})
    • v1.0.0:web3.eth.net.getId().then(console.log)

    获取节点的以太坊协议版本

    • 同步:web3.version.ethereum
    • 异步:web3.version.getEthereum((err, res)=>{console.log(res)})
    • v1.0.0:web3.eth.getProtocolVersion().then(console.log)

    网络状态查询

    是否有节点连接/监听,返回true/false

    • 同步:web3.isConnect() 或者 web3.net.listening
    • 异步:web3.net.getListening((err,res)=>console.log(res))
    • v1.0.0:web3.eth.net.isListening().then(console.log)

    查看当前连接的 peer 节点

    • 同步:web3.net.peerCount
    • 异步:web3.net.getPeerCount((err,res)=>console.log(res))
    • v1.0.0:web3.eth.net.getPeerCount().then(console.log)

    Provider

    查看当前设置的 web3 provider

    • web3.currentProvider

    查看浏览器环境设置的 web3 provider(v1.0.0) • web3.givenProvider

    设置 provider

    • web3.setProvider(provider)
    • web3.setProvider(new web3.providers.HttpProvider(‘http://localhost:8545’))

    web3 通用工具方法

    以太单位转换

    • web3.fromWei web3.toWei

    数据类型转换

    • web3.toString web3.toDecimal web3.toBigNumber

    字符编码转换

    • web3.toHex web3.toAscii web3.toUtf8 web3.fromUtf8

    地址相关

    • web3.isAddress web3.toChecksumAddress
    web3.eth – 账户相关

    coinbase 查询

    • 同步:web3.eth.coinbase
    • 异步:web3.eth.getCoinbase( (err, res)=>console.log(res) )
    • v1.0.0:web3.eth.getCoinbase().then(console.log)

    账户查询

    • 同步:web3.eth.accounts
    • 异步:web3.eth.getAccounts( (err, res)=>console.log(res) )
    • v1.0.0:web3.eth.getAccounts().then(console.log)

    区块相关

    区块高度查询

    • 同步:web3.eth. blockNumber
    • 异步:web3.eth.getBlockNumber( callback )

    gasPrice 查询

    • 同步:web3.eth.gasPrice
    • 异步:web3.eth.getGasPrice( callback )

    区块查询

    • 同步:web3.eth.getBlockNumber( hashStringOrBlockNumber
    [ ,returnTransactionObjects] )
    • 异步:web3.eth.getBlockNumber( hashStringOrBlockNumber, callback )
    块中交易数量查询
    • 同步:
    web3.eth.getBlockTransactionCount( hashStringOrBlockNumber ) • 异步:
    web3.eth.getBlockTransactionCount( hashStringOrBlockNumber
    , callback )
    

    交易相关

    余额查询

    • 同步:web3.eth.getBalance(addressHexString [, defaultBlock])
    • 异步:web3.eth.getBalance(addressHexString [, defaultBlock]
    [, callback])

    交易查询

    • 同步:web3.eth.getTransaction(transactionHash)
    • 异步:web3.eth.getTransaction(transactionHash [, callback])

    交易执行相关
    • 交易收据查询(已进块)
    • 同步:web3.eth.getTransactionReceipt(hashString)
    • 异步:web3.eth.getTransactionReceipt(hashString [, callback])
    • 估计 gas 消耗量
    • 同步:web3.eth.estimateGas(callObject)
    • 异步:web3.eth.estimateGas(callObject [, callback])

    发送交易

    • web3.eth.sendTransaction(transactionObject [, callback])
    • 交易对象:
    • from:发送地址
    • to:接收地址,如果是创建合约交易,可不填
    • value:交易金额,以wei为单位,可选
    • gas:交易消耗 gas 上限,可选
    • gasPrice:交易 gas 单价,可选
    • data:交易携带的字串数据,可选
    • nonce:整数 nonce 值,可选

    消息调用

    • web3.eth.call(callObject [, defaultBlock] [, callback])
    • 参数:
    • 调用对象:与交易对象相同,只是from也是可选的
    • 默认区块:默认“latest”,可以传入指定的区块高度
    • 回调函数,如果没有则为同步调用

    var result = web3.eth.call({ to: 
    "0xc4abd0339eb8d57087278718986382264244252f", 
    data: 
    "0xc6888fa100000000000000000000000000000000000000000000000000
    0 0000000000003" }); 
    console.log(result);
    

    日志过滤(事件监听)

    web3.eth.filter( filterOptions [ , callback ] )
    // filterString 可以是 'latest' or 'pending' 
    var filter = web3.eth.filter(filterString); 
    // 或者可以填入一个日志过滤 options 
    var filter = web3.eth.filter(options); 
    // 监听日志变化
    filter.watch(function(error, result){ if (!error) console.log(result); }); 
    // 还可以用传入回调函数的方法,立刻开始监听日志
    web3.eth.filter(options, function(error, result){ 
    if (!error) console.log(result); 
    });
    

    合约相关 —— 创建合约

    web3.eth.contract
    var MyContract = web3.eth.contract(abiArray); 
    // 通过地址初始化合约实例
    var contractInstance = MyContract.at(address); 
    // 或者部署一个新合约
    var contractInstance = MyContract.new([constructorParam1] 
    [, constructorParam2], {data: '0x12345...', from: 
    myAccount, gas: 1000000});
    

    调用合约函数

    • 可以通过已创建的合约实例,直接调用合约函数
    // 直接调用,自动按函数类型决定用 sendTransaction 还是 call
    myContractInstance.myMethod(param1 [, param2, ...] [, 
    transactionObject] [, defaultBlock] [, callback]); 
    // 显式以消息调用形式 call 该函数
    myContractInstance.myMethod.call(param1 [, param2, ...] [, 
    transactionObject] [, defaultBlock] [, callback]); 
    // 显式以发送交易形式调用该函数
    myContractInstance.myMethod.sendTransaction(param1 [, 
    param2, ...] [, transactionObject] [, callback]); 
    

    监听合约事件

    • 合约的 event 类似于 filter,可以设置过滤选项来监听
    var event = myContractInstance.MyEvent({valueA: 23} 
    [, additionalFilterObject]) 
    // 监听事件
    event.watch(function(error, result){ if (!error) console.log(result); }); 
    //还可以用传入回调函数的方法,立刻开始监听事件
    var event = myContractInstance.MyEvent([{valueA: 23}] 
    [, additionalFilterObject] , function(error, result){ 
    if (!error) console.log(result); 
    }
    );
    
    展开全文
  • 快速学习-web3.js简介与入门

    万次阅读 2020-04-15 09:46:17
    web3.js 是一个JavaScript API库。要使DApp在以太坊上运行,我们可以使用web3.js库提供的web3对象 web3.js 通过RPC调用与本地节点通信,它可以用于任何暴露了RPC层的以太坊节点 web3 包含 eth 对象 - web3.eth(专门...

    web3.js简介与入门

    web3.js简介

    • Web3 JavaScript app API
    • web3.js 是一个JavaScript API库。要使DApp在以太坊上运行,我们可以使用web3.js库提供的web3对象
    • web3.js 通过RPC调用与本地节点通信,它可以用于任何暴露了RPC层的以太坊节点
    • web3 包含 eth 对象 - web3.eth(专门与以太坊区块链交互)和 shh 对象 - web3.shh(用于与 Whisper 交互)

    web3 模块加载

    • 首先需要将 web3 模块安装在项目中:npm install web3@0.20.1
    • 然后创建一个 web3 实例,设置一个“provider” • 为了保证我们的 MetaMask 设置好的 provider 不被覆盖掉,在引入 web3 之前我们一般要做当前环境检查(以v0.20.1为例):
    if (typeof web3 !== 'undefined') {
    	web3 = new Web3(web3.currentProvider);
    } else {
    	web3 = new Web3(new Web3.providers
    		.HttpProvider("http://localhost:8545"));
    }
    

    异步回调(callback)

    • web3js API 设计的最初目的,主要是为了和本地 RPC 节点共同使用,所以默认情况下发送的是同步 HTTP 请求
    • 如果要发送异步请求,可以在函数的最后一个参数位置上,传入一个回调函数。回调函数是可选(optioanl)的
    • 我们一般采用的回调风格是所谓的“错误优先”,例如:
    web3.eth.getBlock(48, function(error, result) {
    	if (!error)
    		console.log(JSON.stringify(result));
    	else
    		console.error(error);
    });
    

    回调 Promise 事件(v1.0.0)

    为了帮助 web3 集成到不同标准的所有类型项目中,1.0.0 版本提供了多种方式来处理异步函数。大多数的 web3 对象允许将一个回调函数作为最后一个函数参数传入,同时会返回一个promise 用于链式函数调用。

    • 以太坊作为一个区块链系统,一次请求具有不同的结束阶段。为了满足这样的要求,1.0.0 版本将这类函数调用的返回值包成一个“承诺事件”(promiEvent),这是一个 promise 和EventEmitter 的结合体。
    • PromiEvent 的用法就像 promise 一样,另外还加入了.on,.once 和.off方法
    web3.eth.sendTransaction({
    		from: '0x123...',
    		data: '0x432...'
    	})
    	.once('transactionHash', function(hash) { ...
    	})
    	.once('receipt', function(receipt) { ...
    	})
    	.on('confirmation', function(confNumber, receipt) { ...
    	})
    	.on('error', function(error) { ...
    	})
    	.then(function(receipt) { // will be fired once the receipt is mined });
    

    应用二进制接口(ABI)

    web3.js 通过以太坊智能合约的 json 接口(Application Binary Interface,ABI)创建一个 JavaScript 对象,用来在 js 代码中描述

    函数(functions)

    • type:函数类型,默认“function”,也可能是“constructor”
    • constant, payable, stateMutability:函数的状态可变性
    • inputs, outputs: 函数输入、输出参数描述列表

    事件(events)

    • type:类型,总是“event”
    • inputs:输入对象列表,包括 name、type、indexed

    批处理请求(batch requests)

    • 批处理请求允许我们将请求排序,然后一起处理它们。
    • 注意:批量请求不会更快。实际上,在某些情况下,一次性地发出许多请求会更快,因为请求是异步处理的。
    • 批处理请求主要用于确保请求的顺序,并串行处理。
    var batch = web3.createBatch();
    batch.add(web3.eth.getBalance.request('0x0000000000000000
    			000000000000000000000000 ', '
    			latest ', callback)); 
    			batch.add(web3.eth.contract(abi).at(address).balance.request(a ddress, callback2)); batch.execute();
    

    大数处理(big numbers)

    • JavaScript 中默认的数字精度较小,所以web3.js 会自动添加一个依赖库 BigNumber,专门用于大数处理
    • 对于数值,我们应该习惯把它转换成 BigNumber 对象来处理
    var balance = new 
    BigNumber('131242344353464564564574574567456');
    // or var balance = web3.eth.getBalance(someAddress); 
    balance.plus(21).toString(10); 
    //"131242344353464564564574574567477"
    
    • BigNumber.toString(10) 对小数只保留20位浮点精度。所以推荐的做法是,我们内部总是用 wei 来表示余额(大整数),只有在需要显示给用户看的时候才转换为ether或其它单位

    常用 API —— 基本信息查询

    查看 web3 版本

    • v0.2x.x:web3.version.api
    • v1.0.0:web3.version 查看 web3 连接到的节点版本(clientVersion) • 同步:web3.version.node

    异步:

    web3.version.getNode((error,result)=>{console.log(result)})
    
    • v1.0.0:web3.eth.getNodeInfo().then(console.log)

    基本信息查询

    获取 network id

    • 同步:web3.version.network
    • 异步:web3.version.getNetwork((err, res)=>{console.log(res)})
    • v1.0.0:web3.eth.net.getId().then(console.log)

    获取节点的以太坊协议版本

    • 同步:web3.version.ethereum
    • 异步:web3.version.getEthereum((err, res)=>{console.log(res)})
    • v1.0.0:web3.eth.getProtocolVersion().then(console.log)

    网络状态查询

    是否有节点连接/监听,返回true/false

    • 同步:web3.isConnect() 或者 web3.net.listening
    • 异步:web3.net.getListening((err,res)=>console.log(res))
    • v1.0.0:web3.eth.net.isListening().then(console.log)

    查看当前连接的 peer 节点

    • 同步:web3.net.peerCount\
    • 异步:web3.net.getPeerCount((err,res)=>console.log(res))
    • v1.0.0:web3.eth.net.getPeerCount().then(console.log)

    Provider

    查看当前设置的 web3 provider

    • web3.currentProvider

    查看浏览器环境设置的 web3 provider(v1.0.0)

    • web3.givenProvider

    设置 provider

    • web3.setProvider(provider)
    • web3.setProvider(new web3.providers.HttpProvider(‘http://localhost:8545’))

    web3 通用工具方法

    以太单位转换

    • web3.fromWei web3.toWei

    数据类型转换

    • web3.toString web3.toDecimal web3.toBigNumber

    字符编码转换

    • web3.toHex web3.toAscii web3.toUtf8 web3.fromUtf8

    地址相关

    • web3.isAddress web3.toChecksumAddress

    web3.eth – 账户相关

    coinbase 查询

    • 同步:web3.eth.coinbase
    • 异步:web3.eth.getCoinbase( (err, res)=>console.log(res) )\
    • v1.0.0:web3.eth.getCoinbase().then(console.log)

    账户查询

    • 同步:web3.eth.accounts
    • 异步:web3.eth.getAccounts( (err, res)=>console.log(res) )
    • v1.0.0:web3.eth.getAccounts().then(console.log)

    区块相关

    区块高度查询

    • 同步:web3.eth. blockNumber
    • 异步:web3.eth.getBlockNumber( callback )

    gasPrice 查询

    • 同步:web3.eth.gasPrice
    • 异步:web3.eth.getGasPrice( callback )

    区块查询

    • 同步:web3.eth.getBlockNumber( hashStringOrBlockNumber [ ,returnTransactionObjects] )
    • 异步:web3.eth.getBlockNumber( hashStringOrBlockNumber, callback )

    块中交易数量查询

    • 同步:web3.eth.getBlockTransactionCount( hashStringOrBlockNumber )
    • 异步:web3.eth.getBlockTransactionCount( hashStringOrBlockNumber, callback )

    交易相关

    余额查询

    • 同步:web3.eth.getBalance(addressHexString [, defaultBlock])
    • 异步:web3.eth.getBalance(addressHexString [, defaultBlock ] , callback])

    交易查询

    • 同步:web3.eth.getTransaction(transactionHash)
    • 异步:web3.eth.getTransaction(transactionHash [, callback])

    交易执行相关

    交易收据查询(已进块)

    • 同步:web3.eth.getTransactionReceipt(hashString)
    • 异步:web3.eth.getTransactionReceipt(hashString [,

    callback])

    • 估计 gas 消耗量
    • 同步:web3.eth.estimateGas(callObject)
    • 异步:web3.eth.estimateGas(callObject [, callback])

    发送交易

    • web3.eth.sendTransaction(transactionObject [, callback])

    交易对象:

    • from:发送地址
    • to:接收地址,如果是创建合约交易,可不填
    • value:交易金额,以wei为单位,可选
    • gas:交易消耗 gas 上限,可选
    • gasPrice:交易 gas 单价,可选
    • data:交易携带的字串数据,可选
    • nonce:整数 nonce 值,可选

    消息调用

    • web3.eth.call(callObject [, defaultBlock] [, callback])

    参数:

    • 调用对象:与交易对象相同,只是from也是可选的
    • 默认区块:默认“latest”,可以传入指定的区块高度
    • 回调函数,如果没有则为同步调用
    var result = web3.eth.call({
    			to: "0xc4abd0339eb8d57087278718986382264244252f",
    			data: "0xc6888fa100000000000000000000000000000000000000000000000000
    			0 0000000000003 " }); 
    			console.log(result);
    

    日志过滤(事件监听)

    web3.eth.filter(filterOptions[, callback])
    // filterString 可以是 'latest' or 'pending' 
    var filter = web3.eth.filter(filterString);
    // 或者可以填入一个日志过滤 options 
    var filter = web3.eth.filter(options);
    // 监听日志变化
    filter.watch(function(error, result) {
    	if (!error) console.log(result);
    });
    // 还可以用传入回调函数的方法,立刻开始监听日志
    web3.eth.filter(options, function(error, result) {
    	if (!error) console.log(result);
    });
    

    合约相关 —— 创建合约

    web3.eth.contract
    var MyContract = web3.eth.contract(abiArray);
    // 通过地址初始化合约实例
    var contractInstance = MyContract.at(address);
    // 或者部署一个新合约
    var contractInstance = MyContract.new([constructorParam1]
    	[, constructorParam2], {
    		data: '0x12345...',
    		from: myAccount,
    		gas: 1000000
    	});
    

    调用合约函数

    • 可以通过已创建的合约实例,直接调用合约函数
    // 直接调用,自动按函数类型决定用 sendTransaction 还是 call
    myContractInstance.myMethod(param1[, param2, ...][,
    	transactionObject
    ][, defaultBlock][, callback]);
    // 显式以消息调用形式 call 该函数
    myContractInstance.myMethod.call(param1[, param2, ...][,
    	transactionObject
    ][, defaultBlock][, callback]);
    // 显式以发送交易形式调用该函数
    myContractInstance.myMethod.sendTransaction(param1[,
    	param2, ...][, transactionObject][, callback]);
    

    监听合约事件

    • 合约的 event 类似于 filter,可以设置过滤选项来监听
    var event = myContractInstance.MyEvent({
    		valueA: 23
    	}
    	[, additionalFilterObject])
    // 监听事件
    event.watch(function(error, result) {
    	if (!error) console.log(result);
    });
    //还可以用传入回调函数的方法,立刻开始监听事件
    var event = myContractInstance.MyEvent([{
    		valueA: 23
    	}]
    	[, additionalFilterObject],
    	function(error, result) {
    		if (!error) console.log(result);
    	}
    );
    
    展开全文
  • 使用web3.js收发ETH或ERC20Token

    千次阅读 2020-11-29 10:33:44
    }, "devDependencies": { "@babel/core": "^7.12.3", "@babel/preset-env": "^7.12.1" } }     3.1.4 安装依赖包 npm install     3.1.5 新建一个文件夹名称为myabi,然后在sendToken\myabi\目录下,新建一个ZTA...
  • Api-web3.js.zip

    2019-09-18 09:28:02
    Api-web3.js.zip,以太坊javascript apiweb3.js-以太坊javascript api,一个api可以被认为是多个软件设备之间通信的指导手册。例如,api可用于web应用程序之间的数据库通信。通过提取实现并将数据放弃到对象中,api...
  • 以太坊系列 - Web3.js

    千次阅读 2021-08-30 15:18:33
    Web3.js web3.js是一组用来和本地或远程以太坊节点进行交互的js库,它可以使用HTTP或IPC建立与以太坊节点旳连接。 底层实现上,它通过RPC 调用与本地或远程节点通信。web3.js可以与任何暴露了RPC接口的以太坊节点...
  • web3.js 中文文档 入门

    千次阅读 2021-03-08 16:48:51
    web3.js 中文文档 v1.3.4 入门 web3.js是包含以太坊生态系统功能的模块集合。 web3-eth用于以太坊区块链和智能合约。 web3-shh是针对whisper协议,用于p2p和广播的通信。 web3-bzz是针对swarm协议的,分散文件存储...
  • web3.js版本0.14.0支持对象的。 要迁移到此版本,请按照指南进行操作: - var web3 = require('web3'); + var Web3 = require('web3'); + var web3 = new Web3(); 以太坊JavaScript API 这是实现规范的与以太坊...
  • 其中web3.js是属于javascript的版本的, web3j是java版本的。 合约交互的类型 以太坊可以看做一个公共数据库,这个数据库提供了读、写功能,但是不能删除。 发起交易其实就是将交易写库,写库不能白写,其他节点帮你...
  • win10系统web3.js安装以及如何使用

    千次阅读 2022-04-21 19:50:42
    win10系统web3.js安装以及如何使用安装:使用: 安装: 需要:node.js(本人node.js版本14.17.6) 直接打开命令行输入: npm install web3 //当前安装的是最新版本的web3.js 查看安装的web3.js的版本: npm view web3 --...
  • 从现在开始,我们鼓励所有使用 quorum.js 的活跃项目用户迁移到 web3js-quorum。 请参阅。 我们将继续支持 quorum.js,特别是在 2021 年底之前修复错误。 如果您有任何问题或疑虑,请通过或通过与 ConsenSys 协议...
  • web3.js查询以太币及代币余额以及进行以太币和代币转账 在私链和主链上查询以太币及代币余额 查询类方法在私链和主链上的方法都是一样的 主链地址。可以去infura申请 contractAbi。合约的abi。可以去...
  • web3.js 与区块链交互 npm install -g express-generator npm install express -g express -e myapp npm install npm start 172.16.13.17:3000 3.1 routes/index.js const express = require('express');...
  • Web3.js连接metaMask钱包

    千次阅读 2022-01-11 11:03:44
    编写前端代码测试,通过npm install web3 引入需要的库 function Init(callback) { //判断用户是否安装MetaMask钱包插件 if (typeof window.ethereum === "undefined") { //没安装MetaMask钱包进行弹框提示 ...
  • 在vue中使用web3.js开发以太坊dapp

    万次阅读 热门讨论 2021-01-22 11:34:07
    web3.js 1.0中文手册 MetaMask官方文档 web3.js文件 链接:https://pan.baidu.com/s/1_mPT-ZcQ9GU_U1CVhBKpLA 提取码:cbey //在vue中安装web3 npm install web3 --save //在main.js引入 import Web3 from 'web3' ...
  • web3.js与以太坊交互的初次使用理解

    千次阅读 2022-03-15 19:50:36
    web3.js能够与以太坊及其仿链(如币安链)进行交互,在控制台实现钱包的创建,代币的查询以及交易等等操作。 在这几天摸索的过程中,顺便还了解了私链的搭建过程,用到了geth或Ganache(这个是图形化界面搭建) 运行...
  • Web3.js与智能合约交互

    千次阅读 2022-01-07 20:48:35
    web3.js - 以太坊 JavaScript API — web3.js 中文文档 — 登链社区https://learnblockchain.cn/docs/web3.js/index.html Web3js源码: GitHub - ChainSafe/web3.js: Ethereum JavaScript APIhttps://github....
  • web3.js调用ETH智能合约里的函数

    千次阅读 2021-03-03 20:35:18
        以太坊的智能合约里的公有变量,可以被web3.js通过call()方式来读取出来,也可以被web3.js通过contractObj.methods.XXXfun(numParam).encodeABI()来更新该变量。     下面,介绍使用web3.js读取和修改Bob...
  • web3.js查询和修改链上的合约数据

    万次阅读 2022-01-06 15:58:48
    web3.js
  • web3.js内部使用JSONRPC与geth通信。它把所有JSON-RPC API当作JavaScript API,也就是说,它不仅支持所有与以太坊相关的API,还支持与Whisper和Swarm相关的API。 相关链接 web3.js托管地址 web3.js文档 导入...
  • 以太坊Dapp开发通过web3.js部署合约

    千次阅读 2021-11-22 17:39:36
    以太坊Dapp开发通过web3.js部署合约 在dapp目录下新建一个deploy目录,并安装web3 npm install web3 -save 创建一个deploy.js文件,并将下面代码贴入 var dapptestContract = new web3.eth.Contract([{"constant...
  • web3.js中有一些与交易发送、签名、合约函数调用相关的api,初学者(如me)常常搞不清什么情况下应该调用哪个,以及它们之间的区别。现将个人浅见记录如下,备忘。 交易发送 sendTransaction web3.eth....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,334,982
精华内容 533,992
关键字:

web3.js

友情链接: Tsp.zip