以太坊开发文档09 - javascriptApi

凌云收藏于2018-02-05 转藏1次

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 对象提供了所有的方法。

例

                    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服务，并且由于安全原因，并不是通过此接口提供所有功能。 --rpcapi geth节点启动时的参数或者 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 接口或 ipc unix套接字使用哪个接口。

例如， 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 可以使用，例如通过 ipc unix系统上的接口：

                     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参考

个人

该 personal API公开方法为个人的方法来管理，控制或监视您的节点。它允许有限的文件系统访问。

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将使用 ~/.ethash Linux和MacOS以及 ~\AppData\Ethash Windows 上的默认目录。 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 方法漂亮打印给定的值（支持颜色）

阅读全部内容
点击查看

特别重申：本篇文档资料为 “好网角收藏夹” 注册用户(收藏家)上传共享，仅供参考之用，请谨慎辨别，不代表本站任何观点。
好网角收藏夹为网友提供资料整理云存储服务，仅提供信息存储共享平台。

信息删除举报或发邮件到：dongye2016@qq.com

转藏到我的收藏夹

转Word文档下载转PDF文档下载

一键复制全文

打印文章

类似文章