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