以太坊开发文档09 - javascriptApi

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
      • API
      • 客户
      • 网络
      • 复仇
      • 耳语
    • 已连接()
    • setProvider(供应商)
    • currentProvider
    • 重启()
    • 沙三段(串)
    • toHex(stringOrNumber)
    • toascii将(十六进制串)
    • fromAscii(textString,[padding])
    • toDecimal(十六进制串)
    • fromDecimal(数字)
    • fromWei(numberStringOrBigNumber,unit)
    • toWei(numberStringOrBigNumber,单位)
    • toBigNumber(numberOrHexString)
    • isAddress(十六进制串)
      • 听/ getListening
      • peerCount / getPeerCount
    • ETH
      • defaultAccount
      • defaultBlock
      • 同步/ getSyncing
      • isSyncing
      • coinbase / getCoinbase
      • hashrate / getHashrate
      • gasPrice / getGasPrice
      • 账户/ getAccounts
      • 采矿/ getMining
      • blockNumber / getBlockNumber
      • 寄存器(hexString)(尚未实现)
      • unRegister(hexString)(尚未实现)
      • 为getBalance(地址)
      • getStorageAt(地址,位置)
      • 引用代码(地址)
      • getBlock(散列/数)
      • getBlockTransactionCount(散列/数)
      • getUncle(散列/数)
      • getBlockUncleCount(散列/数)
      • getTransaction(散)
      • getTransactionFromBlock(hashOrNumber,indexNumber)
      • getTransactionReceipt(散)
      • getTransactionCount(地址)
      • sendTransaction(对象)
      • 呼叫(对象)
      • estimateGas(对象)
      • filter(array(,options))
        • 手表(回调)
        • stopWatching(回调)
        • 得到()
      • 合同(abiArray)
      • contract.myMethod()
      • contract.myEvent()
      • contract.allEvents()
      • getCompilers()
      • compile.lll(串)
      • compile.solidity(串)
      • compile.serpent(串)
      • namereg
      • sendIBANTransaction
      • IBAN
        • FROMADDRESS
        • fromBban
        • createIndirect
        • 已验证
        • isDirect
        • isIndirect
        • 校验
        • 机构
        • 客户
        • 地址
    • D b
      • putString(名称,键,值)
      • getString(名称,键)
      • putHex(名称,键值)
      • getHex(名称,键)
      • 后(postObject)
      • newIdentity()
      • hasIdentity(十六进制串)
      • newGroup(_id,_who)
      • addToGroup(_id,_who)
      • 过滤器(对象/串)
        • 手表(回调)
        • stopWatching(回调)
        • 得到(回调)

用法

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的状态。重设除经理之外的所有事物 卸载所有过滤器。停止轮询。

参数
  1. Boolean- 如果true它将卸载所有的过滤器,但将保持web3.eth.isSyncing()民意调查
返回

undefined

web3.reset();

web3.sha3

web3.sha3(string [, callback])
参数
  1. String - 使用SHA3算法进行散列的字符串
  2. 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。

参数
  1. 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字符串。

参数
  1. String - 要转换为ASCII码的HEX字符串。
返回

String- 由给定的ASCII字符串组成hexString

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

web3.fromAscii

web3.fromAscii(string [, padding]);

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

参数
  1. String - 要转换为HEX的ASCII字符串。
  2. 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字符串转换为其数字表示形式。

参数
  1. String - 要转换为数字的HEX字符串。
返回

Number- 代表数据的数字hexString

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

web3.fromDecimal

web3.fromDecimal(number);

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

参数
  1. 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
  • kethergrand/einstein
  • mether
  • gether
  • tether
参数
  1. Number|String|BigNumber - 一个数字或BigNumber实例。
  2. 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
  • kethergrand/einstein
  • mether
  • gether
  • tether
参数
  1. Number|String|BigNumber - 一个数字或BigNumber实例。
  2. String - 以上以太单位之一。
返回

String|BigNumber- 数字字符串或BigNumber实例,具体取决于给定的number参数。

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

web3.toBigNumber

web3.toBigNumber(numberOrHexString);

将给定的数字转换为BigNumber实例。

请参阅BigNumber上的注释

参数
  1. 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){ ... })

该属性是只读的,说明节点是否正在主动侦听网络连接。

返回

Booleantrue如果客户端正在主动侦听网络连接,否则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属性来选择覆盖它):

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

String,20字节 - 您拥有的任何地址,或者您拥有私钥的地址。

默认是 undefined

返回

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

var defaultAccount = web3.eth.defaultAccount;
console.log(defaultAccount); // ''

// set the default block
web3.eth.defaultAccount = '0x8888f1f195afa192cfee860698584c030f4c9db1';

web3.eth.defaultBlock

web3.eth.defaultBlock

这个默认块用于以下方法(可选地,您可以通过将defaultBlock作为最后一个参数来覆盖defaultBlock):

  • web3.eth.getBalance()
  • web3.eth.getCode()
  • web3.eth.getTransactionCount()
  • web3.eth.getStorageAt()
  • web3.eth.call()

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

  • Number - 一个块号码
  • String"earliest"genisis块
  • String"latest",最新的区块(当前区块链头)
  • String"pending",目前开采的区块(包括待交易)

默认是 latest

返回

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

var defaultBlock = web3.eth.defaultBlock;
console.log(defaultBlock); // 'latest'

// set the default block
web3.eth.defaultBlock = 231;

web3.eth.syncing

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

此属性是只读的,并在节点正在同步时返回同步对象false

返回

Object|Boolean- 同步对象如下所示,当节点当前正在同步或false

  • startingBlockNumber- 同步开始的块号。
  • currentBlockNumber- 节点当前同步到的块的块号。
  • highestBlockNumber- 要同步到的估计块号码。
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():停止同步回调。
回调返回值
  • Booleantrue当同步开始和false停止时,回调将被触发
  • Object - 同步时,将返回同步对象:
    • startingBlockNumber- 同步开始的块号。
    • currentBlockNumber- 节点当前同步到的块的块号。
    • highestBlockNumber- 要同步到的估计块号码。
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){ ... })

该属性是只读的,表示节点是否正在挖掘。

返回

Booleantrue如果客户正在挖矿,否则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这允许将非私钥拥有的账户关联为一个拥有的账户(例如,合同钱包)。

参数
  1. String - 要注册的地址
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

web3.eth.register("0x407d73d8a49eeb85d32cf465507dd71d507100ca")

web3.eth.unRegister

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

(尚未执行)取消注册给定的地址。

参数
  1. String - 取消注册的地址。
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

web3.eth.unregister("0x407d73d8a49eeb85d32cf465507dd71d507100ca")

web3.eth.getBalance

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

获取给定块的地址余额。

参数
  1. String - 获得余额的地址。
  2. Number|String- (可选)如果你传递这个参数,它将不使用web3.eth.defaultBlock设置的默认块
  3. 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])

获取存储在地址的特定位置。

参数
  1. String - 从中​​获取存储的地址。
  2. Number - 存储的索引位置。
  3. Number|String- (可选)如果你传递这个参数,它将不使用web3.eth.defaultBlock设置的默认块
  4. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

String - 给定位置的存储值。

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

web3.eth.getCode

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

获取特定地址的代码。

参数
  1. String - 从中​​获取代码的地址。
  2. Number|String- (可选)如果你传递这个参数,它将不使用web3.eth.defaultBlock设置的默认块
  3. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

String- 给定地址的数据addressHexString

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

web3.eth.getBlock

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

返回与块编号或块散列匹配的块。

参数
  1. String|Number - 块号或散列。或者是字符串"earliest""latest"或者"pending"默认的block参数那样
  2. Boolean- (可选,默认false)如果true返回的块将包含所有事务作为对象,如果false它只包含事务散列。
  3. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

Object - 块对象:

  • numberNumber- 块号。null当其挂起的块。
  • hashString,32字节 - 块的散列。null当其挂起的块。
  • parentHashString,32字节 - 父块的散列。
  • nonceString,8字节 - 生成的工作量证明的散列值。null当其挂起的块。
  • sha3UnclesString,32个字节 - 块中的数据。
  • logsBloomString,256字节 - 块的日志的布隆过滤器。null当其挂起的块。
  • transactionsRootString,32字节 - 块的事务树的根
  • stateRootString,32字节 - 块的最终状态树的根。
  • minerString,20 Bytes - 给予采矿奖励的受益人的地址。
  • difficultyBigNumber- 这个块的难度的整数。
  • totalDifficultyBigNumber- 直到这个块的链条总难度的整数。
  • extraDataString- 该块的“额外数据”字段。
  • sizeNumber- 以字节为单位整数该块的大小。
  • gasLimitNumber- 在这个区块允许的最大的气体。
  • gasUsedNumber- 此区块内所有交易使用的天然气总量。
  • timestampNumber- 块整理时的unix时间戳。
  • transactionsArray- 根据最后给定的参数,事务对象数组或32字节事务散列。
  • unclesArray- 一些叔叔哈希。
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])

返回给定块中的事务数。

参数
  1. String|Number - 块号或散列。或者是字符串"earliest""latest"或者"pending"默认的block参数那样
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

Number - 给定块中的事务数量。

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

web3.eth.getUncle

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

通过给定的叔叔索引位置返回一个块叔叔。

参数
  1. String|Number - 块号或散列。或者是字符串"earliest""latest"或者"pending"默认的block参数那样
  2. Number - 叔叔的指标位置。
  3. Boolean- (可选,默认false)如果true返回的块将包含所有事务作为对象,如果false它只包含事务散列。
  4. 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])

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

参数
  1. String - 交易哈希。
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

Object- 一个交易对象的哈希值transactionHash

  • hashString,32字节 - 交易的散列。
  • nonceNumber- 发件人在此之前进行的交易次数。
  • blockHashString,32字节 - 当这个事务处于null挂起状态时,这个事务所在的块的散列
  • blockNumberNumber- 该交易所在null的区号。
  • transactionIndexNumber- 块中交易指标位置的整数。null当它待定。
  • fromString,20字节 - 发件人的地址。
  • toString,20字节 - 接收器的地址。null当其创建合同交易时。
  • valueBigNumber- 在魏的价值转移。
  • gasPriceBigNumber- 魏先生提供的天然气价格。
  • gasNumber- 发件人提供的气体。
  • inputString- 与交易一起发送的数据。
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])

根据块散列或数字以及交易索引位置返回交易。

参数
  1. String - 一个块号或散列。或者是字符串"earliest""latest"或者"pending"默认的block参数那样
  2. Number - 交易指标头寸。
  3. 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])

按事务散列返回事务的接收。

请注意,收据不可用于未完成的交易。

参数
  1. String - 交易哈希。
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

Object- 交易收据对象,或未null找到收据时:

  • blockHashString,32字节 - 此事务所在块的散列。
  • blockNumberNumber- 此交易所在的区号。
  • transactionHashString,32字节 - 交易的散列。
  • transactionIndexNumber- 块中交易指标位置的整数。
  • fromString,20字节 - 发件人的地址。
  • toString,20字节 - 接收器的地址。null当其创建合同交易时。
  • cumulativeGasUsedNumber- 该交易在区块中执行时使用的天然气总量。
  • gasUsedNumber- 这一特定交易单独使用的天然气量。
  • contractAddressString- 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])

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

参数
  1. String - 从中​​获取交易数量的地址。
  2. Number|String- (可选)如果你传递这个参数,它将不使用web3.eth.defaultBlock设置的默认块
  3. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

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

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

web3.eth.sendTransaction

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

发送一个事务到网络。

参数
  1. Object - 要发送的交易对象:
    • fromString- 发送帐户的地址。如果未指定,请使用web3.eth.defaultAccount属性。
    • toString- (可选)消息的目标地址,对于创建合同的事务没有定义。
    • valueNumber|String|BigNumber- (可选)魏为交易而转让的价值,如果是合同创造交易,则也为捐赠。
    • gasNumber|String|BigNumber- (可选,默认:待定)交易使用的天然气量(未使用的天然气可退还)。
    • gasPriceNumber|String|BigNumber- (可选,默认:待定)wei中此次交易的天然气价格,默认为平均网络天然气价格。
    • dataString- (可选)包含消息关联数据的字节字符串,或者创建合同的事务中的初始化代码。
    • nonceNumber - (可选)一个随机数的整数。这允许覆盖使用相同的随机数的您自己的未决事务。
  2. 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中直接执行,但不会开发到区块链中。

参数
  1. Object- 一个事务对象见web3.eth.sendTransaction,不同之处在于调用该from属性也是可选的。
  2. Number|String- (可选)如果你传递这个参数,它将不使用web3.eth.defaultBlock设置的默认块
  3. 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);
});
参数
  1. String|Object- 字符串"latest""pending"分别监视最新块或未决事务中的更改。或者如下所示的过滤器选项对象:
    • fromBlockNumber|String- 最早的块的数量(latest可以表示最近的和pending当前的挖掘块)。默认情况下latest
    • toBlockNumber|String- 最新块的编号(latest可以表示最近的和pending当前正在挖掘的块)。默认情况下latest
    • addressString- 一个地址或一个地址列表,只能从特定账户获取日志。
    • topicsArray of Strings- 必须分别出现在日志条目中的值数组。顺序是重要的,如果你想离开话题使用null,例如[null, '0x00...']
返回

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

  • filter.get(callback):返回所有符合过滤器的日志条目。
  • filter.watch(callback):监视适合过滤器的状态更改并调用回调。详情请参阅此说明
  • filter.stopWatching():停止监视并卸载节点中的过滤器。一旦完成,应该总是被调用。
观看回调返回值
  • String- 使用"latest"参数时,它返回最后一个传入块的块散列。
  • String- 使用"pending"参数时,它返回最后一个添加挂起事务的事务散列。
  • Object - 使用手动筛选器选项时,它将按如下方式返回一个日志对象:
    • logIndexNumber- 块中日志索引位置的整数。null当其挂起的日志。
    • transactionIndexNumber- 整数交易指标头寸日志是从中创建的。null当其挂起的日志。
    • transactionHashString,32字节 - 创建此日志的事务的散列值。null当其挂起的日志。
    • blockHashString,32字节 - 这个日志所在的块的哈希nullnull当其挂起的日志。
    • blockNumberNumbernull当其挂起时,该日志所在的块号null当其挂起的日志。
    • addressString,32字节 - 这个日志起源的地址。
    • dataString- 包含日志的一个或多个32字节的非索引参数。
    • topicsArray of StringsDATA索引日志参数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)

为合同合同创建一个合同对象,可用于启动地址上的合同。你可以在这里阅读更多关于事件

参数
  1. 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);
});

你可以使用像过滤器这样的事件,它们有相同的方法,但是你传递不同的对象来创建事件过滤器。

参数
  1. Object- 你想过滤日志的索引返回值,例如{'valueA': 1, 'valueB': [myFirstAddress, mySecondAddress]}默认情况下,所有的过滤器值都设置为null这意味着,它们将匹配从本合同发出的任何给定类型的事件。
  2. Object- 其他过滤器选项,请参阅过滤器参数1了解更多。默认情况下,filterObject将字段“地址”设置为合同的地址。另外第一个话题是事件的签名。
  3. Function- (可选)如果您将回叫作为最后一个参数传递,它将立即开始观看,您不需要拨打电话myEvent.watch(function(){})详情请参阅此说明
回调返回

Object - 事件对象如下:

  • argsObject- 来自事件的论据。
  • eventString- 事件名称。
  • logIndexNumber- 块中日志索引位置的整数。
  • transactionIndexNumber- 整数交易指标头寸日志是从中创建的。
  • transactionHashString,32字节 - 创建此日志的事务的散列值。
  • addressString,32字节 - 这个日志起源的地址。
  • blockHashString,32字节 - 这个日志所在的块的哈希null
  • blockNumberNumbernull当其挂起时,该日志所在的块号
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);
});

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

参数
  1. Object- 其他过滤器选项,请参阅过滤器参数1了解更多。默认情况下,filterObject将字段“地址”设置为合同的地址。另外第一个话题是事件的签名。
  2. 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])

获取可用编译器的列表。

参数
  1. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

Array - 可用编译器的字符串数组。

var number = web3.eth.getCompilers();
console.log(number); // ["lll", "solidity", "serpent"]

web3.eth.compile.solidity

web3.eth.compile.solidity(sourceString [, callback])

编译可靠性源代码。

参数
  1. String - 可靠性源代码。
  2. 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源代码。

参数
  1. String - LLL源代码。
  2. 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])

编译蛇的源代码。

参数
  1. String - 蛇的源代码。
  2. 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数据库中存储一个字符串时,应该调用这个方法。

参数
  1. String - 要存储到的数据库。
  2. String - 商店的名称。
  3. String - 要存储的字符串值。
返回

Booleantrue如果成功,否则false

参数是db名称,第二个是键,第三个是字符串值。

web3.db.putString('testDB', 'key', 'myString') // true

web3.db.getString

web3.db.getString(db, key)

当我们想从本地leveldb数据库获取字符串时,应该调用这个方法。

参数
  1. String - 要从中检索的数据库字符串名称。
  2. 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形式存储二进制数据时,应该调用这个方法。

参数
  1. String - 要存储到的数据库。
  2. String - 商店的名称。
  3. String - 要存储的HEX字符串。
返回

Booleantrue如果成功,否则false

web3.db.putHex('testDB', 'key', '0x4f554b443'); // true

web3.db.getHex

web3.db.getHex(db, key)

这个方法应该被调用,当我们想从本地leveldb数据库中获得一个HEX形式的二进制数据。

参数
  1. String - 要存储到的数据库。
  2. 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])

这个方法应该被调用,当我们要发送悄悄话消息到网络。

参数
  1. Object - 帖子对象:
    • fromString,60字节HEX - (可选)发件人的身份。
    • toString,60字节HEX - (可选)接收者的身份。当耳语将加密的消息,只有接收者可以解密它。
    • topicsArray of Strings- 主题数组Strings,供接收者识别消息。
    • payloadString|Number|Object- 消息的有效载荷。之前会自动转换为HEX字符串。
    • priorityNumber- 从...(?)开始的优先级的整数。
    • ttlNumber- 以秒为单位的整数时间。
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

Booleantrue如果消息发送,则返回;否则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])

应该被称为创造新的身份。

参数
  1. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

String - 一个新的身份HEX字符串。

var identity = web3.shh.newIdentity();
console.log(identity); // "0xc931d93e97ab07fe42d923478ba2465f283f440fd6cabea4dd7a2c807108f651b7135d1d6ca9007d5b68aa497e4619ac10aa3b27726e1863c1fd9b570d99bbaf"

web3.shh.hasIdentity

web3.shh.hasIdentity(identity, [callback])

应该被调用,如果我们想检查用户是否给出了身份。

参数
  1. String - 要检查的身份。
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
返回

Booleantrue如果身份存在则返回,否则返回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);
});

留意接收到的低语消息。

参数
  1. Object - 过滤器选项:
    • topicsArray of Strings- 通过这个主题过滤消息。您可以使用以下组合:
      • ['topic1', 'topic2'] == 'topic1' && 'topic2'
      • ['topic1', ['topic2', 'topic3']] == 'topic1' && ('topic2' || 'topic3')
      • [null, 'topic1', 'topic2'] == ANYTHING && 'topic1' && 'topic2'- > null作为通配符使用
    • to:按照消息接收者的身份进行过滤。如果提供并且节点具有此标识,则它将解密传入的加密消息。
  2. Function - (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明
回调返回

Object - 传入消息:

  • fromString,60字节 - 邮件的发件人,如果指定了发件人。
  • toString,60字节 - 消息的接收者,如果指定了接收者。
  • expiryNumber- 此消息应该过期的时间(秒)的整数(?)。
  • ttlNumber- 消息在系统中以秒(?)为单位浮动的时间的整数。
  • sentNumber- 消息发送时的unix时间戳的整数。
  • topicsArray of StringString消息包含主题数组
  • payloadString- 消息的有效载荷。
  • workProvedNumber- 这个消息在发送之前需要的整数(?)。

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),其可以与所述启动consoleattach子命令。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。consoleattach子接受--exec这是一个JavaScript语句的参数。

$ geth --exec "eth.blockNumber" attach

这将打印正在运行的geth实例的当前块号。

或者使用更复杂的语句执行脚本:

$ geth --exec 'loadScript("/tmp/checkbalances.js")' attach
$ geth --jspath "/tmp" --exec 'loadScript("checkbalances.js")' attach

在这里找到一个示例脚本

使用--jspath 为您的js脚本设置libdir。loadScript()没有绝对路径的参数将被理解为相对于这个目录。

您可以通过键入exit或干脆退出控制台CTRL-C

警告

JSRE使用Otto JS VM有一些限制:

  • “严格使用”将解析,但什么都不做。
  • 正则表达式引擎(re2 / regexp)与ECMA5规范不完全兼容。

请注意,Otto的另一个已知的限制(即缺少定时器)被照顾。以太坊JSRE实现了setTimeoutsetInterval除此之外,控制台还提供admin.sleep(seconds)了“阻断睡眠”方法admin.sleepBlocks(number)

自从ethereum.js使用该bignumer.js库(MIT Expat License)以来,它也是自动安装的。

计时器

除了JS的全部功能(按照ECMA5)之外,JSRE还增加了各种定时器。它实现了setIntervalclearIntervalsetTimeoutclearTimeout您可以用来使用的浏览器窗口。它还提供了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}可以rpcunix或命名管道上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)
  • 个人
    • 新账户
    • listAccounts
    • 删除帐户
    • unlockAccount
  • 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/epochLengthdir指定一个目标目录,如果dir是空字符串,那么ethash将使用~/.ethashLinux和MacOS以及~\AppData\EthashWindows 的默认目录DAG文件的名字是full-R-

返回

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


netweb3.net的快捷方式


ETH

ethweb3.eth的快捷方式除了web3eth通过公开的接口web3.js一些额外的电话被曝光。


eth.sign

eth.sign(signer, data)

eth.pendingTransactions

eth.pendingTransactions

返回属于其中一个用户的未决事务eth.accounts


eth.resend

eth.resend(tx, , )

重新发送所返回的给定交易,pendingTransactions()并允许您覆盖交易的天然气价格和天然气限额。

eth.sendTransaction({from: eth.accounts[0], to: "...", gasPrice: "1000"})
var tx = eth.pendingTransactions()[0]
eth.resend(tx, web3.toWei(10, "szabo"))

shhweb3.shh的快捷方式


D b

dbweb3.db的快捷方式


检查

inspect方法漂亮打印给定的值(支持颜色)



你可能感兴趣的:(Dapp)