github.com/bearnetworkchain/go-bearnetwork@v1.10.19-0.20220604150648-d63890c2e42b/ethclient/gethclient/gethclient.go (about) 1 // Copyright 2021 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 // Package gethclient provides an RPC client for geth-specific APIs. 18 package gethclient 19 20 import ( 21 "context" 22 "math/big" 23 "runtime" 24 "runtime/debug" 25 26 "github.com/ethereum/go-ethereum" 27 "github.com/ethereum/go-ethereum/common" 28 "github.com/ethereum/go-ethereum/common/hexutil" 29 "github.com/ethereum/go-ethereum/core/types" 30 "github.com/ethereum/go-ethereum/p2p" 31 "github.com/ethereum/go-ethereum/rpc" 32 ) 33 34 // Client is a wrapper around rpc.Client that implements geth-specific functionality. 35 // 36 // If you want to use the standardized Ethereum RPC functionality, use ethclient.Client instead. 37 type Client struct { 38 c *rpc.Client 39 } 40 41 // New creates a client that uses the given RPC client. 42 func New(c *rpc.Client) *Client { 43 return &Client{c} 44 } 45 46 // CreateAccessList tries to create an access list for a specific transaction based on the 47 // current pending state of the blockchain. 48 func (ec *Client) CreateAccessList(ctx context.Context, msg ethereum.CallMsg) (*types.AccessList, uint64, string, error) { 49 type accessListResult struct { 50 Accesslist *types.AccessList `json:"accessList"` 51 Error string `json:"error,omitempty"` 52 GasUsed hexutil.Uint64 `json:"gasUsed"` 53 } 54 var result accessListResult 55 if err := ec.c.CallContext(ctx, &result, "eth_createAccessList", toCallArg(msg)); err != nil { 56 return nil, 0, "", err 57 } 58 return result.Accesslist, uint64(result.GasUsed), result.Error, nil 59 } 60 61 // AccountResult is the result of a GetProof operation. 62 type AccountResult struct { 63 Address common.Address `json:"address"` 64 AccountProof []string `json:"accountProof"` 65 Balance *big.Int `json:"balance"` 66 CodeHash common.Hash `json:"codeHash"` 67 Nonce uint64 `json:"nonce"` 68 StorageHash common.Hash `json:"storageHash"` 69 StorageProof []StorageResult `json:"storageProof"` 70 } 71 72 // StorageResult provides a proof for a key-value pair. 73 type StorageResult struct { 74 Key string `json:"key"` 75 Value *big.Int `json:"value"` 76 Proof []string `json:"proof"` 77 } 78 79 // GetProof returns the account and storage values of the specified account including the Merkle-proof. 80 // The block number can be nil, in which case the value is taken from the latest known block. 81 func (ec *Client) GetProof(ctx context.Context, account common.Address, keys []string, blockNumber *big.Int) (*AccountResult, error) { 82 83 type storageResult struct { 84 Key string `json:"key"` 85 Value *hexutil.Big `json:"value"` 86 Proof []string `json:"proof"` 87 } 88 89 type accountResult struct { 90 Address common.Address `json:"address"` 91 AccountProof []string `json:"accountProof"` 92 Balance *hexutil.Big `json:"balance"` 93 CodeHash common.Hash `json:"codeHash"` 94 Nonce hexutil.Uint64 `json:"nonce"` 95 StorageHash common.Hash `json:"storageHash"` 96 StorageProof []storageResult `json:"storageProof"` 97 } 98 99 var res accountResult 100 err := ec.c.CallContext(ctx, &res, "eth_getProof", account, keys, toBlockNumArg(blockNumber)) 101 // Turn hexutils back to normal datatypes 102 storageResults := make([]StorageResult, 0, len(res.StorageProof)) 103 for _, st := range res.StorageProof { 104 storageResults = append(storageResults, StorageResult{ 105 Key: st.Key, 106 Value: st.Value.ToInt(), 107 Proof: st.Proof, 108 }) 109 } 110 result := AccountResult{ 111 Address: res.Address, 112 AccountProof: res.AccountProof, 113 Balance: res.Balance.ToInt(), 114 Nonce: uint64(res.Nonce), 115 CodeHash: res.CodeHash, 116 StorageHash: res.StorageHash, 117 StorageProof: storageResults, 118 } 119 return &result, err 120 } 121 122 // OverrideAccount specifies the state of an account to be overridden. 123 type OverrideAccount struct { 124 Nonce uint64 `json:"nonce"` 125 Code []byte `json:"code"` 126 Balance *big.Int `json:"balance"` 127 State map[common.Hash]common.Hash `json:"state"` 128 StateDiff map[common.Hash]common.Hash `json:"stateDiff"` 129 } 130 131 // CallContract executes a message call transaction, which is directly executed in the VM 132 // of the node, but never mined into the blockchain. 133 // 134 // blockNumber selects the block height at which the call runs. It can be nil, in which 135 // case the code is taken from the latest known block. Note that state from very old 136 // blocks might not be available. 137 // 138 // overrides specifies a map of contract states that should be overwritten before executing 139 // the message call. 140 // Please use ethclient.CallContract instead if you don't need the override functionality. 141 func (ec *Client) CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int, overrides *map[common.Address]OverrideAccount) ([]byte, error) { 142 var hex hexutil.Bytes 143 err := ec.c.CallContext( 144 ctx, &hex, "eth_call", toCallArg(msg), 145 toBlockNumArg(blockNumber), toOverrideMap(overrides), 146 ) 147 return hex, err 148 } 149 150 // GCStats retrieves the current garbage collection stats from a geth node. 151 func (ec *Client) GCStats(ctx context.Context) (*debug.GCStats, error) { 152 var result debug.GCStats 153 err := ec.c.CallContext(ctx, &result, "debug_gcStats") 154 return &result, err 155 } 156 157 // MemStats retrieves the current memory stats from a geth node. 158 func (ec *Client) MemStats(ctx context.Context) (*runtime.MemStats, error) { 159 var result runtime.MemStats 160 err := ec.c.CallContext(ctx, &result, "debug_memStats") 161 return &result, err 162 } 163 164 // SetHead sets the current head of the local chain by block number. 165 // Note, this is a destructive action and may severely damage your chain. 166 // Use with extreme caution. 167 func (ec *Client) SetHead(ctx context.Context, number *big.Int) error { 168 return ec.c.CallContext(ctx, nil, "debug_setHead", toBlockNumArg(number)) 169 } 170 171 // GetNodeInfo retrieves the node info of a geth node. 172 func (ec *Client) GetNodeInfo(ctx context.Context) (*p2p.NodeInfo, error) { 173 var result p2p.NodeInfo 174 err := ec.c.CallContext(ctx, &result, "admin_nodeInfo") 175 return &result, err 176 } 177 178 // SubscribePendingTransactions subscribes to new pending transactions. 179 func (ec *Client) SubscribePendingTransactions(ctx context.Context, ch chan<- common.Hash) (*rpc.ClientSubscription, error) { 180 return ec.c.EthSubscribe(ctx, ch, "newPendingTransactions") 181 } 182 183 func toBlockNumArg(number *big.Int) string { 184 if number == nil { 185 return "latest" 186 } 187 pending := big.NewInt(-1) 188 if number.Cmp(pending) == 0 { 189 return "pending" 190 } 191 return hexutil.EncodeBig(number) 192 } 193 194 func toCallArg(msg ethereum.CallMsg) interface{} { 195 arg := map[string]interface{}{ 196 "from": msg.From, 197 "to": msg.To, 198 } 199 if len(msg.Data) > 0 { 200 arg["data"] = hexutil.Bytes(msg.Data) 201 } 202 if msg.Value != nil { 203 arg["value"] = (*hexutil.Big)(msg.Value) 204 } 205 if msg.Gas != 0 { 206 arg["gas"] = hexutil.Uint64(msg.Gas) 207 } 208 if msg.GasPrice != nil { 209 arg["gasPrice"] = (*hexutil.Big)(msg.GasPrice) 210 } 211 return arg 212 } 213 214 func toOverrideMap(overrides *map[common.Address]OverrideAccount) interface{} { 215 if overrides == nil { 216 return nil 217 } 218 type overrideAccount struct { 219 Nonce hexutil.Uint64 `json:"nonce"` 220 Code hexutil.Bytes `json:"code"` 221 Balance *hexutil.Big `json:"balance"` 222 State map[common.Hash]common.Hash `json:"state"` 223 StateDiff map[common.Hash]common.Hash `json:"stateDiff"` 224 } 225 result := make(map[common.Address]overrideAccount) 226 for addr, override := range *overrides { 227 result[addr] = overrideAccount{ 228 Nonce: hexutil.Uint64(override.Nonce), 229 Code: override.Code, 230 Balance: (*hexutil.Big)(override.Balance), 231 State: override.State, 232 StateDiff: override.StateDiff, 233 } 234 } 235 return &result 236 }