cosmos / ethermint

Ethermint is a scalable and interoperable Ethereum, built on Proof-of-Stake with fast-finality using the Cosmos SDK.

Ethermint

IMPORTANT The ongoing development of this project has migrated to the Tharsis organization. Please use tharsis/ethermint instead of this repository.

Ethermint is a scalable, high-throughput Proof-of-Stake blockchain that is fully compatible and interoperable with Ethereum. It's build using the the Cosmos SDK which runs on top of Tendermint Core consensus engine.

ethermint's Issues

create RPC API command through CLI

Ethereum RPC to run implementations of the web3 protocol

Implement evm module Keeper

to ./x/evm/<Keeper?>.go ? Also may need to change logic of the keepers to make it compliant with the evm execution. Function implementations of the keeper are to be determined, as well as the exact fields needed from the Keeper struct.

Set up module CLI commands for queries

CLI is set up outside of the module, but the cobra commands for the queries are defined within the SDK module. Should run logic done in #9

Implement eth_pendingTransactions

Returning txs in tx pool based on the address of the accounts/wallets this node/daemon manages

Implement eth_getCode

Access code through StateDB at a given block number. Should be easy when given StateDB as context.

TBD: This can take an optional block number/tag to retieve the code at that block. How do access state from previous blocks?

Add Query types and querier

To handle queries to get data persisted to store. May not be absolutely necessary in our case, but I assume we will at least need a basic implementation for getting wallets/accounts that were set up through ethermint

Implement eth_coinbase

Address that previously mining rewards get sent to

TBD: ignore or keep to send staking rewards to?

Implement eth_getUncleCountByBlockNumber

Same as #32 but referencing block by number instead of hash

Implement eth_getBlockByHash

Returns block data given hash, can retrieve with blockchain context

Implement eth_newBlockFilter

To watch for new blocks

1. Does a method exist on the daemon to make this query?
2. Expose the method to the http server
3. Enable http server to make a query to the daemon

Implement eth_getBlockTransactionCountByNumber

Gets # txs in a block referenced by hash, same as #30 but by block number/height

Implement eth_sign

Sign calculates an ECDSA signature for:

keccack256("\x19Ethereum Signed Message:\n" + len(message) + message)

TBD: Is this needed for ethermint?

Implement GenesisState implementations

ModuleBasicManager requires these function implementations when starting, stopping, or exporting the chain.

file should be located at x/evm/genesis.go

Implement eth_call

Will be a more extensive issue to monitor and handle the contract execution

Implement eth_newPendingTransactionFilter

To watch for new pending transactions

Can we watch for pending txs?

Implement eth_getTransactionByHash

Reading tx from raw db from raw hash, using backend as context and hash to reference

Implement eth_newFilter

Filter to query logs based on block number, address and/or topics

Set up emintd

Daemon command for block production node running in background to handle txs

Implement eth_uninstallFilter

Removes filter (by ID)

Implement the EVM as a CosmosSDK module

Implement eth_blockNumber

Are we just going to return the Tendermint equivalent of height? If so, that will be an easy implementation

Implement eth_estimateGas

https://godoc.org/github.com/cosmos/cosmos-sdk/x/auth/client/utils#CalculateGas

Implement eth_getTransactionByBlockNumberAndIndex

Same as #43 But instead of block hash, block number

Implement eth_syncing

1. Retrieve node from CLI context cliCtx.GetNode()
2. Return client.Status()

Implement eth_accounts

List accounts available to node.

Logic should be setup already in module to be able to query the Accounts Keeper ?

Move codec to SDK module

Is already setup with the Ethereum codec in crypto/codec.go

Set up emintcli framework

CLI commands to run commands to setup the daemon and run transactions

Implement eth_getTransactionCount

Get nonce at address, which the equivalent in CosmosSDK is sequence

Configure EthermintApp setup and Keepers once logic is implemented and decided

Will rely on other issues to know which Keepers and modules are required for the app, but this will need to be updated to have a functioning implementation of the module

Implement eth_getUncleCountByBlockHash

Uncles per block referenced by hash

Implement eth_getBlockByNumber

Same as #40 but By number instead of hash

Implement eth_getUncleByBlockNumberAndIndex

Same as #47 but block number instead of hash

Build function to set up codec with all configured modules

For consistency, a standard function codec generation with modules for the application should be set up to be used within the CLI and daemon of the application

Implement eth_sendRawTransaction

Same as #36 but RLP decode before sending tx

Note: Ethereum encoded bytes, not an encoded Cosmos tx

Implements eth_getUncleByBlockHashAndIndex

TBD: Uncles in the context of tendermint?

Maybe we will need to replay them but we will never encounter them?

Implement eth_getTransactionByBlockHashAndIndex

Reference tx from block pulled from mem referenced by hash

TBD: How to get block data by hash/ number

Implement eth_gasPrice

Are we mapping gas cost to the ethermint equivalent of photons?

Implement eth_sendTransaction

Move logic from sending Eth Transaction currently in app/ante.go to handle transactions through API

Implement eth_getBlockTransactionCountByHash

Gets # transactions in a block referenced by hash

Set up entry into SDK module

Setting up CLI and daemon locations and module NewBasicManager.

Should be as easy as:

// default home directories for the application CLI
	DefaultCLIHome = os.ExpandEnv("$HOME/.nscli")

	// DefaultNodeHome sets the folder where the applcation data and configuration will be stored
	DefaultNodeHome = os.ExpandEnv("$HOME/.nsd")

	// ModuleBasicManager is in charge of setting up basic module elemnets
	ModuleBasics = module.NewBasicManager(
		genaccounts.AppModuleBasic{},
		genutil.AppModuleBasic{},
		auth.AppModuleBasic{},
		bank.AppModuleBasic{},
		params.AppModuleBasic{},
		evm.AppModule{},
		staking.AppModuleBasic{},
		distr.AppModuleBasic{},
		slashing.AppModuleBasic{},
	)

With changing the other SDK to custom variants generated if needed through our implementation

Set up CLI commands for txs

CLI cobra commands to be added to the CLI defined outside of the SDK module

Implement eth_getStorageAt

Should be able to be easily queried through StateDB committed to KV store with GetStorageAt(...)

Implement eth_getFilterChanges

Returns all changes since last filter read

For pending transaction and block filters the result is []common.Hash. Else returns logs

Implement eth_hashrate

Can probably just keep defaulting as 0?

Implement web3 compatible API layer

Implement eth_protocolVersion

Not sure if this will be necessary to be compliant, but the protocol version is currently defaulted to 63, but there is a version 62 in ethereum as well.

Setup AppModule Interface

Includes setting up the AppModule implementation and AppModuleBasic implementation. Generic Cosmos SDK interface implementations (functions to be implemented can be seen here.

Implement Handler Framework

Handlers define logic that happens when msgs are received. Msgs are implemented in module under x/evm/types/msg.go.

Will most likely just be moving the logic from app/ante.go which includes NewAnteHandler() which handles the different types of txs (ethereum and sdk txs), but there may be more to be built out

See NewHandler() in tutorial's x/nameservice/handler.go.

Implement eth_getBalance

Can get balance through StateDB.GetBalance ? Will this be a different balance than the photons stored within the Supply Keeper?

Implement eth_getTransactionReceipt

Rebuilding receipt interface from tx retrieved from the tx hash

May have to rebuild logs as in eth_getLogs