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