以太坊开发文档09 - javascriptApi

2023-10-29

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

用法

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/ada
mwei/babbage
gwei/shannon
szabo
finney
ether
kether/ grand/einstein
mether
gether
tether

参数

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/ada
mwei/babbage
gwei/shannon
szabo
finney
ether
kether/ grand/einstein
mether
gether
tether

参数

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）：

值

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

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.ipc
RPC： 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.ipc
RPC： curl -X POST --data '{"jsonrpc":"2.0","method":"miner_start","params":[4],"id":74}' localhost:8545

管理API参考

ETH
- 标志
- 待交易
- 重发
管理
- addPeer
- 同行
- 将nodeinfo
- DATADIR
- importChain
- exportChain
- chainSyncStatus
- startRPC
- stopRPC
- 赘言
- setSolc
- sleepBlocks
- startNatSpec
- stopNatSpec
- getContractInfo
- 寄存器
- REGISTERURL
矿工
- 开始
- 停止
- startAutoDAG
- stopAutoDAG
- makeDAG
- hashrate
- setExtra
- [setGasPrice]（#minersetgasprice）
- [setEtherbase]（#minersetetherbase）
个人
txpool
- 状态
调试
- setHead
- seedHash
- processBlock
- getBlockRlp
- printBlock
- dumpBlock
- 指标
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方法漂亮打印给定的值（支持颜色）

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)