Web3 JavaScript app API for 0.2x.x

本文基本上是翻译自 JavaScript API。但是补充了详细的实例代码。

注意：这些文档适用于 web3.js 版本 0.2x.x。如果使用的是 web3.js 1.0，请参阅此文档。要使应用程序在以太坊上运行，可以使用 web3.js 库提供的 web3 对象。在此基础上，它通过 RPC 调用与本地节点通信。 web3.js 适用于暴露 RPC 层的任何以太坊节点。 web3 包含 eth 对象 - web3.eth（特别是以太坊区块链交互）和 shh 对象 - web3.shh（用于 Whisper 交互）。随着时间的推移，我们将为每个其他 web3 协议引入其他对象。可以在这里找到工作示例。如果想使用 web3.js 查看一些更复杂的示例，请查看这些有用的应用程序模式。

1. 开始

1.1 安装 web3

首先，需要将 web3.js 放入项目中。这可以使用以下方法完成：

npm: npm install web3 or npm install [email protected] or npm install [email protected] --save
vanilla: 链接 dist./web3.min.js 然后需要创建一个 web3 实例，设置一个提供者。要确保在 mist 中时不覆盖已设置的 provider，请首先检查 web3 是否可用：

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

之后，可以使用 web3 对象的 API。这实际上是监控 coinbase 最新余额的示例，见我们的 github 仓库。

1.2 使用回调

由于此 API 旨在与本地 RPC 节点一起使用，因此默认情况下其所有函数都使用同步 HTTP 请求。如果要进行异步请求，可以将可选回调作为最后一个参数传递给大多数函数。所有回调都使用错误的第一个回调样式：

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

1.3 批处理请求

批处理请求允许排队请求并一次性处理它们。注意批量请求不会更快！实际上，在某些情况下，一次性地发出许多请求会更快，因为请求是异步处理的。批处理请求主要用于确保请求的串行处理。

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

var Web3 = require('web3');
var web3 = new Web3();

var rpcUrl = "http://localhost:7545";

web3.setProvider(new web3.providers.HttpProvider(rpcUrl));

console.log('Test batch requests.')

var batch = web3.createBatch();

batch.add(web3.eth.getBlock.request(0, function(error, result) {
    if(!error) {
        console.log('\nresult: ', result);
        // console.log(JSON.stringify(result));
    }
    else {
        console.error(error);
    }
}));

batch.add(web3.eth.getBlock.request(1, function(error, result) {
    if(!error) {
        console.log('\nresult: ', result);
        // console.log(JSON.stringify(result));
    }
    else {
        console.error(error);
    }
}));

batch.add(web3.eth.getBlock.request(2, function(error, result) {
    if(!error) {
        console.log('\nresult: ', result);
        // console.log(JSON.stringify(result));
    }
    else {
        console.error(error);
    }
}));

batch.execute();

1.4 关于web3.js中大数字的说明

我们将始终获得数字值的BigNumber对象，因为JavaScript无法正确处理大数字。请看以下示例：

"101010100324325345346456456456456456456"
// "101010100324325345346456456456456456456"
101010100324325345346456456456456456456
// 1.0101010032432535e+38

web3.js取决于BigNumber库并自动添加它。实践下来，有时候还是需要手动安装 `npm install bignumber.js'

var balance = new BigNumber('131242344353464564564574574567456');
// or var balance = web3.eth.getBalance(someAddress);
balance.plus(21).toString(10); // toString(10) converts it to a number string
// "131242344353464564564574574567477"

下一个示例不起作用，因为我们有超过20个浮点，因此建议始终在wei中保持余额，并在呈现给用户时仅将其转换为其他单位：

var balance = new BigNumber('13124.234435346456466666457455567456');
 balance.plus(21).toString(10); // toString(10) converts it to a number string, but can only show upto 20 digits
// "13145.23443534645646666646" // your number will be truncated after the 20th digit

2. Web3.js API Reference

2.1 web3

web3对象提供了所有的方法。

示例：

var Web3 = require('web3');
// create an instance of web3 using the HTTP provider.
// NOTE in mist web3 is already available, so check first if it's available before instantiating
var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));

使用HTTP基本身份验证的示例

var Web3 = require('web3');
var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545", 0, BasicAuthUsername, BasicAuthPassword));
//Note: HttpProvider takes 4 arguments (host, timeout, user, password)

2.2 version

2.2.1 api

接口：

web3.version.api

返回值：

String - 以太坊js api版本。

示例：

var version = web3.version.api;
console.log(version); // "0.2.0"

2.2.2 node/getNode

接口：

web3.version.node

web3.version.node
// or async
web3.version.getNode(callback(error, result){ ... })

返回值：

String - client/node 版本。

示例：

var version = web3.version.node;
console.log(version); // "Mist/v0.9.3/darwin/go1.4.1"

2.2.3 network/getNetwork

接口：

web3.version.network

web3.version.network
// or async
web3.version.getNetwork(callback(error, result){ ... })

返回值：

String - 网络ID。

示例：

var version = web3.version.network;
console.log(version); // 54

2.2.4 ethereum/getEthereum

接口：

web3.version.ethereum

web3.version.ethereum
// or async
web3.version.getEthereum(callback(error, result){ ... })

返回值：
String - 以太坊协议版本

示例：

var version = web3.version.ethereum;
console.log(version); // 60

2.2.5 whisper/getWhisper

接口：

web3.version.whisper

web3.version.whisper
// or async
web3.version.getWhisper(callback(error, result){ ... })

返回值：

String - whisper 协议版本

示例：

var version = web3.version.whisper;
console.log(version); // 20

2.3 isConnected()

接口：

web3.isConnected

web3.isConnected()

应调用以检查是否存在与节点的连接。

参数：

none

返回值

Boolean

示例：

if(!web3.isConnected()) {
 
  // show some dialog to ask the user to start a node
} else {

  // start web3 filters, calls, etc
 
}

2.4 setProvider(provider)

接口：

web3.setProvider

 web3.setProvider(provider)

参数：

none

返回值

undefined

示例：

web3.setProvider(new web3.providers.HttpProvider('http://localhost:8545')); // 8080 for cpp/AZ, 8545 for go/mist

2.5 currentProvider

接口：

web3.currentProvider

web3.currentProvider

将包含当前 provider（如果已设置）。这可以用于检查 mist 等是否已经设置了 provider。

返回值：

Object - provider 集合或 null

示例：

// Check if mist etc. already set a provider
if(!web3.currentProvider)
   web3.setProvider(new web3.providers.HttpProvider("http://localhost:8545"));

2.6 reset()

接口：

web3.reset

web3.reset(keepIsSyncing)

应调用重置web3的状态。重置除经理以外的一切。卸载所有过滤器。停止 polling。

参数：

Boolean - 如果为 true，它将卸载所有过滤器，但将保留web3.eth.isSyncing（）轮询

返回值：

undefined

示例：

web3.reset();

2.7 sha3(string, options)

接口：

web3.sha3

web3.sha3(string [, options])

参数：

String - 要使用Keccak-256 SHA3算法进行哈希处理的字符串
Object - （可选）如果要散列的字符串以十六进制编码，则将 encoding 设置为 hex。前导0x将自动被忽略。

返回值：

String - 给定数据的Keccak-256 SHA3。

示例：

var hash = web3.sha3("Some string to be hashed");
console.log(hash); // "0xed973b234cf2238052c9ac87072c71bcf33abc1bbd721018e0cca448ef79b379"
var hashOfHash = web3.sha3(hash, {encoding: 'hex'});
console.log(hashOfHash); // "0x85dd39c91a64167ba20732b228251e67caed1462d4bcf036af88dc6856d0fdcc"

2.8 toHex(stringOrNumber)

接口：

web3.toHex

web3.toHex(mixed);

将任何值转换为HEX。

参数：

String|Number|Object|Array|BigNumber - 要解析为HEX的值。如果它是一个对象或数组，它将首先是JSON.stringify。如果它是一个BigNumber，它将使它成为数字的HEX值。

返回值：

String - mixed 的十六进制字符串。

示例：

var str = web3.toHex({test: 'test'});
console.log(str); // '0x7b2274657374223a2274657374227d'

2.9 toAscii(hexString)

接口：

web3.toAscii

web3.toAscii(hexString);

将HEX字符串转换为ASCII字符串。

参数：

String - 要转换为ascii的HEX字符串。

示例：

var str = web3.toAscii("0x657468657265756d000000000000000000000000000000000000000000000000");
console.log(str); // "ethereum"

2.10 fromAscii(textString)

接口：

web3.fromAscii

web3.fromAscii(string);

将任何ASCII字符串转换为HEX字符串。

参数：

String - 要转换为HEX的ASCII字符串。

返回值：

String - 转换后的HEX字符串。

示例：

var str = web3.fromAscii('ethereum');
console.log(str); // "0x657468657265756d"

2.11 toDecimal(hexString)

接口：

web3.toDecimal

web3.toDecimal(hexString);

将HEX字符串转换为其数字表示形式。

参数：

String - 要转换为数字的HEX字符串。

返回值：
Number - 表示数据 hexString 的数字。

示例：

var number = web3.toDecimal('0x15');
console.log(number); // 21

2.12 fromDecimal(number)

接口：

web3.fromDecimal

web3.fromDecimal(number);

将数字或数字字符串转换为其HEX表示。

参数：

Number|String - 要转换为HEX字符串的数字。

返回值：

Number - 表示给定 number 的HEX字符串。

示例：

var value = web3.fromDecimal('21');
console.log(value); // "0x15"

2.13 fromWei(numberStringOrBigNumber, unit)

接口：

web3.fromWei

web3.fromWei(number, unit)

将多个wei转换为以下以太坊单位：

Gwei
Kwei
Mwei / babbage / ether / femtoether
ether
finney / gether / grand / gwei
kether / kwei / lovelace / mether / micro
microether / milli / milliether
mwei / nano/ nanoether
noether
picoether / shannon
szabo
tether
wei

参数：

Number|String|BigNumber - 数字或BigNumber实例。
String - 以上以太的单位之一。

返回值：

String|Number - 它是一个数字字符串，或一个BigNumber实例，具体取决于给定的 number 参数。

示例：

var value = web3.fromWei('21000000000000', 'finney');
console.log(value); // "0.021"

2.14 toWei(numberStringOrBigNumber, unit)

接口：
web3.toWei

web3.toWei(number, unit)

将以太坊单位转换为wei。可能的单位是：

kwei / ada
mwei / babbage
gwei / shannon
szabo
finney
ether
kether / grand / einstein
mether
gether
tether

参数：

Number|String|BigNumber - 数字或BigNumber实例。
String - 以上以太的单位之一。

返回值：

String|Number - 它是一个数字字符串，或一个BigNumber实例，具体取决于给定的 number 参数。

示例：

var value = web3.toWei('1', 'ether');
console.log(value); // "1000000000000000000"

2.15 toBigNumber(numberOfHexString)

接口：

web3.toBigNumber

web3.toBigNumber(numberOrHexString);

将给定数字转换为 BigNumber 实例。请参阅 BigNumber 上的注释。

参数：

Number|String - 数字、数字字符串或HEX字符串的数字。

返回值：

BigNumber - 表示给定值的 BigNumber 实例。

示例：

var value = web3.toBigNumber('200000000000000000000001');
console.log(value); // instanceOf BigNumber
console.log(value.toNumber()); // 2.0000000000000002e+23
console.log(value.toString(10)); // '200000000000000000000001'

2.16 isAddress(hexString)

接口：
web3.isAddress

web3.isAddress(HexString);

检查给定的字符串是否是地址。

参数：

String - HEX字符串。

返回值：

Boolean - 如果它不是有效的地址格式，则为 false。如果它是全小写或全部大写有效地址，则返回 true。如果它是一个混合大小写的地址，则使用 web3.isChecksumAddress() 进行检查。

示例：

var isAddress = web3.isAddress("0x8888f1f195afa192cfee860698584c030f4c9db1");
console.log(isAddress); // true

2.17 net

2.17.1 listening/getListening

接口：

web3.net.listening

web3.net.listening
// or async
web3.net.getListening(callback(error, result){ ... })

此属性是只读的，表示节点是否正在主动侦听网络连接。

返回值：

Boolean - 如果客户端正在主动侦听网络连接，则为 true，否则为 false。

示例：

var listening = web3.net.listening;
console.log(listening); // true of false

2.17.2 peerCount/getPerrCount

接口：
web3.net.peerCount

web3.net.peerCount
// or async
web3.net.getPeerCount(callback(error, result){ ... })

此属性是只读的，并返回已连接的对等方的数量。

返回值：

Number - 当前连接到客户端的对等方数量。

示例：

var peerCount = web3.net.peerCount;
console.log(peerCount); // 4

2.18 eth

包含以太坊区块链相关方法。

示例：

var eth = web3.eth;

2.18.1 defaultAccount

接口：

web3.eth.defaultAccount

web3.eth.defaultAccount

此默认地址用于以下方法（可选择通过指定 from 属性覆盖它）：

web3.eth.sendTransaction()
web3.eth.call()

值：

String, 20 字节 - 我们拥有的任何地址，或我们拥有私钥的地址。默认值 undefined。

返回值：

String, 20 字节 - 当前设置的默认地址。

示例：

var defaultAccount = web3.eth.defaultAccount;
console.log(defaultAccount); // ''
// set the default account
web3.eth.defaultAccount = '0x8888f1f195afa192cfee860698584c030f4c9db1';

2.18.2 defaultBlock

接口：

web3.eth.defaultBlock

web3.eth.defaultBlock

此默认块用于以下方法（可选择通过传递 defaultBlock 参数来覆盖它）：

web3.eth.getBalance()
web3.eth.getCode()
web3.eth.getTransactionCount()
web3.eth.getStorageAt()
web3.eth.call()
contract.myMethod.call()
contract.myMethod.estimateGas()

值：

默认块参数可以是以下之一：

Number - 一个区块号
String - "earliest", 创世区块
String - "latest", 最新的块（区块链的当前区块）
String - "pending", 当前挖掘的块（包括待处理的交易）默认是最新的

返回值：

Number|String, 查询状态时使用的默认区块编号。

示例：

var defaultBlock = web3.eth.defaultBlock;
console.log(defaultBlock); // 'latest'
// set the default block
web3.eth.defaultBlock = 231;

2.18.3 syncing/getSyncing

接口：
web3.eth.syncing

web3.eth.syncing
// or async
web3.eth.getSyncing(callback(error, result){ ... })

此属性是只读的，并在节点同步或返回 false 时返回同步对象。

返回值：
Object|Boolean - 当节点当前正在同步或假时，同步对象如下：

startingBlock: Number - 同步开始的区块编号。
currentBlock: Number - 区块编号，节点当前已同步到哪个区块。
highestBlock: Number - 要同步的预期区块编号。

示例：

var sync = web3.eth.syncing;
console.log(sync);
/*
{
  startingBlock: 300,
  currentBlock: 312,
  highestBlock: 512
}
*/

2.18.4 isSyncing

接口：

web3.eth.isSyncing

web3.eth.isSyncing(callback);

每次同步开始，更新和停止时，此便捷功能都会调用回调。

返回值：

Object - 一个 isSyncing 对象，具有以下方法：

syncing.addCallback(): 添加另一个回调，当节点启动或停止同步时将调用该回调。
syncing.stopWatching(): 停止同步回调。

回调返回值

Boolean - 当同步开始时，回调将被触发为 true，而当它停止时，回调将被触发。
Object - 同步时它将返回同步对象：
- startingBlock: Number - 同步开始的区块编号。
- currentBlock: Number - 区块编号，节点当前已同步到哪个区块。
- highestBlock: Number - 要同步的预期区块编号。

示例：

web3.eth.isSyncing(function(error, sync){
   if(!error) {
       // stop all app activity
       if(sync === true) {
          // we use `true`, so it stops all filters, but not the web3.eth.syncing polling
          web3.reset(true);
       
       // show sync info
       } else if(sync) {
          console.log(sync.currentBlock);
       
       // re-gain app operation
       } else {
           // run your app init function...
       }
   }
});

2.18.5 coinbase/getCoinbase

接口：

web3.eth.coinbase

web3.eth.coinbase
// or async
web3.eth.getCoinbase(callback(error, result){ ... })

此属性是只读的，并返回采矿奖励所在的 coinbase 地址。

返回值：

String - 客户的 coinbase 地址。

示例：

var coinbase = web3.eth.coinbase;
console.log(coinbase); // "0x407d73d8a49eeb85d32cf465507dd71d507100c1"

2.18.6 hashrate/getHashrate

接口：

web3.eth.hashrate

web3.eth.hashrate
// or async
web3.eth.getHashrate(callback(error, result){ ... })

此属性是只读的，并返回节点挖掘的每秒哈希数。

返回值：

Number - 每秒哈希数。

示例：

var hashrate = web3.eth.hashrate;
console.log(hashrate); // 493736

2.18.7 gasPrice/getGasPrice

接口：

web3.eth.gasPrice

web3.eth.gasPrice
// or async
web3.eth.getGasPrice(callback(error, result){ ... })

此属性为只读并返回当前的 gas 价格。gas 价格由 x 个最新区块中位数 gas 价格决定。

返回值：

Number - 以 Wei 为单位的当前 gas 价格的 BigNumber 实例。请参阅 BigNumber 上的注释。

示例：

var gasPrice = web3.eth.gasPrice;
console.log(gasPrice.toString(10)); // "10000000000000"

2.18.8 accounts/getAccounts

接口：

web3.eth.accounts

web3.eth.accounts
// or async
web3.eth.getAccounts(callback(error, result){ ... })

此属性是只读的，并返回节点控制的帐户列表。

返回值：

Array - 由客户端控制的地址数组。

示例：

var accounts = web3.eth.accounts;
console.log(accounts); // ["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]

2.18.9 mining/getMining

接口：

web3.eth.mining

web3.eth.mining
// or async
web3.eth.getMining(callback(error, result){ ... })

此属性是只读的，并说明节点是否正在挖矿中。

返回值：

Boolean - 如果客户端正在挖矿，则为 true，否则为 false。

示例：

var mining = web3.eth.mining;
console.log(mining); // true or false

2.18.10 blockNumber/getBlockNumber

接口：

web3.eth.blockNumber

web3.eth.blockNumber
// or async
web3.eth.getBlockNumber(callback(error, result){ ... })

此属性是只读的，并返回当前区块编号。

返回值：

Number - 最近区块的编号。

示例：

var number = web3.eth.blockNumber;
console.log(number); // 2744

2.18.11 register(hexString) (Not implemented yet)

接口：

web3.eth.register

web3.eth.register(addressHexString [, callback])

（尚未实现）注册要包含在 web3.eth.accounts 中的给定地址。这允许非私有密钥拥有的帐户被关联为拥有帐户（例如，合约钱包）。

参数：

String - 要注册的地址
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

示例：

web3.eth.register("0x407d73d8a49eeb85d32cf465507dd71d507100ca")

2.18.12 unRegister(hexString) (Not implemented yet)

接口：
web3.eth.unRegister

web3.eth.unRegister(addressHexString [, callback])

（尚未实施）取消注册给定地址。

参数：

String - 要取消注册的地址
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

示例：

web3.eth.unregister("0x407d73d8a49eeb85d32cf465507dd71d507100ca")

2.18.13 getBalance(address)

接口：

web3.eth.getBalance

web3.eth.getBalance(addressHexString [, defaultBlock] [, callback])

获取给定区块的地址余额。

参数：

String - 获得余额的地址。
Number|String - （可选）如果传递此参数，则不会使用 web3.eth.defaultBlock 设置的默认区块。
Function - 方法 - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信

返回值：

String - wei 中给定地址的当前余额的 BigNumber 实例。请参阅 BigNumber 上的注释。

示例：

var balance = web3.eth.getBalance("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(balance); // instanceof BigNumber
console.log(balance.toString(10)); // '1000000000000'
console.log(balance.toNumber()); // 1000000000000

2.18.14 getStorageAt(address, position)

接口：

web3.eth.getStorageAt

web3.eth.getStorageAt(addressHexString, position [, defaultBlock] [, callback])

将存储空间放在地址的特定位置。

参数：

String - 从中获取存储的地址。
Number - 存储的索引位置。
Number|String - （可选）如果传递此参数，则不会使用 web3.eth.defaultBlock 设置的默认区块。
Function - 方法 - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信

返回值：

String - 给定位置的存储值。

示例：

var state = web3.eth.getStorageAt("0x407d73d8a49eeb85d32cf465507dd71d507100c1", 0);
console.log(state); // "0x03"

2.18.15 getCode(address)

接口：

web3.eth.getCode

web3.eth.getCode(addressHexString [, defaultBlock] [, callback])

获取特定地址的代码。

参数：

String - 从中获取代码的地址。
Number|String - （可选）如果传递此参数，则不会使用 web3.eth.defaultBlock 设置的默认区块。
Function - 方法 - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信

返回值：

String - 给定地址 addressHexString 的数据。

示例：

var code = web3.eth.getCode("0xd5677cf67b5aa051bb40496e68ad359eb97cfbf8");
console.log(code); // "0x600160008035811a818181146012578301005b601b6001356025565b8060005260206000f25b600060078202905091905056"

2.18.16 getBlock(hash/number)

接口：

web3.eth.getBlock

web3.eth.getBlock(blockHashOrBlockNumber [, returnTransactionObjects] [, callback])

返回与区块编号或块哈希匹配的区块。

参数：

String|Number - 区块号或散列。或者是默认区块参数中的字符串 “earliest”，“latest” 或 “pending”。
Boolean - （可选，默认为 false）如果为 true，则返回的区块将包含所有事务作为对象，如果为 false，则仅包含交易哈希。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信

返回值：

Object - 区块对象：

number: Number - 区块号。其挂起块时为 null。
hash: String, 32 Bytes - 区块的哈希值。其挂起块时为 null。
parentHash: String, 32 Bytes - 父区块的哈希值。
nonce: String, 8 Bytes - 生成的工作证明的哈希值。其挂起块时为 null。
sha3Uncles: String, 32 Bytes - 区块中的 uncle 数据的 SHA3。
logsBloom: String, 256 Bytes - 区块的日志的 bloom 过滤器。其挂起块时为 null。
transactionsRoot: String, 32 Bytes - 区块的交易 trie 的根.
stateRoot: String, 32 Bytes - 区块的最终状态 trie 的根。
miner: String, 20 Bytes - 获得采矿奖励的受益人的地址。
difficulty: BigNumber - 这个区块的难度的整数。
totalDifficulty: BigNumber - 链的总难度的整数，直到这个区块。
extraData: String - 该块的“额外数据”字段。
size: Number - 整数这个区块的大小（以字节为单位）。
gasLimit: Number - 该区块允许的最大 gas 量。
gasUsed: Number - 此区块中所有交易的总使用 gas。
timestamp: Number - 整理块时的 unix 时间戳。
transactions: Array - 交易对象的数组，或 32 字节交易哈希，具体取决于最后给定的参数。
uncles: Array - 一堆叔叔哈希。

示例：

var info = web3.eth.getBlock(3150);
console.log(info);
/*
{
 "number": 3,
 "hash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
 "parentHash": "0x2302e1c0b972d00932deb5dab9eb2982f570597d9d42504c05d9c2147eaf9c88",
 "nonce": "0xfb6e1a62d119228b",
 "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
 "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
 "transactionsRoot": "0x3a1b03875115b79539e5bd33fb00d8f7b7cd61929d5a3c574f507b8acf415bee",
 "stateRoot": "0xf1133199d44695dfa8fd1bcfe424d82854b5cebef75bddd7e40ea94cda515bcb",
 "miner": "0x8888f1f195afa192cfee860698584c030f4c9db1",
 "difficulty": BigNumber,
 "totalDifficulty": BigNumber,
 "size": 616,
 "extraData": "0x",
 "gasLimit": 3141592,
 "gasUsed": 21662,
 "timestamp": 1429287689,
 "transactions": [
   "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b"
 ],
 "uncles": []
}
*/

2.18.17 getBlockTransactionCount(hash/number)

接口：

web3.eth.getBlockTransactionCount

web3.eth.getBlockTransactionCount(hashStringOrBlockNumber [, callback])

返回给定区块中的交易数。

参数：

String|Number - 区块号或散列。或者是默认区块参数中的字符串 “earliest”，“latest” 或 “pending”。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信

返回值：

Number - 给定区块中的交易数。

示例：

var number = web3.eth.getBlockTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(number); // 1

2.18.18 getUncle(hash/number)

接口：

web3.eth.getUncle

web3.eth.getUncle(blockHashStringOrNumber, uncleNumber [, returnTransactionObjects] [, callback])

按给定的叔叔索引位置返回一个区块叔叔。

参数：

String|Number - 区块号或散列。或者是默认区块参数中的字符串 “earliest”，“latest” 或 “pending”。
Number - 叔区块的索引位置。
Boolean - （可选，默认为 false）如果为 true，则返回的区块将包含所有事务作为对象，如果为 false，则仅包含交易哈希。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信

返回值：

Object - 返回的的叔区块。有关返回值，请参阅 web3.eth.getBlock()。注意：叔区块不包含单个交易。

示例：

var uncle = web3.eth.getUncle(500, 0);
console.log(uncle); // see web3.eth.getBlock

2.18.19 getBlockUncleCount(hash/number)

2.18.20 getTransaction(hash)

接口：

web3.eth.getTransaction

web3.eth.getTransaction(transactionHash [, callback])

返回与给定交易哈希匹配的事务。

参数：

String - 交易哈希。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

Object - 一个交易对象，它的哈希是 transactionHash：

hash: String, 32 Bytes - 交易的哈希值。
nonce: Number - 发送者在此之前进行的交易次数。
blockHash: String, 32 Bytes - 此交易所在的区块的哈希值。当其挂起时为 null。
blockNumber: Number - 此事务所在的区块编号。当其挂起时为 null。
transactionIndex: Number - 区块中交易索引位置的整数。当它挂起时为 null。
from: String, 20 Bytes - 发送者的地址。
to: String, 20 Bytes - 接收者的地址。合同创建交易时为 null。
value: BigNumber - 以 Wei 为单位，表示转发多少个 Wei。
gasPrice: BigNumber - 发送者提供的 gas 价格。
gas: Number - 发送者提供的 gas。
input: String - 与交易一起发送的数据。

示例：

var transaction = web3.eth.getTransaction('0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b');
console.log(transaction);
/*
{
 "hash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
 "nonce": 2,
 "blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
 "blockNumber": 3,
 "transactionIndex": 0,
 "from": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
 "to": "0x6295ee1b4f6dd65047762f924ecd367c17eabf8f",
 "value": BigNumber,
 "gas": 314159,
 "gasPrice": BigNumber,
 "input": "0x57cb2fc4"
}
*/

2.18.21 getTransactionFromBlock(hashOrNumber, indexNumber)

接口：

web3.eth.getTransactionFromBlock

getTransactionFromBlock(hashStringOrNumber, indexNumber [, callback])

返回基于区块哈希或数字以及交易索引位置的交易。

参数：

String|Number - 区块号或散列。或者是默认区块参数中的字符串 “earliest”，“latest” 或 “pending”。
Number - 交易索引。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

Object - 交易对象，参考 web3.eth.getTransaction。

示例：

var transaction = web3.eth.getTransactionFromBlock('0x4534534534', 2);
console.log(transaction); // see web3.eth.getTransaction

2.18.22 getTransactionReceipt(hash)

接口：

web3.eth.getTransactionReceipt

web3.eth.getTransactionReceipt(hashString [, callback])

按交易哈希返回的交易回执。请注意，交易回执不适用于待处理的交易。

参数：

String - 交易哈希。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

Object - 交易回执对象，当交易回执不存在时返回 null。

blockHash: String, 32 Bytes - 此交易所在的块的哈希值。
blockNumber: Number - 此交易所在的区号。
transactionHash: String, 32 Bytes - 交易的哈希值。
transactionIndex: Number - 区块中交易索引位置的整数。
from: String, 20 Bytes - 发送者的地址。
to: String, 20 Bytes - 接收者的地址。合同创建交易时为 null。
cumulativeGasUsed : Number - 在区块中执行此交易时使用的总 gas。
gasUsed : Number - 仅此特定交易所使用的 gas。
contractAddress : String - 20 Bytes - 如果交易是创建合约，则创建合约地址，否则为 null。
logs : Array - 此交易生成的日志对象数组。
status : String - '0x0' 表示交易失败，'0x1' 表示交易成功。

示例：

var receipt = web3.eth.getTransactionReceipt('0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b');
console.log(receipt);
{
  "transactionHash": "0x9fc76417374aa880d4449a1f7f31ec597f00b1f6f3dd2d66f4c9c6c445836d8b",
  "transactionIndex": 0,
  "blockHash": "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46",
  "blockNumber": 3,
  "contractAddress": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
  "cumulativeGasUsed": 314159,
  "gasUsed": 30234,
  "logs": [{
         // logs as returned by getFilterLogs, etc.
     }, ...],
  "status": "0x1"
}

2.18.23 getTransactionCount(address)

接口：

web3.eth.getTransactionCount

web3.eth.getTransactionCount(addressHexString [, defaultBlock] [, callback])

获取从此地址发送的交易数量。

参数：

String - 从中获取交易数量的地址。
String|Number - 区块号或散列。或者是默认区块参数中的字符串 “earliest”，“latest” 或 “pending”。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

Number - 从给定地址发送的交易数。

示例：

var number = web3.eth.getTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(number); // 1

2.18.24 sendTransaction(object)

接口：

web3.eth.sendTransaction

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

向网络中发送一笔交易。

参数：

Object - 待发送的交易对象。

from: String - 发送帐户的地址。如果未指定，则使用 web3.eth.defaultAccount 属性。
to: String - （可选）消息的目标地址，未定义合同创建交易。
value: Number|String|BigNumber - （可选）以 Wei 为单位进行币转移的交易，如果是合约创建交易，也是捐赠。
gas: Number|String|BigNumber - （可选，默认：待定）用于交易的 gas（未使用的 gas 退还）。
gasPrice: Number|String|BigNumber - （可选，默认：待定）此交易的 gas 价格在 wei 中，默认为平均网络 gas 价格。
data: String - （可选）包含消息的关联数据的字节字符串，或者在合同创建交易的情况下，是初始化代码。
nonce: Number - （可选）随机数的整数。这允许覆盖使用相同 nonce 的自己的挂起交易。

Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

String - 32 字节交易哈希为 HEX 字符串。如果交易是合同创建，则使用 web3.eth.getTransactionReceipt() 获取合同地址，在交易被挖掘之后。

示例：

// compiled solidity source code using https://chriseth.github.io/cpp-ethereum/
var code = "603d80600c6000396000f3007c01000000000000000000000000000000000000000000000000000000006000350463c6888fa18114602d57005b6007600435028060005260206000f3";
web3.eth.sendTransaction({data: code}, function(err, transactionHash) {
 if (!err)
   console.log(transactionHash); // "0x7f9fade1c0d57a7af66ab4ead7c2eb7b11a91385"
});

2.18.25 sendRawTransaction(object)

接口：

web3.eth.sendRawTransaction

web3.eth.sendRawTransaction(signedTransactionData [, callback])

发送已签名的交易。例如，可以使用以下命令进行签名：https：//github.com/SilentCicero/ethereumjs-accounts

参数：

String - 以 HEX 格式签署的交易数据。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

String - 32 字节交易哈希为 HEX 字符串。如果交易是合约创建，则使用 web3.eth.getTransactionReceipt() 获取合约地址，在交易被挖掘之后。

示例：

var Tx = require('ethereumjs-tx');
var privateKey = new Buffer('e331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109', 'hex')
var rawTx = {
 nonce: '0x00',
 gasPrice: '0x09184e72a000', 
 gasLimit: '0x2710',
 to: '0x0000000000000000000000000000000000000000', 
 value: '0x00', 
 data: '0x7f7465737432000000000000000000000000000000000000000000000000000000600057'
}
var tx = new Tx(rawTx);
tx.sign(privateKey);
var serializedTx = tx.serialize();
//console.log(serializedTx.toString('hex'));
//f889808609184e72a00082271094000000000000000000000000000000000000000080a47f74657374320000000000000000000000000000000000000000000000000000006000571ca08a8bbf888cfa37bbf0bb965423625641fc956967b81d12e23709cead01446075a01ce999b56a8a88504be365442ea61239198e23d1fce7d00fcfc5cd3b44b7215f
web3.eth.sendRawTransaction('0x' + serializedTx.toString('hex'), function(err, hash) {
 if (!err)
   console.log(hash); // "0x7f9fade1c0d57a7af66ab4ead79fade1c0d57a7af66ab4ead7c2c2eb7b11a91385"
});

2.18.26 sign(object)

接口：

web3.eth.sign

web3.eth.sign(address, dataToSign, [, callback])

从特定帐户签署数据。此帐户需要解锁。

参数：

String - 要签名的地址。
String - 要签名的数据。
Function - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

String - 签名数据。在十六进制前缀之后，字符对应于 ECDSA 值，如下所示：

r = signature[0:64]
s = signature[64:128]
v = signature[128:130]

请注意，如果使用的是 ecrecover，则 v 将为 “00” 或 “01”。因此，为了使用此值，必须将其解析为整数然后再添加 27.这将导致 27 或 28。

示例：

var result = web3.eth.sign("0x135a7de83802408321b74c322f8558db1679ac20",
   "0x9dd2c369a187b4e6b9c402f030e50743e619301ea62aa4c0737d4ef7e10a3d49"); // second argument is web3.sha3("xyz")
console.log(result); // "0x30755ed65396facf86c53e6217c52b4daebe72aa4941d89635409de4c9c7f9466d4e9aaec7977f05e923889b33c0d0dd27d7226b6e6f56ce737465c5cfd04be400"

2.18.27 call(object)

接口：

web3.eth.call

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

执行消息调用交易，该交易直接在节点的 VM 中执行，但从未开采到区块链中。

参数：

Object - 交易对象参见 web3.eth.sendTransaction，区别在于对于调用，from 属性也是可选的。
Number|String - （可选）如果传递此参数，则不会使用 web3.eth.defaultBlock 设置的默认区块。
Function - 方法 - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信

返回值：

String - 返回调用的结果，例如代码函数返回值。

示例：

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

2.18.28 estimateGas(object)

接口：

web3.eth.estimateGas

web3.eth.estimateGas(callObject [, callback])

执行消息调用或交易，它直接在节点的 VM 中执行，但从未开采到区块链中并返回使用的 gas 量。

参数：

请参阅 web3.eth.sendTransaction，但所有属性都是可选的。

返回值：

Number - 用于模拟调用/交易的用过的 gas。

示例：

var result = web3.eth.estimateGas({
   to: "0xc4abd0339eb8d57087278718986382264244252f", 
   data: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000003"
});
console.log(result); // "0x0000000000000000000000000000000000000000000000000000000000000015"

2.18.29 filter(array (, options)

watch(callback)
stopWatching(callback)
get()

// can be 'latest' or 'pending'
var filter = web3.eth.filter(filterString);
// OR object are log filter options
var filter = web3.eth.filter(options);
// watch for changes
filter.watch(function(error, result){
 if (!error)
   console.log(result);
});
// Additionally you can start watching right away, by passing a callback:
web3.eth.filter(options, function(error, result){
 if (!error)
   console.log(result);
});

参数：

String|Object - 字符串 “latest” 或 “pending” 分别用于监视最新区块或待处理交易中的更改。或者过滤器选项对象如下：

fromBlock: Number|String - 最早的区块的数量（latest 可能是指最近和 pending 当前挖掘区块）。默认情况下 latest。
toBlock: Number|String - 最新区块的编号（latest 可能表示最近和 pending 当前挖掘块）。默认情况下 latest。
address: String - 仅从特定帐户获取日志的地址或地址列表。
topics: Array of Strings - 必须各自出现在日志条目中的值数组。顺序很重要，如果想要将主题留出使用 null，例如[null，'0x00 ...']。还可以为每个主题传递另一个数组，其中包含该主题的选项，例如[null，['option1'，'option2']]

返回值：

Object - 具有以下方法的过滤器对象：

filter.get(callback): 返回适合过滤器的所有日志条目。
filter.watch(callback): 监视适合过滤器的状态更改并调用回调。请参阅此处说明以获取详细信息。
filter.stopWatching(): 停止监视并卸载节点中的过滤器。一旦完成，应始终调用。

观察回调返回值：

String - 使用 “latest” 参数时，它返回最后一个传入区块的区块哈希。
String - 使用 “pending” 参数时，它返回最近挂起交易的交易哈希。
Object - 使用手动过滤器选项时，它返回一个日志对象，如下所示：
- logIndex: Number - 区块中日志索引位置的整数。其挂起日志时为 null。
- transactionIndex: Number - 从中创建了交易索引位置日志的整数。其挂起日志时为 null。
- transactionHash: String, 32 Bytes - 此日志创建的事务的哈希值。其挂起日志时为 null。
- blockHash: String, 32 Bytes - 此日志所在区块的哈希值。当其挂起时为 null。其挂起日志时为 null。
- blockNumber: Number - 此日志所在的区块编号。当其挂起时为 null。其挂起日志时为 null。
- address: String, 32 Bytes - 此日志源自的地址。
- data: String - 包含日志的一个或多个32字节非索引参数。
- topics: Array of Strings - 索引日志参数的 0 到 4 32 字节数组。（实际上：第一个主题是事件签名的哈希值（例如Deposit（address，bytes32，uint256）），除非使用匿名说明符声明了事件。）
- type: STRING - 日志挂起时 pending。如果已经开采了日志，则 mined。注意有关事件筛选器返回值，请参阅合约事件。

示例：

var filter = web3.eth.filter({toBlock:'pending'});
filter.watch(function (error, log) {
 console.log(log); //  {"address":"0x0000000000000000000000000000000000000000", "data":"0x0000000000000000000000000000000000000000000000000000000000000000", ...}
});
// get all past logs again.
var myResults = filter.get(function(error, logs){ ... });
...
// stops and uninstalls the filter
filter.stopWatching();

2.18.30 Contract(abiArray)

接口：

web3.eth.contract

web3.eth.contract(abiArray)

为Solidity合约创建合约对象，该对象可用于在地址上启动合约。可以在此处阅读最新有关事件的更多信。

参数：

Object - 合约对象，可以按如下方式启动：

var MyContract = web3.eth.contract(abiArray);
// instantiate by address
var contractInstance = MyContract.at(address);
// deploy new contract
var contractInstance = MyContract.new([constructorParam1] [, constructorParam2], {data: '0x12345...', from: myAccount, gas: 1000000});
// Get the data to deploy the contract manually
var contractData = MyContract.new.getData([constructorParam1] [, constructorParam2], {data: '0x12345...'});
// contractData = '0x12345643213456000000000023434234'

然后，可以在地址上启动现有合约，或使用已编译的字节代码部署合约：

// Instantiate from an existing address:
var myContractInstance = MyContract.at(myContractAddress);
// Or deploy a new contract:
// Deploy the contract asynchronous from Solidity file:
...
const fs = require("fs");
const solc = require('solc')
let source = fs.readFileSync('nameContract.sol', 'utf8');
let compiledContract = solc.compile(source, 1);
let abi = compiledContract.contracts['nameContract'].interface;
let bytecode = compiledContract.contracts['nameContract'].bytecode;
let gasEstimate = web3.eth.estimateGas({data: bytecode});
let MyContract = web3.eth.contract(JSON.parse(abi));
var myContractReturned = MyContract.new(param1, param2, {
  from:mySenderAddress,
  data:bytecode,
  gas:gasEstimate}, function(err, myContract){
   if(!err) {
      // NOTE: The callback will fire twice!
      // Once the contract has the transactionHash property set and once its deployed on an address.
       // e.g. check tx hash on the first call (transaction send)
      if(!myContract.address) {
          console.log(myContract.transactionHash) // The hash of the transaction, which deploys the contract
      
      // check address on the second call (contract deployed)
      } else {
          console.log(myContract.address) // the contract address
      }
       // Note that the returned "myContractReturned" === "myContract",
      // so the returned "myContractReturned" object will also get the address set.
   }
 });
// Deploy contract syncronous: The address will be added as soon as the contract is mined.
// Additionally you can watch the transaction by using the "transactionHash" property
var myContractInstance = MyContract.new(param1, param2, {data: bytecode, gas: 300000, from: mySenderAddress});
myContractInstance.transactionHash // The hash of the transaction, which created the contract
myContractInstance.address // undefined at start, but will be auto-filled later

示例：

// contract abi
var abi = [{
    name: 'myConstantMethod',
    type: 'function',
    constant: true,
    inputs: [{ name: 'a', type: 'string' }],
    outputs: [{name: 'd', type: 'string' }]
}, {
    name: 'myStateChangingMethod',
    type: 'function',
    constant: false,
    inputs: [{ name: 'a', type: 'string' }, { name: 'b', type: 'int' }],
    outputs: []
}, {
    name: 'myEvent',
    type: 'event',
    inputs: [{name: 'a', type: 'int', indexed: true},{name: 'b', type: 'bool', indexed: false}]
}];
// creation of contract object
var MyContract = web3.eth.contract(abi);
// initiate contract for an address
var myContractInstance = MyContract.at('0xc4abd0339eb8d57087278718986382264244252f');
// call constant function
var result = myContractInstance.myConstantMethod('myParam');
console.log(result) // '0x25434534534'
// send a transaction to a function
myContractInstance.myStateChangingMethod('someParam1', 23, {value: 200, gas: 2000});
// short hand style
web3.eth.contract(abi).at(address).myAwesomeMethod(...);
// create filter
var filter = myContractInstance.myEvent({a: 5}, function (error, result) {
 if (!error)
   console.log(result);
   /*
   {
       address: '0x8718986382264244252fc4abd0339eb8d5708727',
       topics: "0x12345678901234567890123456789012", "0x0000000000000000000000000000000000000000000000000000000000000005",
       data: "0x0000000000000000000000000000000000000000000000000000000000000001",
       ...
   }
   */
});

2.18.31 contract.myMethod()

接口：

Contract Methods

// Automatically determines the use of call or sendTransaction based on the method type
myContractInstance.myMethod(param1 [, param2, ...] [, transactionObject] [, defaultBlock] [, callback]);
// Explicitly calling this method
myContractInstance.myMethod.call(param1 [, param2, ...] [, transactionObject] [, defaultBlock] [, callback]);
// Explicitly sending a transaction to this method
myContractInstance.myMethod.sendTransaction(param1 [, param2, ...] [, transactionObject] [, callback]);
// Get the call data, so you can call the contract through some other means
// var myCallData = myContractInstance.myMethod.request(param1 [, param2, ...]);
var myCallData = myContractInstance.myMethod.getData(param1 [, param2, ...]);
// myCallData = '0x45ff3ff6000000000004545345345345..'

合约对象公开合约的方法，可以使用参数和交易对象调用这些方法。

参数：

String|Number|BigNumber - （可选）零个或多个函数参数。如果传入一个字符串，则必须将其格式化为十六进制数字，例如 “0xdeadbeef” 如果已经创建了 BigNumber 对象，那么也可以通过它。
Object - （可选）（previous）last 参数可以是交易对象，有关详细信息，请参阅 web3.eth.sendTransaction 参数 1。注意：不会考虑 data 和 to 属性。
Number|String - （可选）如果传递此参数，则不会使用 web3.eth.defaultBlock 设置的默认区块。
Function - 方法 - （可选）如果传递回调，则 HTTP 请求将成为异步。请参阅此处说明以获取详细信息。

返回值：

String - 如果它调用结果数据，如果是发送交易的创建合约地址或交易哈希，请参阅 web3.eth.sendTransaction 以获取详细信息。

示例：

// creation of contract object
var MyContract = web3.eth.contract(abi);
// initiate contract for an address
var myContractInstance = MyContract.at('0x78e97bcc5b5dd9ed228fed7a4887c0d7287344a9');
var result = myContractInstance.myConstantMethod('myParam');
console.log(result) // '0x25434534534'
myContractInstance.myStateChangingMethod('someParam1', 23, {value: 200, gas: 2000}, function(err, result){ ... });

2.18.32 contract.myEvent()

接口：

Contract Events

var event = myContractInstance.MyEvent({valueA: 23} [, additionalFilterObject])
// watch for changes
event.watch(function(error, result){
if (!error)
console.log(result);
});
// Or pass a callback to start watching immediately
var event = myContractInstance.MyEvent([{valueA: 23}] [, additionalFilterObject] , function(error, result){
if (!error)
console.log(result);
});

可以使用过滤器等事件，它们具有相同的方法，但可以传递不同的对象来创建事件过滤器。

参数：

Object - 要过滤日志的索引返回值，例如{'valueA'：1，'valueB'：[myFirstAddress，mySecondAddress]}。默认情况下，所有过滤器值都设置为 null。这意味着，它们将匹配从此合同发送的任何给定类型的事件。
Object - 其他过滤选项，请参阅用过滤器参数 1了解更多信息默认情况下，filterObject 将字段 “address” 设置为合约的地址。第一个主题是事件的签名。
Function - （可选）如果将回调作为最后一个参数传递，它将立即开始监听，无需调用 myEvent.watch(function(){})。请参阅此处说明以获取详细信息。

回调返回值：

Object - 一个事件对象如下：

address: String, 32 Bytes - 此日志源自的地址。
args: Object - 来自事件的参数。
blockHash: String, 32 Bytes - 此日志所在区块的哈希值。当其挂起时为 null。
blockNumber: Number - 此日志所在的区块编号。当其挂起时为 null。
logIndex: Number - 区块中日志索引位置的整数。
event: String - 事件名称。
removed: bool - 指示此事件创建的交易是否已从区块链中删除（由于孤立块）或从未到达（由于拒绝交易）。
transactionIndex: Number - 从中创建了交易索引位置日志的整数。
transactionHash: String, 32 Bytes - 此日志创建的交易的哈希值。

示例：

var MyContract = web3.eth.contract(abi);
var myContractInstance = MyContract.at('0x78e97bcc5b5dd9ed228fed7a4887c0d7287344a9');
// watch for an event with {some: 'args'}
var myEvent = myContractInstance.MyEvent({some: 'args'}, {fromBlock: 0, toBlock: 'latest'});
myEvent.watch(function(error, result){
  ...
});
// would get all past logs again.
var myResults = myEvent.get(function(error, logs){ ... });
...
// would stop and uninstall the filter
myEvent.stopWatching();

2.18.33 contract.allEvents()

接口：

Contract allEvents

var events = myContractInstance.allEvents([additionalFilterObject]);
// watch for changes
events.watch(function(error, event){
 if (!error)
   console.log(event);
});
// Or pass a callback to start watching immediately
var events = myContractInstance.allEvents([additionalFilterObject], function(error, log){
 if (!error)
   console.log(log);
});

将为此合约创建的所有事件调用回调。

参数：

Object - 其他过滤选项，请参阅用过滤器参数 1了解更多信息默认情况下，filterObject 将字段 “address” 设置为合约的地址。第一个主题是事件的签名。
Function - （可选）如果将回调作为最后一个参数传递，它将立即开始监听，无需调用 myEvent.watch(function(){})。请参阅此处说明以获取详细信息。

回调返回值：

Object - 参考 Contract Events。

示例：

var MyContract = web3.eth.contract(abi);
var myContractInstance = MyContract.at('0x78e97bcc5b5dd9ed228fed7a4887c0d7287344a9');
// watch for an event with {some: 'args'}
var events = myContractInstance.allEvents({fromBlock: 0, toBlock: 'latest'});
events.watch(function(error, result){
  ...
});
// would get all past logs again.
events.get(function(error, logs){ ... });
...
// would stop and uninstall the filter
events.stopWatching();

2.18.34 getCompilers()

2.18.35 compile.lll(string)

2.18.35 compile.solidity(string)

2.18.36 compile.serpent(string)

2.18.37 namereg

2.18.38 sendIBANTransaction

2.18.39 iban

2.18.39.1 fromAddress

2.18.39.2 fromBban

2.18.39.3 createIndirect

2.18.39.4 isValid

2.18.39.5 isDirect

2.18.39.6 isIndirect

2.18.39.7 checksum

2.18.39.8 institution

2.18.39.9 client

2.18.38.10 address

2.18.38.11 toString

2.19 db

2.19.1 putString(name, key, value)

2.19.2 getString(- var rXArray = stringToNumberArray(form.rX.value); name, key)

2.19.3 putHex(name, key, value)

2.19.4 getHex(name, key)

2.20 shh

2.20.1 post(postObject)

2.20.2 newIdentity()

2.20.3 hasIdentity(hexString)

2.20.4 newGroup(_id, _who)

2.20.5 addToGroup(_id, _who)

2.20.6 filter(object/string)

2.20.6.1 watch(callback)

2.20.6.2 stopWatching(callback)

2.20.6.3 get(callback)

项目源代码

项目源代码会逐步上传到 Github，地址为 https://github.com/windstamp/jsonrpc。

Contributor

Windstamp, https://github.com/windstamp

Reference

https://github.com/ethereum/wiki/wiki/JavaScript-API
https://github.com/ethereum/web3.js
https://web3js.readthedocs.io/en/1.0/index.html
https://github.com/ethereum/wiki/wiki/JSON-RPC
https://github.com/ethereum/web3.js/tree/master/example
https://github.com/ethereum/wiki/wiki/Useful-%C3%90app-Patterns#examples
https://github.com/ethereum/wiki/wiki/web3js-api-reference
http://fredkschott.com/post/2014/03/understanding-error-first-callbacks-in-node-js/
https://github.com/MikeMcl/bignumber.js/
https://web3.learnblockchain.cn/0.2x.x/

3.1 web3.js at version 0.2x.x

Web3 JavaScript app API for 0.2x.x

1. 开始

1.1 安装 web3

1.2 使用回调

1.3 批处理请求

1.4 关于web3.js中大数字的说明

2. Web3.js API Reference

2.1 web3

2.2 version

2.2.1 api

接口：

返回值：

示例：

2.2.2 node/getNode

接口：

返回值：

2.2.3 network/getNetwork

接口：

返回值：

示例：

2.2.4 ethereum/getEthereum

接口：

2.2.5 whisper/getWhisper

接口：

返回值：

示例：

2.3 isConnected()

接口：

参数：

返回值

2.4 setProvider(provider)

接口：

参数：

返回值

2.5 currentProvider

接口：

返回值：

示例：

2.6 reset()

接口：

参数：

返回值：

示例：

2.7 sha3(string, options)

接口：

参数：

返回值：

示例：

2.8 toHex(stringOrNumber)

接口：

参数：

返回值：

示例：

2.9 toAscii(hexString)

接口：

参数：

示例：

2.10 fromAscii(textString)

接口：

参数：

返回值：

示例：

2.11 toDecimal(hexString)

接口：

参数：

示例：

2.12 fromDecimal(number)

接口：

参数：

返回值：

示例：

2.13 fromWei(numberStringOrBigNumber, unit)

接口：

参数：

返回值：

示例：

2.14 toWei(numberStringOrBigNumber, unit)

参数：

返回值：