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