Web3 JavaScriptÐappAPI
为了让您的应用程序能够在以太坊上工作，您可以使用web3.js库web3提供的对象。在底层，它通过RPC调用与本地节点通信。web3.js与任何暴露RPC层的以太坊节点一起工作。
web3包含eth对象 - web3.eth（专门用于以太坊区块链交互）和shh对象 - web3.shh（用于Whisper交互）。随着时间的推移，我们将介绍其他web3协议的其他对象。工作 示例可以在这里找到。
如果您想使用web3.js查看一些更复杂的示例，请查看这些有用的应用程序模式。
使用回调
由于此API旨在与本地RPC节点一起工作，并且其所有功能默认情况下都使用同步HTTP requests.con
如果你想做异步请求，你可以传递一个可选的回调函数作为最后一个参数。所有的回调函数都使用错误的第一个回调风格：
web3.eth.getBlock(48, function(error, result){
if(!error)
console.log(result)
else
console.error(error);
})
批量请求
批量请求允许排队请求并一次处理它们。
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();
关于web3.js中大数字的说明
您将始终得到一个平衡值的BigNumber对象，因为JavaScript无法正确处理大数字。看下面的例子：
"101010100324325345346456456456456456456"
// "101010100324325345346456456456456456456"
101010100324325345346456456456456456456
// 1.0101010032432535e+38
web3.js依赖于BigNumber库并自动添加它。
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个浮动点，因此建议，让你在总平衡伟，只把它转换为其他单位呈现给用户的时候：
var balance = new BigNumber('13124.234435346456466666457455567456');
balance.plus(21).toString(10); // toString(10) converts it to a number string, but can only show max 20 floating points
// "13145.23443534645646666646" // you number would be cut after the 20 floating point
Web3 JavascriptÐappAPI参考
- WEB3
- 版
- 已连接（）
- setProvider（供应商）
- currentProvider
- 重启（）
- 沙三段（串）
- toHex（stringOrNumber）
- toascii将（十六进制串）
- fromAscii（textString，[padding]）
- toDecimal（十六进制串）
- fromDecimal（数字）
- fromWei（numberStringOrBigNumber，unit）
- toWei（numberStringOrBigNumber，单位）
- toBigNumber（numberOrHexString）
- isAddress（十六进制串）
- 净
- ETH
- defaultAccount
- defaultBlock
- 同步/ getSyncing
- isSyncing
- coinbase / getCoinbase
- hashrate / getHashrate
- gasPrice / getGasPrice
- 账户/ getAccounts
- 采矿/ getMining
- blockNumber / getBlockNumber
- 寄存器（hexString）（尚未实现）
- unRegister（hexString）（尚未实现）
- 为getBalance（地址）
- getStorageAt（地址，位置）
- 引用代码（地址）
- getBlock（散列/数）
- getBlockTransactionCount（散列/数）
- getUncle（散列/数）
- getBlockUncleCount（散列/数）
- getTransaction（散）
- getTransactionFromBlock（hashOrNumber，indexNumber）
- getTransactionReceipt（散）
- getTransactionCount（地址）
- sendTransaction（对象）
- 呼叫（对象）
- estimateGas（对象）
- filter（array（，options））
- 合同（abiArray）
- contract.myMethod（）
- contract.myEvent（）
- contract.allEvents（）
- getCompilers（）
- compile.lll（串）
- compile.solidity（串）
- compile.serpent（串）
- namereg
- sendIBANTransaction
- IBAN
- D b
- 嘘
用法
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 its available before instantiating
var web3 = new Web3(new Web3.providers.HttpProvider("http://localhost:8545"));
web3.version.api
web3.version.api
// or async
web3.version.getApi(callback(error, result){ ... })
返回
String - 以太坊js api版本。
例
var version = web3.version.api;
console.log(version); // "0.2.0"
web3.version.client
web3.version.client
// or async
web3.version.getClient(callback(error, result){ ... })
返回
String - 客户机/节点版本。
例
var version = web3.version.client;
console.log(version); // "Mist/v0.9.3/darwin/go1.4.1"
web3.version.network
web3.version.network
// or async
web3.version.getNetwork(callback(error, result){ ... })
返回
String - 网络协议版本。
例
var version = web3.version.network;
console.log(version); // 54
web3.version.ethereum
web3.version.ethereum
// or async
web3.version.getEthereum(callback(error, result){ ... })
返回
String - 以太坊协议版本。
例
var version = web3.version.ethereum;
console.log(version); // 60
web3.version.whisper
web3.version.whisper
// or async
web3.version.getWhisper(callback(error, result){ ... })
返回
String - 耳语协议版本。
例
var version = web3.version.whisper;
console.log(version); // 20
web3.isConnected
web3.isConnected()
应该被调用来检查一个节点的连接是否存在
参数
没有
返回
Boolean
例
if(!web3.isConnected()) {
// show some dialog to ask the user to start a node
} else {
// start web3 filters, calls, etc
}
web3.setProvider
web3.setProvider(provider)
应该被称为设置提供者。
参数
没有
返回
undefined
例
web3.setProvider(new web3.providers.HttpProvider('http://localhost:8545')); // 8080 for cpp/AZ, 8545 for go/mist
web3.currentProvider
web3.currentProvider
将包含当前的提供者，如果有的话。这可以用来检查是否雾等已经提供商。
返回
Object- 提供者设置或null;
例
// Check if mist etc. already set a provider
if(!web3.currentProvider)
web3.setProvider(new web3.providers.HttpProvider("http://localhost:8545"));
web3.reset
web3.reset(keepIsSyncing)
应该调用重置web3的状态。重设除经理之外的所有事物 卸载所有过滤器。停止轮询。
参数
Boolean- 如果true它将卸载所有的过滤器，但将保持web3.eth.isSyncing（）民意调查
返回
undefined
例
web3.reset();
web3.sha3
web3.sha3(string [, callback])
参数
String- 使用SHA3算法进行散列的字符串Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
String - 给定数据的SHA3。
例
var str = web3.sha3("Some ASCII string to be hashed");
console.log(str); // "0x536f6d6520415343494920737472696e6720746f20626520686173686564"
var hash = web3.sha3(str);
console.log(hash); // "0xb21dbc7a5eb6042d91f8f584af266f1a512ac89520f43562c6c1e37eab6eb0c4"
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'
web3.toAscii
web3.toAscii(hexString);
将HEX字符串转换为ASCII字符串。
参数
String- 要转换为ASCII码的HEX字符串。
返回
String- 由给定的ASCII字符串组成hexString。
例
var str = web3.toAscii("0x657468657265756d000000000000000000000000000000000000000000000000");
console.log(str); // "ethereum"
web3.fromAscii
web3.fromAscii(string [, padding]);
将任何ASCII字符串转换为HEX字符串。
参数
String- 要转换为HEX的ASCII字符串。Number- 返回的HEX字符串应该有的字节数。
返回
String - 转换后的HEX字符串。
例
var str = web3.fromAscii('ethereum');
console.log(str); // "0x657468657265756d"
var str2 = web3.fromAscii('ethereum', 32);
console.log(str2); // "0x657468657265756d000000000000000000000000000000000000000000000000"
web3.toDecimal
web3.toDecimal(hexString);
将HEX字符串转换为其数字表示形式。
参数
String- 要转换为数字的HEX字符串。
返回
Number- 代表数据的数字hexString。
例
var number = web3.toDecimal('0x15');
console.log(number); // 21
web3.fromDecimal
web3.fromDecimal(number);
将数字或数字字符串转换为HEX表示形式。
参数
Number|String- 要转换为HEX字符串的数字。
返回
String- 表示给定的HEX字符串number。
例
var value = web3.fromDecimal('21');
console.log(value); // "0x15"
web3.fromWei
web3.fromWei(number, unit)
将一些wei转换成以下的ethereum单元：
kwei/adamwei/babbagegwei/shannonszabofinneyetherkether/grand/einsteinmethergethertether
参数
Number|String|BigNumber- 一个数字或BigNumber实例。String- 以上以太单位之一。
返回
String|BigNumber- 数字字符串或BigNumber实例，具体取决于给定的number参数。
例
var value = web3.fromWei('21000000000000', 'finney');
console.log(value); // "0.021"
web3.toWei
web3.toWei(number, unit)
将以太坊单位转换为wei。可能的单位是：
kwei/adamwei/babbagegwei/shannonszabofinneyetherkether/grand/einsteinmethergethertether
参数
Number|String|BigNumber- 一个数字或BigNumber实例。String- 以上以太单位之一。
返回
String|BigNumber- 数字字符串或BigNumber实例，具体取决于给定的number参数。
例
var value = web3.toWei('1', 'ether');
console.log(value); // "1000000000000000000"
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'
web3.net
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
web3.net.peerCount
web3.net.peerCount
// or async
web3.net.getPeerCount(callback(error, result){ ... })
该属性是只读的，并返回连接的对等体的数量。
返回
Number - 当前连接到客户端的对等点的数量。
例
var peerCount = web3.net.peerCount;
console.log(peerCount); // 4
web3.eth
包含以太坊区块链相关的方法。
例
var eth = web3.eth;
web3.eth.defaultAccount
web3.eth.defaultAccount
这个默认地址用于以下方法（可以通过指定from属性来选择覆盖它）：
值
String，20字节 - 您拥有的任何地址，或者您拥有私钥的地址。
默认是 undefined。
返回
String，20字节 - 当前设置的默认地址。
例
var defaultAccount = web3.eth.defaultAccount;
console.log(defaultAccount); // ''
// set the default block
web3.eth.defaultAccount = '0x8888f1f195afa192cfee860698584c030f4c9db1';
web3.eth.defaultBlock
web3.eth.defaultBlock
这个默认块用于以下方法（可选地，您可以通过将defaultBlock作为最后一个参数来覆盖defaultBlock）：
- web3.eth.getBalance（）
- web3.eth.getCode（）
- web3.eth.getTransactionCount（）
- web3.eth.getStorageAt（）
- web3.eth.call（）
值
默认块参数可以是以下之一：
Number- 一个块号码String-"earliest"genisis块String-"latest"，最新的区块（当前区块链头）String-"pending"，目前开采的区块（包括待交易）
默认是 latest
返回
Number|String - 查询状态时使用的默认块编号。
例
var defaultBlock = web3.eth.defaultBlock;
console.log(defaultBlock); // 'latest'
// set the default block
web3.eth.defaultBlock = 231;
web3.eth.syncing
web3.eth.syncing
// or async
web3.eth.getSyncing(callback(error, result){ ... })
此属性是只读的，并在节点正在同步时返回同步对象false。
返回
Object|Boolean- 同步对象如下所示，当节点当前正在同步或false：
startingBlock：Number- 同步开始的块号。currentBlock：Number- 节点当前同步到的块的块号。highestBlock：Number- 要同步到的估计块号码。
例
var sync = web3.eth.syncing;
console.log(sync);
/*
{
startingBlock: 300,
currentBlock: 312,
highestBlock: 512
}
*/
web3.eth.isSyncing
web3.eth.isSyncing(callback);
这个便利函数调用callback每次同步开始，更新和停止。
返回
Object - 具有以下方法的isSyncing对象：
syncing.addCallback()：添加另一个回调，当节点启动或停止同步时将调用该回调。syncing.stopWatching()：停止同步回调。
回调返回值
Boolean-true当同步开始和false停止时，回调将被触发。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...
}
}
});
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"
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
web3.eth.hashrate
web3.eth.hashrate
// or async
web3.eth.getHashrate(callback(error, result){ ... })
此属性是只读的，并返回节点正在挖掘的每秒散列数。
返回
Number - 每秒的哈希数。
例
var hashrate = web3.eth.hashrate;
console.log(hashrate); // 493736
web3.eth.gasPrice
web3.eth.gasPrice
// or async
web3.eth.getGasPrice(callback(error, result){ ... })
此属性是只读的，并返回当前的天然气价格。天然气价格是由x最新块中位数天然气价格决定的。
返回
BigNumber - 当前天然气价格的一个BigNumber实例。
请参阅BigNumber上的注释。
例
var gasPrice = web3.eth.gasPrice;
console.log(gasPrice.toString(10)); // "10000000000000"
web3.eth.accounts
web3.eth.accounts
// or async
web3.eth.getAccounts(callback(error, result){ ... })
该属性是只读的，并返回节点控制的帐户列表。
返回
Array - 由客户端控制的地址数组。
例
var accounts = web3.eth.accounts;
console.log(accounts); // ["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]
web3.eth.blockNumber
web3.eth.blockNumber
// or async
web3.eth.getBlockNumber(callback(error, result){ ... })
此属性是只读的，并返回当前的块号。
返回
Number - 最近的块的数量。
例
var number = web3.eth.blockNumber;
console.log(number); // 2744
web3.eth.register
web3.eth.register(addressHexString [, callback])
（尚未实施）注册包含的给定地址web3.eth.accounts。这允许将非私钥拥有的账户关联为一个拥有的账户（例如，合同钱包）。
参数
String- 要注册的地址Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
？
例
web3.eth.register("0x407d73d8a49eeb85d32cf465507dd71d507100ca")
web3.eth.unRegister
web3.eth.unRegister(addressHexString [, callback])
（尚未执行）取消注册给定的地址。
参数
String- 取消注册的地址。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
？
例
web3.eth.unregister("0x407d73d8a49eeb85d32cf465507dd71d507100ca")
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
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"
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"
web3.eth.getBlock
web3.eth.getBlock(blockHashOrBlockNumber [, returnTransactionObjects] [, callback])
返回与块编号或块散列匹配的块。
参数
String|Number- 块号或散列。或者是字符串"earliest"，"latest"或者"pending"像默认的block参数那样。Boolean- （可选，默认false）如果true返回的块将包含所有事务作为对象，如果false它只包含事务散列。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Object - 块对象：
number：Number- 块号。null当其挂起的块。hash：String，32字节 - 块的散列。null当其挂起的块。parentHash：String，32字节 - 父块的散列。nonce：String，8字节 - 生成的工作量证明的散列值。null当其挂起的块。sha3Uncles：String，32个字节 - 块中的数据。logsBloom：String，256字节 - 块的日志的布隆过滤器。null当其挂起的块。transactionsRoot：String，32字节 - 块的事务树的根stateRoot：String，32字节 - 块的最终状态树的根。miner：String，20 Bytes - 给予采矿奖励的受益人的地址。difficulty：BigNumber- 这个块的难度的整数。totalDifficulty：BigNumber- 直到这个块的链条总难度的整数。extraData：String- 该块的“额外数据”字段。size：Number- 以字节为单位整数该块的大小。gasLimit：Number- 在这个区块允许的最大的气体。gasUsed：Number- 此区块内所有交易使用的天然气总量。timestamp：Number- 块整理时的unix时间戳。transactions：Array- 根据最后给定的参数，事务对象数组或32字节事务散列。uncles：Array- 一些叔叔哈希。
例
var info = web3.eth.block(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": []
}
*/
web3.eth.getBlockTransactionCount
web3.eth.getBlockTransactionCount(hashStringOrBlockNumber [, callback])
返回给定块中的事务数。
参数
String|Number- 块号或散列。或者是字符串"earliest"，"latest"或者"pending"像默认的block参数那样。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Number - 给定块中的事务数量。
例
var number = web3.eth.getBlockTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(number); // 1
web3.eth.getUncle
web3.eth.getUncle(blockHashStringOrNumber, uncleNumber [, returnTransactionObjects] [, callback])
通过给定的叔叔索引位置返回一个块叔叔。
参数
String|Number- 块号或散列。或者是字符串"earliest"，"latest"或者"pending"像默认的block参数那样。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
web3.eth.getTransaction
web3.eth.getTransaction(transactionHash [, callback])
返回匹配给定事务哈希的事务。
参数
String- 交易哈希。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Object- 一个交易对象的哈希值transactionHash：
hash：String，32字节 - 交易的散列。nonce：Number- 发件人在此之前进行的交易次数。blockHash：String，32字节 - 当这个事务处于null挂起状态时，这个事务所在的块的散列。blockNumber：Number- 该交易所在null的区号。transactionIndex：Number- 块中交易指标位置的整数。null当它待定。from：String，20字节 - 发件人的地址。to：String，20字节 - 接收器的地址。null当其创建合同交易时。value：BigNumber- 在魏的价值转移。gasPrice：BigNumber- 魏先生提供的天然气价格。gas：Number- 发件人提供的气体。input：String- 与交易一起发送的数据。
例
var blockNumber = 668;
var indexOfTransaction = 0
var transaction = web3.eth.getTransaction(blockNumber, indexOfTransaction);
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"
}
*/
web3.eth.getTransactionFromBlock
getTransactionFromBlock(hashStringOrNumber, indexNumber [, callback])
根据块散列或数字以及交易索引位置返回交易。
参数
String- 一个块号或散列。或者是字符串"earliest"，"latest"或者"pending"像默认的block参数那样。Number- 交易指标头寸。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Object- 一个事务对象，请参阅web3.eth.getTransaction：
例
var transaction = web3.eth.getTransactionFromBlock('0x4534534534', 2);
console.log(transaction); // see web3.eth.getTransaction
web3.eth.getTransactionReceipt
web3.eth.getTransactionReceipt(hashString [, callback])
按事务散列返回事务的接收。
请注意，收据不可用于未完成的交易。
参数
String- 交易哈希。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Object- 交易收据对象，或未null找到收据时：
blockHash：String，32字节 - 此事务所在块的散列。blockNumber：Number- 此交易所在的区号。transactionHash：String，32字节 - 交易的散列。transactionIndex：Number- 块中交易指标位置的整数。from：String，20字节 - 发件人的地址。to：String，20字节 - 接收器的地址。null当其创建合同交易时。cumulativeGasUsed：Number- 该交易在区块中执行时使用的天然气总量。gasUsed：Number- 这一特定交易单独使用的天然气量。contractAddress：String- 20字节 - 创建合同地址（如果交易是创建合同），否则null。logs：Array- 该事务生成的日志对象数组。
例
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.
}, ...]
}
web3.eth.getTransactionCount
web3.eth.getTransactionCount(addressHexString [, defaultBlock] [, callback])
获取从该地址发送的交易数量。
参数
String- 从中获取交易数量的地址。Number|String- （可选）如果你传递这个参数，它将不使用web3.eth.defaultBlock设置的默认块。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Number - 从给定地址发送的交易数量。
例
var number = web3.eth.getTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(number); // 1
web3.eth.sendTransaction
web3.eth.sendTransaction(transactionObject [, callback])
发送一个事务到网络。
参数
Object- 要发送的交易对象：from：String- 发送帐户的地址。如果未指定，请使用web3.eth.defaultAccount属性。to：String- （可选）消息的目标地址，对于创建合同的事务没有定义。value：Number|String|BigNumber- （可选）魏为交易而转让的价值，如果是合同创造交易，则也为捐赠。gas：Number|String|BigNumber- （可选，默认：待定）交易使用的天然气量（未使用的天然气可退还）。gasPrice：Number|String|BigNumber- （可选，默认：待定）wei中此次交易的天然气价格，默认为平均网络天然气价格。data：String- （可选）包含消息关联数据的字节字符串，或者创建合同的事务中的初始化代码。nonce：Number- （可选）一个随机数的整数。这允许覆盖使用相同的随机数的您自己的未决事务。
Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
String - 32字节的事务散列为HEX字符串。
如果事务是创建合同，则使用web3.eth.getTransactionReceipt（）获取合同地址。
例
// compiled solidity source code using https://chriseth.github.io/cpp-ethereum/
var code = "603d80600c6000396000f3007c01000000000000000000000000000000000000000000000000000000006000350463c6888fa18114602d57005b600760043502
8060005260206000f3";
web3.eth.sendTransaction({data: code}, function(err, address) {
if (!err)
console.log(address); // "0x7f9fade1c0d57a7af66ab4ead7c2eb7b11a91385"
});
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"
web3.eth.estimateGas
web3.eth.estimateGas(callObject [, defaultBlock] [, callback])
执行消息调用或事务，该消息调用或事务在节点的VM中直接执行，但从未开采到区块链中并返回所使用的气体量。
参数
请参阅web3.eth.sendTransaction，期望所有属性都是可选的。
返回
Number - 用于模拟呼叫/交易的废气。
例
var result = web3.eth.estimateGas({
to: "0xc4abd0339eb8d57087278718986382264244252f",
data: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000003"
});
console.log(result); // "0x0000000000000000000000000000000000000000000000000000000000000015"
web3.eth.filter
// 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...']。
返回
Object - 具有以下方法的过滤器对象：
filter.get(callback)：返回所有符合过滤器的日志条目。filter.watch(callback)：监视适合过滤器的状态更改并调用回调。详情请参阅此说明。filter.stopWatching()：停止监视并卸载节点中的过滤器。一旦完成，应该总是被调用。
观看回调返回值
String- 使用"latest"参数时，它返回最后一个传入块的块散列。String- 使用"pending"参数时，它返回最后一个添加挂起事务的事务散列。Object- 使用手动筛选器选项时，它将按如下方式返回一个日志对象：logIndex：Number- 块中日志索引位置的整数。null当其挂起的日志。transactionIndex：Number- 整数交易指标头寸日志是从中创建的。null当其挂起的日志。transactionHash：String，32字节 - 创建此日志的事务的散列值。null当其挂起的日志。blockHash：String，32字节 - 这个日志所在的块的哈希null。null当其挂起的日志。blockNumber：Number-null当其挂起时，该日志所在的块号。null当其挂起的日志。address：String，32字节 - 这个日志起源的地址。data：String- 包含日志的一个或多个32字节的非索引参数。topics：Array of Strings-DATA索引日志参数0到4 32字节的数组。（稳固性：第一个主题是事件签名的散列（例如Deposit(address,bytes32,uint256)），除了用说明anonymous符声明事件）。
注意事件过滤器返回值请参阅合同事件
例
var filter = web3.eth.filter('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();
web3.eth.contract
web3.eth.contract(abiArray)
为合同合同创建一个合同对象，可用于启动地址上的合同。你可以在这里阅读更多关于事件。
参数
Array- 包含合同功能和事件描述的ABI数组。
返回
Object - 合同对象，可以启动如下：
var MyContract = web3.eth.contract(abiArray);
然后，您可以在地址上启动现有合同，也可以使用编译的字节码来部署合同：
// Instantiate from an existing address:
var myContractInstance = MyContract.at(myContractAddress);
// Or deploy a new contract:
// Deploy the contract asyncronous:
var myContractReturned = MyContract.new(param1, param2, {
data: myContractCode,
gas: 300000,
from: mySenderAddress}, 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: myContractCode, 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
注意当你部署一个新的合同时，如果合同代码仍然在地址上（使用web3.eth.getCode（）），你应该检查接下来的12个块，以确保一个分支没有改变。
例
// 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",
...
}
*/
});
合同方法
// Automatically determines the use of call or sendTransaction based on the method type
myContractInstance.myMethod(param1 [, param2, ...] [, transactionObject] [, callback]);
// Explicitly calling this method
myContractInstance.myMethod.call(param1 [, param2, ...] [, transactionObject] [, callback]);
// Explicitly sending a transaction to this method
myContractInstance.myMethod.sendTransaction(param1 [, param2, ...] [, transactionObject] [, callback]);
契约对象公开可以使用参数和事务对象调用的契约方法。
参数
String|Number- （可选）功能的零个或多个参数。Object- （可选）（上一个）最后一个参数可以是事务对象，请参阅web3.eth.sendTransaction参数1以获取更多信息。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){ ... });
合约事件
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将字段“地址”设置为合同的地址。另外第一个话题是事件的签名。Function- （可选）如果您将回叫作为最后一个参数传递，它将立即开始观看，您不需要拨打电话myEvent.watch(function(){})。详情请参阅此说明。
回调返回
Object - 事件对象如下：
args：Object- 来自事件的论据。event：String- 事件名称。logIndex：Number- 块中日志索引位置的整数。transactionIndex：Number- 整数交易指标头寸日志是从中创建的。transactionHash：String，32字节 - 创建此日志的事务的散列值。address：String，32字节 - 这个日志起源的地址。blockHash：String，32字节 - 这个日志所在的块的哈希null。blockNumber：Number-null当其挂起时，该日志所在的块号。
例
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();
合同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将字段“地址”设置为合同的地址。另外第一个话题是事件的签名。Function- （可选）如果您将回叫作为最后一个参数传递，它将立即开始观看，您不需要拨打电话myEvent.watch(function(){})。详情请参阅此说明。
回调返回
Object- 查看更多的合同事件。
例
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
myEvent.stopWatching();
web3.eth.getCompilers
web3.eth.getCompilers([callback])
获取可用编译器的列表。
参数
Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Array - 可用编译器的字符串数组。
例
var number = web3.eth.getCompilers();
console.log(number); // ["lll", "solidity", "serpent"]
web3.eth.compile.solidity
web3.eth.compile.solidity(sourceString [, callback])
编译可靠性源代码。
参数
String- 可靠性源代码。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Object - 合同和编译器信息。
例
var source = "" +
"contract test {\n" +
" function multiply(uint a) returns(uint d) {\n" +
" return a * 7;\n" +
" }\n" +
"}\n";
var compiled = web3.eth.compile.solidity(source);
console.log(compiled);
// {
"test": {
"code": "0x605280600c6000396000f3006000357c010000000000000000000000000000000000000000000000000000000090048063c6888fa114602e57005b60376004356041565b8060005260206000f35b6000600782029050604d565b91905056",
"info": {
"source": "contract test {\n\tfunction multiply(uint a) returns(uint d) {\n\t\treturn a * 7;\n\t}\n}\n",
"language": "Solidity",
"languageVersion": "0",
"compilerVersion": "0.8.2",
"abiDefinition": [
{
"constant": false,
"inputs": [
{
"name": "a",
"type": "uint256"
}
],
"name": "multiply",
"outputs": [
{
"name": "d",
"type": "uint256"
}
],
"type": "function"
}
],
"userDoc": {
"methods": {}
},
"developerDoc": {
"methods": {}
}
}
}
}
web3.eth.compile.lll
web3. eth.compile.lll(sourceString [, callback])
编译LLL源代码。
参数
String- LLL源代码。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
String - 编译的LLL代码为HEX字符串。
例
var source = "...";
var code = web3.eth.compile.lll(source);
console.log(code); // "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056"
web3.eth.compile.serpent
web3.eth.compile.serpent(sourceString [, callback])
编译蛇的源代码。
参数
String- 蛇的源代码。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
String - 编译后的代码为HEX字符串。
var source = "...";
var code = web3.eth.compile.serpent(source);
console.log(code); // "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056"
web3.eth.namereg
web3.eth.namereg
返回GlobalRegistrar对象。
用法
参见namereg示例
web3.db
web3.db.putString
web3.db.putString(db, key, value)
当我们要在本地leveldb数据库中存储一个字符串时，应该调用这个方法。
参数
String- 要存储到的数据库。String- 商店的名称。String- 要存储的字符串值。
返回
Boolean- true如果成功，否则false。
例
参数是db名称，第二个是键，第三个是字符串值。
web3.db.putString('testDB', 'key', 'myString') // true
web3.db.getString
web3.db.getString(db, key)
当我们想从本地leveldb数据库获取字符串时，应该调用这个方法。
参数
String- 要从中检索的数据库字符串名称。String- 商店的名称。
返回
String - 存储的值。
例
param是db名字，第二个是字符串值的关键字。
var value = web3.db.getString('testDB', 'key');
console.log(value); // "myString"
web3.db.putHex
web3.db.putHex(db, key, value)
当我们要在本地leveldb数据库中以HEX形式存储二进制数据时，应该调用这个方法。
参数
String- 要存储到的数据库。String- 商店的名称。String- 要存储的HEX字符串。
返回
Boolean- true如果成功，否则false。
例
web3.db.putHex('testDB', 'key', '0x4f554b443'); // true
web3.db.getHex
web3.db.getHex(db, key)
这个方法应该被调用，当我们想从本地leveldb数据库中获得一个HEX形式的二进制数据。
参数
String- 要存储到的数据库。String- 商店的名称。
返回
String - 存储的十六进制值。
例
param是db名字，第二个是键值。
var value = web3.db.getHex('testDB', 'key');
console.log(value); // "0x4f554b443"
web3.shh
例
var shh = web3.shh;
web3.shh.post
web3.shh.post（object [，callback]）
这个方法应该被调用，当我们要发送悄悄话消息到网络。
参数
Object- 帖子对象：from：String，60字节HEX - （可选）发件人的身份。to：String，60字节HEX - （可选）接收者的身份。当耳语将加密的消息，只有接收者可以解密它。topics：Array of Strings- 主题数组Strings，供接收者识别消息。payload：String|Number|Object- 消息的有效载荷。之前会自动转换为HEX字符串。priority：Number- 从...（？）开始的优先级的整数。ttl：Number- 以秒为单位的整数时间。
Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Boolean- true如果消息发送，则返回;否则false。
例
var identity = web3.shh.newIdentity();
var topic = 'example';
var payload = 'hello whisper world!';
var message = {
from: identity,
topics: [topic],
payload: payload,
ttl: 100,
workToProve: 100 // or priority TODO
};
web3.shh.post(message);
web3.shh.newIdentity
web3.shh.newIdentity([callback])
应该被称为创造新的身份。
参数
Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
String - 一个新的身份HEX字符串。
例
var identity = web3.shh.newIdentity();
console.log(identity); // "0xc931d93e97ab07fe42d923478ba2465f283f440fd6cabea4dd7a2c807108f651b7135d1d6ca9007d5b68aa497e4619ac10aa3b27726e1863c1fd9b570d99bbaf"
web3.shh.hasIdentity
web3.shh.hasIdentity(identity, [callback])
应该被调用，如果我们想检查用户是否给出了身份。
参数
String- 要检查的身份。Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
返回
Boolean- true如果身份存在则返回，否则返回false。
例
var identity = web3.shh.newIdentity();
var result = web3.shh.hasIdentity(identity);
console.log(result); // true
var result2 = web3.shh.hasIdentity(identity + "0");
console.log(result2); // false
web3.shh.newGroup
例
// TODO: not implemented yet
web3.shh.addToGroup
例
// TODO: not implemented yet
web3.shh.filter
var filter = web3.shh.filter(options)
// watch for changes
filter.watch(function(error, result){
if (!error)
console.log(result);
});
留意接收到的低语消息。
参数
Object- 过滤器选项：topics：Array of Strings- 通过这个主题过滤消息。您可以使用以下组合：['topic1', 'topic2'] == 'topic1' && 'topic2'['topic1', ['topic2', 'topic3']] == 'topic1' && ('topic2' || 'topic3')[null, 'topic1', 'topic2'] == ANYTHING && 'topic1' && 'topic2'- >null作为通配符使用
to：按照消息接收者的身份进行过滤。如果提供并且节点具有此标识，则它将解密传入的加密消息。
Function- （可选）如果传递一个回调，HTTP请求将变为异步。详情请参阅此说明。
回调返回
Object - 传入消息：
from：String，60字节 - 邮件的发件人，如果指定了发件人。to：String，60字节 - 消息的接收者，如果指定了接收者。expiry：Number- 此消息应该过期的时间（秒）的整数（？）。ttl：Number- 消息在系统中以秒（？）为单位浮动的时间的整数。sent：Number- 消息发送时的unix时间戳的整数。topics：Array of String-String消息包含的主题数组。payload：String- 消息的有效载荷。workProved：Number- 这个消息在发送之前需要的整数（？）。
web3.eth.sendIBANTransaction
var txHash = web3.eth.sendIBANTransaction('0x00c5496aee77c1ba1f0854206a26dda82a81d6d8', 'XE81ETHXREGGAVOFYORK', 0x100);
从用户帐户发送IBAN交易到目的地IBAN地址。
参数
string- 我们要发送交易的地址string- 我们想要发送交易的IBAN地址value- 我们想要在IBAN交易中发送的价值
web3.eth.iban
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
web3.eth.iban.fromAddress
var i = web3.eth.iban.fromAddress('0x00c5496aee77c1ba1f0854206a26dda82a81d6d8');
console.log(i.toString()); // 'XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS
web3.eth.iban.fromBban
var i = web3.eth.iban.fromBban('ETHXREGGAVOFYORK');
console.log(i.toString()); // "XE81ETHXREGGAVOFYORK"
web3.eth.iban.createIndirect
var i = web3.eth.iban.createIndirect({
institution: "XREG",
identifier: "GAVOFYORK"
});
console.log(i.toString()); // "XE81ETHXREGGAVOFYORK"
web3.eth.iban.isValid
var valid = web3.eth.iban.isValid("XE81ETHXREGGAVOFYORK");
console.log(valid); // true
var valid2 = web3.eth.iban.isValid("XE82ETHXREGGAVOFYORK");
console.log(valid2); // false, cause checksum is incorrect
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var valid3 = i.isValid();
console.log(valid3); // true
web3.eth.iban.isDirect
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var direct = i.isDirect();
console.log(direct); // false
web3.eth.iban.isIndirect
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var indirect = i.isIndirect();
console.log(indirect); // true
web3.eth.iban.checksum
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var checksum = i.checksum();
console.log(checksum); // "81"
web3.eth.iban.institution
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var institution = i.institution();
console.log(institution); // 'XREG'
web3.eth.iban.client
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var client = i.client();
console.log(client); // 'GAVOFYORK'
web3.eth.iban.address
var i = new web3.eth.iban('XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS');
var address = i.address();
console.log(address); // '00c5496aee77c1ba1f0854206a26dda82a81d6d8'
web3.eth.iban.toString
var i = new web3.eth.iban('XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS');
console.log(i.toString()); // 'XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS'
JavaScript运行时环境
以太坊实现了一个JavaScript运行时环境（JSRE），可以在交互（控制台）或非交互（脚本）模式下使用。
以太坊的Javascript控制台公开了完整的web3 JavaScript Dapp API和管理API。
交互式使用：JSRE REPL控制台
所述
ethereum CLI可执行geth具有JavaScript控制台（一个读取，评价＆打印循环 = REPL暴露JSRE），其可以与所述启动console或attach子命令。该console子命令启动GETH节点，然后打开控制台。该attach子命令将无法启动GETH节点，而是试图打开上运行GETH实例的控制台。$ geth console $ geth attach如果geth节点使用非默认的ipc端点运行，或者您想通过rpc接口连接，则attach节点接受端点。
$ geth attach ipc:/some/custom/path $ geth attach rpc:http://191.168.1.1:8545请注意，默认情况下，geth节点不会启动rpc服务，并且由于安全原因，并不是通过此接口提供所有功能。
--rpcapigeth节点启动时的参数或者admin.startRPC可以覆盖这些默认值。如果您需要日志信息，请从以下开始：
$ geth --verbosity 5 console 2>> /tmp/eth.log否则，请将您的日志静音，以免污染您的控制台：
$ geth console 2>> /dev/null要么
$ geth --verbosity 0 console注意：由于数据库只能被一个进程访问，这意味着
geth console如果你有一个已经运行的geth实例，就不能运行。非交互式使用：JSRE脚本模式
也可以将文件执行到JavaScript intepreter。在
console与attach子接受--exec这是一个JavaScript语句的参数。$ geth --exec "eth.blockNumber" attach这将打印正在运行的geth实例的当前块号。
或者使用更复杂的语句执行脚本：
$ geth --exec 'loadScript("/tmp/checkbalances.js")' attach $ geth --jspath "/tmp" --exec 'loadScript("checkbalances.js")' attach在这里找到一个示例脚本
使用
--jspath <path/to/my/js/root>为您的js脚本设置libdir。loadScript()没有绝对路径的参数将被理解为相对于这个目录。您可以通过键入
exit或干脆退出控制台CTRL-C。警告
JSRE使用Otto JS VM有一些限制：
- “严格使用”将解析，但什么都不做。
- 正则表达式引擎（re2 / regexp）与ECMA5规范不完全兼容。
请注意，Otto的另一个已知的限制（即缺少定时器）被照顾。以太坊JSRE实现了setTimeout和setInterval。除此之外，控制台还提供admin.sleep(seconds)了“阻断睡眠”方法admin.sleepBlocks(number)。
自从ethereum.js使用该bignumer.js库（MIT Expat License）以来，它也是自动安装的。
计时器
除了JS的全部功能（按照ECMA5）之外，JSRE还增加了各种定时器。它实现了setInterval，clearInterval，setTimeout，clearTimeout您可以用来使用的浏览器窗口。它还提供了admin.sleep(seconds)一个基于块的定时器的实现，admin.sleepBlocks(n)该定时器一直睡到所添加的新块的数量等于或大于等于n，则认为“等待n个确认”。
管理API
除了官方的DApp API接口之外，以太坊节点还支持额外的管理API。这些API是使用JSON-RPC提供的，并遵循与DApp API中使用的相同的约定。去ethereum包带有一个控制台客户端，它支持所有额外的API。
如何
可以指定通过接口提供的一组API，--${interface}api用于访问ethereum守护进程的命令行参数。在Windows上，${interface}可以rpc为unix或命名管道上的http接口或ipcunix套接字使用哪个接口。
例如，geth --ipcapi "admin,eth,miner" --rpcapi "eth,web3"将
- 通过IPC接口启用管理员，官方DApp和矿工API
- 通过RPC接口启用eth和web3 API
请注意，通过rpc接口提供API 将使每个人都可以访问可以访问此接口的API（例如DApp）。所以要小心你启用了哪些API。默认情况下，geth通过ipc接口启用所有的API，而接口上只启用db，eth，net和web3 API rpc。
要确定哪个接口提供的API modules可以使用，例如通过ipcunix系统上的接口：
echo '{"jsonrpc":"2.0","method":"modules","params":[],"id":1}' | nc -U $datadir/geth.ipc
将提供所有启用的模块，包括版本号：
{
"id":1,
"jsonrpc":"2.0",
"result":{
"admin":"1.0",
"db":"1.0",
"debug":"1.0",
"eth":"1.0",
"miner":"1.0",
"net":"1.0",
"personal":"1.0",
"shh":"1.0",
"txpool":"1.0",
"web3":"1.0"
}
}
积分
这些额外的API遵循与官方DApp API相同的约定。Web3可以扩展并用于使用这些额外的API。
不同的功能被分成多个较小的逻辑分组API。给出的例子是Javascript控制台，但可以很容易地转换为rpc请求。
2例子：
安慰：
miner.start()IPC：
echo '{"jsonrpc":"2.0","method":"miner_start","params":[],"id":1}' | nc -U $datadir/geth.ipcRPC：
curl -X POST --data '{"jsonrpc":"2.0","method":"miner_start","params":[],"id":74}' localhost:8545
以THREADS的数量作为参数：
安慰：
miner.start(4)IPC：
echo '{"jsonrpc":"2.0","method":"miner_start","params":[4],"id":1}' | nc -U $datadir/geth.ipcRPC：
curl -X POST --data '{"jsonrpc":"2.0","method":"miner_start","params":[4],"id":74}' localhost:8545
管理API参考
- ETH
- 管理
- 矿工
- 开始
- 停止
- startAutoDAG
- stopAutoDAG
- makeDAG
- hashrate
- setExtra
- [setGasPrice]（#minersetgasprice）
- [setEtherbase]（#minersetetherbase）
- 个人
- txpool
- 调试
- loadScript
- 睡觉
- 的setInterval
- clearInterval
- 的setTimeout
- clearTimeout
- WEB3
- 净
- ETH
- 嘘
- D b
- 检查
个人
该personalAPI公开方法为个人的方法来管理，控制或监视您的节点。它允许有限的文件系统访问。
personal.listAccounts
personal.listAccounts
列出所有帐户
返回
与帐户收集
例
personal.listAccounts
personal.newAccount
personal.newAccount(passwd)
创建一个新的密码保护的帐户
返回
string 新帐户的地址
例
personal.newAccount("mypasswd")
personal.deleteAccount
personal.deleteAccount(addr, passwd)
删除具有给定地址和密码的帐户
返回
指示账户是否被删除
例
personal.deleteAccount(eth.coinbase, "mypasswd")
personal.unlockAccount
personal.unlockAccount(addr, passwd, duration)
使用给定的地址，密码和可选的持续时间（秒）解锁账户。
返回
boolean 指示账户是否被解锁
例
personal.unlockAccount(eth.coinbase, "mypasswd", 300)
TxPool
txpool.status
txpool.status
待处理/排队交易的数量
返回
pending 所有可处理的交易
queued 所有不可处理的交易
例
txpool.status
管理
该admin公开的管理，控制或监视您节点的方法。它允许有限的文件系统访问。
admin.chainSyncStatus
admin.chainSyncStatus
打印区块链同步的信息。
返回
blocksAvailable，还没有被下载的块
blocksWaitingForImport，导入之前等待下载的块
estimate，在节点导入所有块之前的（非常粗略的）估计
importing，目前正在导入的块
admin.verbosity
admin.verbosity(level)
记录器详细级别设置为级别。1-6：沉默，错误，警告，信息，调试，细节
例
> admin.verbosity(6)
admin.nodeInfo
admin.nodeInfo
返回
节点上的信息。
例
> admin.nodeInfo
{
Name: 'Ethereum(G)/v0.9.36/darwin/go1.4.1',
NodeUrl: 'enode://c32e13952965e5f7ebc85b02a2eb54b09d55f553161c6729695ea34482af933d0a4b035efb5600fc5c3ea9306724a8cbd83845bb8caaabe0b599fc444e36db7e@89.42.0.12:30303',
NodeID: '0xc32e13952965e5f7ebc85b02a2eb54b09d55f553161c6729695ea34482af933d0a4b035efb5600fc5c3ea9306724a8cbd83845bb8caaabe0b599fc444e36db7e',
IP: '89.42.0.12',
DiscPort: 30303,
TCPPort: 30303,
Td: '0',
ListenAddr: '[::]:30303'
}
要连接到节点，请使用enode-format nodeUrl作为addPeer或CLI参数的参数bootnodes。
admin.addPeer
admin.addPeer(nodeURL)
通过一个nodeURL连接到网络上的对等。该nodeURL需求是在的eNode URL格式。geth将保持连接，直到它关闭，并尝试重新连接，如果连接间歇性下降。
您可以使用nodeInfo查找自己的节点URL，或者在节点启动时查看日志，例如：
[P2P Discovery] Listening, enode://6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0@54.169.166.226:30303
返回
true 成功。
例
> admin.addPeer('enode://6f8a80d14311c39f35f516fa664deaaaa13e85b2f7493f37f6144d86991ec012937307647bd3b9a82abe2974e1407241d54947bbb39763a4cac9f77166ad92a0@54.169.166.226:30303')
admin.peers
admin.peers
返回
包含关于连接的同级的信息的对象数组。
例
> admin.peers
[ { ID: '0x6cdd090303f394a1cac34ecc9f7cda18127eafa2a3a06de39f6d920b0e583e062a7362097c7c65ee490a758b442acd5c80c6fce4b148c6a391e946b45131365b', Name: 'Ethereum(G)/v0.9.0/linux/go1.4.1', Caps: 'eth/56, shh/2', RemoteAddress: '54.169.166.226:30303', LocalAddress: '10.1.4.216:58888' } { ID: '0x4f06e802d994aaea9b9623308729cf7e4da61090ffb3615bc7124c5abbf46694c4334e304be4314392fafcee46779e506c6e00f2d31371498db35d28adf85f35', Name: 'Mist/v0.9.0/linux/go1.4.2', Caps: 'eth/58, shh/2', RemoteAddress: '37.142.103.9:30303', LocalAddress: '10.1.4.216:62393' } ]
admin.importChain
admin.importChain(file)
从编组二进制格式导入区块链。 请注意，在导入的块被插入到链中之前，区块链被重置（生成）。
返回
true否则就成功了false。
例
admin.importChain('path/to/file')
// true
admin.exportChain
admin.exportChain(file)
以二进制格式将区块链导出到给定文件。
返回
true否则就成功了false。
例
admin.exportChain('path/to/file')
admin.startRPC
admin.startRPC(host, portNumber, corsheader, modules)
启动JSON-RPC的HTTP服务器。
返回
true否则就成功了false。
例
admin.startRPC("127.0.0.1", 8545, "*", "web3,db,net,eth")
// true
admin.stopRPC
admin.stopRPC()
停止JSON-RPC的HTTP服务器。
返回
true否则就成功了false。
例
admin.stopRPC()
// true
admin.sleepBlocks
admin.sleepBlocks(n)
睡n块。
admin.datadir
admin.datadir
该节点存储其数据的目录
返回
目录成功
例
admin.datadir
'/Users/username/Library/Ethereum'
admin.setSolc
admin.setSolc(path2solc)
设置固体编译器
返回
描述路径有效时编译器版本的字符串，否则为错误
例
admin.setSolc('/some/path/solc')
'solc v0.9.29
Solidity Compiler: /some/path/solc
'
admin.startNatSpec
admin.startNatSpec()
激活NatSpec：将事务发送到合同时，将使用注册表查找和url提取来为其检索真实的合同信息。它允许用户提供真实的特定于合同的确认消息。
admin.stopNatSpec
admin.stopNatSpec()
停用NatSpec：发送一个事务时，用户将被提示一个通用的确认消息，没有合约信息被提取
admin.getContractInfo
admin.getContractInfo(address)
这将检索地址上合同的合同信息json
返回
返回合同信息对象
例子
> info = admin.getContractInfo(contractaddress)
> source = info.source
> abi = info.abiDefinition
admin.saveInfo
admin.saveInfo(contract.info, filename);
将合约信息json写入目标文件，计算其内容hash。这个内容哈希然后可以用来将公共URL与合约信息公开可用和可验证的地方联系起来。如果您注册codehash（contractaddress上的合同代码的散列）。
返回
contenthash否则就成功了undefined。
例子
source = "contract test {\n" +
" /// @notice will multiply `a` by 7.\n" +
" function multiply(uint a) returns(uint d) {\n" +
" return a * 7;\n" +
" }\n" +
"} ";
contract = eth.compile.solidity(source).test;
txhash = eth.sendTransaction({from: primary, data: contract.code });
// after it is uncluded
contractaddress = eth.getTransactionReceipt(txhash);
filename = "/tmp/info.json";
contenthash = admin.saveInfo(contract.info, filename);
admin.register
admin.register(address, contractaddress, contenthash);
将内容哈希注册到codehash（contractaddress上的合约代码的哈希）。寄存器事务从第一个参数中的地址发送。交易需要在规范链上进行处理和确认，才能使注册生效。
返回
true否则就成功了false。
例子
source = "contract test {\n" +
" /// @notice will multiply `a` by 7.\n" +
" function multiply(uint a) returns(uint d) {\n" +
" return a * 7;\n" +
" }\n" +
"} ";
contract = eth.compile.solidity(source).test;
txhash = eth.sendTransaction({from: primary, data: contract.code });
// after it is uncluded
contractaddress = eth.getTransactionReceipt(txhash);
filename = "/tmp/info.json";
contenthash = admin.saveInfo(contract.info, filename);
admin.register(primary, contractaddress, contenthash);
admin.registerUrl
admin.registerUrl(address, codehash, contenthash);
这将注册一个Contant哈希到合同的codehash。这将用于查找合约信息json 文件。第一个参数中的地址将用于发送事务。
返回
true否则就成功了false。
例子
source = "contract test {\n" +
" /// @notice will multiply `a` by 7.\n" +
" function multiply(uint a) returns(uint d) {\n" +
" return a * 7;\n" +
" }\n" +
"} ";
contract = eth.compile.solidity(source).test;
txhash = eth.sendTransaction({from: primary, data: contract.code });
// after it is uncluded
contractaddress = eth.getTransactionReceipt(txhash);
filename = "/tmp/info.json";
contenthash = admin.saveInfo(contract.info, filename);
admin.register(primary, contractaddress, contenthash);
admin.registerUrl(primary, contenthash, "file://"+filename);
矿工
miner.start
miner.start(threadCount)
从给定的并行线程开始挖掘threadNumber。这是一个可选的参数。
返回
true否则就成功了false。
例
miner.start()
// true
miner.stop
miner.stop(threadCount)
阻止threadCount矿工。这是一个可选的参数。
返回
true否则就成功了false。
例
miner.stop()
// true
miner.startAutoDAG
miner.startAutoDAG()
开始ethash DAG的自动预生成。这个过程确保后续时代的DAG可用，允许在新纪元开始后立即开采。如果这被大多数网络节点使用，则在时期转换期间，阻塞时间预期是正常的。自动DAG在采矿开始时自动打开，当矿工停止时关闭。
返回
true否则就成功了false。
miner.stopAutoDAG
miner.stopAutoDAG()
停止ethash DAG的自动预生成。采矿停止时，自动DAG将自动关闭。
返回
true否则就成功了false。
miner.makeDAG
miner.makeDAG(blockNumber, dir)
为时代生成DAG blockNumber/epochLength。dir指定一个目标目录，如果dir是空字符串，那么ethash将使用~/.ethashLinux和MacOS以及~\AppData\EthashWindows 上的默认目录。DAG文件的名字是full-<revision-number>R-<seedhash>
返回
true否则就成功了false。
miner.hashrate
miner.hashrate
返回
以H / s返回当前的散列速率。
miner.setExtra
miner.setExtra("extra data")
找到块时设置块的额外数据。限于32个字节。
miner.setGasPrice
miner.setGasPrice(gasPrice)
设置矿工的价格
miner.setEtherbase
miner.setEtherbase(account)
设置以太基地，将获得采矿奖励的地址。
调试
debug.setHead
debug.setHead(blockNumber)
将区块链的当前头部设置为由blockNumber引用的块。请参阅web3.eth.getBlock以获取有关块字段的更多详细信息，并通过编号或散列进行查找。
返回
true否则就成功了false。
例
debug.setHead(eth.blockNumber-1000)
debug.seedHash
debug.seedHash(blockNumber)
返回给定块所在时元的散列值。
返回
散列在十六进制格式
例
> debug.seedHash(eth.blockNumber)
'0xf2e59013a0a379837166b59f871b20a8a0d101d1c355ea85d35329360e69c000'
debug.processBlock
debug.processBlock(blockNumber)
在调试模式下，使用VM 处理由blockNumber引用的给定块。请参阅web3.eth.getBlock以获取有关块字段的更多详细信息，并通过编号或散列进行查找。结合使用setHead，这可以用来重播块的处理来调试虚拟机的执行。
返回
true否则就成功了false。
例
debug.processBlock(140101)
debug.getBlockRlp
debug.getBlockRlp(blockNumber)
返回块的RLP编码的十六进制表示形式。请参阅web3.eth.getBlock以获取有关块字段的更多详细信息，并通过编号或散列进行查找。
返回
块的RLP编码的十六进制表示。
例
> debug.getBlockRlp(131805) 'f90210f9020ba0ea4dcb53fe575e23742aa30266722a15429b7ba3d33ba8c87012881d7a77e81ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794a4d8e9cae4d04b093aac82e6cd355b6b963fb7ffa01f892bfd6f8fb2ec69f30c8799e371c24ebc5a9d55558640de1fb7ca8787d26da056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083bb9266830202dd832fefd880845534406d91ce9e5448ce9ed0af535048ce9ed0afce9ea04cf6d2c4022dfab72af44e9a58d7ac9f7238ffce31d4da72ed6ec9eda60e1850883f9e9ce6a261381cc0c0'
debug.printBlock
debug.printBlock(blockNumber)
打印有关块的信息，如大小，总难度，以及正确格式化的页眉字段。
请参阅web3.eth.getBlock以获取有关块字段的更多详细信息，并通过编号或散列进行查找。
返回
格式化字符串表示的块
例
> debug.printBlock(131805)
BLOCK(be465b020fdbedc4063756f0912b5a89bbb4735bd1d1df84363e05ade0195cb1): Size: 531.00 B TD: 643485290485 {
NoNonce: ee48752c3a0bfe3d85339451a5f3f411c21c8170353e450985e1faab0a9ac4cc
Header:
[
ParentHash: ea4dcb53fe575e23742aa30266722a15429b7ba3d33ba8c87012881d7a77e81e
UncleHash: 1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347
Coinbase: a4d8e9cae4d04b093aac82e6cd355b6b963fb7ff
Root: 1f892bfd6f8fb2ec69f30c8799e371c24ebc5a9d55558640de1fb7ca8787d26d
TxSha 56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421
ReceiptSha: 56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421
Bloom: 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Difficulty: 12292710
Number: 131805
GasLimit: 3141592
GasUsed: 0
Time: 1429487725
Extra: ΞTHΞЯSPHΞЯΞ
MixDigest: 4cf6d2c4022dfab72af44e9a58d7ac9f7238ffce31d4da72ed6ec9eda60e1850
Nonce: 3f9e9ce6a261381c
]
Transactions:
[]
Uncles:
[]
}
debug.dumpBlock
debug.dumpBlock(blockNumber)
返回
块号或块散列引用的块的原始转储，或者如果找不到块，则为undefined。请参阅web3.eth.getBlock获取有关块字段的更多详细信息，并通过编号或散列查找。
例
> debug.dumpBlock(eth.blockNumber)
debug.metrics
debug.metrics(raw)
返回
指标的收集，参见这个 wiki页面的更多信息。
例
> metrics(true)
loadScript
loadScript('/path/to/myfile.js');
加载一个JavaScript文件并执行它。相对路径被解释为相对jspath于其被指定为命令行标志，请参阅命令行选项。
睡觉
sleep(s)
睡了几秒钟。
的setInterval
setInterval(s, func() {})
clearInterval
的setTimeout
clearTimeout
WEB3
该web3公开的所有方法的JavaScript API。
净
这net是web3.net的快捷方式。
ETH
这eth是web3.eth的快捷方式。除了web3和eth通过公开的接口web3.js一些额外的电话被曝光。
eth.sign
eth.sign(signer, data)
eth.pendingTransactions
eth.pendingTransactions
返回属于其中一个用户的未决事务eth.accounts。
eth.resend
eth.resend(tx, <optional gas price>, <optional gas limit>)
重新发送所返回的给定交易，pendingTransactions()并允许您覆盖交易的天然气价格和天然气限额。
例
eth.sendTransaction({from: eth.accounts[0], to: "...", gasPrice: "1000"})
var tx = eth.pendingTransactions()[0]
eth.resend(tx, web3.toWei(10, "szabo"))
嘘
这shh是web3.shh的快捷方式。
D b
这db是web3.db的快捷方式。
检查
该inspect方法漂亮打印给定的值（支持颜色）