为了让您的应用程序能够在以太坊上工作,您可以使用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();
您将始终得到一个平衡值的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
对象提供了所有的方法。
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
// 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
// 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
// or async
web3.version.getNetwork(callback(error, result){ ... })
String
- 网络协议版本。
var version = web3.version.network;
console.log(version); // 54
web3.version.ethereum
// or async
web3.version.getEthereum(callback(error, result){ ... })
String
- 以太坊协议版本。
var version = web3.version.ethereum;
console.log(version); // 60
web3.version.whisper
// or async
web3.version.getWhisper(callback(error, result){ ... })
String
- 耳语协议版本。
var version = web3.version.whisper;
console.log(version); // 20
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(provider)
应该被称为设置提供者。
没有
undefined
web3.setProvider(new web3.providers.HttpProvider('http://localhost:8545')); // 8080 for cpp/AZ, 8545 for go/mist
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(keepIsSyncing)
应该调用重置web3的状态。重设除经理之外的所有事物 卸载所有过滤器。停止轮询。
Boolean
- 如果true
它将卸载所有的过滤器,但将保持web3.eth.isSyncing()民意调查undefined
web3.reset();
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(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(hexString);
将HEX字符串转换为ASCII字符串。
String
- 要转换为ASCII码的HEX字符串。String
- 由给定的ASCII字符串组成hexString
。
var str = web3.toAscii("0x657468657265756d000000000000000000000000000000000000000000000000");
console.log(str); // "ethereum"
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(hexString);
将HEX字符串转换为其数字表示形式。
String
- 要转换为数字的HEX字符串。Number
- 代表数据的数字hexString
。
var number = web3.toDecimal('0x15');
console.log(number); // 21
web3.fromDecimal(number);
将数字或数字字符串转换为HEX表示形式。
Number|String
- 要转换为HEX字符串的数字。String
- 表示给定的HEX字符串number
。
var value = web3.fromDecimal('21');
console.log(value); // "0x15"
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(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(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.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
// or async
web3.net.getPeerCount(callback(error, result){ ... })
该属性是只读的,并返回连接的对等体的数量。
Number
- 当前连接到客户端的对等点的数量。
var peerCount = web3.net.peerCount;
console.log(peerCount); // 4
包含以太坊区块链相关的方法。
var eth = web3.eth;
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
这个默认块用于以下方法(可选地,您可以通过将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
// 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(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
// or async
web3.eth.getCoinbase(callback(error, result){ ... })
这个属性是只读的,并返回采矿奖励去的coinbase地址。
String
- 客户的coinbase地址。
var coinbase = web3.eth.coinbase;
console.log(coinbase); // "0x407d73d8a49eeb85d32cf465507dd71d507100c1"
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
// or async
web3.eth.getHashrate(callback(error, result){ ... })
此属性是只读的,并返回节点正在挖掘的每秒散列数。
Number
- 每秒的哈希数。
var hashrate = web3.eth.hashrate;
console.log(hashrate); // 493736
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
// or async
web3.eth.getAccounts(callback(error, result){ ... })
该属性是只读的,并返回节点控制的帐户列表。
Array
- 由客户端控制的地址数组。
var accounts = web3.eth.accounts;
console.log(accounts); // ["0x407d73d8a49eeb85d32cf465507dd71d507100c1"]
web3.eth.blockNumber
// or async
web3.eth.getBlockNumber(callback(error, result){ ... })
此属性是只读的,并返回当前的块号。
Number
- 最近的块的数量。
var number = web3.eth.blockNumber;
console.log(number); // 2744
web3.eth.register(addressHexString [, callback])
(尚未实施)注册包含的给定地址web3.eth.accounts
。这允许将非私钥拥有的账户关联为一个拥有的账户(例如,合同钱包)。
String
- 要注册的地址Function
- (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明。?
web3.eth.register("0x407d73d8a49eeb85d32cf465507dd71d507100ca")
web3.eth.unRegister(addressHexString [, callback])
(尚未执行)取消注册给定的地址。
String
- 取消注册的地址。Function
- (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明。?
web3.eth.unregister("0x407d73d8a49eeb85d32cf465507dd71d507100ca")
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(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(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(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(hashStringOrBlockNumber [, callback])
返回给定块中的事务数。
String|Number
- 块号或散列。或者是字符串"earliest"
,"latest"
或者"pending"
像默认的block参数那样。Function
- (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明。Number
- 给定块中的事务数量。
var number = web3.eth.getBlockTransactionCount("0x407d73d8a49eeb85d32cf465507dd71d507100c1");
console.log(number); // 1
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(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"
}
*/
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(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(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(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(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(callObject [, defaultBlock] [, callback])
执行消息调用或事务,该消息调用或事务在节点的VM中直接执行,但从未开采到区块链中并返回所使用的气体量。
请参阅web3.eth.sendTransaction,期望所有属性都是可选的。
Number
- 用于模拟呼叫/交易的废气。
var result = web3.eth.estimateGas({
to: "0xc4abd0339eb8d57087278718986382264244252f",
data: "0xc6888fa10000000000000000000000000000000000000000000000000000000000000003"
});
console.log(result); // "0x0000000000000000000000000000000000000000000000000000000000000015"
// 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(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();
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([callback])
获取可用编译器的列表。
Function
- (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明。Array
- 可用编译器的字符串数组。
var number = web3.eth.getCompilers();
console.log(number); // ["lll", "solidity", "serpent"]
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(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(sourceString [, callback])
编译蛇的源代码。
String
- 蛇的源代码。Function
- (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明。String
- 编译后的代码为HEX字符串。
var source = "...";
var code = web3.eth.compile.serpent(source);
console.log(code); // "0x603880600c6000396000f3006001600060e060020a600035048063c6888fa114601857005b6021600435602b565b8060005260206000f35b600081600702905091905056"
web3.eth.namereg
返回GlobalRegistrar对象。
参见namereg示例
web3.db.putString(db, key, value)
当我们要在本地leveldb数据库中存储一个字符串时,应该调用这个方法。
String
- 要存储到的数据库。String
- 商店的名称。String
- 要存储的字符串值。Boolean
- true
如果成功,否则false
。
参数是db名称,第二个是键,第三个是字符串值。
web3.db.putString('testDB', 'key', 'myString') // true
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(db, key, value)
当我们要在本地leveldb数据库中以HEX形式存储二进制数据时,应该调用这个方法。
String
- 要存储到的数据库。String
- 商店的名称。String
- 要存储的HEX字符串。Boolean
- true
如果成功,否则false
。
web3.db.putHex('testDB', 'key', '0x4f554b443'); // true
web3.db.getHex(db, key)
这个方法应该被调用,当我们想从本地leveldb数据库中获得一个HEX形式的二进制数据。
String
- 要存储到的数据库。String
- 商店的名称。String
- 存储的十六进制值。
param是db名字,第二个是键值。
var value = web3.db.getHex('testDB', 'key');
console.log(value); // "0x4f554b443"
耳语概述
var shh = web3.shh;
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([callback])
应该被称为创造新的身份。
Function
- (可选)如果传递一个回调,HTTP请求将变为异步。详情请参阅此说明。String
- 一个新的身份HEX字符串。
var identity = web3.shh.newIdentity();
console.log(identity); // "0xc931d93e97ab07fe42d923478ba2465f283f440fd6cabea4dd7a2c807108f651b7135d1d6ca9007d5b68aa497e4619ac10aa3b27726e1863c1fd9b570d99bbaf"
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
// TODO: not implemented yet
// TODO: not implemented yet
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
- 这个消息在发送之前需要的整数(?)。var txHash = web3.eth.sendIBANTransaction('0x00c5496aee77c1ba1f0854206a26dda82a81d6d8', 'XE81ETHXREGGAVOFYORK', 0x100);
从用户帐户发送IBAN交易到目的地IBAN地址。
string
- 我们要发送交易的地址string
- 我们想要发送交易的IBAN地址value
- 我们想要在IBAN交易中发送的价值var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var i = web3.eth.iban.fromAddress('0x00c5496aee77c1ba1f0854206a26dda82a81d6d8');
console.log(i.toString()); // 'XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS
var i = web3.eth.iban.fromBban('ETHXREGGAVOFYORK');
console.log(i.toString()); // "XE81ETHXREGGAVOFYORK"
var i = web3.eth.iban.createIndirect({
institution: "XREG",
identifier: "GAVOFYORK"
});
console.log(i.toString()); // "XE81ETHXREGGAVOFYORK"
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
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var direct = i.isDirect();
console.log(direct); // false
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var indirect = i.isIndirect();
console.log(indirect); // true
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var checksum = i.checksum();
console.log(checksum); // "81"
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var institution = i.institution();
console.log(institution); // 'XREG'
var i = new web3.eth.iban("XE81ETHXREGGAVOFYORK");
var client = i.client();
console.log(client); // 'GAVOFYORK'
var i = new web3.eth.iban('XE7338O073KYGTWWZN0F2WZ0R8PX5ZPPZS');
var address = i.address();
console.log(address); // '00c5496aee77c1ba1f0854206a26dda82a81d6d8'
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
为您的js脚本设置libdir。loadScript()
没有绝对路径的参数将被理解为相对于这个目录。您可以通过键入
exit
或干脆退出控制台CTRL-C
。警告
JSRE使用Otto JS VM有一些限制:
请注意,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个确认”。
除了官方的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"
将
请注意,通过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
该personal
API公开方法为个人的方法来管理,控制或监视您的节点。它允许有限的文件系统访问。
personal.listAccounts
列出所有帐户
与帐户收集
personal.listAccounts
personal.newAccount(passwd)
创建一个新的密码保护的帐户
string
新帐户的地址
personal.newAccount("mypasswd")
personal.deleteAccount(addr, passwd)
删除具有给定地址和密码的帐户
指示账户是否被删除
personal.deleteAccount(eth.coinbase, "mypasswd")
personal.unlockAccount(addr, passwd, duration)
使用给定的地址,密码和可选的持续时间(秒)解锁账户。
boolean
指示账户是否被解锁
personal.unlockAccount(eth.coinbase, "mypasswd", 300)
txpool.status
待处理/排队交易的数量
pending
所有可处理的交易
queued
所有不可处理的交易
txpool.status
该admin
公开的管理,控制或监视您节点的方法。它允许有限的文件系统访问。
admin.chainSyncStatus
打印区块链同步的信息。
blocksAvailable
,还没有被下载的块
blocksWaitingForImport
,导入之前等待下载的块
estimate
,在节点导入所有块之前的(非常粗略的)估计
importing
,目前正在导入的块
admin.verbosity(level)
记录器详细级别设置为级别。1-6:沉默,错误,警告,信息,调试,细节
> admin.verbosity(6)
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(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
[ { 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(file)
从编组二进制格式导入区块链。 请注意,在导入的块被插入到链中之前,区块链被重置(生成)。
true
否则就成功了false
。
admin.importChain('path/to/file')
// true
admin.exportChain(file)
以二进制格式将区块链导出到给定文件。
true
否则就成功了false
。
admin.exportChain('path/to/file')
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()
停止JSON-RPC的HTTP服务器。
true
否则就成功了false
。
admin.stopRPC()
// true
admin.sleepBlocks(n)
睡n块。
admin.datadir
该节点存储其数据的目录
目录成功
admin.datadir
'/Users/username/Library/Ethereum'
admin.setSolc(path2solc)
设置固体编译器
描述路径有效时编译器版本的字符串,否则为错误
admin.setSolc('/some/path/solc')
'solc v0.9.29
Solidity Compiler: /some/path/solc
'
admin.startNatSpec()
激活NatSpec:将事务发送到合同时,将使用注册表查找和url提取来为其检索真实的合同信息。它允许用户提供真实的特定于合同的确认消息。
admin.stopNatSpec()
停用NatSpec:发送一个事务时,用户将被提示一个通用的确认消息,没有合约信息被提取
admin.getContractInfo(address)
这将检索地址上合同的合同信息json
返回合同信息对象
> info = admin.getContractInfo(contractaddress)
> source = info.source
> abi = info.abiDefinition
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(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(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(threadCount)
从给定的并行线程开始挖掘threadNumber
。这是一个可选的参数。
true
否则就成功了false
。
miner.start()
// true
miner.stop(threadCount)
阻止threadCount
矿工。这是一个可选的参数。
true
否则就成功了false
。
miner.stop()
// true
miner.startAutoDAG()
开始ethash DAG的自动预生成。这个过程确保后续时代的DAG可用,允许在新纪元开始后立即开采。如果这被大多数网络节点使用,则在时期转换期间,阻塞时间预期是正常的。自动DAG在采矿开始时自动打开,当矿工停止时关闭。
true
否则就成功了false
。
miner.stopAutoDAG()
停止ethash DAG的自动预生成。采矿停止时,自动DAG将自动关闭。
true
否则就成功了false
。
miner.makeDAG(blockNumber, dir)
为时代生成DAG blockNumber/epochLength
。dir指定一个目标目录,如果dir
是空字符串,那么ethash将使用~/.ethash
Linux和MacOS以及~\AppData\Ethash
Windows 上的默认目录。DAG文件的名字是full-
true
否则就成功了false
。
miner.hashrate
以H / s返回当前的散列速率。
miner.setExtra("extra data")
找到块时设置块的额外数据。限于32个字节。
miner.setGasPrice(gasPrice)
设置矿工的价格
miner.setEtherbase(account)
设置以太基地,将获得采矿奖励的地址。
debug.setHead(blockNumber)
将区块链的当前头部设置为由blockNumber引用的块。请参阅web3.eth.getBlock以获取有关块字段的更多详细信息,并通过编号或散列进行查找。
true
否则就成功了false
。
debug.setHead(eth.blockNumber-1000)
debug.seedHash(blockNumber)
返回给定块所在时元的散列值。
散列在十六进制格式
> debug.seedHash(eth.blockNumber)
'0xf2e59013a0a379837166b59f871b20a8a0d101d1c355ea85d35329360e69c000'
debug.processBlock(blockNumber)
在调试模式下,使用VM 处理由blockNumber引用的给定块。请参阅web3.eth.getBlock以获取有关块字段的更多详细信息,并通过编号或散列进行查找。结合使用setHead
,这可以用来重播块的处理来调试虚拟机的执行。
true
否则就成功了false
。
debug.processBlock(140101)
debug.getBlockRlp(blockNumber)
返回块的RLP编码的十六进制表示形式。请参阅web3.eth.getBlock以获取有关块字段的更多详细信息,并通过编号或散列进行查找。
块的RLP编码的十六进制表示。
> debug.getBlockRlp(131805) 'f90210f9020ba0ea4dcb53fe575e23742aa30266722a15429b7ba3d33ba8c87012881d7a77e81ea01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794a4d8e9cae4d04b093aac82e6cd355b6b963fb7ffa01f892bfd6f8fb2ec69f30c8799e371c24ebc5a9d55558640de1fb7ca8787d26da056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b901000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000083bb9266830202dd832fefd880845534406d91ce9e5448ce9ed0af535048ce9ed0afce9ea04cf6d2c4022dfab72af44e9a58d7ac9f7238ffce31d4da72ed6ec9eda60e1850883f9e9ce6a261381cc0c0'
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(blockNumber)
块号或块散列引用的块的原始转储,或者如果找不到块,则为undefined。请参阅web3.eth.getBlock获取有关块字段的更多详细信息,并通过编号或散列查找。
> debug.dumpBlock(eth.blockNumber)
debug.metrics(raw)
指标的收集,参见这个 wiki页面的更多信息。
> metrics(true)
loadScript('/path/to/myfile.js');
加载一个JavaScript文件并执行它。相对路径被解释为相对jspath
于其被指定为命令行标志,请参阅命令行选项。
sleep(s)
睡了几秒钟。
setInterval(s, func() {})
该web3
公开的所有方法的JavaScript API。
这net
是web3.net的快捷方式。
这eth
是web3.eth的快捷方式。除了web3
和eth
通过公开的接口web3.js一些额外的电话被曝光。
eth.sign(signer, data)
eth.pendingTransactions
返回属于其中一个用户的未决事务eth.accounts
。
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"))
这shh
是web3.shh的快捷方式。
这db
是web3.db的快捷方式。
该inspect
方法漂亮打印给定的值(支持颜色)