status-im
/
nimbus-eth1
mirror of https://github.com/status-im/nimbus-eth1.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
nimbus-eth1/nimbus/rpc/server_api.nim

261 lines
9.7 KiB
Nim
Raw Blame History

# Nimbus
# Copyright (c) 2024 Status Research & Development GmbH
# Licensed under either of
# * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
# * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.
{.push raises: [].}
import
stint,
web3/conversions,
json_rpc/rpcserver,
../common,
../db/ledger,
../core/chain/forked_chain,
../core/tx_pool,
../beacon/web3_eth_conv,
../transaction,
../transaction/call_evm,
../evm/evm_errors,
./rpc_types,
./filters,
./server_api_helpers
type
ServerAPIRef* = ref object
com: CommonRef
chain: ForkedChainRef
txPool: TxPoolRef
const
defaultTag = blockId("latest")
func newServerAPI*(c: ForkedChainRef, t: TxPoolRef): ServerAPIRef =
ServerAPIRef(
com: c.com,
chain: c,
txPool: t
)
proc headerFromTag(api: ServerAPIRef, blockTag: BlockTag): Result[common.BlockHeader, string] =
if blockTag.kind == bidAlias:
let tag = blockTag.alias.toLowerAscii
case tag
of "latest": return ok(api.chain.latestHeader)
else:
return err("Unsupported block tag " & tag)
else:
let blockNum = common.BlockNumber blockTag.number
return api.chain.headerByNumber(blockNum)
proc headerFromTag(api: ServerAPIRef, blockTag: Opt[BlockTag]): Result[common.BlockHeader, string] =
let blockId = blockTag.get(defaultTag)
api.headerFromTag(blockId)
proc ledgerFromTag(api: ServerAPIRef, blockTag: BlockTag): Result[LedgerRef, string] =
let header = ?api.headerFromTag(blockTag)
if api.chain.stateReady(header):
ok(LedgerRef.init(api.com.db, header.stateRoot))
else:
# TODO: Replay state?
err("Block state not ready")
proc blockFromTag(api: ServerAPIRef, blockTag: BlockTag): Result[EthBlock, string] =
if blockTag.kind == bidAlias:
let tag = blockTag.alias.toLowerAscii
case tag
of "latest":
return ok(api.chain.latestBlock)
else:
return err("Unsupported block tag " & tag)
else:
let blockNum = common.BlockNumber blockTag.number
return api.chain.blockByNumber(blockNum)
proc setupServerAPI*(api: ServerAPIRef, server: RpcServer) =
server.rpc("eth_getBalance") do(data: Web3Address, blockTag: BlockTag) -> UInt256:
## Returns the balance of the account of given address.
let
ledger = api.ledgerFromTag(blockTag).valueOr:
raise newException(ValueError, error)
address = ethAddr data
ledger.getBalance(address)
server.rpc("eth_getStorageAt") do(data: Web3Address, slot: UInt256, blockTag: BlockTag) -> Web3FixedBytes[32]:
## Returns the value from a storage position at a given address.
let
ledger = api.ledgerFromTag(blockTag).valueOr:
raise newException(ValueError, error)
address = ethAddr data
value = ledger.getStorage(address, slot)
w3FixedBytes value
server.rpc("eth_getTransactionCount") do(data: Web3Address, blockTag: BlockTag) -> Web3Quantity:
## Returns the number of transactions ak.s. nonce sent from an address.
let
ledger = api.ledgerFromTag(blockTag).valueOr:
raise newException(ValueError, error)
address = ethAddr data
nonce = ledger.getNonce(address)
w3Qty nonce
server.rpc("eth_blockNumber") do() -> Web3Quantity:
## Returns integer of the current block number the client is on.
w3Qty(api.chain.latestNumber)
server.rpc("eth_chainId") do() -> Web3Quantity:
return w3Qty(distinctBase(api.com.chainId))
server.rpc("eth_getCode") do(data: Web3Address, blockTag: BlockTag) -> seq[byte]:
## Returns code at a given address.
##
## data: address
## blockTag: integer block number, or the string "latest", "earliest" or "pending", see the default block parameter.
## Returns the code from the given address.
let
ledger = api.ledgerFromTag(blockTag).valueOr:
raise newException(ValueError, error)
address = ethAddr data
ledger.getCode(address).bytes()
server.rpc("eth_getBlockByHash") do(data: Web3Hash, fullTransactions: bool) -> BlockObject:
## Returns information about a block by hash.
##
## data: Hash of a block.
## fullTransactions: If true it returns the full transaction objects, if false only the hashes of the transactions.
## Returns BlockObject or nil when no block was found.
let blockHash = data.ethHash
let blk = api.chain.blockByHash(blockHash).valueOr:
return nil
return populateBlockObject(blockHash, blk, fullTransactions)
server.rpc("eth_getBlockByNumber") do(blockTag: BlockTag, fullTransactions: bool) -> BlockObject:
## Returns information about a block by block number.
##
## blockTag: integer of a block number, or the string "earliest", "latest" or "pending", as in the default block parameter.
## fullTransactions: If true it returns the full transaction objects, if false only the hashes of the transactions.
## Returns BlockObject or nil when no block was found.
let blk = api.blockFromTag(blockTag).valueOr:
return nil
let blockHash = blk.header.blockHash
return populateBlockObject(blockHash, blk, fullTransactions)
server.rpc("eth_syncing") do() -> SyncingStatus:
## Returns SyncObject or false when not syncing.
if api.com.syncState != Waiting:
let sync = SyncObject(
startingBlock: w3Qty api.com.syncStart,
currentBlock : w3Qty api.com.syncCurrent,
highestBlock : w3Qty api.com.syncHighest
)
return SyncingStatus(syncing: true, syncObject: sync)
else:
return SyncingStatus(syncing: false)
proc getLogsForBlock(
chain: ForkedChainRef,
blk: EthBlock,
opts: FilterOptions): seq[FilterLog]
{.gcsafe, raises: [RlpError].} =
if headerBloomFilter(blk.header, opts.address, opts.topics):
let receipts = chain.db.getReceipts(blk.header.receiptsRoot)
# Note: this will hit assertion error if number of block transactions
# do not match block receipts.
# Although this is fine as number of receipts should always match number
# of transactions
let logs = deriveLogs(blk.header, blk.transactions, receipts)
let filteredLogs = filterLogs(logs, opts.address, opts.topics)
return filteredLogs
else:
return @[]
proc getLogsForRange(
chain: ForkedChainRef,
start: common.BlockNumber,
finish: common.BlockNumber,
opts: FilterOptions): seq[FilterLog]
{.gcsafe, raises: [RlpError].} =
var
logs = newSeq[FilterLog]()
blockNum = start
while blockNum <= finish:
let
blk = chain.blockByNumber(blockNum).valueOr:
return logs
filtered = chain.getLogsForBlock(blk, opts)
logs.add(filtered)
blockNum = blockNum + 1
return logs
server.rpc("eth_getLogs") do(filterOptions: FilterOptions) -> seq[FilterLog]:
## filterOptions: settings for this filter.
## Returns a list of all logs matching a given filter object.
## TODO: Current implementation is pretty naive and not efficient
## as it requires to fetch all transactions and all receipts from database.
## Other clients (Geth):
## - Store logs related data in receipts.
## - Have separate indexes for Logs in given block
## Both of those changes require improvements to the way how we keep our data
## in Nimbus.
if filterOptions.blockHash.isSome():
let
hash = ethHash filterOptions.blockHash.expect("blockHash")
blk = api.chain.blockByHash(hash).valueOr:
raise newException(ValueError, "Block not found")
return getLogsForBlock(api.chain, blk, filterOptions)
else:
# TODO: do something smarter with tags. It would be the best if
# tag would be an enum (Earliest, Latest, Pending, Number), and all operations
# would operate on this enum instead of raw strings. This change would need
# to be done on every endpoint to be consistent.
let
blockFrom = api.headerFromTag(filterOptions.fromBlock).valueOr:
raise newException(ValueError, "Block not found")
blockTo = api.headerFromTag(filterOptions.toBlock).valueOr:
raise newException(ValueError, "Block not found")
# Note: if fromHeader.number > toHeader.number, no logs will be
# returned. This is consistent with, what other ethereum clients return
return api.chain.getLogsForRange(
blockFrom.number,
blockTo.number,
filterOptions
)
server.rpc("eth_sendRawTransaction") do(txBytes: seq[byte]) -> Web3Hash:
## Creates new message call transaction or a contract creation for signed transactions.
##
## data: the signed transaction data.
## Returns the transaction hash, or the zero hash if the transaction is not yet available.
## Note: Use eth_getTransactionReceipt to get the contract address, after the transaction was mined, when you created a contract.
let
pooledTx = decodePooledTx(txBytes)
txHash = rlpHash(pooledTx)
api.txPool.add(pooledTx)
let res = api.txPool.inPoolAndReason(txHash)
if res.isErr:
raise newException(ValueError, res.error)
txHash.w3Hash
server.rpc("eth_call") do(args: TransactionArgs, blockTag: BlockTag) -> seq[byte]:
## Executes a new message call immediately without creating a transaction on the block chain.
##
## call: the transaction call object.
## quantityTag: integer block number, or the string "latest", "earliest" or "pending", see the default block parameter.
## Returns the return value of executed contract.
let
header = api.headerFromTag(blockTag).valueOr:
raise newException(ValueError, "Block not found")
res = rpcCallEvm(args, header, api.com).valueOr:
raise newException(ValueError, "rpcCallEvm error: " & $error.code)
res.output
Reference in New Issue View Git Blame Copy Permalink