区块链

以太坊源码解析（六）JSON-RPC API

Posted by 姚飞亮 on 2020-07-11

以太坊源码解析（六）JSON-RPC API

JSON-RPC服务器

Geth支持所有标准的web3 JSON-RPC API。您可以在Ethereum Wiki JSON-RPC页面上找到这些API的文档。

JSON-RPC在多种传输方式上提供。Geth支持基于HTTP，WebSocket和Unix域套接字的JSON-RPC。必须通过命令行标志启用传输。

以太坊JSON-RPC API使用命名空间系统。RPC方法根据其用途分为几类。所有方法名称均由名称空间，下划线和名称空间内的实际方法名称组成。例如，该eth_call方法位于eth名称空间中。

可以基于每个命名空间启用对RPC方法的访问。在边栏中查找各个名称空间的文档。

HTTP服务器

要启用HTTP服务器，请使用--rpc标志。

1
geth --rpc

默认情况下，geth接受来自回送接口（127.0.0.1）的连接。默认监听端口为8545。您可以使用--rpcport和--rpcaddr标志来自定义地址和端口 。

1
geth --rpc --rpcport 3334

必须将JSON-RPC方法名称空间列入白名单，才能通过HTTP服务器使用。-32602如果调用未列入白名单的名称空间，则会生成带有错误代码的RPC错误。默认白名单允许访问“ eth”和“ shh”名称空间。要启用对其他API（例如帐户管理（“个人”）和调试（“调试”））的访问，必须通过该--rpcapi标志对其进行配置。我们不建议您通过HTTP启用此类API，因为对这些方法的访问会增加攻击面。

1
geth --rpc --rpcapi personal,eth,net,web3b

由于可以从任何本地应用程序访问HTTP服务器，因此服务器中内置了附加保护功能，以防止从网页滥用API。如果要允许从网页访问API，则必须将服务器配置为接受带有--rpccorsdomain标志的跨域请求。

示例：如果您想将Remix与geth 一起使用，请允许来自remix域的请求。

1
geth --rpc --rpccorsdomain https://remix.ethereum.org

使用--rpccorsdomain '*'，以便从任何来源获得。

WebSocket服务器

WebSocket终结点的配置类似于HTTP传输。要启用WebSocket访问，请使用--ws标志。默认的WebSocket端口是8546。--wsaddr，--wsport和--wsapi标志可用于自定义WebSocket服务器的设置。

1
geth --ws --wsport 3334 --wsapi eth,net,web3

跨域请求保护也适用于WebSocket服务器。使用该 --wsorigins标志允许从网页访问服务器：

1
geth --ws --wsorigins http://myapp.example.com

与一样--rpccorsdomain，使用--wsorigins '*'可以从任何来源访问。

IPC服务器

UNIX域套接字上还提供了JSON-RPC API。该服务器默认情况下处于启用状态，并且可以访问所有JSON-RPC名称空间。

默认情况下，侦听套接字位于数据目录中。在Linux和macOS上，geth套接字的默认位置是

1
~/.ethereum/geth.ipc

在Windows上，通过命名管道提供IPC。geth管道的默认位置是：

1
\\.\pipe\geth.ipc

您可以使用该--ipcpath标志配置套接字的位置。可以使用该--ipcdisable标志禁用IPC 。

实时事件

Geth v1.4和更高版本支持使用JSON-RPC通知进行发布/订阅。这使客户端可以等待事件而不是轮询事件。

它通过订阅特定事件来工作。该节点将返回订阅ID。对于与订阅匹配的每个事件，带有相关数据的通知将与订阅ID一起发送。

例：

1
2
3
4
5
6
7
8
9
10
11
// create subscription
>> {"id": 1, "method": "eth_subscribe", "params": ["newHeads", {}]}
<< {"jsonrpc":"2.0","id":1,"result":"0xcd0c3e8af590364c09d0fa6a1210faf5"}

// incoming notifications
<< {"jsonrpc":"2.0","method":"eth_subscription","params":{"subscription":"0xcd0c3e8af590364c09d0fa6a1210faf5","result":{"difficulty":"0xd9263f42a87",<...>, "uncles":[]}}}
<< {"jsonrpc":"2.0","method":"eth_subscription","params":{"subscription":"0xcd0c3e8af590364c09d0fa6a1210faf5","result":{"difficulty":"0xd90b1a7ad02", <...>, "uncles":["0x80aacd1ea4c9da32efd8c2cc9ab38f8f70578fcd46a1a4ed73f82f3e0957f936"]}}}

// cancel subscription
>> {"id": 1, "method": "eth_unsubscribe", "params": ["0xcd0c3e8af590364c09d0fa6a1210faf5"]}
<< {"jsonrpc":"2.0","id":1,"result":true}

注意事项

  1. 通知是针对当前事件而不是针对过去事件发送的。如果您的用例要求您不要错过任何通知，那么订阅可能不是最佳选择。
  2. 订阅需要全双工连接。Geth以WebSocket和IPC的形式提供此类连接（默认情况下启用）。
  3. 订阅耦合到连接。如果连接已关闭，则将删除通过该连接创建的所有订阅。
  4. 通知存储在内部缓冲区中，并从该缓冲区发送到客户端。如果客户端无法跟上，并且缓冲的通知数达到限制（当前为10k），则连接将关闭。请记住，订阅某些事件可能会导致大量通知，例如，在节点开始同步时侦听所有日志/块。

创建订阅

订阅是使用常规RPC调用创建的，其中RPC eth_subscribe作为方法，订阅名称为第一个参数。如果成功，则返回订阅ID。

参量

  1. 订阅名称
  2. 可选参数

例

1
2
>> {"id": 1, "method": "eth_subscribe", "params": ["newHeads", {"includeTransactions": true}]}
<< {"id": 1, "jsonrpc": "2.0", "result": "0x9cef478923ff08bf67fde6c64013158d"}

取消订阅

使用常规的RPC调用取消订阅，该调用使用eth_unsubscribeas方法并将订阅id作为第一个参数。它返回一个布尔值，指示是否成功取消了订阅。

参量

  1. 订阅编号

例

1
2
>> {"id": 1, "method": "eth_unsubscribe", "params": ["0x9cef478923ff08bf67fde6c64013158d"]}
<< {"jsonrpc":"2.0","id":1,"result":true}

支持的订阅

newHeads

每次将新标头附加到链（包括链重组）时，都会触发通知。用户可以使用Bloom筛选器确定该块是否包含对其感兴趣的日志。

如果进行链重组，则订阅将发出新链的所有新标头。因此，订阅可以在相同高度上发出多个标头。

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
>> {"id": 1, "method": "eth_subscribe", "params": ["newHeads"]}
<< {"jsonrpc":"2.0","id":2,"result":"0x9ce59a13059e417087c02d3236a0b1cc"}

<< {
       "jsonrpc": "2.0",
       "method": "eth_subscription",
       "params": {
         "result": {
           "difficulty": "0x15d9223a23aa",
           "extraData": "0xd983010305844765746887676f312e342e328777696e646f7773",
           "gasLimit": "0x47e7c4",
           "gasUsed": "0x38658",
           "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
           "miner": "0xf8b483dba2c3b7176a3da549ad41a48bb3121069",
           "nonce": "0x084149998194cc5f",
           "number": "0x1348c9",
           "parentHash": "0x7736fab79e05dc611604d22470dadad26f56fe494421b5b333de816ce1f25701",
           "receiptRoot": "0x2fab35823ad00c7bb388595cb46652fe7886e00660a01e867824d3dceb1c8d36",
           "sha3Uncles": "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
           "stateRoot": "0xb3346685172db67de536d8765c43c31009d0eb3bd9c501c9be3229203f15f378",
           "timestamp": "0x56ffeff8",
           "transactionsRoot": "0x0167ffa60e3ebc0b080cdb95f7c0087dd6c0e61413140e39d94d3468d7c9689f"
         },
         "subscription": "0x9ce59a13059e417087c02d3236a0b1cc"
       }
     }

日志

返回包含在新导入的块中并符合给定过滤条件的日志。

如果进行链重组，则将重新发送旧链上的先前发送的日志，并将removed属性设置为true。来自结束于新链中的事务的日志被发出。因此，订阅可以多次发出同一事务的日志。

参量

  1. 1
    object

    具有以下（可选）字段

    • address，一个地址或一个地址数组。仅返回从这些地址创建的日志（可选）
    • topic，仅匹配指定主题的日志（可选）

例

1
2
3
4
>> {"id": 1, "method": "eth_subscribe", "params": ["logs", {"address": "0x8320fe7702b96808f7bbc0d4a888ed1468216cfd", "topics": ["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"]}]}
<< {"jsonrpc":"2.0","id":2,"result":"0x4a8a4c0517381924f9838102c5a4dcb7"}

<< {"jsonrpc":"2.0","method":"eth_subscription","params": {"subscription":"0x4a8a4c0517381924f9838102c5a4dcb7","result":{"address":"0x8320fe7702b96808f7bbc0d4a888ed1468216cfd","blockHash":"0x61cdb2a09ab99abf791d474f20c2ea89bf8de2923a2d42bb49944c8c993cbf04","blockNumber":"0x29e87","data":"0x00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000003","logIndex":"0x0","topics":["0xd78a0cb8bb633d06981248b816e7bd33c2a35a6089241d099fa519e361cab902"],"transactionHash":"0xe044554a0a55067caafd07f8020ab9f2af60bdfe337e395ecd84b4877a3d1ab4","transactionIndex":"0x0"}}}

newPendingTransactions

返回添加到挂起状态并使用节点中可用密钥签名的所有事务的哈希。

当重新定义后，以前属于规范链的交易不属于新规范链的交易。

参量

没有

例

1
2
3
4
5
6
7
8
9
10
>> {"id": 1, "method": "eth_subscribe", "params": ["newPendingTransactions"]}
<< {"jsonrpc":"2.0","id":2,"result":"0xc3b33aa549fb9a60e95d21862596617c"}
<< {
        "jsonrpc":"2.0",
        "method":"eth_subscription",
        "params":{
            "subscription":"0xc3b33aa549fb9a60e95d21862596617c",
            "result":"0xd6fdc5cc41a9959e922f30cb772a9aef46f4daea279307bc5f7024edc4ccd7fa"
        }
   }

正在同步

指示节点何时开始或停止同步。结果可以是指示同步已开始（true），完成（false）的布尔值，也可以是具有各种进度指示器的对象。

参量

没有

例

1
2
3
4
>> {"id": 1, "method": "eth_subscribe", "params": ["syncing"]}
<< {"jsonrpc":"2.0","id":2,"result":"0xe2ffeb2703bcf602d42922385829ce96"}

<< {"subscription":"0xe2ffeb2703bcf602d42922385829ce96","result":{"syncing":true,"status":{"startingBlock

管理员命名空间

该adminAPI使您可以访问几种非标准RPC方法，这将使您能够对Geth实例进行精细控制，包括但不限于网络对等方和RPC端点管理。

admin_addPeer

该addPeer管理方法要求将新的远程节点添加到跟踪的静态节点列表中。该节点将一直尝试保持与这些节点的连接，如果远程连接断开，则每隔一段时间重新连接一次。

该方法接受一个参数，即enode 远程对等方的URL以开始跟踪，并返回一个BOOL指示是否接受对等方进行跟踪或发生了一些错误。

客户 方法调用
Go admin.AddPeer(url string) (bool, error)
Console admin.addPeer(url)
RPC {"method": "admin_addPeer", "params": [url]}

例

1
2
> admin.addPeer("enode://a979fb575495b8d6db44f750317d0f4622bf4c2aa3365d6af7c284339968eef29b69ad0dce72a4d8db5ebb4968de0e3bec910127f134779fbcb0cb6d3331163c@52.16.188.185:30303")
true

admin_datadir

该datadir行政财产，可以被询问运行Geth的节点当前用来存储所有数据库的绝对路径。

客户 方法调用
Go admin.Datadir() (string, error）
Console admin.datadir
RPC {"method": "admin_datadir"}

例

1
2
> admin.datadir
"/home/john/.ethereum"

admin_nodeInfo

nodeInfo可以在网络粒度上查询有关正在运行的Geth节点的所有已知信息的管理属性。这些包括关于节点本身作为的参与者一般信息ÐΞVp2p P2P覆盖协议由每个运行的应用程序的协议加入，以及专门的信息（例如eth，les，shh，bzz）。

客户 方法调用
Go admin.NodeInfo() (*p2p.NodeInfo, error）
Console admin.nodeInfo
RPC {"method": "admin_nodeInfo"}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
> admin.nodeInfo
{
  enode: "enode://44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d@[::]:30303",
  id: "44826a5d6a55f88a18298bca4773fca5749cdc3a5c9f308aa7d810e9b31123f3e7c5fba0b1d70aac5308426f47df2a128a6747040a3815cc7dd7167d03be320d",
  ip: "::",
  listenAddr: "[::]:30303",
  name: "Geth/v1.5.0-unstable/linux/go1.6",
  ports: {
    discovery: 30303,
    listener: 30303
  },
  protocols: {
    eth: {
      difficulty: 17334254859343145000,
      genesis: "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3",
      head: "0xb83f73fbe6220c111136aefd27b160bf4a34085c65ba89f24246b3162257c36a",
      network: 1
    }
  }
}

admin_peers

peers可以查询联网属性下有关连接的远程节点的所有已知信息的管理属性。这些包括关于节点本身作为参与者一般信息ÐΞVp2p P2P覆盖协议由每个运行的应用程序的协议加入，以及专门的信息（例如eth，les，shh，bzz）。

客户 方法调用
Go admin.Peers() ([]*p2p.PeerInfo, error）
Console admin.peers
RPC {"method": "admin_peers"}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
> admin.peers
[{
    caps: ["eth/61", "eth/62", "eth/63"],
    id: "08a6b39263470c78d3e4f58e3c997cd2e7af623afce64656cfc56480babcea7a9138f3d09d7b9879344c2d2e457679e3655d4b56eaff5fd4fd7f147bdb045124",
    name: "Geth/v1.5.0-unstable/linux/go1.5.1",
    network: {
      localAddress: "192.168.0.104:51068",
      remoteAddress: "71.62.31.72:30303"
    },
    protocols: {
      eth: {
        difficulty: 17334052235346465000,
        head: "5794b768dae6c6ee5366e6ca7662bdff2882576e09609bf778633e470e0e7852",
        version: 63
      }
    }
}, /* ... */ {
    caps: ["eth/61", "eth/62", "eth/63"],
    id: "fcad9f6d3faf89a0908a11ddae9d4be3a1039108263b06c96171eb3b0f3ba85a7095a03bb65198c35a04829032d198759edfca9b63a8b69dc47a205d94fce7cc",
    name: "Geth/v1.3.5-506c9277/linux/go1.4.2",
    network: {
      localAddress: "192.168.0.104:55968",
      remoteAddress: "121.196.232.205:30303"
    },
    protocols: {
      eth: {
        difficulty: 17335165914080772000,
        head: "5794b768dae6c6ee5366e6ca7662bdff2882576e09609bf778633e470e0e7852",
        version: 63
      }
    }
}]

admin_startRPC

该startRPC管理方法启动基于HTTP的JSON RPC API Web服务器来处理客户端请求。所有参数都是可选的：

  • host：用于打开监听器套接字的网络接口（默认为"localhost"）
  • port：用于打开侦听器套接字的网络端口（默认为8545）
  • cors：要使用的跨域资源共享标头（默认为""）
  • apis：通过此接口提供的API模块（默认为"eth,net,web3"）

该方法返回一个布尔标志，用于指定是否打开HTTP RPC侦听器。请注意，任何时候都只允许一个HTTP端点处于活动状态。

客户 方法调用
Go admin.StartRPC(host *string, port *rpc.HexNumber, cors *string, apis *string) (bool, error)
Console admin.startRPC(host, port, cors, apis)
RPC {"method": "admin_startRPC", "params": [host, port, cors, apis]}

例

1
2
> admin.startRPC("127.0.0.1", 8545)
true

admin_startWS

该startWS管理方法启动基于WebSocket的JSON RPC API Web服务器来处理客户端请求。所有参数都是可选的：

  • host：用于打开监听器套接字的网络接口（默认为"localhost"）
  • port：用于打开侦听器套接字的网络端口（默认为8546）
  • cors：要使用的跨域资源共享标头（默认为""）
  • apis：通过此接口提供的API模块（默认为"eth,net,web3"）

该方法返回一个布尔标志，指定是否打开WebSocket RPC侦听器。请注意，任何时候都只允许一个WebSocket端点处于活动状态。

客户 方法调用
Go admin.StartWS(host *string, port *rpc.HexNumber, cors *string, apis *string) (bool, error)
Console admin.startWS(host, port, cors, apis)
RPC {"method": "admin_startWS", "params": [host, port, cors, apis]}

例

1
2
> admin.startWS("127.0.0.1", 8546)
true

admin_stopRPC

该stopRPC管理方法将关闭当前打开的HTTP RPC端点。由于节点只能运行一个HTTP终结点，因此此方法不使用任何参数，无论终结点是否关闭，都返回一个布尔值。

客户 方法调用
Go admin.StopRPC() (bool, error）
Console admin.stopRPC()
RPC {"method": "admin_stopRPC"

例

1
2
> admin.stopRPC()
true

admin_stopWS

该stopWS管理方法将关闭当前打开的WebSocket RPC端点。由于节点只能运行一个WebSocket端点，因此此方法不使用任何参数，无论端点是否关闭，都返回一个布尔值。

客户 方法调用
Go admin.StopWS() (bool, error）
Console admin.stopWS()
RPC {"method": "admin_stopWS"

例

1
2
> admin.stopWS()
true

集团命名空间

该cliqueAPI提供对集团共识引擎状态的访问。您可以使用此API来管理签名者的投票并检查专用网络的运行状况。

clique_getSnapshot

检索给定块上所有集团状态的快照。

客户 方法调用
Console clique.getSnapshot(blockNumber)
RPC {"method": "clique_getSnapsnot", "params": [blockNumber]}

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
> clique.getSnapshot(5463755)
{
  hash: "0x018194fc50ca62d973e2f85cffef1e6811278ffd2040a4460537f8dbec3d5efc",
  number: 5463755,
  recents: {
    5463752: "0x42eb768f2244c8811c63729a21a3569731535f06",
    5463753: "0x6635f83421bf059cd8111f180f0727128685bae4",
    5463754: "0x7ffc57839b00206d1ad20c69a1981b489f772031",
    5463755: "0xb279182d99e65703f0076e4812653aab85fca0f0"
  },
  signers: {
    0x42eb768f2244c8811c63729a21a3569731535f06: {},
    0x6635f83421bf059cd8111f180f0727128685bae4: {},
    0x7ffc57839b00206d1ad20c69a1981b489f772031: {},
    0xb279182d99e65703f0076e4812653aab85fca0f0: {},
    0xd6ae8250b8348c94847280928c79fb3b63ca453e: {},
    0xda35dee8eddeaa556e4c26268463e26fb91ff74f: {},
    0xfc18cbc391de84dbd87db83b20935d3e89f5dd91: {}
  },
  tally: {},
  votes: []
}

clique_getSnapshotAtHash

检索给定块上的状态快照。

客户 方法调用
Console clique.getSnapshotAtHash(blockHash)
RPC {"method": "clique_getSnapshotAtHash", "params": [blockHash]}

clique_getSigners

检索指定块上的授权签署者列表。

客户 方法调用
Console clique.getSigners(blockNumber)
RPC {"method": "clique_getSigners", "params": [blockNumber]}

clique_proposals

返回节点正在投票的当前投标。

客户 方法调用
Console clique.proposals()
RPC {"method": "clique_proposals", "params": []}

clique_propose

添加签名者将尝试推送的新授权提议。如果 auth参数为true，则本地签名者对给定地址进行投票，以将其包括在授权签名者集中。如果auth设置为false，则投票反对该地址。

客户 方法调用
Console clique.propose(address, auth)
RPC {"method": "clique_propose", "params": [address, auth]}

clique_discard

此方法删除当前正在运行的投标。签名者将不会对该地址再投票（赞成或反对）。

客户 方法调用
Console clique.discard(address)
RPC {"method": "clique_discard", "params": [address]}

clique_status

这是一种调试方法，可返回有关最后64个块的签名者活动的统计信息。返回的对象包含以下字段：

  • inturnPercent：依次签名的块百分比
  • sealerActivity：包含签名者地址及其签名的块数的对象
  • numBlocks：分析的块数
客户 方法调用
Console clique.status()
RPC {"method": "clique_status", "params": [}

例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
> clique.status()
{
  inturnPercent: 100,
  numBlocks: 64,
  sealerActivity: {
    0x42eb768f2244c8811c63729a21a3569731535f06: 9,
    0x6635f83421bf059cd8111f180f0727128685bae4: 9,
    0x7ffc57839b00206d1ad20c69a1981b489f772031: 9,
    0xb279182d99e65703f0076e4812653aab85fca0f0: 10,
    0xd6ae8250b8348c94847280928c79fb3b63ca453e: 9,
    0xda35dee8eddeaa556e4c26268463e26fb91ff74f: 9,
    0xfc18cbc391de84dbd87db83b20935d3e89f5dd91: 9
  }
}

调试命名空间

通过该debugAPI，您可以访问几种非标准的RPC方法，从而可以在运行时检查，调试和设置某些调试标志。

debug_backtraceAt

设置日志回溯位置。当设置了backtrace位置并在该位置发出日志消息时，执行log语句的goroutine堆栈将被打印到stderr。

该位置指定为:。

客户 方法调用
Console debug.backtraceAt(string)
RPC {"method": "debug_backtraceAt", "params": [string]}

例：

1
> debug.backtraceAt("server.go:443")

debug_blockProfile

在给定的时间段内打开块分析，并将配置文件数据写入磁盘。它使用1的配置文件速率来获取最准确的信息。如果需要不同的速率，请设置速率并使用手动写入配置文件 debug_writeBlockProfile。

客户 方法调用
Console debug.blockProfile(file, seconds)
RPC {"method": "debug_blockProfile", "params": [string, number]}

debug_cpuProfile

在给定的时间内打开CPU性能分析，并将配置文件数据写入磁盘。

客户 方法调用
Console debug.cpuProfile(file, seconds)
RPC {"method": "debug_cpuProfile", "params": [string, number]}

debug_dumpBlock

检索与块编号相对应的状态，并返回帐户列表（包括存储和代码）。

客户 方法调用
Go debug.DumpBlock(number uint64) (state.World, error)
Console debug.traceBlockByHash(number, [options])
RPC {"method": "debug_dumpBlock", "params": [number]}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
> debug.dumpBlock(10)
{
    fff7ac99c8e4feb60c9750054bdc14ce1857f181: {
      balance: "49358640978154672",
      code: "",
      codeHash: "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
      nonce: 2,
      root: "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
      storage: {}
    },
    fffbca3a38c3c5fcb3adbb8e63c04c3e629aafce: {
      balance: "3460945928",
      code: "",
      codeHash: "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
      nonce: 657,
      root: "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
      storage: {}
    }
  },
  root: "19f4ed94e188dd9c7eb04226bd240fa6b449401a6c656d6d2816a87ccaf206f1"
}

debug_gcStats

返回GC统计信息。

有关返回的对象的字段的信息，请参见https://golang.org/pkg/runtime/debug/#GCStats。

客户 方法调用
Console debug.gcStats()
RPC {"method": "debug_gcStats", "params": []}

debug_getBlockRlp

按编号检索并返回RLP编码的块。

客户 方法调用
Go debug.GetBlockRlp(number uint64) (string, error)
Console debug.getBlockRlp(number, [options])
RPC {"method": "debug_getBlockRlp", "params": [number]}

参考：RLP

debug_goTrace

在给定的持续时间内打开Go运行时跟踪，并将跟踪数据写入磁盘。

客户 方法调用
Console debug.goTrace(file, seconds)
RPC {"method": "debug_goTrace", "params": [string, number]}

debug_memStats

返回详细的运行时内存统计信息。

有关返回的对象的字段的信息，请参见https://golang.org/pkg/runtime/#MemStats。

客户 方法调用
Console debug.memStats()
RPC {"method": "debug_memStats", "params": []}

debug_seedHash

按编号获取和检索块的种子哈希

客户 方法调用
Go debug.SeedHash(number uint64) (string, error)
Console debug.seedHash(number, [options])
RPC {"method": "debug_seedHash", "params": [number]}

debug_setHead

通过块号设置本地链的当前首部。请注意，这是一种破坏性行为，可能会严重损坏您的链条。使用时要格外小心。

客户 方法调用
Go debug.SetHead(number uint64)
Console debug.setHead(number)
RPC {"method": "debug_setHead", "params": [number]}

参考： Ethash

debug_setBlockProfileRate

设置goroutine块概要文件数据收集的速率（以样本/秒为单位）。非零速率启用块分析，将其设置为零将停止配置文件。收集的配置文件数据可以使用写入debug_writeBlockProfile。

客户 方法调用
Console debug.setBlockProfileRate(rate)
RPC {"method": "debug_setBlockProfileRate", "params": [number]}

debug_stacks

返回所有goroutine堆栈的打印表示形式。请注意，此方法的web3包装器负责打印，并且不返回字符串。

客户 方法调用
Console debug.stacks()
RPC {"method": "debug_stacks", "params": []}

debug_startCPUProfile

无限期打开CPU配置文件，写入给定文件。

客户 方法调用
Console debug.startCPUProfile(file)
RPC {"method": "debug_startCPUProfile", "params": [string]}

debug_startGoTrace

开始将Go运行时跟踪信息写入给定文件。

客户 方法调用
Console debug.startGoTrace(file)
RPC {"method": "debug_startGoTrace", "params": [string]}

debug_stopCPUProfile

停止正在进行的CPU配置文件。

客户 方法调用
Console debug.stopCPUProfile()
RPC {"method": "debug_stopCPUProfile", "params": []}

debug_stopGoTrace

停止编写Go运行时跟踪。

客户 方法调用
Console debug.startGoTrace(file)
RPC {"method": "debug_stopGoTrace", "params": []}

debug_traceBlock

该traceBlock方法将返回此块中包括的所有事务的所有已调用操作码的完整堆栈跟踪。注意，此块的父级必须存在，否则将失败。

客户 方法调用
Go debug.TraceBlock(blockRlp []byte, config. *vm.Config) BlockTraceResult
Console debug.traceBlock(tblockRlp, [options])
RPC {"method": "debug_traceBlock", "params": [blockRlp, {}]}

参考： RLP

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
> debug.traceBlock("0xblock_rlp")
{
  gas: 85301,
  returnValue: "",
  structLogs: [{
      depth: 1,
      error: "",
      gas: 162106,
      gasCost: 3,
      memory: null,
      op: "PUSH1",
      pc: 0,
      stack: [],
      storage: {}
  },
    /* snip */
  {
      depth: 1,
      error: "",
      gas: 100000,
      gasCost: 0,
      memory: ["0000000000000000000000000000000000000000000000000000000000000006", "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000060"],
      op: "STOP",
      pc: 120,
      stack: ["00000000000000000000000000000000000000000000000000000000d67cbec9"],
      storage: {
        0000000000000000000000000000000000000000000000000000000000000004: "8241fa522772837f0d05511f20caa6da1d5a3209000000000000000400000001",
        0000000000000000000000000000000000000000000000000000000000000006: "0000000000000000000000000000000000000000000000000000000000000001",
        f652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f: "00000000000000000000000002e816afc1b5c0f39852131959d946eb3b07b5ad"
      }
  }]

debug_traceBlockByNumber

与debug_traceBlock相似，traceBlockByNumber接受一个块号并重播数据库中已经存在的块。

客户 方法调用
Go debug.TraceBlockByNumber(number uint64, config. *vm.Config) BlockTraceResult
Console debug.traceBlockByNumber(number, [options])
RPC {"method": "debug_traceBlockByNumber", "params": [number, {}]}

参考： RLP

debug_traceBlockByHash

与debug_traceBlock相似，traceBlockByHash接受块哈希并重播数据库中已经存在的块。

客户 方法调用
Go debug.TraceBlockByHash(hash common.Hash, config. *vm.Config) BlockTraceResult
Console debug.traceBlockByHash(hash, [options])
RPC {"method": "debug_traceBlockByHash", "params": [hash {}]}

参考： RLP

debug_traceBlockFromFile

与debug_traceBlock相似，traceBlockFromFile接受包含该块的RLP的文件。

客户 方法调用
Go debug.TraceBlockFromFile(fileName string, config. *vm.Config) BlockTraceResult
Console debug.traceBlockFromFile(fileName, [options])
RPC {"method": "debug_traceBlockFromFile", "params": [fileName, {}]}

参考： RLP

debug_standardTraceBlockToFile

首次实现基于JS的跟踪（见下文）时，预期的用例是启用长时间运行的跟踪器，这些跟踪器可以通过订阅通道将结果流回。此方法的工作方式略有不同。（有关详细信息，请参阅PR）

  • 它在执行期间将输出流传输到磁盘，以免消耗节点上的内存使用量
  • 它jsonl用作输出格式（允许流式传输）
  • 使用跨客户端标准化输出，即所谓的“标准json”
    • 用途op为操作码的字符串表示，而不是op/ opName对数字/串，和其他小simlar差异。
    • 有 refund
    • 将内存表示为连续的数据块，而不是32像-byte段这样的列表debug_traceTransaction

这意味着该方法仅对控制该节点的调用者“有用”，至少足以在事发后从文件系统中读取伪像。

该方法可用于将特定事务转出给定块：

1
2
> debug.standardTraceBlockToFile("0x0bbe9f1484668a2bf159c63f0cf556ed8c8282f99e3ffdb03ad2175a863bca63", {txHash:"0x4049f61ffbb0747bb88dc1c85dd6686ebf225a3c10c282c45a8e0c644739f7e9", disableMemory:true})
["/tmp/block_0x0bbe9f14-14-0x4049f61f-099048234"]

或某个区块中的所有TX：

1
2
> debug.standardTraceBlockToFile("0x0bbe9f1484668a2bf159c63f0cf556ed8c8282f99e3ffdb03ad2175a863bca63", {disableMemory:true})
["/tmp/block_0x0bbe9f14-0-0xb4502ea7-409046657", "/tmp/block_0x0bbe9f14-1-0xe839be8f-954614764", "/tmp/block_0x0bbe9f14-2-0xc6e2052f-542255195", "/tmp/block_0x0bbe9f14-3-0x01b7f3fe-209673214", "/tmp/block_0x0bbe9f14-4-0x0f290422-320999749", "/tmp/block_0x0bbe9f14-5-0x2dc0fb80-844117472", "/tmp/block_0x0bbe9f14-6-0x35542da1-256306111", "/tmp/block_0x0bbe9f14-7-0x3e199a08-086370834", "/tmp/block_0x0bbe9f14-8-0x87778b88-194603593", "/tmp/block_0x0bbe9f14-9-0xbcb081ba-629580052", "/tmp/block_0x0bbe9f14-10-0xc254381a-578605923", "/tmp/block_0x0bbe9f14-11-0xcc434d58-405931366", "/tmp/block_0x0bbe9f14-12-0xce61967d-874423181", "/tmp/block_0x0bbe9f14-13-0x05a20b35-267153288", "/tmp/block_0x0bbe9f14-14-0x4049f61f-606653767", "/tmp/block_0x0bbe9f14-15-0x46d473d2-614457338", "/tmp/block_0x0bbe9f14-16-0x35cf5500-411906321", "/tmp/block_0x0bbe9f14-17-0x79222961-278569788", "/tmp/block_0x0bbe9f14-18-0xad84e7b1-095032683", "/tmp/block_0x0bbe9f14-19-0x4bd48260-019097038", "/tmp/block_0x0bbe9f14-20-0x1517411d-292624085", "/tmp/block_0x0bbe9f14-21-0x6857e350-971385904", "/tmp/block_0x0bbe9f14-22-0xbe3ae2ca-236639695"]

使用命名标准在临时位置创建文件block_---。每个操作码都会立即流到文件，除了os正常进行的缓冲外，没有缓冲缓冲。

在服务器端，当重新生成历史状态时，它还会添加一些更多信息，即required historical state is not avaiable遇到reexec-number 时，以便用户可以尝试增加该设置。它还打印出剩余的块，直到到达目标：

1
2
3
4
5
6
INFO [10-15|13:48:25.263] Regenerating historical state            block=2385959 target=2386012 remaining=53   elapsed=3m30.990537767s
INFO [10-15|13:48:33.342] Regenerating historical state            block=2386012 target=2386012 remaining=0    elapsed=3m39.070073163s
INFO [10-15|13:48:33.343] Historical state regenerated             block=2386012 elapsed=3m39.070454362s nodes=10.03mB preimages=652.08kB
INFO [10-15|13:48:33.352] Wrote trace                              file=/tmp/block_0x14490c57-0-0xfbbd6d91-715824834
INFO [10-15|13:48:33.352] Wrote trace                              file=/tmp/block_0x14490c57-1-0x71076194-187462969
INFO [10-15|13:48:34.421] Wrote trace file=/tmp/block_0x14490c57-2-0x3f4263fe-056924484

该options如下：

1
2
3
4
5
type StdTraceConfig struct {
  *vm.LogConfig
  Reexec *uint64
  TxHash *common.Hash
}

debug_standardTraceBadBlockToFile

此方法与相似debug_standardTraceBlockToFile，但可用于获取有关已被拒绝为无效（由于某种原因）的块的信息。

debug_traceTransaction

OBS在大多数情况下，debug.standardTraceBlockToFile更适合于跟踪！

的traceTransaction调试方法将尝试，因为它是在网络上执行以完全相同的方式来运行事务。在最终尝试执行与给定哈希对应的事务之前，它将重放在此之前可能已执行的任何事务。

除了事务的哈希值，您还可以给它一个辅助的可选参数，它指定此特定调用的选项。可能的选项是：

  • disableStorage：BOOL。将此设置为true将禁用存储捕获（默认= false）。
  • disableMemory：BOOL。将此设置为true将禁用内存捕获（默认= false）。
  • disableStack：BOOL。将此设置为true将禁用堆栈捕获（默认= false）。
  • tracer：STRING。设置此选项将启用基于JavaScript的事务跟踪，如下所述。如果设置，则前四个参数将被忽略。
  • timeout：STRING。替代基于JavaScript的跟踪调用的默认超时5秒。有效值在此处描述。
客户 方法调用
Go debug.TraceTransaction(txHash common.Hash, logger *vm.LogConfig) (*ExecutionResurt, error)
Console debug.traceTransaction(txHash, [options])
RPC {"method": "debug_traceTransaction", "params": [txHash, {}]}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
> debug.traceTransaction("0x2059dd53ecac9827faad14d364f9e04b1d5fe5b506e3acc886eff7a6f88a696a")
{
  gas: 85301,
  returnValue: "",
  structLogs: [{
      depth: 1,
      error: "",
      gas: 162106,
      gasCost: 3,
      memory: null,
      op: "PUSH1",
      pc: 0,
      stack: [],
      storage: {}
  },
    /* snip */
  {
      depth: 1,
      error: "",
      gas: 100000,
      gasCost: 0,
      memory: ["0000000000000000000000000000000000000000000000000000000000000006", "0000000000000000000000000000000000000000000000000000000000000000", "0000000000000000000000000000000000000000000000000000000000000060"],
      op: "STOP",
      pc: 120,
      stack: ["00000000000000000000000000000000000000000000000000000000d67cbec9"],
      storage: {
        0000000000000000000000000000000000000000000000000000000000000004: "8241fa522772837f0d05511f20caa6da1d5a3209000000000000000400000001",
        0000000000000000000000000000000000000000000000000000000000000006: "0000000000000000000000000000000000000000000000000000000000000001",
        f652222313e28459528d920b65115c16c04f3efc82aaedc97be59f3f377c0d3f: "00000000000000000000000002e816afc1b5c0f39852131959d946eb3b07b5ad"
      }
  }]

基于JavaScript的跟踪

tracer在第二个参数中指定选项将启用基于JavaScript的跟踪。在此模式下，tracer被解释为一个JavaScript表达式，该表达式应使用（至少）两个方法（名为step和）对一个对象求值result。

step是一个带有两个参数log和db的函数，该函数针对EVM的每个步骤或在跟踪指定事务时发生错误时被调用。

log 具有以下字段：

  • pc：编号，当前程序计数器
  • op：对象，一个表示当前操作码的OpCode对象
  • gas：数量，剩余气体量
  • gasPrice：数量，每单位燃气的单位为单位的成本
  • memory：对象，表示合同的内存空间的结构
  • stack：array [big.Int]，EVM执行堆栈
  • depth：执行深度
  • account：执行当前操作的帐户的地址
  • err：如果发生错误，则有关该错误的信息

如果err为非null，则应忽略所有其他字段。

为了提高效率，同一log对象在每个执行步骤中都被重用，并用当前值进行更新；确保将要保留的值复制到当前调用之外。例如，此步骤功能将不起作用：

1
2
3
function(log) {
  this.logs.append(log);
}

但是此步骤功能将：

1
2
3
function(log) {
  this.logs.append({gas: log.gas, pc: log.pc, ...});
}

log.op 具有以下方法：

  • isPush() -如果操作码为PUSHn，则返回true
  • toString() -返回操作码的字符串表示形式
  • toNumber() -返回操作码的编号

log.memory 具有以下方法：

  • slice(start, stop) -将指定的内存段作为字节片返回
  • length() -返回内存的长度

log.stack 具有以下方法：

  • peek(idx) -从堆栈的顶部返回第idx个元素（0是最顶部的元素）为big.Int
  • length() -返回堆栈中的元素数

db 具有以下方法：

  • getBalance(address)-返回big.Int具有指定帐户余额的
  • getNonce(address) -返回带有指定帐户随机数的数字
  • getCode(address) -返回带有指定帐户代码的字节片
  • getState(address, hash) -返回指定帐户和指定哈希的状态值
  • exists(address) -如果指定的地址存在，则返回true

第二个函数’result’不带任何参数，并且期望返回JSON可序列化的值以返回到RPC调用程序。

如果step函数在任何时候抛出异常或执行非法操作，则将不会在任何其他VM步骤上调用它，并且错误将返回给调用方。

请注意，有几个值是Golang big.Int对象，而不是JavaScript数字或JS bigints。因此，它们具有与godocs中描述的相同的界面。它们默认的序列化为JSON是一个Javascript数字。要序列化大量数字，请准确调用.String()它们。为方便起见，big.NewInt(x)提供了，并将uint转换为Go BigInt。

用法示例，仅在每个CALL操作码处返回堆栈的顶部元素：

1
debug.traceTransaction(txhash, {tracer: '{data: [], fault: function(log) {}, step: function(log) { if(log.op.toString() == "CALL") this.data.push(log.stack.peek(0)); }, result: function() { return this.data; }}'});

debug_verbosity

设置日志记录的详细信息上限。将打印级别达到并包括给定级别的日志消息。

可以使用来提高单个软件包和源文件的详细程度debug_vmodule。

客户 方法调用
Console debug.verbosity(level)
RPC {"method": "debug_vmodule", "params": [number]}

debug_vmodule

设置日志记录的详细模式。

客户 方法调用
Console debug.vmodule(string)
RPC {"method": "debug_vmodule", "params": [string]}

例子

如果要查看来自特定Go包（目录）和所有子目录的消息，请使用：

1
> debug.vmodule("eth/*=6")

如果要将消息限制为特定的程序包（例如p2p），但排除子目录，请使用：

1
> debug.vmodule("p2p=6")

如果要查看来自特定源文件的日志消息，请使用

1
> debug.vmodule("server.go=6")

您可以组成这些基本模式。如果要在eth（eth / peer.go，eth / downloader / peer.go）之下的包中查看来自peer.go的所有输出，以及在级别<= 5时从p2p包获得的输出，请使用：

1
debug.vmodule("eth/*/peer.go=6,p2p=5")

debug_writeBlockProfile

将goroutine阻止配置文件写入给定文件。

客户 方法调用
Console debug.writeBlockProfile(file)
RPC {"method": "debug_writeBlockProfile", "params": [string]}

debug_writeMemProfile

将分配配置文件写入给定文件。请注意，无法通过API来设置分析速率，必须在命令行中使用--memprofilerate 标志来设置分析速率。

客户 方法调用
Console debug.writeMemProfile(file string)
RPC {"method": "debug_writeBlockProfile", "params": [string]}

eth命名空间

Geth提供了对标准“ eth” JSON-RPC名称空间的几个扩展。

这些方法用于通过订阅进行的实时事件。有关更多信息，请参见订阅文档。

eth_call

立即执行新的消息调用，而无需在区块链上创建事务。该eth_call方法可用于查询内部合同状态，执行编码到合同中的验证，甚至可以测试不实时运行交易的效果。

参量

该方法采用3个参数：一个以只读模式执行的未签名事务对象；执行调用的程序段号；以及可选的状态覆盖集，以允许针对修改后的链状态执行调用。

1.- Object交易调用对象

该交易调用对象是强制性的，包含了所有必要的参数执行只读EVM合同法。

领域 类型 字节数 可选的 描述
from Address 20 是 模拟已发送交易的地址。默认为本地密钥库中的第一个帐户，0x00..0如果没有可用的本地帐户，则为地址。
to Address 20 没有 交易发送到的地址。
gas Quantity <8 是 代码执行的最大气体余量，可以避免无限循环。默认为2^63或节点运算符通过指定的任何值--rpc.gascap。
gasPrice Quantity <32 是 wei在执行期间模拟为每单位天然气支付的数量。默认为1 gwei。
value Quantity <32 是 量wei来模拟与交易一起发送。默认为0。
data Binary 任何 是 二进制数据发送到目标合同。通常，方法签名的4字节哈希值后跟ABI编码的参数。有关详细信息，请参阅以太坊合约ABI。

例：

1
2
3
4
5
6
{
  "from": "0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3",
  "to":   "0xebe8efa441b9302a0d7eaecc277c09d20d684540",
  "gas":  "0x1bd7c",
  "data": "0xd459fc46000000000000000000000000000000000000000000000000000000000046c650dbb5e8cb2bac4d2ed0b1e6475d37361157738801c494ca482f96527eb48f9eec488c2eba92d31baeccfb6968fad5c21a3df93181b43b4cf253b4d572b64172ef000000000000000000000000000000000000000000000000000000000000008c00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000002b85c0c828d7a98633b4e1b65eac0c017502da909420aeade9a280675013df36bdc71cffdf420cef3d24ba4b3f9b980bfbb26bd5e2dcf7795b3519a3fd22ffbb2000000000000000000000000000000000000000000000000000000000000000238fb6606dc2b5e42d00c653372c153da8560de77bd9afaba94b4ab6e4aa11d565d858c761320dbf23a94018d843772349bd9d92301b0ca9ca983a22d86a70628",
}
2. Quantity | Tag-块数或字符串latest或pending

的块号是强制性的，并且限定针对其指定的事务应该被执行的上下文（状态）。无法对重组后的块执行调用；或大于128的块（除非该节点是归档节点）。

3.- Object状态替代集

的状态覆写集是一个可选的地址到状态映射，其中每个条目指定一些状态之前执行呼叫被短暂地覆盖。每个地址都映射到一个包含以下内容的对象：

领域 类型 字节数 可选的 描述
balance Quantity <32 是 在执行呼叫之前为帐户设置假余额。
nonce Quantity <8 是 在执行呼叫之前，先为帐户设置伪随机数。
code Binary 任何 是 伪造EVM字节码以在执行调用之前注入帐户。
state Object 任何 是 伪造的键值映射可在执行调用之前覆盖帐户存储中的所有插槽。
stateDiff Object 任何 是 伪造的键值映射可在执行调用之前覆盖帐户存储中的各个插槽。

状态覆盖集的目标有很多：

  • DApp可以使用它来减少需要在链上部署的合同代码的数量。可以简单地返回内部状态或执行预定义验证的代码可以保持脱链状态，并按需提供给节点。
  • 通过使用自定义方法扩展部署在链上的代码并调用它们，可以将其用于智能合约分析。这避免了必须下载并重建沙箱中的整个状态以针对其运行自定义代码。
  • 通过有选择地重写某些代码或状态并查看执行方式如何变化，可以将其用于调试已部署的大型合同套件中的智能合同。可能需要专门的工具。

例：

1
2
3
4
5
6
7
8
9
10
11
{
  "0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3": {
    "balance": "0xde0b6b3a7640000"
  },
  "0xebe8efa441b9302a0d7eaecc277c09d20d684540": {
    "code": "0x...",
    "state": {
      ""
    }
  }
}

返回值

该方法返回一个Binary包含执行的合同调用的返回值的单一对象。

简单的例子

通过在localhost（geth --rinkeby --rpc）上公开了带有RPC的同步Rinkeby节点，我们可以对Checkpoint Oracle 进行调用以检索管理员列表：

1
$ curl --data '{"method":"eth_call","params":[{"to":"0xebe8efa441b9302a0d7eaecc277c09d20d684540","data":"0x45848dfc"},"latest"],"id":1,"jsonrpc":"2.0"}' -H "Content-Type: application/json" -X POST localhost:8545

结果是以太坊ABI编码的帐户列表：

1
2
3
4
5
{
  "id":      1,
  "jsonrpc": "2.0",
  "result":  "0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000004000000000000000000000000d9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f300000000000000000000000078d1ad571a1a09d60d9bbf25894b44e4c8859595000000000000000000000000286834935f4a8cfb4ff4c77d5770c2775ae2b0e7000000000000000000000000b86e2b0ab5a4b1373e40c51a7c712c70ba2f9f8e"
}

仅出于完整性考虑，解码后的响应为：

1
2
3
4
0xd9c9cd5f6779558b6e0ed4e6acf6b1947e7fa1f3,
0x78d1ad571a1a09d60d9bbf25894b44e4c8859595,
0x286834935f4a8cfb4ff4c77d5770c2775ae2b0e7,
0xb86e2b0ab5a4b1373e40c51a7c712c70ba2f9f8e

覆盖示例

上面的简单示例显示了如何调用链上智能合约已经公开的方法。如果我们想访问一些未公开的数据怎么办？

我们可以 使用保留相同字段（以保留相同存储布局）的 原始检查点Oracle合同，但包含不同方法集的一个合同：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
pragma solidity ^0.5.10;

contract CheckpointOracle {
    mapping(address => bool) admins;
    address[] adminList;
    uint64 sectionIndex;
    uint height;
    bytes32 hash;
    uint sectionSize;
    uint processConfirms;
    uint threshold;

    function VotingThreshold() public view returns (uint) {
        return threshold;
    }
}

通过在localhost（geth --rinkeby --rpc）上公开了带有RPC的同步Rinkeby节点，我们可以对实时Checkpoint Oracle进行调用，但是可以使用我们自己的版本覆盖其字节代码，该版本具有用于投票阈值字段的访问器：

1
$ curl --data '{"method":"eth_call","params":[{"to":"0xebe8efa441b9302a0d7eaecc277c09d20d684540","data":"0x0be5b6ba"}, "latest", {"0xebe8efa441b9302a0d7eaecc277c09d20d684540": {"code":"0x6080604052348015600f57600080fd5b506004361060285760003560e01c80630be5b6ba14602d575b600080fd5b60336045565b60408051918252519081900360200190f35b6007549056fea265627a7a723058206f26bd0433456354d8d1228d8fe524678a8aeeb0594851395bdbd35efc2a65f164736f6c634300050a0032"}}],"id":1,"jsonrpc":"2.0"}' -H "Content-Type: application/json" -X POST localhost:8545

结果是以太坊ABI编码的阈值编号：

1
2
3
4
5
{
  "id":      1,
  "jsonrpc": "2.0",
  "result":  "0x0000000000000000000000000000000000000000000000000000000000000002"
}

仅出于完整性考虑，解码后的响应为：2。

les命名空间

该lesAPI可让您管理LES服务器设置，包括客户端参数和优先客户端的付款设置。它还提供了在服务器和客户端模式下查询检查点信息的功能。

les_serverInfo

获取有关当前已连接以及允许的总/单独连接容量的信息。

客户 方法调用
les.ServerInfo() map[string]interface{}
Console les.serverInfo()
RPC {"method": "les_serverInfo", "params": []}

例

1
2
3
4
5
6
7
8
9
> les.serverInfo
{
  freeClientCapacity: 16000,
  maximumCapacity: 1600000,
  minimumCapacity: 16000,
  priorityConnectedCapacity: 180000,
  totalCapacity: 1600000,
  totalConnectedCapacity: 180000
}

les_clientInfo

如果指定的客户列表或ID列表为空，则获取所有指定客户列表上的所有客户信息（联系，余额，定价）。

客户 方法调用
les.ClientInfo(ids []enode.ID) map[enode.ID]map[string]interface{}
Console les.clientInfo([id, ...])
RPC {"method": "les_clientInfo", "params": [[id, ...]]}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
> les.clientInfo([])
{
  37078bf8ea160a2b3d129bb4f3a930ce002356f83b820f467a07c1fe291531ea: {
    capacity: 16000,
    connectionTime: 11225.335901136,
    isConnected: true,
    pricing/balance: 998266395881,
    pricing/balanceMeta: "",
    pricing/negBalance: 501657912857,
    priority: true
  },
  6a47fe7bb23fd335df52ef1690f37ab44265a537b1d18eb616a3e77f898d9e77: {
    capacity: 100000,
    connectionTime: 9874.839293082,
    isConnected: true,
    pricing/balance: 2908840710198,
    pricing/balanceMeta: "qwerty",
    pricing/negBalance: 206242704507,
    priority: true
  },
  740c78f7d914e5c763731bc751b513fc2388ffa0b47db080ded3e8b305e68c75: {
    capacity: 16000,
    connectionTime: 3089.286712188,
    isConnected: true,
    pricing/balance: 998266400174,
    pricing/balanceMeta: "",
    pricing/negBalance: 55135348863,
    priority: true
  },
  9985ade55b515f79f64274bf2ae440ca8c433cfb0f283fb6010bf46f796b2a3b: {
    capacity: 16000,
    connectionTime: 11479.335479545,
    isConnected: true,
    pricing/balance: 998266452203,
    pricing/balanceMeta: "",
    pricing/negBalance: 564116425655,
    priority: true
  },
  ce65ada2c3e17d6da00cec0b3cc4c8ed5e74428b60f42fa287eaaec8cca62544: {
    capacity: 16000,
    connectionTime: 7095.794385419,
    isConnected: true,
    pricing/balance: 998266448492,
    pricing/balanceMeta: "",
    pricing/negBalance: 214617753229,
    priority: true
  },
  e1495ceb6db842f3ee66428d4bb7f4a124b2b17111dae35d141c3d568b869ef1: {
    capacity: 16000,
    connectionTime: 8614.018237937,
    isConnected: true,
    pricing/balance: 998266391796,
    pricing/balanceMeta: "",
    pricing/negBalance: 185964891797,
    priority: true
  }
}

les_priorityClientInfo

获取有关指定ID范围内正余额（start包括（stop不包括））的客户的单个客户信息。如果stop为零，则返回结果，直到最后一个现有余额输入。maxCount限制返回结果的数量。如果达到计数限制，但该范围内有更多ID，则结果中将包含第一个缺少的ID，并为其分配一个空值。

客户 方法调用
Go les.PriorityClientInfo(start, stop enode.ID, maxCount int) map[enode.ID]map[string]interface{}
Console les.priorityClientInfo(id, id, number)
RPC {"method": "les_priorityClientInfo", "params": [id, id, number]}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
> les.priorityClientInfo("0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", 100)
{
  37078bf8ea160a2b3d129bb4f3a930ce002356f83b820f467a07c1fe291531ea: {
    capacity: 16000,
    connectionTime: 11128.247204027,
    isConnected: true,
    pricing/balance: 999819815030,
    pricing/balanceMeta: "",
    pricing/negBalance: 501657912857,
    priority: true
  },
  6a47fe7bb23fd335df52ef1690f37ab44265a537b1d18eb616a3e77f898d9e77: {
    capacity: 100000,
    connectionTime: 9777.750592047,
    isConnected: true,
    pricing/balance: 2918549830576,
    pricing/balanceMeta: "qwerty",
    pricing/negBalance: 206242704507,
    priority: true
  },
  740c78f7d914e5c763731bc751b513fc2388ffa0b47db080ded3e8b305e68c75: {
    capacity: 16000,
    connectionTime: 2992.198001116,
    isConnected: true,
    pricing/balance: 999819845102,
    pricing/balanceMeta: "",
    pricing/negBalance: 55135348863,
    priority: true
  },
  9985ade55b515f79f64274bf2ae440ca8c433cfb0f283fb6010bf46f796b2a3b: {
    capacity: 16000,
    connectionTime: 11382.246766963,
    isConnected: true,
    pricing/balance: 999819871598,
    pricing/balanceMeta: "",
    pricing/negBalance: 564116425655,
    priority: true
  },
  ce65ada2c3e17d6da00cec0b3cc4c8ed5e74428b60f42fa287eaaec8cca62544: {
    capacity: 16000,
    connectionTime: 6998.705683407,
    isConnected: true,
    pricing/balance: 999819882177,
    pricing/balanceMeta: "",
    pricing/negBalance: 214617753229,
    priority: true
  },
  e1495ceb6db842f3ee66428d4bb7f4a124b2b17111dae35d141c3d568b869ef1: {
    capacity: 16000,
    connectionTime: 8516.929533901,
    isConnected: true,
    pricing/balance: 999819891640,
    pricing/balanceMeta: "",
    pricing/negBalance: 185964891797,
    priority: true
  }
}

> les.priorityClientInfo("0x4000000000000000000000000000000000000000000000000000000000000000", "0xe000000000000000000000000000000000000000000000000000000000000000", 2)
{
  6a47fe7bb23fd335df52ef1690f37ab44265a537b1d18eb616a3e77f898d9e77: {
    capacity: 100000,
    connectionTime: 9842.11178361,
    isConnected: true,
    pricing/balance: 2912113588853,
    pricing/balanceMeta: "qwerty",
    pricing/negBalance: 206242704507,
    priority: true
  },
  740c78f7d914e5c763731bc751b513fc2388ffa0b47db080ded3e8b305e68c75: {
    capacity: 16000,
    connectionTime: 3056.559199029,
    isConnected: true,
    pricing/balance: 998790060237,
    pricing/balanceMeta: "",
    pricing/negBalance: 55135348863,
    priority: true
  },
  9985ade55b515f79f64274bf2ae440ca8c433cfb0f283fb6010bf46f796b2a3b: {}
}

les_addBalance

将签名的值添加到指定客户端的令牌余额中并更新其meta标签。余额不能低于零或超过零2^^63-1。返回更新前后的余额值。该meta标签可用于存储序列号或对上次处理的传入付款，令牌到期信息，其他货币余额或任何特定于应用程序的其他信息的引用。

客户 方法调用
les.AddBalance(id enode.ID, value int64, meta string) ([2]uint64, error)}
Console les.addBalance(id, number, string)
RPC {"method": "les_addBalance", "params": [id, number, string]}

例

1
2
> les.addBalance("0x6a47fe7bb23fd335df52ef1690f37ab44265a537b1d18eb616a3e77f898d9e77", 1000000000, "qwerty")
[968379616, 1968379616]

les_setClientParams

如果ID列表为空，请为指定的已连接客户端列表或所有已连接客户端设置容量和价格因素。

客户 方法调用
Go les.SetClientParams(ids []enode.ID, params map[string]interface{}) error
Console les.setClientParams([id, ...], {string: value, ...})
RPC {"method": "les_setClientParams", "params": [[id, ...], {string: value, ...}]}

例

1
2
3
4
5
6
7
8
9
10
> les.setClientParams(["0x6a47fe7bb23fd335df52ef1690f37ab44265a537b1d18eb616a3e77f898d9e77"], {
	"capacity": 100000,
	"pricing/timeFactor": 0,
	"pricing/capacityFactor": 1000000000,
	"pricing/requestCostFactor": 1000000000,
	"pricing/negative/timeFactor": 0,
	"pricing/negative/capacityFactor": 1000000000,
	"pricing/negative/requestCostFactor": 1000000000,
})
null

les_setDefaultParams

为后续连接的客户设置默认定价因子。

客户 方法调用
Go les.SetDefaultParams(params map[string]interface{}) error
Console les.setDefaultParams({string: value, ...})
RPC {"method": "les_setDefaultParams", "params": [{string: value, ...}]}

例

1
2
3
4
5
6
7
8
9
> les.setDefaultParams({
	"pricing/timeFactor": 0,
	"pricing/capacityFactor": 1000000000,
	"pricing/requestCostFactor": 1000000000,
	"pricing/negative/timeFactor": 0,
	"pricing/negative/capacityFactor": 1000000000,
	"pricing/negative/requestCostFactor": 1000000000,
})
null

les_latestCheckpoint

获取最新已知检查点的索引和哈希。

客户 方法调用
les.LatestCheckpoint() ([4]string, error)
Console les.latestCheckpoint()
RPC {"method": "les_latestCheckpoint", "params": []}

例

1
2
> les.latestCheckpoint
["0x110", "0x6eedf8142d06730b391bfcbd32e9bbc369ab0b46ae226287ed5b29505a376164", "0x191bb2265a69c30201a616ae0d65a4ceb5937c2f0c94b125ff55343d707463e5", "0xf58409088a5cb2425350a59d854d546d37b1e7bef8bbf6afee7fd15f943d626a"]

les_getCheckpoint

通过索引获取检查点哈希。

客户 方法调用
Go les.GetCheckpoint(index uint64) ([3]string, error)
Console les.getCheckpoint(number)
RPC {"method": "les_getCheckpoint", "params": [number]}

例

1
2
> les.getCheckpoint(256)
["0x93eb4af0b224b1097e09181c2e51536fe0a3bf3bb4d93e9a69cab9eb3e28c75f", "0x0eb055e384cf58bc72ca20ca5e2b37d8d4115dce80ab4a19b72b776502c4dd5b", "0xda6c02f7c51f9ecc3eca71331a7eaad724e5a0f4f906ce9251a2f59e3115dd6a"]

les_getCheckpointContractAddress

获取检查点Oracle合同的地址。

客户 方法调用
Go les.GetCheckpointContractAddress() (string, error)
Console les.checkpointContractAddress()
RPC {"method": "les_getCheckpointContractAddress", "params": []}

例

1
2
> les.checkpointContractAddress
"0x9a9070028361F7AAbeB3f2F2Dc07F82C4a98A02a"

矿工命名空间

该minerAPI使您可以远程控制节点的挖掘操作并设置各种挖掘特定的设置。

miner_getHashrate

获得以H / s为单位的哈希率（每秒哈希操作）。

客户 方法调用
Console miner.getHashrate()
RPC {"method": "miner_getHashrate", "params": []}

miner_setExtra

设置矿工阻止时矿工可以包括的额外数据。上限为32个字节。

客户 方法调用
Go miner.setExtra(extra string) (bool, error)
Console miner.setExtra(string)
RPC {"method": "miner_setExtra", "params": [string]}

miner_setGasPrice

设置采矿交易时的最低可接受天然气价格。低于此限制的任何交易都将从挖掘过程中排除。

客户 方法调用
Go miner.setGasPrice(number *rpc.HexNumber) bool
Console miner.setGasPrice(number)
RPC {"method": "miner_setGasPrice", "params": [number]}

miner_start

使用给定数量的线程启动CPU挖掘过程，并在需要时生成新的DAG。

客户 方法调用
Go miner.Start(threads *rpc.HexNumber) (bool, error)
Console miner.start(number)
RPC {"method": "miner_start", "params": [number]}

miner_stop

停止CPU挖掘操作。

客户 方法调用
Go miner.Stop() bool
Console miner.stop()
RPC {"method": "miner_stop", "params": []}

miner_setEtherbase

设置以太坊，挖矿奖励将运往此。

客户 方法调用
Go miner.SetEtherbase(common.Address) bool
Console miner.setEtherbase(address)
RPC {"method": "miner_setEtherbase", "params": [address]}

个人命名空间

个人API管理密钥存储区中的私钥。

personal_importRawKey

将给定的未加密私钥（十六进制字符串）导入密钥存储区，并使用密码对其进行加密。

返回新帐户的地址。

客户 方法调用
Console personal.importRawKey(keydata, passphrase)
RPC {"method": "personal_importRawKey", "params": [string, string]}

personal_list帐户

返回密钥库中所有密钥的所有以太坊账户地址。

客户 方法调用
Console personal.listAccounts
RPC {"method": "personal_listAccounts", "params": []}

例

1
2
> personal.listAccounts
["0x5e97870f263700f46aa00d967821199b9bc5a120", "0x3d80b31a78c30fc628f20b2c89d7ddbf6e53cedc"]

personal_lock帐户

从内存中删除具有给定地址的私钥。该帐户不能再用于发送交易。

客户 方法调用
Console personal.lockAccount(address)
RPC {"method": "personal_lockAccount", "params": [string]}

personal_new帐户

生成一个新的私钥并将其存储在密钥库目录中。密钥文件使用给定的密码加密。返回新帐户的地址。

在geth控制台上，newAccount如果未提供密码作为参数，则将提示您输入密码。

客户 方法调用
Console personal.newAccount()
RPC {"method": "personal_newAccount", "params": [string]}

例

1
2
3
4
> personal.newAccount()
Passphrase: 
Repeat passphrase: 
"0x5e97870f263700f46aa00d967821199b9bc5a120"

密码也可以字符串形式提供。

1
2
> personal.newAccount("h4ck3r")
"0x3d80b31a78c30fc628f20b2c89d7ddbf6e53cedc"

personal_unlock帐户

从密钥存储区使用给定的地址解密密钥。

使用JavaScript控制台时，密码短语和解锁持续时间都是可选的。如果未提供密码短语作为参数，则控制台将交互提示输入密码短语。

未加密的密钥将保留在内存中，直到解锁持续时间到期为止。如果解锁持续时间默认为300秒。明确的零秒持续时间将锁解锁，直到geth退出。

该账户可以使用eth_sign，并eth_sendTransaction同时被解锁。

客户 方法调用
Console personal.unlockAccount(address, passphrase, duration)
RPC {"method": "personal_unlockAccount", "params": [string, string, number]}

例子

1
2
3
4
> personal.unlockAccount("0x5e97870f263700f46aa00d967821199b9bc5a120")
Unlock account 0x5e97870f263700f46aa00d967821199b9bc5a120
Passphrase: 
true

提供密码和解锁持续时间作为参数：

1
2
> personal.unlockAccount("0x5e97870f263700f46aa00d967821199b9bc5a120", "foo", 30)
true

如果要输入密码，并且stil覆盖默认的解锁持续时间，请null以密码形式通过。

1
2
3
4
> personal.unlockAccount("0x5e97870f263700f46aa00d967821199b9bc5a120", null, 30)
Unlock account 0x5e97870f263700f46aa00d967821199b9bc5a120
Passphrase: 
true

personal_sendTransaction

验证给定的密码短语并提交交易。

事务与for相同，eth_sendTransaction并且包含from地址。如果密码短语可用于解密私钥，则将tx.from验证登录到事务的签名，签名并发送到网络上。该帐户未在节点中全局解锁，因此无法在其他RPC调用中使用。

客户 方法调用
Console personal.sendTransaction(tx, passphrase)
RPC {"method": "personal_sendTransaction", "params": [tx, string]}

请注意，在Geth 1.5之前，请使用personal_signAndSendTransaction该名称，因为它是原始的介绍性名称，之后才重命名为当前的最终版本。

例子

1
2
3
4
> var tx = {from: "0x391694e7e0b0cce554cb130d723a9d27458f9298", to: "0xafa3f8684e54059998bc3a7b0d2b0da075154d66", value: web3.toWei(1.23, "ether")}
undefined
> personal.sendTransaction(tx, "passphrase")
0x8474441674cdd47b35b875fd1a530b800b51a5264b9975fb21129eeb8c18582f

personal_sign

sign方法使用来计算以太坊特定的签名 sign(keccack256("\x19Ethereum Signed Message:\n" + len(message) + message)))。

通过在消息中添加前缀，可以将计算出的签名识别为以太坊特定的签名。这样可以防止在恶意DApp可以签名任意数据（例如交易）并使用签名模拟受害者的情况下进行滥用。

请参阅ecRecover以验证签名。

客户 方法调用
Console personal.sign(message, account, [password])
RPC {"method": "personal_sign", "params": [message, account, password]}

例子

1
2
> personal.sign("0xdeadbeaf", "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83", "")
"0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a12d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee1b"

personal_ecRecover

ecRecover返回与用于计算中的签名的私钥关联的地址personal_sign。

客户 方法调用
Console personal.ecRecover(message, signature)
RPC {"method": "personal_ecRecover", "params": [message, signature]}

例子

1
2
3
4
> personal.sign("0xdeadbeaf", "0x9b2055d370f73ec7d8a03e965129118dc8f5bf83", "")
"0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a12d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee1b"
> personal.ecRecover("0xdeadbeaf", "0xa3f20717a250c2b0b729b7e5becbff67fdaef7e0699da4de7ca5895b02a170a12d887fd3b17bfdce3481f10bea41f45ba9f709d39ce8325427b57afcfc994cee1b")
"0x9b2055d370f73ec7d8a03e965129118dc8f5bf83"

txpool命名空间

通过该txpoolAPI，您可以访问几种非标准RPC方法，以检查包含所有当前未决事务以及排队等待将来处理的事务的事务池的内容。

txpool_content

该content检查性可以查询列出所有交易的具体细节目前尚待列入下一个块（一个或多个），以及正在计划在未来只有执行的人。

结果是具有两个字段pending和的对象queued。这些字段中的每一个都是关联数组，其中每个条目将原始地址映射到一批计划的事务。这些批次本身是将随机数与实际交易相关联的映射。

请注意，同一帐户和随机数可能有多个交易。如果用户播报了多种汽油配额（甚至完全不同的交易）的多种汽油，就会发生这种情况。

客户 方法调用
Go txpool.Content() (map[string]map[string]map[string]*RPCTransaction)
Console txpool.content
RPC {"method": "txpool_content"}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
> txpool.content
{
  pending: {
    0x0216d5032f356960cd3749c31ab34eeff21b3395: {
      806: {
        blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
        blockNumber: null,
        from: "0x0216d5032f356960cd3749c31ab34eeff21b3395",
        gas: "0x5208",
        gasPrice: "0xba43b7400",
        hash: "0xaf953a2d01f55cfe080c0c94150a60105e8ac3d51153058a1f03dd239dd08586",
        input: "0x",
        nonce: "0x326",
        to: "0x7f69a91a3cf4be60020fb58b893b7cbb65376db8",
        transactionIndex: null,
        value: "0x19a99f0cf456000"
      }
    },
    0x24d407e5a0b506e1cb2fae163100b5de01f5193c: {
      34: {
        blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
        blockNumber: null,
        from: "0x24d407e5a0b506e1cb2fae163100b5de01f5193c",
        gas: "0x44c72",
        gasPrice: "0x4a817c800",
        hash: "0xb5b8b853af32226755a65ba0602f7ed0e8be2211516153b75e9ed640a7d359fe",
        input: "0xb61d27f600000000000000000000000024d407e5a0b506e1cb2fae163100b5de01f5193c00000000000000000000000000000000000000000000000053444835ec580000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
        nonce: "0x22",
        to: "0x7320785200f74861b69c49e4ab32399a71b34f1a",
        transactionIndex: null,
        value: "0x0"
      }
    }
  },
  queued: {
    0x976a3fc5d6f7d259ebfb4cc2ae75115475e9867c: {
      3: {
        blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
        blockNumber: null,
        from: "0x976a3fc5d6f7d259ebfb4cc2ae75115475e9867c",
        gas: "0x15f90",
        gasPrice: "0x4a817c800",
        hash: "0x57b30c59fc39a50e1cba90e3099286dfa5aaf60294a629240b5bbec6e2e66576",
        input: "0x",
        nonce: "0x3",
        to: "0x346fb27de7e7370008f5da379f74dd49f5f2f80f",
        transactionIndex: null,
        value: "0x1f161421c8e0000"
      }
    },
    0x9b11bf0459b0c4b2f87f8cebca4cfc26f294b63a: {
      2: {
        blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
        blockNumber: null,
        from: "0x9b11bf0459b0c4b2f87f8cebca4cfc26f294b63a",
        gas: "0x15f90",
        gasPrice: "0xba43b7400",
        hash: "0x3a3c0698552eec2455ed3190eac3996feccc806970a4a056106deaf6ceb1e5e3",
        input: "0x",
        nonce: "0x2",
        to: "0x24a461f25ee6a318bdef7f33de634a67bb67ac9d",
        transactionIndex: null,
        value: "0xebec21ee1da40000"
      },
      6: {
        blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
        blockNumber: null,
        from: "0x9b11bf0459b0c4b2f87f8cebca4cfc26f294b63a",
        gas: "0x15f90",
        gasPrice: "0x4a817c800",
        hash: "0xbbcd1e45eae3b859203a04be7d6e1d7b03b222ec1d66dfcc8011dd39794b147e",
        input: "0x",
        nonce: "0x6",
        to: "0x6368f3f8c2b42435d6c136757382e4a59436a681",
        transactionIndex: null,
        value: "0xf9a951af55470000"
      }
    }
  }
}

txpool_inspect

该inspect检查性可以查询列出所有交易的文本摘要目前正在等待列入下一个块（一个或多个），以及正在计划在未来只有执行的人。这是专门为开发人员量身定制的方法，用于快速查看池中的事务并发现任何潜在问题。

结果是具有两个字段pending和的对象queued。这些字段中的每一个都是关联数组，其中每个条目将原始地址映射到一批计划的事务。这些批处理本身是将随机数与事务摘要字符串相关联的映射。

请注意，同一帐户和随机数可能有多个交易。如果用户播报了多种汽油配额（甚至完全不同的交易）的多种汽油，就会发生这种情况。

客户 方法调用
Go txpool.Inspect() (map[string]map[string]map[string]string)
Console txpool.inspect
RPC {"method": "txpool_inspect"}

例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
> txpool.inspect
{
  pending: {
    0x26588a9301b0428d95e6fc3a5024fce8bec12d51: {
      31813: "0x3375ee30428b2a71c428afa5e89e427905f95f7e: 0 wei + 500000 × 20000000000 gas"
    },
    0x2a65aca4d5fc5b5c859090a6c34d164135398226: {
      563662: "0x958c1fa64b34db746925c6f8a3dd81128e40355e: 1051546810000000000 wei + 90000 × 20000000000 gas",
      563663: "0x77517b1491a0299a44d668473411676f94e97e34: 1051190740000000000 wei + 90000 × 20000000000 gas",
      563664: "0x3e2a7fe169c8f8eee251bb00d9fb6d304ce07d3a: 1050828950000000000 wei + 90000 × 20000000000 gas",
      563665: "0xaf6c4695da477f8c663ea2d8b768ad82cb6a8522: 1050544770000000000 wei + 90000 × 20000000000 gas",
      563666: "0x139b148094c50f4d20b01caf21b85edb711574db: 1048598530000000000 wei + 90000 × 20000000000 gas",
      563667: "0x48b3bd66770b0d1eecefce090dafee36257538ae: 1048367260000000000 wei + 90000 × 20000000000 gas",
      563668: "0x468569500925d53e06dd0993014ad166fd7dd381: 1048126690000000000 wei + 90000 × 20000000000 gas",
      563669: "0x3dcb4c90477a4b8ff7190b79b524773cbe3be661: 1047965690000000000 wei + 90000 × 20000000000 gas",
      563670: "0x6dfef5bc94b031407ffe71ae8076ca0fbf190963: 1047859050000000000 wei + 90000 × 20000000000 gas"
    },
    0x9174e688d7de157c5c0583df424eaab2676ac162: {
      3: "0xbb9bc244d798123fde783fcc1c72d3bb8c189413: 30000000000000000000 wei + 85000 × 21000000000 gas"
    },
    0xb18f9d01323e150096650ab989cfecd39d757aec: {
      777: "0xcd79c72690750f079ae6ab6ccd7e7aedc03c7720: 0 wei + 1000000 × 20000000000 gas"
    },
    0xb2916c870cf66967b6510b76c07e9d13a5d23514: {
      2: "0x576f25199d60982a8f31a8dff4da8acb982e6aba: 26000000000000000000 wei + 90000 × 20000000000 gas"
    },
    0xbc0ca4f217e052753614d6b019948824d0d8688b: {
      0: "0x2910543af39aba0cd09dbb2d50200b3e800a63d2: 1000000000000000000 wei + 50000 × 1171602790622 gas"
    },
    0xea674fdde714fd979de3edf0f56aa9716b898ec8: {
      70148: "0xe39c55ead9f997f7fa20ebe40fb4649943d7db66: 1000767667434026200 wei + 90000 × 20000000000 gas"
    }
  },
  queued: {
    0x0f6000de1578619320aba5e392706b131fb1de6f: {
      6: "0x8383534d0bcd0186d326c993031311c0ac0d9b2d: 9000000000000000000 wei + 21000 × 20000000000 gas"
    },
    0x5b30608c678e1ac464a8994c3b33e5cdf3497112: {
      6: "0x9773547e27f8303c87089dc42d9288aa2b9d8f06: 50000000000000000000 wei + 90000 × 50000000000 gas"
    },
    0x976a3fc5d6f7d259ebfb4cc2ae75115475e9867c: {
      3: "0x346fb27de7e7370008f5da379f74dd49f5f2f80f: 140000000000000000 wei + 90000 × 20000000000 gas"
    },
    0x9b11bf0459b0c4b2f87f8cebca4cfc26f294b63a: {
      2: "0x24a461f25ee6a318bdef7f33de634a67bb67ac9d: 17000000000000000000 wei + 90000 × 50000000000 gas",
      6: "0x6368f3f8c2b42435d6c136757382e4a59436a681: 17990000000000000000 wei + 90000 × 20000000000 gas",
      7: "0x6368f3f8c2b42435d6c136757382e4a59436a681: 17900000000000000000 wei + 90000 × 20000000000 gas"
    }
  }
}

txpool_status

该status检查性，可以被询问的交易目前正等待列入下一个块（一个或多个）的数量，以及正在计划在未来只有执行的人。

结果是具有两个字段pending和的对象queued，每个字段都是一个计数器，代表该特定状态下的事务数。

客户 方法调用
Go txpool.Status() (map[string]*rpc.HexNumber)
Console txpool.status
RPC {"method": "txpool_status"}

例

1
2
3
4
5
> txpool.status
{
  pending: 10,
  queued: 7
}

Ω
FEATURED TAGS
区块链
FRIENDS