github.com/daeglee/go-ethereum@v0.0.0-20190504220456-cad3e8d18e9b/internal/ethapi/api.go (about) 1 // Copyright 2015 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 ethapi 18 19 import ( 20 "bytes" 21 "context" 22 "errors" 23 "fmt" 24 "math/big" 25 "strings" 26 "time" 27 28 "github.com/davecgh/go-spew/spew" 29 "github.com/ethereum/go-ethereum/accounts" 30 "github.com/ethereum/go-ethereum/accounts/keystore" 31 "github.com/ethereum/go-ethereum/common" 32 "github.com/ethereum/go-ethereum/common/hexutil" 33 "github.com/ethereum/go-ethereum/common/math" 34 "github.com/ethereum/go-ethereum/consensus/clique" 35 "github.com/ethereum/go-ethereum/consensus/ethash" 36 "github.com/ethereum/go-ethereum/core" 37 "github.com/ethereum/go-ethereum/core/rawdb" 38 "github.com/ethereum/go-ethereum/core/types" 39 "github.com/ethereum/go-ethereum/core/vm" 40 "github.com/ethereum/go-ethereum/crypto" 41 "github.com/ethereum/go-ethereum/log" 42 "github.com/ethereum/go-ethereum/p2p" 43 "github.com/ethereum/go-ethereum/params" 44 "github.com/ethereum/go-ethereum/rlp" 45 "github.com/ethereum/go-ethereum/rpc" 46 "github.com/syndtr/goleveldb/leveldb" 47 ) 48 49 const ( 50 defaultGasPrice = params.GWei 51 ) 52 53 // PublicEthereumAPI provides an API to access Ethereum related information. 54 // It offers only methods that operate on public data that is freely available to anyone. 55 type PublicEthereumAPI struct { 56 b Backend 57 } 58 59 // NewPublicEthereumAPI creates a new Ethereum protocol API. 60 func NewPublicEthereumAPI(b Backend) *PublicEthereumAPI { 61 return &PublicEthereumAPI{b} 62 } 63 64 // GasPrice returns a suggestion for a gas price. 65 func (s *PublicEthereumAPI) GasPrice(ctx context.Context) (*hexutil.Big, error) { 66 price, err := s.b.SuggestPrice(ctx) 67 return (*hexutil.Big)(price), err 68 } 69 70 // ProtocolVersion returns the current Ethereum protocol version this node supports 71 func (s *PublicEthereumAPI) ProtocolVersion() hexutil.Uint { 72 return hexutil.Uint(s.b.ProtocolVersion()) 73 } 74 75 // Syncing returns false in case the node is currently not syncing with the network. It can be up to date or has not 76 // yet received the latest block headers from its pears. In case it is synchronizing: 77 // - startingBlock: block number this node started to synchronise from 78 // - currentBlock: block number this node is currently importing 79 // - highestBlock: block number of the highest block header this node has received from peers 80 // - pulledStates: number of state entries processed until now 81 // - knownStates: number of known state entries that still need to be pulled 82 func (s *PublicEthereumAPI) Syncing() (interface{}, error) { 83 progress := s.b.Downloader().Progress() 84 85 // Return not syncing if the synchronisation already completed 86 if progress.CurrentBlock >= progress.HighestBlock { 87 return false, nil 88 } 89 // Otherwise gather the block sync stats 90 return map[string]interface{}{ 91 "startingBlock": hexutil.Uint64(progress.StartingBlock), 92 "currentBlock": hexutil.Uint64(progress.CurrentBlock), 93 "highestBlock": hexutil.Uint64(progress.HighestBlock), 94 "pulledStates": hexutil.Uint64(progress.PulledStates), 95 "knownStates": hexutil.Uint64(progress.KnownStates), 96 }, nil 97 } 98 99 // PublicTxPoolAPI offers and API for the transaction pool. It only operates on data that is non confidential. 100 type PublicTxPoolAPI struct { 101 b Backend 102 } 103 104 // NewPublicTxPoolAPI creates a new tx pool service that gives information about the transaction pool. 105 func NewPublicTxPoolAPI(b Backend) *PublicTxPoolAPI { 106 return &PublicTxPoolAPI{b} 107 } 108 109 // Content returns the transactions contained within the transaction pool. 110 func (s *PublicTxPoolAPI) Content() map[string]map[string]map[string]*RPCTransaction { 111 content := map[string]map[string]map[string]*RPCTransaction{ 112 "pending": make(map[string]map[string]*RPCTransaction), 113 "queued": make(map[string]map[string]*RPCTransaction), 114 } 115 pending, queue := s.b.TxPoolContent() 116 117 // Flatten the pending transactions 118 for account, txs := range pending { 119 dump := make(map[string]*RPCTransaction) 120 for _, tx := range txs { 121 dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx) 122 } 123 content["pending"][account.Hex()] = dump 124 } 125 // Flatten the queued transactions 126 for account, txs := range queue { 127 dump := make(map[string]*RPCTransaction) 128 for _, tx := range txs { 129 dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx) 130 } 131 content["queued"][account.Hex()] = dump 132 } 133 return content 134 } 135 136 // Status returns the number of pending and queued transaction in the pool. 137 func (s *PublicTxPoolAPI) Status() map[string]hexutil.Uint { 138 pending, queue := s.b.Stats() 139 return map[string]hexutil.Uint{ 140 "pending": hexutil.Uint(pending), 141 "queued": hexutil.Uint(queue), 142 } 143 } 144 145 // Inspect retrieves the content of the transaction pool and flattens it into an 146 // easily inspectable list. 147 func (s *PublicTxPoolAPI) Inspect() map[string]map[string]map[string]string { 148 content := map[string]map[string]map[string]string{ 149 "pending": make(map[string]map[string]string), 150 "queued": make(map[string]map[string]string), 151 } 152 pending, queue := s.b.TxPoolContent() 153 154 // Define a formatter to flatten a transaction into a string 155 var format = func(tx *types.Transaction) string { 156 if to := tx.To(); to != nil { 157 return fmt.Sprintf("%s: %v wei + %v gas × %v wei", tx.To().Hex(), tx.Value(), tx.Gas(), tx.GasPrice()) 158 } 159 return fmt.Sprintf("contract creation: %v wei + %v gas × %v wei", tx.Value(), tx.Gas(), tx.GasPrice()) 160 } 161 // Flatten the pending transactions 162 for account, txs := range pending { 163 dump := make(map[string]string) 164 for _, tx := range txs { 165 dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx) 166 } 167 content["pending"][account.Hex()] = dump 168 } 169 // Flatten the queued transactions 170 for account, txs := range queue { 171 dump := make(map[string]string) 172 for _, tx := range txs { 173 dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx) 174 } 175 content["queued"][account.Hex()] = dump 176 } 177 return content 178 } 179 180 // PublicAccountAPI provides an API to access accounts managed by this node. 181 // It offers only methods that can retrieve accounts. 182 type PublicAccountAPI struct { 183 am *accounts.Manager 184 } 185 186 // NewPublicAccountAPI creates a new PublicAccountAPI. 187 func NewPublicAccountAPI(am *accounts.Manager) *PublicAccountAPI { 188 return &PublicAccountAPI{am: am} 189 } 190 191 // Accounts returns the collection of accounts this node manages 192 func (s *PublicAccountAPI) Accounts() []common.Address { 193 addresses := make([]common.Address, 0) // return [] instead of nil if empty 194 for _, wallet := range s.am.Wallets() { 195 for _, account := range wallet.Accounts() { 196 addresses = append(addresses, account.Address) 197 } 198 } 199 return addresses 200 } 201 202 // PrivateAccountAPI provides an API to access accounts managed by this node. 203 // It offers methods to create, (un)lock en list accounts. Some methods accept 204 // passwords and are therefore considered private by default. 205 type PrivateAccountAPI struct { 206 am *accounts.Manager 207 nonceLock *AddrLocker 208 b Backend 209 } 210 211 // NewPrivateAccountAPI create a new PrivateAccountAPI. 212 func NewPrivateAccountAPI(b Backend, nonceLock *AddrLocker) *PrivateAccountAPI { 213 return &PrivateAccountAPI{ 214 am: b.AccountManager(), 215 nonceLock: nonceLock, 216 b: b, 217 } 218 } 219 220 // listAccounts will return a list of addresses for accounts this node manages. 221 func (s *PrivateAccountAPI) ListAccounts() []common.Address { 222 addresses := make([]common.Address, 0) // return [] instead of nil if empty 223 for _, wallet := range s.am.Wallets() { 224 for _, account := range wallet.Accounts() { 225 addresses = append(addresses, account.Address) 226 } 227 } 228 return addresses 229 } 230 231 // rawWallet is a JSON representation of an accounts.Wallet interface, with its 232 // data contents extracted into plain fields. 233 type rawWallet struct { 234 URL string `json:"url"` 235 Status string `json:"status"` 236 Failure string `json:"failure,omitempty"` 237 Accounts []accounts.Account `json:"accounts,omitempty"` 238 } 239 240 // ListWallets will return a list of wallets this node manages. 241 func (s *PrivateAccountAPI) ListWallets() []rawWallet { 242 wallets := make([]rawWallet, 0) // return [] instead of nil if empty 243 for _, wallet := range s.am.Wallets() { 244 status, failure := wallet.Status() 245 246 raw := rawWallet{ 247 URL: wallet.URL().String(), 248 Status: status, 249 Accounts: wallet.Accounts(), 250 } 251 if failure != nil { 252 raw.Failure = failure.Error() 253 } 254 wallets = append(wallets, raw) 255 } 256 return wallets 257 } 258 259 // OpenWallet initiates a hardware wallet opening procedure, establishing a USB 260 // connection and attempting to authenticate via the provided passphrase. Note, 261 // the method may return an extra challenge requiring a second open (e.g. the 262 // Trezor PIN matrix challenge). 263 func (s *PrivateAccountAPI) OpenWallet(url string, passphrase *string) error { 264 wallet, err := s.am.Wallet(url) 265 if err != nil { 266 return err 267 } 268 pass := "" 269 if passphrase != nil { 270 pass = *passphrase 271 } 272 return wallet.Open(pass) 273 } 274 275 // DeriveAccount requests a HD wallet to derive a new account, optionally pinning 276 // it for later reuse. 277 func (s *PrivateAccountAPI) DeriveAccount(url string, path string, pin *bool) (accounts.Account, error) { 278 wallet, err := s.am.Wallet(url) 279 if err != nil { 280 return accounts.Account{}, err 281 } 282 derivPath, err := accounts.ParseDerivationPath(path) 283 if err != nil { 284 return accounts.Account{}, err 285 } 286 if pin == nil { 287 pin = new(bool) 288 } 289 return wallet.Derive(derivPath, *pin) 290 } 291 292 // NewAccount will create a new account and returns the address for the new account. 293 func (s *PrivateAccountAPI) NewAccount(password string) (common.Address, error) { 294 acc, err := fetchKeystore(s.am).NewAccount(password) 295 if err == nil { 296 return acc.Address, nil 297 } 298 return common.Address{}, err 299 } 300 301 // fetchKeystore retrives the encrypted keystore from the account manager. 302 func fetchKeystore(am *accounts.Manager) *keystore.KeyStore { 303 return am.Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore) 304 } 305 306 // ImportRawKey stores the given hex encoded ECDSA key into the key directory, 307 // encrypting it with the passphrase. 308 func (s *PrivateAccountAPI) ImportRawKey(privkey string, password string) (common.Address, error) { 309 key, err := crypto.HexToECDSA(privkey) 310 if err != nil { 311 return common.Address{}, err 312 } 313 acc, err := fetchKeystore(s.am).ImportECDSA(key, password) 314 return acc.Address, err 315 } 316 317 // UnlockAccount will unlock the account associated with the given address with 318 // the given password for duration seconds. If duration is nil it will use a 319 // default of 300 seconds. It returns an indication if the account was unlocked. 320 func (s *PrivateAccountAPI) UnlockAccount(addr common.Address, password string, duration *uint64) (bool, error) { 321 const max = uint64(time.Duration(math.MaxInt64) / time.Second) 322 var d time.Duration 323 if duration == nil { 324 d = 300 * time.Second 325 } else if *duration > max { 326 return false, errors.New("unlock duration too large") 327 } else { 328 d = time.Duration(*duration) * time.Second 329 } 330 err := fetchKeystore(s.am).TimedUnlock(accounts.Account{Address: addr}, password, d) 331 if err != nil { 332 log.Warn("Failed account unlock attempt", "address", addr, "err", err) 333 } 334 return err == nil, err 335 } 336 337 // LockAccount will lock the account associated with the given address when it's unlocked. 338 func (s *PrivateAccountAPI) LockAccount(addr common.Address) bool { 339 return fetchKeystore(s.am).Lock(addr) == nil 340 } 341 342 // signTransaction sets defaults and signs the given transaction 343 // NOTE: the caller needs to ensure that the nonceLock is held, if applicable, 344 // and release it after the transaction has been submitted to the tx pool 345 func (s *PrivateAccountAPI) signTransaction(ctx context.Context, args *SendTxArgs, passwd string) (*types.Transaction, error) { 346 // Look up the wallet containing the requested signer 347 account := accounts.Account{Address: args.From} 348 wallet, err := s.am.Find(account) 349 if err != nil { 350 return nil, err 351 } 352 // Set some sanity defaults and terminate on failure 353 if err := args.setDefaults(ctx, s.b); err != nil { 354 return nil, err 355 } 356 // Assemble the transaction and sign with the wallet 357 tx := args.toTransaction() 358 359 return wallet.SignTxWithPassphrase(account, passwd, tx, s.b.ChainConfig().ChainID) 360 } 361 362 // SendTransaction will create a transaction from the given arguments and 363 // tries to sign it with the key associated with args.To. If the given passwd isn't 364 // able to decrypt the key it fails. 365 func (s *PrivateAccountAPI) SendTransaction(ctx context.Context, args SendTxArgs, passwd string) (common.Hash, error) { 366 if args.Nonce == nil { 367 // Hold the addresse's mutex around signing to prevent concurrent assignment of 368 // the same nonce to multiple accounts. 369 s.nonceLock.LockAddr(args.From) 370 defer s.nonceLock.UnlockAddr(args.From) 371 } 372 signed, err := s.signTransaction(ctx, &args, passwd) 373 if err != nil { 374 log.Warn("Failed transaction send attempt", "from", args.From, "to", args.To, "value", args.Value.ToInt(), "err", err) 375 return common.Hash{}, err 376 } 377 return SubmitTransaction(ctx, s.b, signed) 378 } 379 380 // SignTransaction will create a transaction from the given arguments and 381 // tries to sign it with the key associated with args.To. If the given passwd isn't 382 // able to decrypt the key it fails. The transaction is returned in RLP-form, not broadcast 383 // to other nodes 384 func (s *PrivateAccountAPI) SignTransaction(ctx context.Context, args SendTxArgs, passwd string) (*SignTransactionResult, error) { 385 // No need to obtain the noncelock mutex, since we won't be sending this 386 // tx into the transaction pool, but right back to the user 387 if args.Gas == nil { 388 return nil, fmt.Errorf("gas not specified") 389 } 390 if args.GasPrice == nil { 391 return nil, fmt.Errorf("gasPrice not specified") 392 } 393 if args.Nonce == nil { 394 return nil, fmt.Errorf("nonce not specified") 395 } 396 signed, err := s.signTransaction(ctx, &args, passwd) 397 if err != nil { 398 log.Warn("Failed transaction sign attempt", "from", args.From, "to", args.To, "value", args.Value.ToInt(), "err", err) 399 return nil, err 400 } 401 data, err := rlp.EncodeToBytes(signed) 402 if err != nil { 403 return nil, err 404 } 405 return &SignTransactionResult{data, signed}, nil 406 } 407 408 // Sign calculates an Ethereum ECDSA signature for: 409 // keccack256("\x19Ethereum Signed Message:\n" + len(message) + message)) 410 // 411 // Note, the produced signature conforms to the secp256k1 curve R, S and V values, 412 // where the V value will be 27 or 28 for legacy reasons. 413 // 414 // The key used to calculate the signature is decrypted with the given password. 415 // 416 // https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_sign 417 func (s *PrivateAccountAPI) Sign(ctx context.Context, data hexutil.Bytes, addr common.Address, passwd string) (hexutil.Bytes, error) { 418 // Look up the wallet containing the requested signer 419 account := accounts.Account{Address: addr} 420 421 wallet, err := s.b.AccountManager().Find(account) 422 if err != nil { 423 return nil, err 424 } 425 // Assemble sign the data with the wallet 426 signature, err := wallet.SignTextWithPassphrase(account, passwd, data) 427 if err != nil { 428 log.Warn("Failed data sign attempt", "address", addr, "err", err) 429 return nil, err 430 } 431 signature[64] += 27 // Transform V from 0/1 to 27/28 according to the yellow paper 432 return signature, nil 433 } 434 435 // EcRecover returns the address for the account that was used to create the signature. 436 // Note, this function is compatible with eth_sign and personal_sign. As such it recovers 437 // the address of: 438 // hash = keccak256("\x19Ethereum Signed Message:\n"${message length}${message}) 439 // addr = ecrecover(hash, signature) 440 // 441 // Note, the signature must conform to the secp256k1 curve R, S and V values, where 442 // the V value must be 27 or 28 for legacy reasons. 443 // 444 // https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_ecRecover 445 func (s *PrivateAccountAPI) EcRecover(ctx context.Context, data, sig hexutil.Bytes) (common.Address, error) { 446 if len(sig) != 65 { 447 return common.Address{}, fmt.Errorf("signature must be 65 bytes long") 448 } 449 if sig[64] != 27 && sig[64] != 28 { 450 return common.Address{}, fmt.Errorf("invalid Ethereum signature (V is not 27 or 28)") 451 } 452 sig[64] -= 27 // Transform yellow paper V from 27/28 to 0/1 453 454 rpk, err := crypto.SigToPub(accounts.TextHash(data), sig) 455 if err != nil { 456 return common.Address{}, err 457 } 458 return crypto.PubkeyToAddress(*rpk), nil 459 } 460 461 // SignAndSendTransaction was renamed to SendTransaction. This method is deprecated 462 // and will be removed in the future. It primary goal is to give clients time to update. 463 func (s *PrivateAccountAPI) SignAndSendTransaction(ctx context.Context, args SendTxArgs, passwd string) (common.Hash, error) { 464 return s.SendTransaction(ctx, args, passwd) 465 } 466 467 // PublicBlockChainAPI provides an API to access the Ethereum blockchain. 468 // It offers only methods that operate on public data that is freely available to anyone. 469 type PublicBlockChainAPI struct { 470 b Backend 471 } 472 473 // NewPublicBlockChainAPI creates a new Ethereum blockchain API. 474 func NewPublicBlockChainAPI(b Backend) *PublicBlockChainAPI { 475 return &PublicBlockChainAPI{b} 476 } 477 478 // BlockNumber returns the block number of the chain head. 479 func (s *PublicBlockChainAPI) BlockNumber() hexutil.Uint64 { 480 header, _ := s.b.HeaderByNumber(context.Background(), rpc.LatestBlockNumber) // latest header should always be available 481 return hexutil.Uint64(header.Number.Uint64()) 482 } 483 484 // GetBalance returns the amount of wei for the given address in the state of the 485 // given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta 486 // block numbers are also allowed. 487 func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (*hexutil.Big, error) { 488 state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr) 489 if state == nil || err != nil { 490 return nil, err 491 } 492 return (*hexutil.Big)(state.GetBalance(address)), state.Error() 493 } 494 495 // Result structs for GetProof 496 type AccountResult struct { 497 Address common.Address `json:"address"` 498 AccountProof []string `json:"accountProof"` 499 Balance *hexutil.Big `json:"balance"` 500 CodeHash common.Hash `json:"codeHash"` 501 Nonce hexutil.Uint64 `json:"nonce"` 502 StorageHash common.Hash `json:"storageHash"` 503 StorageProof []StorageResult `json:"storageProof"` 504 } 505 type StorageResult struct { 506 Key string `json:"key"` 507 Value *hexutil.Big `json:"value"` 508 Proof []string `json:"proof"` 509 } 510 511 // GetProof returns the Merkle-proof for a given account and optionally some storage keys. 512 func (s *PublicBlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNr rpc.BlockNumber) (*AccountResult, error) { 513 state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr) 514 if state == nil || err != nil { 515 return nil, err 516 } 517 518 storageTrie := state.StorageTrie(address) 519 storageHash := types.EmptyRootHash 520 codeHash := state.GetCodeHash(address) 521 storageProof := make([]StorageResult, len(storageKeys)) 522 523 // if we have a storageTrie, (which means the account exists), we can update the storagehash 524 if storageTrie != nil { 525 storageHash = storageTrie.Hash() 526 } else { 527 // no storageTrie means the account does not exist, so the codeHash is the hash of an empty bytearray. 528 codeHash = crypto.Keccak256Hash(nil) 529 } 530 531 // create the proof for the storageKeys 532 for i, key := range storageKeys { 533 if storageTrie != nil { 534 proof, storageError := state.GetStorageProof(address, common.HexToHash(key)) 535 if storageError != nil { 536 return nil, storageError 537 } 538 storageProof[i] = StorageResult{key, (*hexutil.Big)(state.GetState(address, common.HexToHash(key)).Big()), common.ToHexArray(proof)} 539 } else { 540 storageProof[i] = StorageResult{key, &hexutil.Big{}, []string{}} 541 } 542 } 543 544 // create the accountProof 545 accountProof, proofErr := state.GetProof(address) 546 if proofErr != nil { 547 return nil, proofErr 548 } 549 550 return &AccountResult{ 551 Address: address, 552 AccountProof: common.ToHexArray(accountProof), 553 Balance: (*hexutil.Big)(state.GetBalance(address)), 554 CodeHash: codeHash, 555 Nonce: hexutil.Uint64(state.GetNonce(address)), 556 StorageHash: storageHash, 557 StorageProof: storageProof, 558 }, state.Error() 559 } 560 561 // GetBlockByNumber returns the requested block. When blockNr is -1 the chain head is returned. When fullTx is true all 562 // transactions in the block are returned in full detail, otherwise only the transaction hash is returned. 563 func (s *PublicBlockChainAPI) GetBlockByNumber(ctx context.Context, blockNr rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) { 564 block, err := s.b.BlockByNumber(ctx, blockNr) 565 if block != nil { 566 response, err := s.rpcOutputBlock(block, true, fullTx) 567 if err == nil && blockNr == rpc.PendingBlockNumber { 568 // Pending blocks need to nil out a few fields 569 for _, field := range []string{"hash", "nonce", "miner"} { 570 response[field] = nil 571 } 572 } 573 return response, err 574 } 575 return nil, err 576 } 577 578 // GetBlockByHash returns the requested block. When fullTx is true all transactions in the block are returned in full 579 // detail, otherwise only the transaction hash is returned. 580 func (s *PublicBlockChainAPI) GetBlockByHash(ctx context.Context, blockHash common.Hash, fullTx bool) (map[string]interface{}, error) { 581 block, err := s.b.GetBlock(ctx, blockHash) 582 if block != nil { 583 return s.rpcOutputBlock(block, true, fullTx) 584 } 585 return nil, err 586 } 587 588 // GetUncleByBlockNumberAndIndex returns the uncle block for the given block hash and index. When fullTx is true 589 // all transactions in the block are returned in full detail, otherwise only the transaction hash is returned. 590 func (s *PublicBlockChainAPI) GetUncleByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (map[string]interface{}, error) { 591 block, err := s.b.BlockByNumber(ctx, blockNr) 592 if block != nil { 593 uncles := block.Uncles() 594 if index >= hexutil.Uint(len(uncles)) { 595 log.Debug("Requested uncle not found", "number", blockNr, "hash", block.Hash(), "index", index) 596 return nil, nil 597 } 598 block = types.NewBlockWithHeader(uncles[index]) 599 return s.rpcOutputBlock(block, false, false) 600 } 601 return nil, err 602 } 603 604 // GetUncleByBlockHashAndIndex returns the uncle block for the given block hash and index. When fullTx is true 605 // all transactions in the block are returned in full detail, otherwise only the transaction hash is returned. 606 func (s *PublicBlockChainAPI) GetUncleByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (map[string]interface{}, error) { 607 block, err := s.b.GetBlock(ctx, blockHash) 608 if block != nil { 609 uncles := block.Uncles() 610 if index >= hexutil.Uint(len(uncles)) { 611 log.Debug("Requested uncle not found", "number", block.Number(), "hash", blockHash, "index", index) 612 return nil, nil 613 } 614 block = types.NewBlockWithHeader(uncles[index]) 615 return s.rpcOutputBlock(block, false, false) 616 } 617 return nil, err 618 } 619 620 // GetUncleCountByBlockNumber returns number of uncles in the block for the given block number 621 func (s *PublicBlockChainAPI) GetUncleCountByBlockNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint { 622 if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil { 623 n := hexutil.Uint(len(block.Uncles())) 624 return &n 625 } 626 return nil 627 } 628 629 // GetUncleCountByBlockHash returns number of uncles in the block for the given block hash 630 func (s *PublicBlockChainAPI) GetUncleCountByBlockHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint { 631 if block, _ := s.b.GetBlock(ctx, blockHash); block != nil { 632 n := hexutil.Uint(len(block.Uncles())) 633 return &n 634 } 635 return nil 636 } 637 638 // GetCode returns the code stored at the given address in the state for the given block number. 639 func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (hexutil.Bytes, error) { 640 state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr) 641 if state == nil || err != nil { 642 return nil, err 643 } 644 code := state.GetCode(address) 645 return code, state.Error() 646 } 647 648 // GetStorageAt returns the storage from the state at the given address, key and 649 // block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block 650 // numbers are also allowed. 651 func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNr rpc.BlockNumber) (hexutil.Bytes, error) { 652 state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr) 653 if state == nil || err != nil { 654 return nil, err 655 } 656 res := state.GetState(address, common.HexToHash(key)) 657 return res[:], state.Error() 658 } 659 660 // CallArgs represents the arguments for a call. 661 type CallArgs struct { 662 From *common.Address `json:"from"` 663 To *common.Address `json:"to"` 664 Gas *hexutil.Uint64 `json:"gas"` 665 GasPrice *hexutil.Big `json:"gasPrice"` 666 Value *hexutil.Big `json:"value"` 667 Data *hexutil.Bytes `json:"data"` 668 } 669 670 func DoCall(ctx context.Context, b Backend, args CallArgs, blockNr rpc.BlockNumber, vmCfg vm.Config, timeout time.Duration) ([]byte, uint64, bool, error) { 671 defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now()) 672 673 state, header, err := b.StateAndHeaderByNumber(ctx, blockNr) 674 if state == nil || err != nil { 675 return nil, 0, false, err 676 } 677 // Set sender address or use a default if none specified 678 var addr common.Address 679 if args.From == nil { 680 if wallets := b.AccountManager().Wallets(); len(wallets) > 0 { 681 if accounts := wallets[0].Accounts(); len(accounts) > 0 { 682 addr = accounts[0].Address 683 } 684 } 685 } else { 686 addr = *args.From 687 } 688 // Set default gas & gas price if none were set 689 gas := uint64(math.MaxUint64 / 2) 690 if args.Gas != nil { 691 gas = uint64(*args.Gas) 692 } 693 gasPrice := new(big.Int).SetUint64(defaultGasPrice) 694 if args.GasPrice != nil { 695 gasPrice = args.GasPrice.ToInt() 696 } 697 698 value := new(big.Int) 699 if args.Value != nil { 700 value = args.Value.ToInt() 701 } 702 703 var data []byte 704 if args.Data != nil { 705 data = []byte(*args.Data) 706 } 707 708 // Create new call message 709 msg := types.NewMessage(addr, args.To, 0, value, gas, gasPrice, data, false) 710 711 // Setup context so it may be cancelled the call has completed 712 // or, in case of unmetered gas, setup a context with a timeout. 713 var cancel context.CancelFunc 714 if timeout > 0 { 715 ctx, cancel = context.WithTimeout(ctx, timeout) 716 } else { 717 ctx, cancel = context.WithCancel(ctx) 718 } 719 // Make sure the context is cancelled when the call has completed 720 // this makes sure resources are cleaned up. 721 defer cancel() 722 723 // Get a new instance of the EVM. 724 evm, vmError, err := b.GetEVM(ctx, msg, state, header) 725 if err != nil { 726 return nil, 0, false, err 727 } 728 // Wait for the context to be done and cancel the evm. Even if the 729 // EVM has finished, cancelling may be done (repeatedly) 730 go func() { 731 <-ctx.Done() 732 evm.Cancel() 733 }() 734 735 // Setup the gas pool (also for unmetered requests) 736 // and apply the message. 737 gp := new(core.GasPool).AddGas(math.MaxUint64) 738 res, gas, failed, err := core.ApplyMessage(evm, msg, gp) 739 if err := vmError(); err != nil { 740 return nil, 0, false, err 741 } 742 return res, gas, failed, err 743 } 744 745 // Call executes the given transaction on the state for the given block number. 746 // It doesn't make and changes in the state/blockchain and is useful to execute and retrieve values. 747 func (s *PublicBlockChainAPI) Call(ctx context.Context, args CallArgs, blockNr rpc.BlockNumber) (hexutil.Bytes, error) { 748 result, _, _, err := DoCall(ctx, s.b, args, blockNr, vm.Config{}, 5*time.Second) 749 return (hexutil.Bytes)(result), err 750 } 751 752 func DoEstimateGas(ctx context.Context, b Backend, args CallArgs, blockNr rpc.BlockNumber) (hexutil.Uint64, error) { 753 // Binary search the gas requirement, as it may be higher than the amount used 754 var ( 755 lo uint64 = params.TxGas - 1 756 hi uint64 757 cap uint64 758 ) 759 if args.Gas != nil && uint64(*args.Gas) >= params.TxGas { 760 hi = uint64(*args.Gas) 761 } else { 762 // Retrieve the block to act as the gas ceiling 763 block, err := b.BlockByNumber(ctx, blockNr) 764 if err != nil { 765 return 0, err 766 } 767 hi = block.GasLimit() 768 } 769 cap = hi 770 771 // Create a helper to check if a gas allowance results in an executable transaction 772 executable := func(gas uint64) bool { 773 args.Gas = (*hexutil.Uint64)(&gas) 774 775 _, _, failed, err := DoCall(ctx, b, args, rpc.PendingBlockNumber, vm.Config{}, 0) 776 if err != nil || failed { 777 return false 778 } 779 return true 780 } 781 // Execute the binary search and hone in on an executable gas limit 782 for lo+1 < hi { 783 mid := (hi + lo) / 2 784 if !executable(mid) { 785 lo = mid 786 } else { 787 hi = mid 788 } 789 } 790 // Reject the transaction as invalid if it still fails at the highest allowance 791 if hi == cap { 792 if !executable(hi) { 793 return 0, fmt.Errorf("gas required exceeds allowance or always failing transaction") 794 } 795 } 796 return hexutil.Uint64(hi), nil 797 } 798 799 // EstimateGas returns an estimate of the amount of gas needed to execute the 800 // given transaction against the current pending block. 801 func (s *PublicBlockChainAPI) EstimateGas(ctx context.Context, args CallArgs) (hexutil.Uint64, error) { 802 return DoEstimateGas(ctx, s.b, args, rpc.PendingBlockNumber) 803 } 804 805 // ExecutionResult groups all structured logs emitted by the EVM 806 // while replaying a transaction in debug mode as well as transaction 807 // execution status, the amount of gas used and the return value 808 type ExecutionResult struct { 809 Gas uint64 `json:"gas"` 810 Failed bool `json:"failed"` 811 ReturnValue string `json:"returnValue"` 812 StructLogs []StructLogRes `json:"structLogs"` 813 } 814 815 // StructLogRes stores a structured log emitted by the EVM while replaying a 816 // transaction in debug mode 817 type StructLogRes struct { 818 Pc uint64 `json:"pc"` 819 Op string `json:"op"` 820 Gas uint64 `json:"gas"` 821 GasCost uint64 `json:"gasCost"` 822 Depth int `json:"depth"` 823 Error error `json:"error,omitempty"` 824 Stack *[]string `json:"stack,omitempty"` 825 Memory *[]string `json:"memory,omitempty"` 826 Storage *map[string]string `json:"storage,omitempty"` 827 } 828 829 // FormatLogs formats EVM returned structured logs for json output 830 func FormatLogs(logs []vm.StructLog) []StructLogRes { 831 formatted := make([]StructLogRes, len(logs)) 832 for index, trace := range logs { 833 formatted[index] = StructLogRes{ 834 Pc: trace.Pc, 835 Op: trace.Op.String(), 836 Gas: trace.Gas, 837 GasCost: trace.GasCost, 838 Depth: trace.Depth, 839 Error: trace.Err, 840 } 841 if trace.Stack != nil { 842 stack := make([]string, len(trace.Stack)) 843 for i, stackValue := range trace.Stack { 844 stack[i] = fmt.Sprintf("%x", math.PaddedBigBytes(stackValue, 32)) 845 } 846 formatted[index].Stack = &stack 847 } 848 if trace.Memory != nil { 849 memory := make([]string, 0, (len(trace.Memory)+31)/32) 850 for i := 0; i+32 <= len(trace.Memory); i += 32 { 851 memory = append(memory, fmt.Sprintf("%x", trace.Memory[i:i+32])) 852 } 853 formatted[index].Memory = &memory 854 } 855 if trace.Storage != nil { 856 storage := make(map[string]string) 857 for i, storageValue := range trace.Storage { 858 storage[fmt.Sprintf("%x", i)] = fmt.Sprintf("%x", storageValue) 859 } 860 formatted[index].Storage = &storage 861 } 862 } 863 return formatted 864 } 865 866 // RPCMarshalBlock converts the given block to the RPC output which depends on fullTx. If inclTx is true transactions are 867 // returned. When fullTx is true the returned block contains full transaction details, otherwise it will only contain 868 // transaction hashes. 869 func RPCMarshalBlock(b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) { 870 head := b.Header() // copies the header once 871 fields := map[string]interface{}{ 872 "number": (*hexutil.Big)(head.Number), 873 "hash": b.Hash(), 874 "parentHash": head.ParentHash, 875 "nonce": head.Nonce, 876 "mixHash": head.MixDigest, 877 "sha3Uncles": head.UncleHash, 878 "logsBloom": head.Bloom, 879 "stateRoot": head.Root, 880 "miner": head.Coinbase, 881 "difficulty": (*hexutil.Big)(head.Difficulty), 882 "extraData": hexutil.Bytes(head.Extra), 883 "size": hexutil.Uint64(b.Size()), 884 "gasLimit": hexutil.Uint64(head.GasLimit), 885 "gasUsed": hexutil.Uint64(head.GasUsed), 886 "timestamp": (*hexutil.Big)(head.Time), 887 "transactionsRoot": head.TxHash, 888 "receiptsRoot": head.ReceiptHash, 889 } 890 891 if inclTx { 892 formatTx := func(tx *types.Transaction) (interface{}, error) { 893 return tx.Hash(), nil 894 } 895 if fullTx { 896 formatTx = func(tx *types.Transaction) (interface{}, error) { 897 return newRPCTransactionFromBlockHash(b, tx.Hash()), nil 898 } 899 } 900 txs := b.Transactions() 901 transactions := make([]interface{}, len(txs)) 902 var err error 903 for i, tx := range txs { 904 if transactions[i], err = formatTx(tx); err != nil { 905 return nil, err 906 } 907 } 908 fields["transactions"] = transactions 909 } 910 911 uncles := b.Uncles() 912 uncleHashes := make([]common.Hash, len(uncles)) 913 for i, uncle := range uncles { 914 uncleHashes[i] = uncle.Hash() 915 } 916 fields["uncles"] = uncleHashes 917 918 return fields, nil 919 } 920 921 // rpcOutputBlock uses the generalized output filler, then adds the total difficulty field, which requires 922 // a `PublicBlockchainAPI`. 923 func (s *PublicBlockChainAPI) rpcOutputBlock(b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) { 924 fields, err := RPCMarshalBlock(b, inclTx, fullTx) 925 if err != nil { 926 return nil, err 927 } 928 fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(b.Hash())) 929 return fields, err 930 } 931 932 // RPCTransaction represents a transaction that will serialize to the RPC representation of a transaction 933 type RPCTransaction struct { 934 BlockHash common.Hash `json:"blockHash"` 935 BlockNumber *hexutil.Big `json:"blockNumber"` 936 From common.Address `json:"from"` 937 Gas hexutil.Uint64 `json:"gas"` 938 GasPrice *hexutil.Big `json:"gasPrice"` 939 Hash common.Hash `json:"hash"` 940 Input hexutil.Bytes `json:"input"` 941 Nonce hexutil.Uint64 `json:"nonce"` 942 To *common.Address `json:"to"` 943 TransactionIndex hexutil.Uint `json:"transactionIndex"` 944 Value *hexutil.Big `json:"value"` 945 V *hexutil.Big `json:"v"` 946 R *hexutil.Big `json:"r"` 947 S *hexutil.Big `json:"s"` 948 } 949 950 // newRPCTransaction returns a transaction that will serialize to the RPC 951 // representation, with the given location metadata set (if available). 952 func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber uint64, index uint64) *RPCTransaction { 953 var signer types.Signer = types.FrontierSigner{} 954 if tx.Protected() { 955 signer = types.NewEIP155Signer(tx.ChainId()) 956 } 957 from, _ := types.Sender(signer, tx) 958 v, r, s := tx.RawSignatureValues() 959 960 result := &RPCTransaction{ 961 From: from, 962 Gas: hexutil.Uint64(tx.Gas()), 963 GasPrice: (*hexutil.Big)(tx.GasPrice()), 964 Hash: tx.Hash(), 965 Input: hexutil.Bytes(tx.Data()), 966 Nonce: hexutil.Uint64(tx.Nonce()), 967 To: tx.To(), 968 Value: (*hexutil.Big)(tx.Value()), 969 V: (*hexutil.Big)(v), 970 R: (*hexutil.Big)(r), 971 S: (*hexutil.Big)(s), 972 } 973 if blockHash != (common.Hash{}) { 974 result.BlockHash = blockHash 975 result.BlockNumber = (*hexutil.Big)(new(big.Int).SetUint64(blockNumber)) 976 result.TransactionIndex = hexutil.Uint(index) 977 } 978 return result 979 } 980 981 // newRPCPendingTransaction returns a pending transaction that will serialize to the RPC representation 982 func newRPCPendingTransaction(tx *types.Transaction) *RPCTransaction { 983 return newRPCTransaction(tx, common.Hash{}, 0, 0) 984 } 985 986 // newRPCTransactionFromBlockIndex returns a transaction that will serialize to the RPC representation. 987 func newRPCTransactionFromBlockIndex(b *types.Block, index uint64) *RPCTransaction { 988 txs := b.Transactions() 989 if index >= uint64(len(txs)) { 990 return nil 991 } 992 return newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), index) 993 } 994 995 // newRPCRawTransactionFromBlockIndex returns the bytes of a transaction given a block and a transaction index. 996 func newRPCRawTransactionFromBlockIndex(b *types.Block, index uint64) hexutil.Bytes { 997 txs := b.Transactions() 998 if index >= uint64(len(txs)) { 999 return nil 1000 } 1001 blob, _ := rlp.EncodeToBytes(txs[index]) 1002 return blob 1003 } 1004 1005 // newRPCTransactionFromBlockHash returns a transaction that will serialize to the RPC representation. 1006 func newRPCTransactionFromBlockHash(b *types.Block, hash common.Hash) *RPCTransaction { 1007 for idx, tx := range b.Transactions() { 1008 if tx.Hash() == hash { 1009 return newRPCTransactionFromBlockIndex(b, uint64(idx)) 1010 } 1011 } 1012 return nil 1013 } 1014 1015 // PublicTransactionPoolAPI exposes methods for the RPC interface 1016 type PublicTransactionPoolAPI struct { 1017 b Backend 1018 nonceLock *AddrLocker 1019 } 1020 1021 // NewPublicTransactionPoolAPI creates a new RPC service with methods specific for the transaction pool. 1022 func NewPublicTransactionPoolAPI(b Backend, nonceLock *AddrLocker) *PublicTransactionPoolAPI { 1023 return &PublicTransactionPoolAPI{b, nonceLock} 1024 } 1025 1026 // GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number. 1027 func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint { 1028 if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil { 1029 n := hexutil.Uint(len(block.Transactions())) 1030 return &n 1031 } 1032 return nil 1033 } 1034 1035 // GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash. 1036 func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint { 1037 if block, _ := s.b.GetBlock(ctx, blockHash); block != nil { 1038 n := hexutil.Uint(len(block.Transactions())) 1039 return &n 1040 } 1041 return nil 1042 } 1043 1044 // GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index. 1045 func (s *PublicTransactionPoolAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) *RPCTransaction { 1046 if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil { 1047 return newRPCTransactionFromBlockIndex(block, uint64(index)) 1048 } 1049 return nil 1050 } 1051 1052 // GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index. 1053 func (s *PublicTransactionPoolAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) *RPCTransaction { 1054 if block, _ := s.b.GetBlock(ctx, blockHash); block != nil { 1055 return newRPCTransactionFromBlockIndex(block, uint64(index)) 1056 } 1057 return nil 1058 } 1059 1060 // GetRawTransactionByBlockNumberAndIndex returns the bytes of the transaction for the given block number and index. 1061 func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) hexutil.Bytes { 1062 if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil { 1063 return newRPCRawTransactionFromBlockIndex(block, uint64(index)) 1064 } 1065 return nil 1066 } 1067 1068 // GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index. 1069 func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) hexutil.Bytes { 1070 if block, _ := s.b.GetBlock(ctx, blockHash); block != nil { 1071 return newRPCRawTransactionFromBlockIndex(block, uint64(index)) 1072 } 1073 return nil 1074 } 1075 1076 // GetTransactionCount returns the number of transactions the given address has sent for the given block number 1077 func (s *PublicTransactionPoolAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNr rpc.BlockNumber) (*hexutil.Uint64, error) { 1078 // Ask transaction pool for the nonce which includes pending transactions 1079 if blockNr == rpc.PendingBlockNumber { 1080 nonce, err := s.b.GetPoolNonce(ctx, address) 1081 if err != nil { 1082 return nil, err 1083 } 1084 return (*hexutil.Uint64)(&nonce), nil 1085 } 1086 // Resolve block number and use its state to ask for the nonce 1087 state, _, err := s.b.StateAndHeaderByNumber(ctx, blockNr) 1088 if state == nil || err != nil { 1089 return nil, err 1090 } 1091 nonce := state.GetNonce(address) 1092 return (*hexutil.Uint64)(&nonce), state.Error() 1093 } 1094 1095 // GetTransactionByHash returns the transaction for the given hash 1096 func (s *PublicTransactionPoolAPI) GetTransactionByHash(ctx context.Context, hash common.Hash) *RPCTransaction { 1097 // Try to return an already finalized transaction 1098 if tx, blockHash, blockNumber, index := rawdb.ReadTransaction(s.b.ChainDb(), hash); tx != nil { 1099 return newRPCTransaction(tx, blockHash, blockNumber, index) 1100 } 1101 // No finalized transaction, try to retrieve it from the pool 1102 if tx := s.b.GetPoolTransaction(hash); tx != nil { 1103 return newRPCPendingTransaction(tx) 1104 } 1105 // Transaction unknown, return as such 1106 return nil 1107 } 1108 1109 // GetRawTransactionByHash returns the bytes of the transaction for the given hash. 1110 func (s *PublicTransactionPoolAPI) GetRawTransactionByHash(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) { 1111 var tx *types.Transaction 1112 1113 // Retrieve a finalized transaction, or a pooled otherwise 1114 if tx, _, _, _ = rawdb.ReadTransaction(s.b.ChainDb(), hash); tx == nil { 1115 if tx = s.b.GetPoolTransaction(hash); tx == nil { 1116 // Transaction not found anywhere, abort 1117 return nil, nil 1118 } 1119 } 1120 // Serialize to RLP and return 1121 return rlp.EncodeToBytes(tx) 1122 } 1123 1124 // GetTransactionReceipt returns the transaction receipt for the given transaction hash. 1125 func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, hash common.Hash) (map[string]interface{}, error) { 1126 tx, blockHash, blockNumber, index := rawdb.ReadTransaction(s.b.ChainDb(), hash) 1127 if tx == nil { 1128 return nil, nil 1129 } 1130 receipts, err := s.b.GetReceipts(ctx, blockHash) 1131 if err != nil { 1132 return nil, err 1133 } 1134 if len(receipts) <= int(index) { 1135 return nil, nil 1136 } 1137 receipt := receipts[index] 1138 1139 var signer types.Signer = types.FrontierSigner{} 1140 if tx.Protected() { 1141 signer = types.NewEIP155Signer(tx.ChainId()) 1142 } 1143 from, _ := types.Sender(signer, tx) 1144 1145 fields := map[string]interface{}{ 1146 "blockHash": blockHash, 1147 "blockNumber": hexutil.Uint64(blockNumber), 1148 "transactionHash": hash, 1149 "transactionIndex": hexutil.Uint64(index), 1150 "from": from, 1151 "to": tx.To(), 1152 "gasUsed": hexutil.Uint64(receipt.GasUsed), 1153 "cumulativeGasUsed": hexutil.Uint64(receipt.CumulativeGasUsed), 1154 "contractAddress": nil, 1155 "logs": receipt.Logs, 1156 "logsBloom": receipt.Bloom, 1157 } 1158 1159 // Assign receipt status or post state. 1160 if len(receipt.PostState) > 0 { 1161 fields["root"] = hexutil.Bytes(receipt.PostState) 1162 } else { 1163 fields["status"] = hexutil.Uint(receipt.Status) 1164 } 1165 if receipt.Logs == nil { 1166 fields["logs"] = [][]*types.Log{} 1167 } 1168 // If the ContractAddress is 20 0x0 bytes, assume it is not a contract creation 1169 if receipt.ContractAddress != (common.Address{}) { 1170 fields["contractAddress"] = receipt.ContractAddress 1171 } 1172 return fields, nil 1173 } 1174 1175 // sign is a helper function that signs a transaction with the private key of the given address. 1176 func (s *PublicTransactionPoolAPI) sign(addr common.Address, tx *types.Transaction) (*types.Transaction, error) { 1177 // Look up the wallet containing the requested signer 1178 account := accounts.Account{Address: addr} 1179 1180 wallet, err := s.b.AccountManager().Find(account) 1181 if err != nil { 1182 return nil, err 1183 } 1184 // Request the wallet to sign the transaction 1185 return wallet.SignTx(account, tx, s.b.ChainConfig().ChainID) 1186 } 1187 1188 // SendTxArgs represents the arguments to sumbit a new transaction into the transaction pool. 1189 type SendTxArgs struct { 1190 From common.Address `json:"from"` 1191 To *common.Address `json:"to"` 1192 Gas *hexutil.Uint64 `json:"gas"` 1193 GasPrice *hexutil.Big `json:"gasPrice"` 1194 Value *hexutil.Big `json:"value"` 1195 Nonce *hexutil.Uint64 `json:"nonce"` 1196 // We accept "data" and "input" for backwards-compatibility reasons. "input" is the 1197 // newer name and should be preferred by clients. 1198 Data *hexutil.Bytes `json:"data"` 1199 Input *hexutil.Bytes `json:"input"` 1200 } 1201 1202 // setDefaults is a helper function that fills in default values for unspecified tx fields. 1203 func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error { 1204 if args.Gas == nil { 1205 args.Gas = new(hexutil.Uint64) 1206 *(*uint64)(args.Gas) = 90000 1207 } 1208 if args.GasPrice == nil { 1209 price, err := b.SuggestPrice(ctx) 1210 if err != nil { 1211 return err 1212 } 1213 args.GasPrice = (*hexutil.Big)(price) 1214 } 1215 if args.Value == nil { 1216 args.Value = new(hexutil.Big) 1217 } 1218 if args.Nonce == nil { 1219 nonce, err := b.GetPoolNonce(ctx, args.From) 1220 if err != nil { 1221 return err 1222 } 1223 args.Nonce = (*hexutil.Uint64)(&nonce) 1224 } 1225 if args.Data != nil && args.Input != nil && !bytes.Equal(*args.Data, *args.Input) { 1226 return errors.New(`Both "data" and "input" are set and not equal. Please use "input" to pass transaction call data.`) 1227 } 1228 if args.To == nil { 1229 // Contract creation 1230 var input []byte 1231 if args.Data != nil { 1232 input = *args.Data 1233 } else if args.Input != nil { 1234 input = *args.Input 1235 } 1236 if len(input) == 0 { 1237 return errors.New(`contract creation without any data provided`) 1238 } 1239 } 1240 return nil 1241 } 1242 1243 func (args *SendTxArgs) toTransaction() *types.Transaction { 1244 var input []byte 1245 if args.Data != nil { 1246 input = *args.Data 1247 } else if args.Input != nil { 1248 input = *args.Input 1249 } 1250 if args.To == nil { 1251 return types.NewContractCreation(uint64(*args.Nonce), (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input) 1252 } 1253 return types.NewTransaction(uint64(*args.Nonce), *args.To, (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input) 1254 } 1255 1256 // SubmitTransaction is a helper function that submits tx to txPool and logs a message. 1257 func SubmitTransaction(ctx context.Context, b Backend, tx *types.Transaction) (common.Hash, error) { 1258 if err := b.SendTx(ctx, tx); err != nil { 1259 return common.Hash{}, err 1260 } 1261 if tx.To() == nil { 1262 signer := types.MakeSigner(b.ChainConfig(), b.CurrentBlock().Number()) 1263 from, err := types.Sender(signer, tx) 1264 if err != nil { 1265 return common.Hash{}, err 1266 } 1267 addr := crypto.CreateAddress(from, tx.Nonce()) 1268 log.Info("Submitted contract creation", "fullhash", tx.Hash().Hex(), "contract", addr.Hex()) 1269 } else { 1270 log.Info("Submitted transaction", "fullhash", tx.Hash().Hex(), "recipient", tx.To()) 1271 } 1272 return tx.Hash(), nil 1273 } 1274 1275 // SendTransaction creates a transaction for the given argument, sign it and submit it to the 1276 // transaction pool. 1277 func (s *PublicTransactionPoolAPI) SendTransaction(ctx context.Context, args SendTxArgs) (common.Hash, error) { 1278 1279 // Look up the wallet containing the requested signer 1280 account := accounts.Account{Address: args.From} 1281 1282 wallet, err := s.b.AccountManager().Find(account) 1283 if err != nil { 1284 return common.Hash{}, err 1285 } 1286 1287 if args.Nonce == nil { 1288 // Hold the addresse's mutex around signing to prevent concurrent assignment of 1289 // the same nonce to multiple accounts. 1290 s.nonceLock.LockAddr(args.From) 1291 defer s.nonceLock.UnlockAddr(args.From) 1292 } 1293 1294 // Set some sanity defaults and terminate on failure 1295 if err := args.setDefaults(ctx, s.b); err != nil { 1296 return common.Hash{}, err 1297 } 1298 // Assemble the transaction and sign with the wallet 1299 tx := args.toTransaction() 1300 1301 signed, err := wallet.SignTx(account, tx, s.b.ChainConfig().ChainID) 1302 if err != nil { 1303 return common.Hash{}, err 1304 } 1305 return SubmitTransaction(ctx, s.b, signed) 1306 } 1307 1308 // SendRawTransaction will add the signed transaction to the transaction pool. 1309 // The sender is responsible for signing the transaction and using the correct nonce. 1310 func (s *PublicTransactionPoolAPI) SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (common.Hash, error) { 1311 tx := new(types.Transaction) 1312 if err := rlp.DecodeBytes(encodedTx, tx); err != nil { 1313 return common.Hash{}, err 1314 } 1315 return SubmitTransaction(ctx, s.b, tx) 1316 } 1317 1318 // Sign calculates an ECDSA signature for: 1319 // keccack256("\x19Ethereum Signed Message:\n" + len(message) + message). 1320 // 1321 // Note, the produced signature conforms to the secp256k1 curve R, S and V values, 1322 // where the V value will be 27 or 28 for legacy reasons. 1323 // 1324 // The account associated with addr must be unlocked. 1325 // 1326 // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign 1327 func (s *PublicTransactionPoolAPI) Sign(addr common.Address, data hexutil.Bytes) (hexutil.Bytes, error) { 1328 // Look up the wallet containing the requested signer 1329 account := accounts.Account{Address: addr} 1330 1331 wallet, err := s.b.AccountManager().Find(account) 1332 if err != nil { 1333 return nil, err 1334 } 1335 // Sign the requested hash with the wallet 1336 signature, err := wallet.SignText(account, data) 1337 if err == nil { 1338 signature[64] += 27 // Transform V from 0/1 to 27/28 according to the yellow paper 1339 } 1340 return signature, err 1341 } 1342 1343 // SignTransactionResult represents a RLP encoded signed transaction. 1344 type SignTransactionResult struct { 1345 Raw hexutil.Bytes `json:"raw"` 1346 Tx *types.Transaction `json:"tx"` 1347 } 1348 1349 // SignTransaction will sign the given transaction with the from account. 1350 // The node needs to have the private key of the account corresponding with 1351 // the given from address and it needs to be unlocked. 1352 func (s *PublicTransactionPoolAPI) SignTransaction(ctx context.Context, args SendTxArgs) (*SignTransactionResult, error) { 1353 if args.Gas == nil { 1354 return nil, fmt.Errorf("gas not specified") 1355 } 1356 if args.GasPrice == nil { 1357 return nil, fmt.Errorf("gasPrice not specified") 1358 } 1359 if args.Nonce == nil { 1360 return nil, fmt.Errorf("nonce not specified") 1361 } 1362 if err := args.setDefaults(ctx, s.b); err != nil { 1363 return nil, err 1364 } 1365 tx, err := s.sign(args.From, args.toTransaction()) 1366 if err != nil { 1367 return nil, err 1368 } 1369 data, err := rlp.EncodeToBytes(tx) 1370 if err != nil { 1371 return nil, err 1372 } 1373 return &SignTransactionResult{data, tx}, nil 1374 } 1375 1376 // PendingTransactions returns the transactions that are in the transaction pool 1377 // and have a from address that is one of the accounts this node manages. 1378 func (s *PublicTransactionPoolAPI) PendingTransactions() ([]*RPCTransaction, error) { 1379 pending, err := s.b.GetPoolTransactions() 1380 if err != nil { 1381 return nil, err 1382 } 1383 accounts := make(map[common.Address]struct{}) 1384 for _, wallet := range s.b.AccountManager().Wallets() { 1385 for _, account := range wallet.Accounts() { 1386 accounts[account.Address] = struct{}{} 1387 } 1388 } 1389 transactions := make([]*RPCTransaction, 0, len(pending)) 1390 for _, tx := range pending { 1391 var signer types.Signer = types.HomesteadSigner{} 1392 if tx.Protected() { 1393 signer = types.NewEIP155Signer(tx.ChainId()) 1394 } 1395 from, _ := types.Sender(signer, tx) 1396 if _, exists := accounts[from]; exists { 1397 transactions = append(transactions, newRPCPendingTransaction(tx)) 1398 } 1399 } 1400 return transactions, nil 1401 } 1402 1403 // Resend accepts an existing transaction and a new gas price and limit. It will remove 1404 // the given transaction from the pool and reinsert it with the new gas price and limit. 1405 func (s *PublicTransactionPoolAPI) Resend(ctx context.Context, sendArgs SendTxArgs, gasPrice *hexutil.Big, gasLimit *hexutil.Uint64) (common.Hash, error) { 1406 if sendArgs.Nonce == nil { 1407 return common.Hash{}, fmt.Errorf("missing transaction nonce in transaction spec") 1408 } 1409 if err := sendArgs.setDefaults(ctx, s.b); err != nil { 1410 return common.Hash{}, err 1411 } 1412 matchTx := sendArgs.toTransaction() 1413 pending, err := s.b.GetPoolTransactions() 1414 if err != nil { 1415 return common.Hash{}, err 1416 } 1417 1418 for _, p := range pending { 1419 var signer types.Signer = types.HomesteadSigner{} 1420 if p.Protected() { 1421 signer = types.NewEIP155Signer(p.ChainId()) 1422 } 1423 wantSigHash := signer.Hash(matchTx) 1424 1425 if pFrom, err := types.Sender(signer, p); err == nil && pFrom == sendArgs.From && signer.Hash(p) == wantSigHash { 1426 // Match. Re-sign and send the transaction. 1427 if gasPrice != nil && (*big.Int)(gasPrice).Sign() != 0 { 1428 sendArgs.GasPrice = gasPrice 1429 } 1430 if gasLimit != nil && *gasLimit != 0 { 1431 sendArgs.Gas = gasLimit 1432 } 1433 signedTx, err := s.sign(sendArgs.From, sendArgs.toTransaction()) 1434 if err != nil { 1435 return common.Hash{}, err 1436 } 1437 if err = s.b.SendTx(ctx, signedTx); err != nil { 1438 return common.Hash{}, err 1439 } 1440 return signedTx.Hash(), nil 1441 } 1442 } 1443 1444 return common.Hash{}, fmt.Errorf("Transaction %#x not found", matchTx.Hash()) 1445 } 1446 1447 // PublicDebugAPI is the collection of Ethereum APIs exposed over the public 1448 // debugging endpoint. 1449 type PublicDebugAPI struct { 1450 b Backend 1451 } 1452 1453 // NewPublicDebugAPI creates a new API definition for the public debug methods 1454 // of the Ethereum service. 1455 func NewPublicDebugAPI(b Backend) *PublicDebugAPI { 1456 return &PublicDebugAPI{b: b} 1457 } 1458 1459 // GetBlockRlp retrieves the RLP encoded for of a single block. 1460 func (api *PublicDebugAPI) GetBlockRlp(ctx context.Context, number uint64) (string, error) { 1461 block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number)) 1462 if block == nil { 1463 return "", fmt.Errorf("block #%d not found", number) 1464 } 1465 encoded, err := rlp.EncodeToBytes(block) 1466 if err != nil { 1467 return "", err 1468 } 1469 return fmt.Sprintf("%x", encoded), nil 1470 } 1471 1472 // TestSignCliqueBlock fetches the given block number, and attempts to sign it as a clique header with the 1473 // given address, returning the address of the recovered signature 1474 // 1475 // This is a temporary method to debug the externalsigner integration, 1476 // TODO: Remove this method when the integration is mature 1477 func (api *PublicDebugAPI) TestSignCliqueBlock(ctx context.Context, address common.Address, number uint64) (common.Address, error) { 1478 block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number)) 1479 if block == nil { 1480 return common.Address{}, fmt.Errorf("block #%d not found", number) 1481 } 1482 header := block.Header() 1483 header.Extra = make([]byte, 32+65) 1484 encoded := clique.CliqueRLP(header) 1485 1486 // Look up the wallet containing the requested signer 1487 account := accounts.Account{Address: address} 1488 wallet, err := api.b.AccountManager().Find(account) 1489 if err != nil { 1490 return common.Address{}, err 1491 } 1492 1493 signature, err := wallet.SignData(account, accounts.MimetypeClique, encoded) 1494 if err != nil { 1495 return common.Address{}, err 1496 } 1497 sealHash := clique.SealHash(header).Bytes() 1498 log.Info("test signing of clique block", 1499 "Sealhash", fmt.Sprintf("%x", sealHash), 1500 "signature", fmt.Sprintf("%x", signature)) 1501 pubkey, err := crypto.Ecrecover(sealHash, signature) 1502 if err != nil { 1503 return common.Address{}, err 1504 } 1505 var signer common.Address 1506 copy(signer[:], crypto.Keccak256(pubkey[1:])[12:]) 1507 1508 return signer, nil 1509 } 1510 1511 // PrintBlock retrieves a block and returns its pretty printed form. 1512 func (api *PublicDebugAPI) PrintBlock(ctx context.Context, number uint64) (string, error) { 1513 block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number)) 1514 if block == nil { 1515 return "", fmt.Errorf("block #%d not found", number) 1516 } 1517 return spew.Sdump(block), nil 1518 } 1519 1520 // SeedHash retrieves the seed hash of a block. 1521 func (api *PublicDebugAPI) SeedHash(ctx context.Context, number uint64) (string, error) { 1522 block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number)) 1523 if block == nil { 1524 return "", fmt.Errorf("block #%d not found", number) 1525 } 1526 return fmt.Sprintf("0x%x", ethash.SeedHash(number)), nil 1527 } 1528 1529 // PrivateDebugAPI is the collection of Ethereum APIs exposed over the private 1530 // debugging endpoint. 1531 type PrivateDebugAPI struct { 1532 b Backend 1533 } 1534 1535 // NewPrivateDebugAPI creates a new API definition for the private debug methods 1536 // of the Ethereum service. 1537 func NewPrivateDebugAPI(b Backend) *PrivateDebugAPI { 1538 return &PrivateDebugAPI{b: b} 1539 } 1540 1541 // ChaindbProperty returns leveldb properties of the chain database. 1542 func (api *PrivateDebugAPI) ChaindbProperty(property string) (string, error) { 1543 ldb, ok := api.b.ChainDb().(interface { 1544 LDB() *leveldb.DB 1545 }) 1546 if !ok { 1547 return "", fmt.Errorf("chaindbProperty does not work for memory databases") 1548 } 1549 if property == "" { 1550 property = "leveldb.stats" 1551 } else if !strings.HasPrefix(property, "leveldb.") { 1552 property = "leveldb." + property 1553 } 1554 return ldb.LDB().GetProperty(property) 1555 } 1556 1557 func (api *PrivateDebugAPI) ChaindbCompact() error { 1558 for b := byte(0); b < 255; b++ { 1559 log.Info("Compacting chain database", "range", fmt.Sprintf("0x%0.2X-0x%0.2X", b, b+1)) 1560 if err := api.b.ChainDb().Compact([]byte{b}, []byte{b + 1}); err != nil { 1561 log.Error("Database compaction failed", "err", err) 1562 return err 1563 } 1564 } 1565 return nil 1566 } 1567 1568 // SetHead rewinds the head of the blockchain to a previous block. 1569 func (api *PrivateDebugAPI) SetHead(number hexutil.Uint64) { 1570 api.b.SetHead(uint64(number)) 1571 } 1572 1573 // PublicNetAPI offers network related RPC methods 1574 type PublicNetAPI struct { 1575 net *p2p.Server 1576 networkVersion uint64 1577 } 1578 1579 // NewPublicNetAPI creates a new net API instance. 1580 func NewPublicNetAPI(net *p2p.Server, networkVersion uint64) *PublicNetAPI { 1581 return &PublicNetAPI{net, networkVersion} 1582 } 1583 1584 // Listening returns an indication if the node is listening for network connections. 1585 func (s *PublicNetAPI) Listening() bool { 1586 return true // always listening 1587 } 1588 1589 // PeerCount returns the number of connected peers 1590 func (s *PublicNetAPI) PeerCount() hexutil.Uint { 1591 return hexutil.Uint(s.net.PeerCount()) 1592 } 1593 1594 // Version returns the current ethereum protocol version. 1595 func (s *PublicNetAPI) Version() string { 1596 return fmt.Sprintf("%d", s.networkVersion) 1597 }