api.go 68 KB
Newer Older
1
// Copyright 2015 The go-ethereum Authors
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
// This file is part of the go-ethereum library.
//
// The go-ethereum library is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// The go-ethereum library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.

package ethapi

import (
20
	"bytes"
21
	"context"
22
	"errors"
23 24 25 26 27
	"fmt"
	"math/big"
	"strings"
	"time"

28
	"github.com/davecgh/go-spew/spew"
29
	"github.com/ethereum/go-ethereum/accounts"
30
	"github.com/ethereum/go-ethereum/accounts/abi"
31
	"github.com/ethereum/go-ethereum/accounts/keystore"
32
	"github.com/ethereum/go-ethereum/accounts/scwallet"
33
	"github.com/ethereum/go-ethereum/common"
34
	"github.com/ethereum/go-ethereum/common/hexutil"
35
	"github.com/ethereum/go-ethereum/common/math"
36
	"github.com/ethereum/go-ethereum/consensus/clique"
37
	"github.com/ethereum/go-ethereum/consensus/ethash"
38 39 40 41
	"github.com/ethereum/go-ethereum/core"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/core/vm"
	"github.com/ethereum/go-ethereum/crypto"
42
	"github.com/ethereum/go-ethereum/log"
43
	"github.com/ethereum/go-ethereum/p2p"
44
	"github.com/ethereum/go-ethereum/params"
45 46
	"github.com/ethereum/go-ethereum/rlp"
	"github.com/ethereum/go-ethereum/rpc"
47
	"github.com/tyler-smith/go-bip39"
48 49 50 51 52
)

// PublicEthereumAPI provides an API to access Ethereum related information.
// It offers only methods that operate on public data that is freely available to anyone.
type PublicEthereumAPI struct {
53
	b Backend
54 55
}

56
// NewPublicEthereumAPI creates a new Ethereum protocol API.
57 58
func NewPublicEthereumAPI(b Backend) *PublicEthereumAPI {
	return &PublicEthereumAPI{b}
59 60 61
}

// GasPrice returns a suggestion for a gas price.
62 63 64
func (s *PublicEthereumAPI) GasPrice(ctx context.Context) (*hexutil.Big, error) {
	price, err := s.b.SuggestPrice(ctx)
	return (*hexutil.Big)(price), err
65 66 67
}

// ProtocolVersion returns the current Ethereum protocol version this node supports
68 69
func (s *PublicEthereumAPI) ProtocolVersion() hexutil.Uint {
	return hexutil.Uint(s.b.ProtocolVersion())
70 71 72 73 74 75 76 77 78 79
}

// Syncing returns false in case the node is currently not syncing with the network. It can be up to date or has not
// yet received the latest block headers from its pears. In case it is synchronizing:
// - startingBlock: block number this node started to synchronise from
// - currentBlock:  block number this node is currently importing
// - highestBlock:  block number of the highest block header this node has received from peers
// - pulledStates:  number of state entries processed until now
// - knownStates:   number of known state entries that still need to be pulled
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 85 86 87
		return false, nil
	}
	// Otherwise gather the block sync stats
	return map[string]interface{}{
88 89 90 91 92
		"startingBlock": hexutil.Uint64(progress.StartingBlock),
		"currentBlock":  hexutil.Uint64(progress.CurrentBlock),
		"highestBlock":  hexutil.Uint64(progress.HighestBlock),
		"pulledStates":  hexutil.Uint64(progress.PulledStates),
		"knownStates":   hexutil.Uint64(progress.KnownStates),
93 94 95 96 97 98 99 100 101 102 103 104 105 106
	}, nil
}

// PublicTxPoolAPI offers and API for the transaction pool. It only operates on data that is non confidential.
type PublicTxPoolAPI struct {
	b Backend
}

// NewPublicTxPoolAPI creates a new tx pool service that gives information about the transaction pool.
func NewPublicTxPoolAPI(b Backend) *PublicTxPoolAPI {
	return &PublicTxPoolAPI{b}
}

// Content returns the transactions contained within the transaction pool.
107 108 109 110
func (s *PublicTxPoolAPI) Content() map[string]map[string]map[string]*RPCTransaction {
	content := map[string]map[string]map[string]*RPCTransaction{
		"pending": make(map[string]map[string]*RPCTransaction),
		"queued":  make(map[string]map[string]*RPCTransaction),
111 112 113 114
	}
	pending, queue := s.b.TxPoolContent()

	// Flatten the pending transactions
115 116
	for account, txs := range pending {
		dump := make(map[string]*RPCTransaction)
117 118
		for _, tx := range txs {
			dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx)
119 120 121 122
		}
		content["pending"][account.Hex()] = dump
	}
	// Flatten the queued transactions
123 124
	for account, txs := range queue {
		dump := make(map[string]*RPCTransaction)
125 126
		for _, tx := range txs {
			dump[fmt.Sprintf("%d", tx.Nonce())] = newRPCPendingTransaction(tx)
127 128 129 130 131 132 133
		}
		content["queued"][account.Hex()] = dump
	}
	return content
}

// 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 137 138
	return map[string]hexutil.Uint{
		"pending": hexutil.Uint(pending),
		"queued":  hexutil.Uint(queue),
139 140 141 142 143
	}
}

// Inspect retrieves the content of the transaction pool and flattens it into an
// easily inspectable list.
144 145 146 147
func (s *PublicTxPoolAPI) Inspect() map[string]map[string]map[string]string {
	content := map[string]map[string]map[string]string{
		"pending": make(map[string]map[string]string),
		"queued":  make(map[string]map[string]string),
148 149 150 151 152 153
	}
	pending, queue := s.b.TxPoolContent()

	// Define a formatter to flatten a transaction into a string
	var format = func(tx *types.Transaction) string {
		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 160
	for account, txs := range pending {
		dump := make(map[string]string)
161 162
		for _, tx := range txs {
			dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx)
163 164 165 166
		}
		content["pending"][account.Hex()] = dump
	}
	// Flatten the queued transactions
167 168
	for account, txs := range queue {
		dump := make(map[string]string)
169 170
		for _, tx := range txs {
			dump[fmt.Sprintf("%d", tx.Nonce())] = format(tx)
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
		}
		content["queued"][account.Hex()] = dump
	}
	return content
}

// PublicAccountAPI provides an API to access accounts managed by this node.
// It offers only methods that can retrieve accounts.
type PublicAccountAPI struct {
	am *accounts.Manager
}

// NewPublicAccountAPI creates a new PublicAccountAPI.
func NewPublicAccountAPI(am *accounts.Manager) *PublicAccountAPI {
	return &PublicAccountAPI{am: am}
}

// Accounts returns the collection of accounts this node manages
189
func (s *PublicAccountAPI) Accounts() []common.Address {
190
	return s.am.Accounts()
191 192 193 194 195 196
}

// PrivateAccountAPI provides an API to access accounts managed by this node.
// It offers methods to create, (un)lock en list accounts. Some methods accept
// passwords and are therefore considered private by default.
type PrivateAccountAPI struct {
197 198 199
	am        *accounts.Manager
	nonceLock *AddrLocker
	b         Backend
200 201 202
}

// NewPrivateAccountAPI create a new PrivateAccountAPI.
203
func NewPrivateAccountAPI(b Backend, nonceLock *AddrLocker) *PrivateAccountAPI {
204
	return &PrivateAccountAPI{
205 206 207
		am:        b.AccountManager(),
		nonceLock: nonceLock,
		b:         b,
208 209 210
	}
}

211
// listAccounts will return a list of addresses for accounts this node manages.
212
func (s *PrivateAccountAPI) ListAccounts() []common.Address {
213
	return s.am.Accounts()
214 215
}

216 217 218 219 220
// rawWallet is a JSON representation of an accounts.Wallet interface, with its
// data contents extracted into plain fields.
type rawWallet struct {
	URL      string             `json:"url"`
	Status   string             `json:"status"`
221 222
	Failure  string             `json:"failure,omitempty"`
	Accounts []accounts.Account `json:"accounts,omitempty"`
223 224 225 226
}

// ListWallets will return a list of wallets this node manages.
func (s *PrivateAccountAPI) ListWallets() []rawWallet {
227
	wallets := make([]rawWallet, 0) // return [] instead of nil if empty
228
	for _, wallet := range s.am.Wallets() {
229 230 231
		status, failure := wallet.Status()

		raw := rawWallet{
232
			URL:      wallet.URL().String(),
233
			Status:   status,
234
			Accounts: wallet.Accounts(),
235 236 237 238 239
		}
		if failure != nil {
			raw.Failure = failure.Error()
		}
		wallets = append(wallets, raw)
240 241 242 243
	}
	return wallets
}

244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
// OpenWallet initiates a hardware wallet opening procedure, establishing a USB
// connection and attempting to authenticate via the provided passphrase. Note,
// the method may return an extra challenge requiring a second open (e.g. the
// Trezor PIN matrix challenge).
func (s *PrivateAccountAPI) OpenWallet(url string, passphrase *string) error {
	wallet, err := s.am.Wallet(url)
	if err != nil {
		return err
	}
	pass := ""
	if passphrase != nil {
		pass = *passphrase
	}
	return wallet.Open(pass)
}

260 261 262 263 264 265 266
// DeriveAccount requests a HD wallet to derive a new account, optionally pinning
// it for later reuse.
func (s *PrivateAccountAPI) DeriveAccount(url string, path string, pin *bool) (accounts.Account, error) {
	wallet, err := s.am.Wallet(url)
	if err != nil {
		return accounts.Account{}, err
	}
267 268 269 270
	derivPath, err := accounts.ParseDerivationPath(path)
	if err != nil {
		return accounts.Account{}, err
	}
271 272 273
	if pin == nil {
		pin = new(bool)
	}
274
	return wallet.Derive(derivPath, *pin)
275 276
}

277 278
// NewAccount will create a new account and returns the address for the new account.
func (s *PrivateAccountAPI) NewAccount(password string) (common.Address, error) {
279 280 281 282 283
	ks, err := fetchKeystore(s.am)
	if err != nil {
		return common.Address{}, err
	}
	acc, err := ks.NewAccount(password)
284
	if err == nil {
285 286 287
		log.Info("Your new key was generated", "address", acc.Address)
		log.Warn("Please backup your key file!", "path", acc.URL.Path)
		log.Warn("Please remember your password!")
288 289 290 291 292
		return acc.Address, nil
	}
	return common.Address{}, err
}

293
// fetchKeystore retrieves the encrypted keystore from the account manager.
294 295 296 297 298
func fetchKeystore(am *accounts.Manager) (*keystore.KeyStore, error) {
	if ks := am.Backends(keystore.KeyStoreType); len(ks) > 0 {
		return ks[0].(*keystore.KeyStore), nil
	}
	return nil, errors.New("local keystore not used")
299 300
}

301 302 303
// ImportRawKey stores the given hex encoded ECDSA key into the key directory,
// encrypting it with the passphrase.
func (s *PrivateAccountAPI) ImportRawKey(privkey string, password string) (common.Address, error) {
304
	key, err := crypto.HexToECDSA(privkey)
305 306 307
	if err != nil {
		return common.Address{}, err
	}
308 309 310 311 312
	ks, err := fetchKeystore(s.am)
	if err != nil {
		return common.Address{}, err
	}
	acc, err := ks.ImportECDSA(key, password)
313 314 315 316 317 318
	return acc.Address, err
}

// UnlockAccount will unlock the account associated with the given address with
// the given password for duration seconds. If duration is nil it will use a
// default of 300 seconds. It returns an indication if the account was unlocked.
319 320 321 322 323 324 325 326
func (s *PrivateAccountAPI) UnlockAccount(ctx context.Context, addr common.Address, password string, duration *uint64) (bool, error) {
	// When the API is exposed by external RPC(http, ws etc), unless the user
	// explicitly specifies to allow the insecure account unlocking, otherwise
	// it is disabled.
	if s.b.ExtRPCEnabled() && !s.b.AccountManager().Config().InsecureUnlockAllowed {
		return false, errors.New("account unlock with HTTP access is forbidden")
	}

327
	const max = uint64(time.Duration(math.MaxInt64) / time.Second)
328
	var d time.Duration
329
	if duration == nil {
330
		d = 300 * time.Second
331 332
	} else if *duration > max {
		return false, errors.New("unlock duration too large")
333 334
	} else {
		d = time.Duration(*duration) * time.Second
335
	}
336 337 338 339 340
	ks, err := fetchKeystore(s.am)
	if err != nil {
		return false, err
	}
	err = ks.TimedUnlock(accounts.Account{Address: addr}, password, d)
341 342 343
	if err != nil {
		log.Warn("Failed account unlock attempt", "address", addr, "err", err)
	}
344
	return err == nil, err
345 346 347 348
}

// LockAccount will lock the account associated with the given address when it's unlocked.
func (s *PrivateAccountAPI) LockAccount(addr common.Address) bool {
349 350 351 352
	if ks, err := fetchKeystore(s.am); err == nil {
		return ks.Lock(addr) == nil
	}
	return false
353 354
}

355
// signTransaction sets defaults and signs the given transaction
356 357
// NOTE: the caller needs to ensure that the nonceLock is held, if applicable,
// and release it after the transaction has been submitted to the tx pool
358
func (s *PrivateAccountAPI) signTransaction(ctx context.Context, args *SendTxArgs, passwd string) (*types.Transaction, error) {
359 360 361 362
	// Look up the wallet containing the requested signer
	account := accounts.Account{Address: args.From}
	wallet, err := s.am.Find(account)
	if err != nil {
363
		return nil, err
364 365 366
	}
	// Set some sanity defaults and terminate on failure
	if err := args.setDefaults(ctx, s.b); err != nil {
367
		return nil, err
368
	}
369
	// Assemble the transaction and sign with the wallet
370
	tx := args.toTransaction()
371

372
	return wallet.SignTxWithPassphrase(account, passwd, tx, s.b.ChainConfig().ChainID)
373 374 375 376 377 378 379 380 381 382 383 384
}

// SendTransaction will create a transaction from the given arguments and
// tries to sign it with the key associated with args.To. If the given passwd isn't
// able to decrypt the key it fails.
func (s *PrivateAccountAPI) SendTransaction(ctx context.Context, args SendTxArgs, passwd string) (common.Hash, error) {
	if args.Nonce == nil {
		// Hold the addresse's mutex around signing to prevent concurrent assignment of
		// the same nonce to multiple accounts.
		s.nonceLock.LockAddr(args.From)
		defer s.nonceLock.UnlockAddr(args.From)
	}
385
	signed, err := s.signTransaction(ctx, &args, passwd)
386
	if err != nil {
387
		log.Warn("Failed transaction send attempt", "from", args.From, "to", args.To, "value", args.Value.ToInt(), "err", err)
388 389
		return common.Hash{}, err
	}
390
	return SubmitTransaction(ctx, s.b, signed)
391 392
}

393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
// SignTransaction will create a transaction from the given arguments and
// tries to sign it with the key associated with args.To. If the given passwd isn't
// able to decrypt the key it fails. The transaction is returned in RLP-form, not broadcast
// to other nodes
func (s *PrivateAccountAPI) SignTransaction(ctx context.Context, args SendTxArgs, passwd string) (*SignTransactionResult, error) {
	// No need to obtain the noncelock mutex, since we won't be sending this
	// tx into the transaction pool, but right back to the user
	if args.Gas == nil {
		return nil, fmt.Errorf("gas not specified")
	}
	if args.GasPrice == nil {
		return nil, fmt.Errorf("gasPrice not specified")
	}
	if args.Nonce == nil {
		return nil, fmt.Errorf("nonce not specified")
	}
409 410 411 412
	// Before actually sign the transaction, ensure the transaction fee is reasonable.
	if err := checkTxFee(args.GasPrice.ToInt(), uint64(*args.Gas), s.b.RPCTxFeeCap()); err != nil {
		return nil, err
	}
413
	signed, err := s.signTransaction(ctx, &args, passwd)
414
	if err != nil {
415
		log.Warn("Failed transaction sign attempt", "from", args.From, "to", args.To, "value", args.Value.ToInt(), "err", err)
416 417 418 419 420 421 422 423 424
		return nil, err
	}
	data, err := rlp.EncodeToBytes(signed)
	if err != nil {
		return nil, err
	}
	return &SignTransactionResult{data, signed}, nil
}

425 426 427
// Sign calculates an Ethereum ECDSA signature for:
// keccack256("\x19Ethereum Signed Message:\n" + len(message) + message))
//
428 429 430
// Note, the produced signature conforms to the secp256k1 curve R, S and V values,
// where the V value will be 27 or 28 for legacy reasons.
//
431 432 433
// The key used to calculate the signature is decrypted with the given password.
//
// https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_sign
434
func (s *PrivateAccountAPI) Sign(ctx context.Context, data hexutil.Bytes, addr common.Address, passwd string) (hexutil.Bytes, error) {
435 436 437 438 439 440 441 442
	// Look up the wallet containing the requested signer
	account := accounts.Account{Address: addr}

	wallet, err := s.b.AccountManager().Find(account)
	if err != nil {
		return nil, err
	}
	// Assemble sign the data with the wallet
443
	signature, err := wallet.SignTextWithPassphrase(account, passwd, data)
444
	if err != nil {
445
		log.Warn("Failed data sign attempt", "address", addr, "err", err)
446 447
		return nil, err
	}
448
	signature[crypto.RecoveryIDOffset] += 27 // Transform V from 0/1 to 27/28 according to the yellow paper
449
	return signature, nil
450 451 452 453 454 455 456 457
}

// EcRecover returns the address for the account that was used to create the signature.
// Note, this function is compatible with eth_sign and personal_sign. As such it recovers
// the address of:
// hash = keccak256("\x19Ethereum Signed Message:\n"${message length}${message})
// addr = ecrecover(hash, signature)
//
458
// Note, the signature must conform to the secp256k1 curve R, S and V values, where
459
// the V value must be 27 or 28 for legacy reasons.
460
//
461
// https://github.com/ethereum/go-ethereum/wiki/Management-APIs#personal_ecRecover
462
func (s *PrivateAccountAPI) EcRecover(ctx context.Context, data, sig hexutil.Bytes) (common.Address, error) {
463 464
	if len(sig) != crypto.SignatureLength {
		return common.Address{}, fmt.Errorf("signature must be %d bytes long", crypto.SignatureLength)
465
	}
466
	if sig[crypto.RecoveryIDOffset] != 27 && sig[crypto.RecoveryIDOffset] != 28 {
467
		return common.Address{}, fmt.Errorf("invalid Ethereum signature (V is not 27 or 28)")
468
	}
469
	sig[crypto.RecoveryIDOffset] -= 27 // Transform yellow paper V from 27/28 to 0/1
470

471
	rpk, err := crypto.SigToPub(accounts.TextHash(data), sig)
472 473 474
	if err != nil {
		return common.Address{}, err
	}
475
	return crypto.PubkeyToAddress(*rpk), nil
476 477
}

478 479 480 481 482 483
// SignAndSendTransaction was renamed to SendTransaction. This method is deprecated
// and will be removed in the future. It primary goal is to give clients time to update.
func (s *PrivateAccountAPI) SignAndSendTransaction(ctx context.Context, args SendTxArgs, passwd string) (common.Hash, error) {
	return s.SendTransaction(ctx, args, passwd)
}

484
// InitializeWallet initializes a new wallet at the provided URL, by generating and returning a new private key.
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506
func (s *PrivateAccountAPI) InitializeWallet(ctx context.Context, url string) (string, error) {
	wallet, err := s.am.Wallet(url)
	if err != nil {
		return "", err
	}

	entropy, err := bip39.NewEntropy(256)
	if err != nil {
		return "", err
	}

	mnemonic, err := bip39.NewMnemonic(entropy)
	if err != nil {
		return "", err
	}

	seed := bip39.NewSeed(mnemonic, "")

	switch wallet := wallet.(type) {
	case *scwallet.Wallet:
		return mnemonic, wallet.Initialize(seed)
	default:
507
		return "", fmt.Errorf("specified wallet does not support initialization")
508 509 510
	}
}

511
// Unpair deletes a pairing between wallet and geth.
512 513 514 515 516 517 518 519 520 521
func (s *PrivateAccountAPI) Unpair(ctx context.Context, url string, pin string) error {
	wallet, err := s.am.Wallet(url)
	if err != nil {
		return err
	}

	switch wallet := wallet.(type) {
	case *scwallet.Wallet:
		return wallet.Unpair([]byte(pin))
	default:
522
		return fmt.Errorf("specified wallet does not support pairing")
523 524 525
	}
}

526 527 528
// PublicBlockChainAPI provides an API to access the Ethereum blockchain.
// It offers only methods that operate on public data that is freely available to anyone.
type PublicBlockChainAPI struct {
529
	b Backend
530 531
}

532
// NewPublicBlockChainAPI creates a new Ethereum blockchain API.
533
func NewPublicBlockChainAPI(b Backend) *PublicBlockChainAPI {
534
	return &PublicBlockChainAPI{b}
535 536
}

537 538 539 540 541
// ChainId returns the chainID value for transaction replay protection.
func (s *PublicBlockChainAPI) ChainId() *hexutil.Big {
	return (*hexutil.Big)(s.b.ChainConfig().ChainID)
}

542
// BlockNumber returns the block number of the chain head.
543
func (s *PublicBlockChainAPI) BlockNumber() hexutil.Uint64 {
544
	header, _ := s.b.HeaderByNumber(context.Background(), rpc.LatestBlockNumber) // latest header should always be available
545
	return hexutil.Uint64(header.Number.Uint64())
546 547 548 549 550
}

// GetBalance returns the amount of wei for the given address in the state of the
// given block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta
// block numbers are also allowed.
551 552
func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
553 554 555
	if state == nil || err != nil {
		return nil, err
	}
556
	return (*hexutil.Big)(state.GetBalance(address)), state.Error()
557 558
}

559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
// Result structs for GetProof
type AccountResult struct {
	Address      common.Address  `json:"address"`
	AccountProof []string        `json:"accountProof"`
	Balance      *hexutil.Big    `json:"balance"`
	CodeHash     common.Hash     `json:"codeHash"`
	Nonce        hexutil.Uint64  `json:"nonce"`
	StorageHash  common.Hash     `json:"storageHash"`
	StorageProof []StorageResult `json:"storageProof"`
}
type StorageResult struct {
	Key   string       `json:"key"`
	Value *hexutil.Big `json:"value"`
	Proof []string     `json:"proof"`
}

// GetProof returns the Merkle-proof for a given account and optionally some storage keys.
576 577
func (s *PublicBlockChainAPI) GetProof(ctx context.Context, address common.Address, storageKeys []string, blockNrOrHash rpc.BlockNumberOrHash) (*AccountResult, error) {
	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
	if state == nil || err != nil {
		return nil, err
	}

	storageTrie := state.StorageTrie(address)
	storageHash := types.EmptyRootHash
	codeHash := state.GetCodeHash(address)
	storageProof := make([]StorageResult, len(storageKeys))

	// if we have a storageTrie, (which means the account exists), we can update the storagehash
	if storageTrie != nil {
		storageHash = storageTrie.Hash()
	} else {
		// no storageTrie means the account does not exist, so the codeHash is the hash of an empty bytearray.
		codeHash = crypto.Keccak256Hash(nil)
	}

	// create the proof for the storageKeys
	for i, key := range storageKeys {
		if storageTrie != nil {
			proof, storageError := state.GetStorageProof(address, common.HexToHash(key))
			if storageError != nil {
				return nil, storageError
			}
			storageProof[i] = StorageResult{key, (*hexutil.Big)(state.GetState(address, common.HexToHash(key)).Big()), common.ToHexArray(proof)}
		} else {
			storageProof[i] = StorageResult{key, &hexutil.Big{}, []string{}}
		}
	}

	// create the accountProof
	accountProof, proofErr := state.GetProof(address)
	if proofErr != nil {
		return nil, proofErr
	}

	return &AccountResult{
		Address:      address,
		AccountProof: common.ToHexArray(accountProof),
		Balance:      (*hexutil.Big)(state.GetBalance(address)),
		CodeHash:     codeHash,
		Nonce:        hexutil.Uint64(state.GetNonce(address)),
		StorageHash:  storageHash,
		StorageProof: storageProof,
	}, state.Error()
}

625 626 627 628 629 630
// GetHeaderByNumber returns the requested canonical block header.
// * When blockNr is -1 the chain head is returned.
// * When blockNr is -2 the pending chain head is returned.
func (s *PublicBlockChainAPI) GetHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (map[string]interface{}, error) {
	header, err := s.b.HeaderByNumber(ctx, number)
	if header != nil && err == nil {
631
		response := s.rpcMarshalHeader(ctx, header)
632 633 634 635 636 637 638 639 640 641 642 643 644
		if number == rpc.PendingBlockNumber {
			// Pending header need to nil out a few fields
			for _, field := range []string{"hash", "nonce", "miner"} {
				response[field] = nil
			}
		}
		return response, err
	}
	return nil, err
}

// GetHeaderByHash returns the requested header by hash.
func (s *PublicBlockChainAPI) GetHeaderByHash(ctx context.Context, hash common.Hash) map[string]interface{} {
645
	header, _ := s.b.HeaderByHash(ctx, hash)
646
	if header != nil {
647
		return s.rpcMarshalHeader(ctx, header)
648 649 650 651 652 653 654 655 656 657 658 659
	}
	return nil
}

// GetBlockByNumber returns the requested canonical block.
// * When blockNr is -1 the chain head is returned.
// * When blockNr is -2 the pending chain head is returned.
// * When fullTx is true all transactions in the block are returned, otherwise
//   only the transaction hash is returned.
func (s *PublicBlockChainAPI) GetBlockByNumber(ctx context.Context, number rpc.BlockNumber, fullTx bool) (map[string]interface{}, error) {
	block, err := s.b.BlockByNumber(ctx, number)
	if block != nil && err == nil {
660
		response, err := s.rpcMarshalBlock(ctx, block, true, fullTx)
661
		if err == nil && number == rpc.PendingBlockNumber {
662
			// Pending blocks need to nil out a few fields
663
			for _, field := range []string{"hash", "nonce", "miner"} {
664 665 666 667 668 669 670 671 672 673
				response[field] = nil
			}
		}
		return response, err
	}
	return nil, err
}

// GetBlockByHash returns the requested block. When fullTx is true all transactions in the block are returned in full
// detail, otherwise only the transaction hash is returned.
674
func (s *PublicBlockChainAPI) GetBlockByHash(ctx context.Context, hash common.Hash, fullTx bool) (map[string]interface{}, error) {
675
	block, err := s.b.BlockByHash(ctx, hash)
676
	if block != nil {
677
		return s.rpcMarshalBlock(ctx, block, true, fullTx)
678 679 680 681 682 683
	}
	return nil, err
}

// GetUncleByBlockNumberAndIndex returns the uncle block for the given block hash and index. When fullTx is true
// all transactions in the block are returned in full detail, otherwise only the transaction hash is returned.
684
func (s *PublicBlockChainAPI) GetUncleByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) (map[string]interface{}, error) {
685 686 687
	block, err := s.b.BlockByNumber(ctx, blockNr)
	if block != nil {
		uncles := block.Uncles()
688
		if index >= hexutil.Uint(len(uncles)) {
689
			log.Debug("Requested uncle not found", "number", blockNr, "hash", block.Hash(), "index", index)
690 691
			return nil, nil
		}
692
		block = types.NewBlockWithHeader(uncles[index])
693
		return s.rpcMarshalBlock(ctx, block, false, false)
694 695 696 697 698 699
	}
	return nil, err
}

// GetUncleByBlockHashAndIndex returns the uncle block for the given block hash and index. When fullTx is true
// all transactions in the block are returned in full detail, otherwise only the transaction hash is returned.
700
func (s *PublicBlockChainAPI) GetUncleByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) (map[string]interface{}, error) {
701
	block, err := s.b.BlockByHash(ctx, blockHash)
702 703
	if block != nil {
		uncles := block.Uncles()
704
		if index >= hexutil.Uint(len(uncles)) {
705
			log.Debug("Requested uncle not found", "number", block.Number(), "hash", blockHash, "index", index)
706 707
			return nil, nil
		}
708
		block = types.NewBlockWithHeader(uncles[index])
709
		return s.rpcMarshalBlock(ctx, block, false, false)
710 711 712 713 714
	}
	return nil, err
}

// GetUncleCountByBlockNumber returns number of uncles in the block for the given block number
715
func (s *PublicBlockChainAPI) GetUncleCountByBlockNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {
716
	if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
717 718
		n := hexutil.Uint(len(block.Uncles()))
		return &n
719 720 721 722 723
	}
	return nil
}

// GetUncleCountByBlockHash returns number of uncles in the block for the given block hash
724
func (s *PublicBlockChainAPI) GetUncleCountByBlockHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
725
	if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
726 727
		n := hexutil.Uint(len(block.Uncles()))
		return &n
728 729 730 731 732
	}
	return nil
}

// GetCode returns the code stored at the given address in the state for the given block number.
733 734
func (s *PublicBlockChainAPI) GetCode(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
735
	if state == nil || err != nil {
736
		return nil, err
737
	}
738 739
	code := state.GetCode(address)
	return code, state.Error()
740 741 742 743 744
}

// GetStorageAt returns the storage from the state at the given address, key and
// block number. The rpc.LatestBlockNumber and rpc.PendingBlockNumber meta block
// numbers are also allowed.
745 746
func (s *PublicBlockChainAPI) GetStorageAt(ctx context.Context, address common.Address, key string, blockNrOrHash rpc.BlockNumberOrHash) (hexutil.Bytes, error) {
	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
747
	if state == nil || err != nil {
748
		return nil, err
749
	}
750 751
	res := state.GetState(address, common.HexToHash(key))
	return res[:], state.Error()
752 753 754 755
}

// CallArgs represents the arguments for a call.
type CallArgs struct {
756
	From     *common.Address `json:"from"`
757
	To       *common.Address `json:"to"`
758 759 760 761
	Gas      *hexutil.Uint64 `json:"gas"`
	GasPrice *hexutil.Big    `json:"gasPrice"`
	Value    *hexutil.Big    `json:"value"`
	Data     *hexutil.Bytes  `json:"data"`
762 763
}

764
// ToMessage converts CallArgs to the Message type used by the core evm
765
func (args *CallArgs) ToMessage(globalGasCap uint64) types.Message {
766 767 768 769 770 771 772
	// Set sender address or use zero address if none specified.
	var addr common.Address
	if args.From != nil {
		addr = *args.From
	}

	// Set default gas & gas price if none were set
773 774 775 776
	gas := globalGasCap
	if gas == 0 {
		gas = uint64(math.MaxUint64 / 2)
	}
777 778 779
	if args.Gas != nil {
		gas = uint64(*args.Gas)
	}
780
	if globalGasCap != 0 && globalGasCap < gas {
781
		log.Warn("Caller gas above allowance, capping", "requested", gas, "cap", globalGasCap)
782
		gas = globalGasCap
783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
	}
	gasPrice := new(big.Int)
	if args.GasPrice != nil {
		gasPrice = args.GasPrice.ToInt()
	}

	value := new(big.Int)
	if args.Value != nil {
		value = args.Value.ToInt()
	}

	var data []byte
	if args.Data != nil {
		data = []byte(*args.Data)
	}

	msg := types.NewMessage(addr, args.To, 0, value, gas, gasPrice, data, false)
	return msg
}

803 804 805 806 807 808 809 810 811 812 813 814 815 816
// account indicates the overriding fields of account during the execution of
// a message call.
// Note, state and stateDiff can't be specified at the same time. If state is
// set, message execution will only use the data in the given state. Otherwise
// if statDiff is set, all diff will be applied first and then execute the call
// message.
type account struct {
	Nonce     *hexutil.Uint64              `json:"nonce"`
	Code      *hexutil.Bytes               `json:"code"`
	Balance   **hexutil.Big                `json:"balance"`
	State     *map[common.Hash]common.Hash `json:"state"`
	StateDiff *map[common.Hash]common.Hash `json:"stateDiff"`
}

817
func DoCall(ctx context.Context, b Backend, args CallArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides map[common.Address]account, vmCfg vm.Config, timeout time.Duration, globalGasCap uint64) (*core.ExecutionResult, error) {
818
	defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now())
819

820
	state, header, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
821
	if state == nil || err != nil {
822
		return nil, err
823
	}
824 825 826 827 828 829 830 831 832 833 834 835 836 837 838
	// Override the fields of specified contracts before execution.
	for addr, account := range overrides {
		// Override account nonce.
		if account.Nonce != nil {
			state.SetNonce(addr, uint64(*account.Nonce))
		}
		// Override account(contract) code.
		if account.Code != nil {
			state.SetCode(addr, *account.Code)
		}
		// Override account balance.
		if account.Balance != nil {
			state.SetBalance(addr, (*big.Int)(*account.Balance))
		}
		if account.State != nil && account.StateDiff != nil {
839
			return nil, fmt.Errorf("account %s has both 'state' and 'stateDiff'", addr.Hex())
840 841 842 843 844 845 846 847 848 849 850 851
		}
		// Replace entire state if caller requires.
		if account.State != nil {
			state.SetStorage(addr, *account.State)
		}
		// Apply state diff into specified accounts.
		if account.StateDiff != nil {
			for key, value := range *account.StateDiff {
				state.SetState(addr, key, value)
			}
		}
	}
852 853 854
	// Setup context so it may be cancelled the call has completed
	// or, in case of unmetered gas, setup a context with a timeout.
	var cancel context.CancelFunc
855 856
	if timeout > 0 {
		ctx, cancel = context.WithTimeout(ctx, timeout)
857 858
	} else {
		ctx, cancel = context.WithCancel(ctx)
859
	}
860 861
	// Make sure the context is cancelled when the call has completed
	// this makes sure resources are cleaned up.
862
	defer cancel()
863 864

	// Get a new instance of the EVM.
865
	msg := args.ToMessage(globalGasCap)
866
	evm, vmError, err := b.GetEVM(ctx, msg, state, header)
867
	if err != nil {
868
		return nil, err
869 870 871 872
	}
	// Wait for the context to be done and cancel the evm. Even if the
	// EVM has finished, cancelling may be done (repeatedly)
	go func() {
873 874
		<-ctx.Done()
		evm.Cancel()
875 876 877 878
	}()

	// Setup the gas pool (also for unmetered requests)
	// and apply the message.
879
	gp := new(core.GasPool).AddGas(math.MaxUint64)
880
	result, err := core.ApplyMessage(evm, msg, gp)
881
	if err := vmError(); err != nil {
882
		return nil, err
883
	}
884 885
	// If the timer caused an abort, return an appropriate error message
	if evm.Cancelled() {
886
		return nil, fmt.Errorf("execution aborted (timeout = %v)", timeout)
887
	}
888 889 890 891
	if err != nil {
		return result, fmt.Errorf("err: %w (supplied gas %d)", err, msg.Gas())
	}
	return result, nil
892 893
}

894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
func newRevertError(result *core.ExecutionResult) *revertError {
	reason, errUnpack := abi.UnpackRevert(result.Revert())
	err := errors.New("execution reverted")
	if errUnpack == nil {
		err = fmt.Errorf("execution reverted: %v", reason)
	}
	return &revertError{
		error:  err,
		reason: hexutil.Encode(result.Revert()),
	}
}

// revertError is an API error that encompassas an EVM revertal with JSON error
// code and a binary data blob.
type revertError struct {
	error
	reason string // revert reason hex encoded
}

// ErrorCode returns the JSON error code for a revertal.
// See: https://github.com/ethereum/wiki/wiki/JSON-RPC-Error-Codes-Improvement-Proposal
func (e *revertError) ErrorCode() int {
	return 3
}

// ErrorData returns the hex encoded revert reason.
func (e *revertError) ErrorData() interface{} {
	return e.reason
}

924
// Call executes the given transaction on the state for the given block number.
925 926 927 928 929
//
// Additionally, the caller can specify a batch of contract for fields overriding.
//
// Note, this function doesn't make and changes in the state/blockchain and is
// useful to execute and retrieve values.
930
func (s *PublicBlockChainAPI) Call(ctx context.Context, args CallArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *map[common.Address]account) (hexutil.Bytes, error) {
931 932 933 934
	var accounts map[common.Address]account
	if overrides != nil {
		accounts = *overrides
	}
935 936 937 938
	result, err := DoCall(ctx, s.b, args, blockNrOrHash, accounts, vm.Config{}, 5*time.Second, s.b.RPCGasCap())
	if err != nil {
		return nil, err
	}
939 940 941
	// If the result contains a revert reason, try to unpack and return it.
	if len(result.Revert()) > 0 {
		return nil, newRevertError(result)
942
	}
943
	return result.Return(), result.Err
944 945
}

946
func DoEstimateGas(ctx context.Context, b Backend, args CallArgs, blockNrOrHash rpc.BlockNumberOrHash, gasCap uint64) (hexutil.Uint64, error) {
947
	// Binary search the gas requirement, as it may be higher than the amount used
948
	var (
949 950 951
		lo  uint64 = params.TxGas - 1
		hi  uint64
		cap uint64
952
	)
953 954 955 956 957
	// Use zero address if sender unspecified.
	if args.From == nil {
		args.From = new(common.Address)
	}
	// Determine the highest gas limit can be used during the estimation.
958 959
	if args.Gas != nil && uint64(*args.Gas) >= params.TxGas {
		hi = uint64(*args.Gas)
960
	} else {
961
		// Retrieve the block to act as the gas ceiling
962
		block, err := b.BlockByNumberOrHash(ctx, blockNrOrHash)
963
		if err != nil {
964
			return 0, err
965
		}
966
		hi = block.GasLimit()
967
	}
968
	// Recap the highest gas limit with account's available balance.
969
	if args.GasPrice != nil && args.GasPrice.ToInt().BitLen() != 0 {
970 971 972 973 974 975 976 977 978 979 980 981 982
		state, _, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
		if err != nil {
			return 0, err
		}
		balance := state.GetBalance(*args.From) // from can't be nil
		available := new(big.Int).Set(balance)
		if args.Value != nil {
			if args.Value.ToInt().Cmp(available) >= 0 {
				return 0, errors.New("insufficient funds for transfer")
			}
			available.Sub(available, args.Value.ToInt())
		}
		allowance := new(big.Int).Div(available, args.GasPrice.ToInt())
983 984 985

		// If the allowance is larger than maximum uint64, skip checking
		if allowance.IsUint64() && hi > allowance.Uint64() {
986 987 988 989 990 991 992 993 994 995
			transfer := args.Value
			if transfer == nil {
				transfer = new(hexutil.Big)
			}
			log.Warn("Gas estimation capped by limited funds", "original", hi, "balance", balance,
				"sent", transfer.ToInt(), "gasprice", args.GasPrice.ToInt(), "fundable", allowance)
			hi = allowance.Uint64()
		}
	}
	// Recap the highest gas allowance with specified gascap.
996
	if gasCap != 0 && hi > gasCap {
997
		log.Warn("Caller gas above allowance, capping", "requested", hi, "cap", gasCap)
998
		hi = gasCap
999
	}
1000
	cap = hi
1001

1002
	// Create a helper to check if a gas allowance results in an executable transaction
1003
	executable := func(gas uint64) (bool, *core.ExecutionResult, error) {
1004
		args.Gas = (*hexutil.Uint64)(&gas)
1005

1006 1007
		result, err := DoCall(ctx, b, args, blockNrOrHash, nil, vm.Config{}, 0, gasCap)
		if err != nil {
1008
			if errors.Is(err, core.ErrIntrinsicGas) {
1009 1010 1011
				return true, nil, nil // Special case, raise gas limit
			}
			return true, nil, err // Bail out
1012
		}
1013
		return result.Failed(), result, nil
1014 1015 1016 1017
	}
	// Execute the binary search and hone in on an executable gas limit
	for lo+1 < hi {
		mid := (hi + lo) / 2
1018 1019 1020 1021
		failed, _, err := executable(mid)

		// If the error is not nil(consensus error), it means the provided message
		// call or transaction will never be accepted no matter how much gas it is
1022
		// assigned. Return the error directly, don't struggle any more.
1023 1024 1025 1026
		if err != nil {
			return 0, err
		}
		if failed {
1027
			lo = mid
1028 1029 1030 1031 1032 1033
		} else {
			hi = mid
		}
	}
	// Reject the transaction as invalid if it still fails at the highest allowance
	if hi == cap {
1034 1035 1036 1037 1038 1039 1040
		failed, result, err := executable(hi)
		if err != nil {
			return 0, err
		}
		if failed {
			if result != nil && result.Err != vm.ErrOutOfGas {
				if len(result.Revert()) > 0 {
1041
					return 0, newRevertError(result)
1042
				}
1043
				return 0, result.Err
1044 1045
			}
			// Otherwise, the specified gas cap is too low
1046
			return 0, fmt.Errorf("gas required exceeds allowance (%d)", cap)
1047 1048
		}
	}
1049
	return hexutil.Uint64(hi), nil
1050 1051
}

1052 1053 1054
// EstimateGas returns an estimate of the amount of gas needed to execute the
// given transaction against the current pending block.
func (s *PublicBlockChainAPI) EstimateGas(ctx context.Context, args CallArgs) (hexutil.Uint64, error) {
1055 1056
	blockNrOrHash := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
	return DoEstimateGas(ctx, s.b, args, blockNrOrHash, s.b.RPCGasCap())
1057 1058
}

1059
// ExecutionResult groups all structured logs emitted by the EVM
1060 1061
// while replaying a transaction in debug mode as well as transaction
// execution status, the amount of gas used and the return value
1062
type ExecutionResult struct {
1063
	Gas         uint64         `json:"gas"`
1064
	Failed      bool           `json:"failed"`
1065 1066 1067 1068 1069 1070 1071
	ReturnValue string         `json:"returnValue"`
	StructLogs  []StructLogRes `json:"structLogs"`
}

// StructLogRes stores a structured log emitted by the EVM while replaying a
// transaction in debug mode
type StructLogRes struct {
1072 1073 1074 1075 1076 1077 1078 1079 1080
	Pc      uint64             `json:"pc"`
	Op      string             `json:"op"`
	Gas     uint64             `json:"gas"`
	GasCost uint64             `json:"gasCost"`
	Depth   int                `json:"depth"`
	Error   error              `json:"error,omitempty"`
	Stack   *[]string          `json:"stack,omitempty"`
	Memory  *[]string          `json:"memory,omitempty"`
	Storage *map[string]string `json:"storage,omitempty"`
1081 1082
}

1083
// FormatLogs formats EVM returned structured logs for json output
1084 1085 1086 1087
func FormatLogs(logs []vm.StructLog) []StructLogRes {
	formatted := make([]StructLogRes, len(logs))
	for index, trace := range logs {
		formatted[index] = StructLogRes{
1088 1089 1090 1091 1092 1093 1094
			Pc:      trace.Pc,
			Op:      trace.Op.String(),
			Gas:     trace.Gas,
			GasCost: trace.GasCost,
			Depth:   trace.Depth,
			Error:   trace.Err,
		}
1095 1096 1097 1098 1099 1100
		if trace.Stack != nil {
			stack := make([]string, len(trace.Stack))
			for i, stackValue := range trace.Stack {
				stack[i] = fmt.Sprintf("%x", math.PaddedBigBytes(stackValue, 32))
			}
			formatted[index].Stack = &stack
1101
		}
1102 1103 1104 1105 1106 1107
		if trace.Memory != nil {
			memory := make([]string, 0, (len(trace.Memory)+31)/32)
			for i := 0; i+32 <= len(trace.Memory); i += 32 {
				memory = append(memory, fmt.Sprintf("%x", trace.Memory[i:i+32]))
			}
			formatted[index].Memory = &memory
1108
		}
1109 1110 1111 1112 1113 1114
		if trace.Storage != nil {
			storage := make(map[string]string)
			for i, storageValue := range trace.Storage {
				storage[fmt.Sprintf("%x", i)] = fmt.Sprintf("%x", storageValue)
			}
			formatted[index].Storage = &storage
1115 1116
		}
	}
1117
	return formatted
1118 1119
}

1120 1121 1122
// RPCMarshalHeader converts the given header to the RPC output .
func RPCMarshalHeader(head *types.Header) map[string]interface{} {
	return map[string]interface{}{
1123
		"number":           (*hexutil.Big)(head.Number),
1124
		"hash":             head.Hash(),
1125 1126 1127 1128 1129 1130 1131
		"parentHash":       head.ParentHash,
		"nonce":            head.Nonce,
		"mixHash":          head.MixDigest,
		"sha3Uncles":       head.UncleHash,
		"logsBloom":        head.Bloom,
		"stateRoot":        head.Root,
		"miner":            head.Coinbase,
1132
		"difficulty":       (*hexutil.Big)(head.Difficulty),
1133
		"extraData":        hexutil.Bytes(head.Extra),
1134
		"size":             hexutil.Uint64(head.Size()),
1135 1136
		"gasLimit":         hexutil.Uint64(head.GasLimit),
		"gasUsed":          hexutil.Uint64(head.GasUsed),
1137
		"timestamp":        hexutil.Uint64(head.Time),
1138
		"transactionsRoot": head.TxHash,
1139
		"receiptsRoot":     head.ReceiptHash,
1140
	}
1141 1142 1143 1144 1145 1146 1147
}

// RPCMarshalBlock converts the given block to the RPC output which depends on fullTx. If inclTx is true transactions are
// returned. When fullTx is true the returned block contains full transaction details, otherwise it will only contain
// transaction hashes.
func RPCMarshalBlock(block *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
	fields := RPCMarshalHeader(block.Header())
1148
	fields["size"] = hexutil.Uint64(block.Size())
1149 1150 1151 1152 1153 1154 1155

	if inclTx {
		formatTx := func(tx *types.Transaction) (interface{}, error) {
			return tx.Hash(), nil
		}
		if fullTx {
			formatTx = func(tx *types.Transaction) (interface{}, error) {
1156
				return newRPCTransactionFromBlockHash(block, tx.Hash()), nil
1157 1158
			}
		}
1159
		txs := block.Transactions()
1160 1161
		transactions := make([]interface{}, len(txs))
		var err error
1162
		for i, tx := range txs {
1163 1164 1165 1166 1167 1168
			if transactions[i], err = formatTx(tx); err != nil {
				return nil, err
			}
		}
		fields["transactions"] = transactions
	}
1169
	uncles := block.Uncles()
1170 1171 1172 1173 1174 1175 1176 1177 1178
	uncleHashes := make([]common.Hash, len(uncles))
	for i, uncle := range uncles {
		uncleHashes[i] = uncle.Hash()
	}
	fields["uncles"] = uncleHashes

	return fields, nil
}

1179 1180
// rpcMarshalHeader uses the generalized output filler, then adds the total difficulty field, which requires
// a `PublicBlockchainAPI`.
1181
func (s *PublicBlockChainAPI) rpcMarshalHeader(ctx context.Context, header *types.Header) map[string]interface{} {
1182
	fields := RPCMarshalHeader(header)
1183
	fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, header.Hash()))
1184 1185 1186 1187
	return fields
}

// rpcMarshalBlock uses the generalized output filler, then adds the total difficulty field, which requires
1188
// a `PublicBlockchainAPI`.
1189
func (s *PublicBlockChainAPI) rpcMarshalBlock(ctx context.Context, b *types.Block, inclTx bool, fullTx bool) (map[string]interface{}, error) {
1190 1191 1192 1193
	fields, err := RPCMarshalBlock(b, inclTx, fullTx)
	if err != nil {
		return nil, err
	}
1194
	if inclTx {
1195
		fields["totalDifficulty"] = (*hexutil.Big)(s.b.GetTd(ctx, b.Hash()))
1196
	}
1197 1198 1199
	return fields, err
}

1200 1201
// RPCTransaction represents a transaction that will serialize to the RPC representation of a transaction
type RPCTransaction struct {
1202
	BlockHash        *common.Hash    `json:"blockHash"`
1203
	BlockNumber      *hexutil.Big    `json:"blockNumber"`
1204
	From             common.Address  `json:"from"`
1205
	Gas              hexutil.Uint64  `json:"gas"`
1206
	GasPrice         *hexutil.Big    `json:"gasPrice"`
1207
	Hash             common.Hash     `json:"hash"`
1208
	Input            hexutil.Bytes   `json:"input"`
1209
	Nonce            hexutil.Uint64  `json:"nonce"`
1210
	To               *common.Address `json:"to"`
1211
	TransactionIndex *hexutil.Uint64 `json:"transactionIndex"`
1212 1213 1214 1215
	Value            *hexutil.Big    `json:"value"`
	V                *hexutil.Big    `json:"v"`
	R                *hexutil.Big    `json:"r"`
	S                *hexutil.Big    `json:"s"`
1216 1217
}

1218 1219 1220
// newRPCTransaction returns a transaction that will serialize to the RPC
// representation, with the given location metadata set (if available).
func newRPCTransaction(tx *types.Transaction, blockHash common.Hash, blockNumber uint64, index uint64) *RPCTransaction {
1221 1222 1223 1224 1225
	var signer types.Signer = types.FrontierSigner{}
	if tx.Protected() {
		signer = types.NewEIP155Signer(tx.ChainId())
	}
	from, _ := types.Sender(signer, tx)
1226
	v, r, s := tx.RawSignatureValues()
1227 1228

	result := &RPCTransaction{
1229
		From:     from,
1230
		Gas:      hexutil.Uint64(tx.Gas()),
1231
		GasPrice: (*hexutil.Big)(tx.GasPrice()),
1232
		Hash:     tx.Hash(),
1233
		Input:    hexutil.Bytes(tx.Data()),
1234
		Nonce:    hexutil.Uint64(tx.Nonce()),
1235
		To:       tx.To(),
1236 1237 1238 1239
		Value:    (*hexutil.Big)(tx.Value()),
		V:        (*hexutil.Big)(v),
		R:        (*hexutil.Big)(r),
		S:        (*hexutil.Big)(s),
1240
	}
1241
	if blockHash != (common.Hash{}) {
1242
		result.BlockHash = &blockHash
1243
		result.BlockNumber = (*hexutil.Big)(new(big.Int).SetUint64(blockNumber))
1244
		result.TransactionIndex = (*hexutil.Uint64)(&index)
1245 1246
	}
	return result
1247 1248
}

1249 1250 1251
// newRPCPendingTransaction returns a pending transaction that will serialize to the RPC representation
func newRPCPendingTransaction(tx *types.Transaction) *RPCTransaction {
	return newRPCTransaction(tx, common.Hash{}, 0, 0)
1252 1253
}

1254 1255 1256 1257 1258
// newRPCTransactionFromBlockIndex returns a transaction that will serialize to the RPC representation.
func newRPCTransactionFromBlockIndex(b *types.Block, index uint64) *RPCTransaction {
	txs := b.Transactions()
	if index >= uint64(len(txs)) {
		return nil
1259
	}
1260 1261
	return newRPCTransaction(txs[index], b.Hash(), b.NumberU64(), index)
}
1262

1263 1264 1265 1266 1267 1268 1269 1270
// newRPCRawTransactionFromBlockIndex returns the bytes of a transaction given a block and a transaction index.
func newRPCRawTransactionFromBlockIndex(b *types.Block, index uint64) hexutil.Bytes {
	txs := b.Transactions()
	if index >= uint64(len(txs)) {
		return nil
	}
	blob, _ := rlp.EncodeToBytes(txs[index])
	return blob
1271 1272
}

1273 1274
// newRPCTransactionFromBlockHash returns a transaction that will serialize to the RPC representation.
func newRPCTransactionFromBlockHash(b *types.Block, hash common.Hash) *RPCTransaction {
1275
	for idx, tx := range b.Transactions() {
1276 1277
		if tx.Hash() == hash {
			return newRPCTransactionFromBlockIndex(b, uint64(idx))
1278 1279
		}
	}
1280
	return nil
1281 1282 1283 1284
}

// PublicTransactionPoolAPI exposes methods for the RPC interface
type PublicTransactionPoolAPI struct {
1285 1286
	b         Backend
	nonceLock *AddrLocker
1287 1288 1289
}

// NewPublicTransactionPoolAPI creates a new RPC service with methods specific for the transaction pool.
1290 1291
func NewPublicTransactionPoolAPI(b Backend, nonceLock *AddrLocker) *PublicTransactionPoolAPI {
	return &PublicTransactionPoolAPI{b, nonceLock}
1292 1293 1294
}

// GetBlockTransactionCountByNumber returns the number of transactions in the block with the given block number.
1295
func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByNumber(ctx context.Context, blockNr rpc.BlockNumber) *hexutil.Uint {
1296
	if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
1297 1298
		n := hexutil.Uint(len(block.Transactions()))
		return &n
1299 1300 1301 1302 1303
	}
	return nil
}

// GetBlockTransactionCountByHash returns the number of transactions in the block with the given hash.
1304
func (s *PublicTransactionPoolAPI) GetBlockTransactionCountByHash(ctx context.Context, blockHash common.Hash) *hexutil.Uint {
1305
	if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
1306 1307
		n := hexutil.Uint(len(block.Transactions()))
		return &n
1308 1309 1310 1311 1312
	}
	return nil
}

// GetTransactionByBlockNumberAndIndex returns the transaction for the given block number and index.
1313
func (s *PublicTransactionPoolAPI) GetTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) *RPCTransaction {
1314
	if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
1315
		return newRPCTransactionFromBlockIndex(block, uint64(index))
1316
	}
1317
	return nil
1318 1319 1320
}

// GetTransactionByBlockHashAndIndex returns the transaction for the given block hash and index.
1321
func (s *PublicTransactionPoolAPI) GetTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) *RPCTransaction {
1322
	if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
1323
		return newRPCTransactionFromBlockIndex(block, uint64(index))
1324
	}
1325
	return nil
1326 1327
}

1328
// GetRawTransactionByBlockNumberAndIndex returns the bytes of the transaction for the given block number and index.
1329
func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockNumberAndIndex(ctx context.Context, blockNr rpc.BlockNumber, index hexutil.Uint) hexutil.Bytes {
1330
	if block, _ := s.b.BlockByNumber(ctx, blockNr); block != nil {
1331
		return newRPCRawTransactionFromBlockIndex(block, uint64(index))
1332
	}
1333
	return nil
1334 1335 1336
}

// GetRawTransactionByBlockHashAndIndex returns the bytes of the transaction for the given block hash and index.
1337
func (s *PublicTransactionPoolAPI) GetRawTransactionByBlockHashAndIndex(ctx context.Context, blockHash common.Hash, index hexutil.Uint) hexutil.Bytes {
1338
	if block, _ := s.b.BlockByHash(ctx, blockHash); block != nil {
1339
		return newRPCRawTransactionFromBlockIndex(block, uint64(index))
1340
	}
1341
	return nil
1342 1343
}

1344
// GetTransactionCount returns the number of transactions the given address has sent for the given block number
1345
func (s *PublicTransactionPoolAPI) GetTransactionCount(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Uint64, error) {
1346
	// Ask transaction pool for the nonce which includes pending transactions
1347
	if blockNr, ok := blockNrOrHash.Number(); ok && blockNr == rpc.PendingBlockNumber {
1348 1349 1350 1351 1352 1353 1354
		nonce, err := s.b.GetPoolNonce(ctx, address)
		if err != nil {
			return nil, err
		}
		return (*hexutil.Uint64)(&nonce), nil
	}
	// Resolve block number and use its state to ask for the nonce
1355
	state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
1356 1357 1358
	if state == nil || err != nil {
		return nil, err
	}
1359 1360
	nonce := state.GetNonce(address)
	return (*hexutil.Uint64)(&nonce), state.Error()
1361 1362 1363
}

// GetTransactionByHash returns the transaction for the given hash
1364
func (s *PublicTransactionPoolAPI) GetTransactionByHash(ctx context.Context, hash common.Hash) (*RPCTransaction, error) {
1365
	// Try to return an already finalized transaction
1366 1367 1368 1369 1370 1371
	tx, blockHash, blockNumber, index, err := s.b.GetTransaction(ctx, hash)
	if err != nil {
		return nil, err
	}
	if tx != nil {
		return newRPCTransaction(tx, blockHash, blockNumber, index), nil
1372
	}
1373 1374
	// No finalized transaction, try to retrieve it from the pool
	if tx := s.b.GetPoolTransaction(hash); tx != nil {
1375
		return newRPCPendingTransaction(tx), nil
1376
	}
1377

1378
	// Transaction unknown, return as such
1379
	return nil, nil
1380 1381
}

1382
// GetRawTransactionByHash returns the bytes of the transaction for the given hash.
1383
func (s *PublicTransactionPoolAPI) GetRawTransactionByHash(ctx context.Context, hash common.Hash) (hexutil.Bytes, error) {
1384
	// Retrieve a finalized transaction, or a pooled otherwise
1385 1386 1387 1388 1389
	tx, _, _, _, err := s.b.GetTransaction(ctx, hash)
	if err != nil {
		return nil, err
	}
	if tx == nil {
1390 1391 1392 1393
		if tx = s.b.GetPoolTransaction(hash); tx == nil {
			// Transaction not found anywhere, abort
			return nil, nil
		}
1394
	}
1395
	// Serialize to RLP and return
1396 1397 1398
	return rlp.EncodeToBytes(tx)
}

1399
// GetTransactionReceipt returns the transaction receipt for the given transaction hash.
1400
func (s *PublicTransactionPoolAPI) GetTransactionReceipt(ctx context.Context, hash common.Hash) (map[string]interface{}, error) {
1401 1402
	tx, blockHash, blockNumber, index, err := s.b.GetTransaction(ctx, hash)
	if err != nil {
1403
		return nil, nil
1404
	}
1405 1406 1407 1408 1409
	receipts, err := s.b.GetReceipts(ctx, blockHash)
	if err != nil {
		return nil, err
	}
	if len(receipts) <= int(index) {
1410
		return nil, nil
1411
	}
1412
	receipt := receipts[index]
1413

1414 1415 1416
	var signer types.Signer = types.FrontierSigner{}
	if tx.Protected() {
		signer = types.NewEIP155Signer(tx.ChainId())
1417
	}
1418
	from, _ := types.Sender(signer, tx)
1419 1420

	fields := map[string]interface{}{
1421 1422
		"blockHash":         blockHash,
		"blockNumber":       hexutil.Uint64(blockNumber),
1423
		"transactionHash":   hash,
1424
		"transactionIndex":  hexutil.Uint64(index),
1425 1426
		"from":              from,
		"to":                tx.To(),
1427 1428
		"gasUsed":           hexutil.Uint64(receipt.GasUsed),
		"cumulativeGasUsed": hexutil.Uint64(receipt.CumulativeGasUsed),
1429 1430
		"contractAddress":   nil,
		"logs":              receipt.Logs,
1431
		"logsBloom":         receipt.Bloom,
1432
	}
1433 1434 1435 1436 1437

	// Assign receipt status or post state.
	if len(receipt.PostState) > 0 {
		fields["root"] = hexutil.Bytes(receipt.PostState)
	} else {
1438
		fields["status"] = hexutil.Uint(receipt.Status)
1439
	}
1440
	if receipt.Logs == nil {
1441
		fields["logs"] = [][]*types.Log{}
1442 1443
	}
	// If the ContractAddress is 20 0x0 bytes, assume it is not a contract creation
1444
	if receipt.ContractAddress != (common.Address{}) {
1445 1446 1447 1448 1449 1450 1451
		fields["contractAddress"] = receipt.ContractAddress
	}
	return fields, nil
}

// sign is a helper function that signs a transaction with the private key of the given address.
func (s *PublicTransactionPoolAPI) sign(addr common.Address, tx *types.Transaction) (*types.Transaction, error) {
1452 1453 1454 1455 1456 1457 1458 1459
	// Look up the wallet containing the requested signer
	account := accounts.Account{Address: addr}

	wallet, err := s.b.AccountManager().Find(account)
	if err != nil {
		return nil, err
	}
	// Request the wallet to sign the transaction
1460
	return wallet.SignTx(account, tx, s.b.ChainConfig().ChainID)
1461 1462 1463 1464 1465 1466
}

// SendTxArgs represents the arguments to sumbit a new transaction into the transaction pool.
type SendTxArgs struct {
	From     common.Address  `json:"from"`
	To       *common.Address `json:"to"`
1467
	Gas      *hexutil.Uint64 `json:"gas"`
1468 1469 1470
	GasPrice *hexutil.Big    `json:"gasPrice"`
	Value    *hexutil.Big    `json:"value"`
	Nonce    *hexutil.Uint64 `json:"nonce"`
1471 1472 1473 1474
	// We accept "data" and "input" for backwards-compatibility reasons. "input" is the
	// newer name and should be preferred by clients.
	Data  *hexutil.Bytes `json:"data"`
	Input *hexutil.Bytes `json:"input"`
1475 1476
}

1477
// setDefaults is a helper function that fills in default values for unspecified tx fields.
1478
func (args *SendTxArgs) setDefaults(ctx context.Context, b Backend) error {
1479 1480 1481
	if args.GasPrice == nil {
		price, err := b.SuggestPrice(ctx)
		if err != nil {
1482
			return err
1483
		}
1484
		args.GasPrice = (*hexutil.Big)(price)
1485 1486
	}
	if args.Value == nil {
1487 1488 1489 1490 1491 1492 1493 1494 1495
		args.Value = new(hexutil.Big)
	}
	if args.Nonce == nil {
		nonce, err := b.GetPoolNonce(ctx, args.From)
		if err != nil {
			return err
		}
		args.Nonce = (*hexutil.Uint64)(&nonce)
	}
1496
	if args.Data != nil && args.Input != nil && !bytes.Equal(*args.Data, *args.Input) {
1497
		return errors.New(`both "data" and "input" are set and not equal. Please use "input" to pass transaction call data`)
1498
	}
1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
	if args.To == nil {
		// Contract creation
		var input []byte
		if args.Data != nil {
			input = *args.Data
		} else if args.Input != nil {
			input = *args.Input
		}
		if len(input) == 0 {
			return errors.New(`contract creation without any data provided`)
		}
	}
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
	// Estimate the gas usage if necessary.
	if args.Gas == nil {
		// For backwards-compatibility reason, we try both input and data
		// but input is preferred.
		input := args.Input
		if input == nil {
			input = args.Data
		}
		callArgs := CallArgs{
			From:     &args.From, // From shouldn't be nil
			To:       args.To,
			GasPrice: args.GasPrice,
			Value:    args.Value,
			Data:     input,
		}
1526 1527
		pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber)
		estimated, err := DoEstimateGas(ctx, b, callArgs, pendingBlockNr, b.RPCGasCap())
1528 1529 1530 1531 1532 1533
		if err != nil {
			return err
		}
		args.Gas = &estimated
		log.Trace("Estimate gas usage automatically", "gas", args.Gas)
	}
1534 1535 1536 1537
	return nil
}

func (args *SendTxArgs) toTransaction() *types.Transaction {
1538
	var input []byte
1539
	if args.Input != nil {
1540
		input = *args.Input
1541 1542
	} else if args.Data != nil {
		input = *args.Data
1543
	}
1544
	if args.To == nil {
1545
		return types.NewContractCreation(uint64(*args.Nonce), (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input)
1546
	}
1547
	return types.NewTransaction(uint64(*args.Nonce), *args.To, (*big.Int)(args.Value), uint64(*args.Gas), (*big.Int)(args.GasPrice), input)
1548 1549
}

1550 1551
// SubmitTransaction is a helper function that submits tx to txPool and logs a message.
func SubmitTransaction(ctx context.Context, b Backend, tx *types.Transaction) (common.Hash, error) {
1552 1553
	// If the transaction fee cap is already specified, ensure the
	// fee of the given transaction is _reasonable_.
1554 1555
	if err := checkTxFee(tx.GasPrice(), tx.Gas(), b.RPCTxFeeCap()); err != nil {
		return common.Hash{}, err
1556
	}
1557
	if err := b.SendTx(ctx, tx); err != nil {
1558 1559
		return common.Hash{}, err
	}
1560 1561
	if tx.To() == nil {
		signer := types.MakeSigner(b.ChainConfig(), b.CurrentBlock().Number())
1562 1563 1564 1565
		from, err := types.Sender(signer, tx)
		if err != nil {
			return common.Hash{}, err
		}
1566
		addr := crypto.CreateAddress(from, tx.Nonce())
1567
		log.Info("Submitted contract creation", "fullhash", tx.Hash().Hex(), "contract", addr.Hex())
1568
	} else {
1569
		log.Info("Submitted transaction", "fullhash", tx.Hash().Hex(), "recipient", tx.To())
1570
	}
1571
	return tx.Hash(), nil
1572 1573 1574 1575 1576
}

// SendTransaction creates a transaction for the given argument, sign it and submit it to the
// transaction pool.
func (s *PublicTransactionPoolAPI) SendTransaction(ctx context.Context, args SendTxArgs) (common.Hash, error) {
1577 1578 1579 1580 1581 1582 1583
	// Look up the wallet containing the requested signer
	account := accounts.Account{Address: args.From}

	wallet, err := s.b.AccountManager().Find(account)
	if err != nil {
		return common.Hash{}, err
	}
1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595

	if args.Nonce == nil {
		// Hold the addresse's mutex around signing to prevent concurrent assignment of
		// the same nonce to multiple accounts.
		s.nonceLock.LockAddr(args.From)
		defer s.nonceLock.UnlockAddr(args.From)
	}

	// Set some sanity defaults and terminate on failure
	if err := args.setDefaults(ctx, s.b); err != nil {
		return common.Hash{}, err
	}
1596
	// Assemble the transaction and sign with the wallet
1597
	tx := args.toTransaction()
1598

1599
	signed, err := wallet.SignTx(account, tx, s.b.ChainConfig().ChainID)
1600 1601 1602
	if err != nil {
		return common.Hash{}, err
	}
1603
	return SubmitTransaction(ctx, s.b, signed)
1604 1605
}

1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
// FillTransaction fills the defaults (nonce, gas, gasPrice) on a given unsigned transaction,
// and returns it to the caller for further processing (signing + broadcast)
func (s *PublicTransactionPoolAPI) FillTransaction(ctx context.Context, args SendTxArgs) (*SignTransactionResult, error) {
	// Set some sanity defaults and terminate on failure
	if err := args.setDefaults(ctx, s.b); err != nil {
		return nil, err
	}
	// Assemble the transaction and obtain rlp
	tx := args.toTransaction()
	data, err := rlp.EncodeToBytes(tx)
	if err != nil {
		return nil, err
	}
	return &SignTransactionResult{data, tx}, nil
}

1622 1623
// SendRawTransaction will add the signed transaction to the transaction pool.
// The sender is responsible for signing the transaction and using the correct nonce.
1624
func (s *PublicTransactionPoolAPI) SendRawTransaction(ctx context.Context, encodedTx hexutil.Bytes) (common.Hash, error) {
1625
	tx := new(types.Transaction)
1626
	if err := rlp.DecodeBytes(encodedTx, tx); err != nil {
1627
		return common.Hash{}, err
1628
	}
1629
	return SubmitTransaction(ctx, s.b, tx)
1630 1631
}

1632 1633 1634
// Sign calculates an ECDSA signature for:
// keccack256("\x19Ethereum Signed Message:\n" + len(message) + message).
//
1635 1636 1637
// Note, the produced signature conforms to the secp256k1 curve R, S and V values,
// where the V value will be 27 or 28 for legacy reasons.
//
1638 1639 1640
// The account associated with addr must be unlocked.
//
// https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign
1641
func (s *PublicTransactionPoolAPI) Sign(addr common.Address, data hexutil.Bytes) (hexutil.Bytes, error) {
1642 1643 1644 1645 1646 1647 1648 1649
	// Look up the wallet containing the requested signer
	account := accounts.Account{Address: addr}

	wallet, err := s.b.AccountManager().Find(account)
	if err != nil {
		return nil, err
	}
	// Sign the requested hash with the wallet
1650
	signature, err := wallet.SignText(account, data)
1651
	if err == nil {
1652
		signature[64] += 27 // Transform V from 0/1 to 27/28 according to the yellow paper
1653 1654
	}
	return signature, err
1655 1656 1657 1658
}

// SignTransactionResult represents a RLP encoded signed transaction.
type SignTransactionResult struct {
1659 1660
	Raw hexutil.Bytes      `json:"raw"`
	Tx  *types.Transaction `json:"tx"`
1661 1662 1663 1664 1665
}

// SignTransaction will sign the given transaction with the from account.
// The node needs to have the private key of the account corresponding with
// the given from address and it needs to be unlocked.
1666
func (s *PublicTransactionPoolAPI) SignTransaction(ctx context.Context, args SendTxArgs) (*SignTransactionResult, error) {
1667 1668 1669 1670 1671 1672
	if args.Gas == nil {
		return nil, fmt.Errorf("gas not specified")
	}
	if args.GasPrice == nil {
		return nil, fmt.Errorf("gasPrice not specified")
	}
1673
	if args.Nonce == nil {
1674
		return nil, fmt.Errorf("nonce not specified")
1675
	}
1676 1677
	if err := args.setDefaults(ctx, s.b); err != nil {
		return nil, err
1678
	}
1679 1680 1681 1682
	// Before actually sign the transaction, ensure the transaction fee is reasonable.
	if err := checkTxFee(args.GasPrice.ToInt(), uint64(*args.Gas), s.b.RPCTxFeeCap()); err != nil {
		return nil, err
	}
1683
	tx, err := s.sign(args.From, args.toTransaction())
1684 1685 1686
	if err != nil {
		return nil, err
	}
1687
	data, err := rlp.EncodeToBytes(tx)
1688 1689 1690
	if err != nil {
		return nil, err
	}
1691
	return &SignTransactionResult{data, tx}, nil
1692 1693
}

1694 1695
// PendingTransactions returns the transactions that are in the transaction pool
// and have a from address that is one of the accounts this node manages.
1696 1697 1698 1699 1700
func (s *PublicTransactionPoolAPI) PendingTransactions() ([]*RPCTransaction, error) {
	pending, err := s.b.GetPoolTransactions()
	if err != nil {
		return nil, err
	}
1701 1702 1703 1704 1705 1706
	accounts := make(map[common.Address]struct{})
	for _, wallet := range s.b.AccountManager().Wallets() {
		for _, account := range wallet.Accounts() {
			accounts[account.Address] = struct{}{}
		}
	}
1707 1708
	transactions := make([]*RPCTransaction, 0, len(pending))
	for _, tx := range pending {
1709 1710 1711 1712 1713
		var signer types.Signer = types.HomesteadSigner{}
		if tx.Protected() {
			signer = types.NewEIP155Signer(tx.ChainId())
		}
		from, _ := types.Sender(signer, tx)
1714
		if _, exists := accounts[from]; exists {
1715 1716 1717
			transactions = append(transactions, newRPCPendingTransaction(tx))
		}
	}
1718
	return transactions, nil
1719 1720
}

1721 1722
// Resend accepts an existing transaction and a new gas price and limit. It will remove
// the given transaction from the pool and reinsert it with the new gas price and limit.
1723
func (s *PublicTransactionPoolAPI) Resend(ctx context.Context, sendArgs SendTxArgs, gasPrice *hexutil.Big, gasLimit *hexutil.Uint64) (common.Hash, error) {
1724 1725 1726 1727 1728 1729 1730
	if sendArgs.Nonce == nil {
		return common.Hash{}, fmt.Errorf("missing transaction nonce in transaction spec")
	}
	if err := sendArgs.setDefaults(ctx, s.b); err != nil {
		return common.Hash{}, err
	}
	matchTx := sendArgs.toTransaction()
1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744

	// Before replacing the old transaction, ensure the _new_ transaction fee is reasonable.
	var price = matchTx.GasPrice()
	if gasPrice != nil {
		price = gasPrice.ToInt()
	}
	var gas = matchTx.Gas()
	if gasLimit != nil {
		gas = uint64(*gasLimit)
	}
	if err := checkTxFee(price, gas, s.b.RPCTxFeeCap()); err != nil {
		return common.Hash{}, err
	}
	// Iterate the pending list for replacement
1745 1746 1747 1748
	pending, err := s.b.GetPoolTransactions()
	if err != nil {
		return common.Hash{}, err
	}
1749
	for _, p := range pending {
1750 1751 1752 1753
		var signer types.Signer = types.HomesteadSigner{}
		if p.Protected() {
			signer = types.NewEIP155Signer(p.ChainId())
		}
1754
		wantSigHash := signer.Hash(matchTx)
1755

1756 1757
		if pFrom, err := types.Sender(signer, p); err == nil && pFrom == sendArgs.From && signer.Hash(p) == wantSigHash {
			// Match. Re-sign and send the transaction.
1758
			if gasPrice != nil && (*big.Int)(gasPrice).Sign() != 0 {
1759
				sendArgs.GasPrice = gasPrice
1760
			}
1761
			if gasLimit != nil && *gasLimit != 0 {
1762
				sendArgs.Gas = gasLimit
1763
			}
1764
			signedTx, err := s.sign(sendArgs.From, sendArgs.toTransaction())
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774
			if err != nil {
				return common.Hash{}, err
			}
			if err = s.b.SendTx(ctx, signedTx); err != nil {
				return common.Hash{}, err
			}
			return signedTx.Hash(), nil
		}
	}

1775
	return common.Hash{}, fmt.Errorf("transaction %#x not found", matchTx.Hash())
1776 1777
}

1778
// PublicDebugAPI is the collection of Ethereum APIs exposed over the public
1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
// debugging endpoint.
type PublicDebugAPI struct {
	b Backend
}

// NewPublicDebugAPI creates a new API definition for the public debug methods
// of the Ethereum service.
func NewPublicDebugAPI(b Backend) *PublicDebugAPI {
	return &PublicDebugAPI{b: b}
}

// GetBlockRlp retrieves the RLP encoded for of a single block.
func (api *PublicDebugAPI) GetBlockRlp(ctx context.Context, number uint64) (string, error) {
	block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number))
	if block == nil {
		return "", fmt.Errorf("block #%d not found", number)
	}
	encoded, err := rlp.EncodeToBytes(block)
	if err != nil {
		return "", err
	}
	return fmt.Sprintf("%x", encoded), nil
}

1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841
// TestSignCliqueBlock fetches the given block number, and attempts to sign it as a clique header with the
// given address, returning the address of the recovered signature
//
// This is a temporary method to debug the externalsigner integration,
// TODO: Remove this method when the integration is mature
func (api *PublicDebugAPI) TestSignCliqueBlock(ctx context.Context, address common.Address, number uint64) (common.Address, error) {
	block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number))
	if block == nil {
		return common.Address{}, fmt.Errorf("block #%d not found", number)
	}
	header := block.Header()
	header.Extra = make([]byte, 32+65)
	encoded := clique.CliqueRLP(header)

	// Look up the wallet containing the requested signer
	account := accounts.Account{Address: address}
	wallet, err := api.b.AccountManager().Find(account)
	if err != nil {
		return common.Address{}, err
	}

	signature, err := wallet.SignData(account, accounts.MimetypeClique, encoded)
	if err != nil {
		return common.Address{}, err
	}
	sealHash := clique.SealHash(header).Bytes()
	log.Info("test signing of clique block",
		"Sealhash", fmt.Sprintf("%x", sealHash),
		"signature", fmt.Sprintf("%x", signature))
	pubkey, err := crypto.Ecrecover(sealHash, signature)
	if err != nil {
		return common.Address{}, err
	}
	var signer common.Address
	copy(signer[:], crypto.Keccak256(pubkey[1:])[12:])

	return signer, nil
}

1842 1843 1844 1845 1846 1847
// PrintBlock retrieves a block and returns its pretty printed form.
func (api *PublicDebugAPI) PrintBlock(ctx context.Context, number uint64) (string, error) {
	block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number))
	if block == nil {
		return "", fmt.Errorf("block #%d not found", number)
	}
1848
	return spew.Sdump(block), nil
1849 1850 1851 1852 1853 1854 1855 1856
}

// SeedHash retrieves the seed hash of a block.
func (api *PublicDebugAPI) SeedHash(ctx context.Context, number uint64) (string, error) {
	block, _ := api.b.BlockByNumber(ctx, rpc.BlockNumber(number))
	if block == nil {
		return "", fmt.Errorf("block #%d not found", number)
	}
1857
	return fmt.Sprintf("0x%x", ethash.SeedHash(number)), nil
1858 1859
}

1860
// PrivateDebugAPI is the collection of Ethereum APIs exposed over the private
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
// debugging endpoint.
type PrivateDebugAPI struct {
	b Backend
}

// NewPrivateDebugAPI creates a new API definition for the private debug methods
// of the Ethereum service.
func NewPrivateDebugAPI(b Backend) *PrivateDebugAPI {
	return &PrivateDebugAPI{b: b}
}

1872
// ChaindbProperty returns leveldb properties of the key-value database.
1873 1874 1875 1876 1877 1878
func (api *PrivateDebugAPI) ChaindbProperty(property string) (string, error) {
	if property == "" {
		property = "leveldb.stats"
	} else if !strings.HasPrefix(property, "leveldb.") {
		property = "leveldb." + property
	}
1879
	return api.b.ChainDb().Stat(property)
1880 1881
}

1882 1883
// ChaindbCompact flattens the entire key-value database into a single level,
// removing all unused slots and merging all keys.
1884 1885
func (api *PrivateDebugAPI) ChaindbCompact() error {
	for b := byte(0); b < 255; b++ {
1886
		log.Info("Compacting chain database", "range", fmt.Sprintf("0x%0.2X-0x%0.2X", b, b+1))
1887
		if err := api.b.ChainDb().Compact([]byte{b}, []byte{b + 1}); err != nil {
1888
			log.Error("Database compaction failed", "err", err)
1889 1890 1891 1892 1893 1894
			return err
		}
	}
	return nil
}

1895
// SetHead rewinds the head of the blockchain to a previous block.
1896 1897
func (api *PrivateDebugAPI) SetHead(number hexutil.Uint64) {
	api.b.SetHead(uint64(number))
1898 1899 1900 1901 1902
}

// PublicNetAPI offers network related RPC methods
type PublicNetAPI struct {
	net            *p2p.Server
1903
	networkVersion uint64
1904 1905 1906
}

// NewPublicNetAPI creates a new net API instance.
1907
func NewPublicNetAPI(net *p2p.Server, networkVersion uint64) *PublicNetAPI {
1908 1909 1910 1911 1912 1913 1914 1915 1916
	return &PublicNetAPI{net, networkVersion}
}

// Listening returns an indication if the node is listening for network connections.
func (s *PublicNetAPI) Listening() bool {
	return true // always listening
}

// PeerCount returns the number of connected peers
1917 1918
func (s *PublicNetAPI) PeerCount() hexutil.Uint {
	return hexutil.Uint(s.net.PeerCount())
1919 1920 1921 1922 1923 1924
}

// Version returns the current ethereum protocol version.
func (s *PublicNetAPI) Version() string {
	return fmt.Sprintf("%d", s.networkVersion)
}
1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939

// checkTxFee is an internal function used to check whether the fee of
// the given transaction is _reasonable_(under the cap).
func checkTxFee(gasPrice *big.Int, gas uint64, cap float64) error {
	// Short circuit if there is no cap for transaction fee at all.
	if cap == 0 {
		return nil
	}
	feeEth := new(big.Float).Quo(new(big.Float).SetInt(new(big.Int).Mul(gasPrice, new(big.Int).SetUint64(gas))), new(big.Float).SetInt(big.NewInt(params.Ether)))
	feeFloat, _ := feeEth.Float64()
	if feeFloat > cap {
		return fmt.Errorf("tx fee (%.2f ether) exceeds the configured cap (%.2f ether)", feeFloat, cap)
	}
	return nil
}