ethRPCExecShells

var AllShells = []*EthRPCExecShell{

	GenUnsupportedShell(Method_web3_sha3),
	GenUnsupportedShell(Method_web3_sha3),
	GenUnsupportedShell(Method_net_listening),
	GenUnsupportedShell(Method_net_peerCount),
	GenUnsupportedShell(Method_eth_protocolVersion),
	GenUnsupportedShell(Method_eth_sign),
	GenUnsupportedShell(Method_eth_signTransaction),
	GenUnsupportedShell(Method_eth_newFilter),
	GenUnsupportedShell(Method_eth_newBlockFilter),
	GenUnsupportedShell(Method_eth_newPendingTransactionFilter),
	GenUnsupportedShell(Method_eth_uninstallFilter),
	GenUnsupportedShell(Method_eth_getFilterChanges),
	GenUnsupportedShell(Method_eth_getFilterLogs),

	Web3ClientVersion,
	NetVersion,
	ETHSyncing,
	ETHGetStorageAt,
	ETHGetCode,
	ETHGetLogs,

	ETHCoinbase,
	ETHChainId,
	ETHMining,
	ETHHashRate,
	ETHGasPrice,
	ETHBlockNumber,

	ETHAccounts,
	ETHGetBalance,
	ETHGetTransactionCount,

	ETHGetUncleCountByBlockHash,
	ETHGetUncleCountByBlockNumber,
	ETHGetBlockByHash,
	ETHGetBlockByNumber,
	ETHGetBlockTransactionCountByHash,
	ETHGetBlockTransactionCountByNumber,
	ETHGetUncleByBlockHashAndIndex,
	ETHGetUncleByBlockNumberAndIndex,

	ETHSendTransaction,
	ETHSendRawTransaction,
	ETHCall,
	ETHEstimateGas,
	ETHGetTransactionByHash,
	ETHGetTransactionByBlockHashAndIndex,
	ETHGetTransactionByBlockNumberAndIndex,
	ETHGetTransactionReceipt,
}

var ETHAccounts = &EthRPCExecShell{
	name:   Method_eth_accounts,
	defRet: []types.Address{},
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.Accounts()
	},
}

var ETHBlockNumber = &EthRPCExecShell{
	name:   Method_eth_blockNumber,
	defRet: "0",
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.BlockNumber()
	},
}

var ETHCall = &EthRPCExecShell{
	name:        Method_eth_call,
	minParamLen: 1,
	maxParamLen: 2,
	execFn: func(params []any) (any, *RPCProviderError) {
		tx, blk, err := getETHCallParam(params)
		if err != nil {
			return nil, err
		}
		return rpcProvider.Call(*tx, *blk)
	},
}

var ETHChainId = &EthRPCExecShell{
	name: Method_eth_chainId,
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.ChainId()
	},
}

var ETHCoinbase = &EthRPCExecShell{
	name:   Method_eth_coinbase,
	defRet: types.Address{},
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.Coinbase()
	},
}

var ETHEstimateGas = &EthRPCExecShell{
	name:        Method_eth_estimateGas,
	minParamLen: 1,
	maxParamLen: 2,
	execFn: func(params []any) (any, *RPCProviderError) {
		tx, blk, err := getETHCallParam(params)
		if err != nil {
			return nil, err
		}
		return rpcProvider.EstimateGas(*tx, *blk)
	},
}

var ETHGasPrice = &EthRPCExecShell{
	name:   Method_eth_gasPrice,
	defRet: "0",
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.GasPrice()
	},
}

var ETHGetBalance = &EthRPCExecShell{
	name:        Method_eth_getBalance,
	minParamLen: 2,
	maxParamLen: 2,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		addr, blk, err := extractAddressAndBlock(params[0], params[1])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.Balance(*addr, *blk)
	},
}

var ETHGetBlockByHash = &EthRPCExecShell{
	name:        Method_eth_getBlockByHash,
	minParamLen: 2,
	maxParamLen: 2,
	execFn: func(params []any) (any, *RPCProviderError) {
		blkHash, err := extractHash(params[0])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		txFlag, flagOk := params[1].(bool)
		if !flagOk {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.BlockByHash(*blkHash, txFlag)
	},
}

var ETHGetBlockByNumber = &EthRPCExecShell{
	name:        Method_eth_getBlockByNumber,
	minParamLen: 2,
	maxParamLen: 2,
	execFn: func(params []any) (any, *RPCProviderError) {
		var blk EthBlockNumString

		if !blk.FromAny(params[0]) {
			return nil, ProviderInvalidParams
		}

		txFlag, flagOk := params[1].(bool)
		if !flagOk {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.BlockByNumber(blk, txFlag)
	},
}

var ETHGetBlockTransactionCountByHash = &EthRPCExecShell{
	name:        Method_eth_getBlockTransactionCountByHash,
	minParamLen: 1,
	maxParamLen: 1,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		blkHash, err := extractHash(params[0])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.BlockTransactionCountByHash(*blkHash)
	},
}

var ETHGetBlockTransactionCountByNumber = &EthRPCExecShell{
	name:        Method_eth_getBlockTransactionCountByNumber,
	minParamLen: 1,
	maxParamLen: 1,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		var blk EthBlockNumString

		if !blk.FromAny(params[0]) {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.BlockTransactionCountByNumber(blk)
	},
}

var ETHGetCode = &EthRPCExecShell{
	name:        Method_eth_getCode,
	minParamLen: 2,
	maxParamLen: 2,
	defRet:      "0x",
	execFn: func(params []any) (any, *RPCProviderError) {
		addr, blk, err := extractAddressAndBlock(params[0], params[1])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.Code(*addr, *blk)
	},
}

var ETHGetLogs = &EthRPCExecShell{
	name:        Method_eth_getLogs,
	minParamLen: 1,
	maxParamLen: 1,
	defRet:      []EthLog{},
	execFn: func(params []any) (any, *RPCProviderError) {
		logParam := &EthGetLogsParam{}
		paramJSON, _ := json.Marshal(params[0])

		err := json.Unmarshal(paramJSON, logParam)
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.Logs(*logParam)
	},
}

var ETHGetStorageAt = &EthRPCExecShell{
	name:        Method_eth_getStorageAt,
	minParamLen: 3,
	maxParamLen: 3,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		var addr types.Address
		err := addr.FromParam(params[0])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		var pos types.Key
		err = pos.FromParam(params[1])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		var blk EthBlockNumString
		if !blk.FromAny(params[2]) {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.StorageAt(addr, pos, blk)
	},
}

var ETHGetTransactionByBlockHashAndIndex = &EthRPCExecShell{
	name:        Method_eth_getTransactionByBlockHashAndIndex,
	minParamLen: 2,
	maxParamLen: 2,
	execFn: func(params []any) (any, *RPCProviderError) {
		blkHash, idx, err := extractHashAndInt(params[0], params[1])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.TransactionByBlockHashAndIndex(*blkHash, idx)
	},
}

var ETHGetTransactionByBlockNumberAndIndex = &EthRPCExecShell{
	name:        Method_eth_getTransactionByBlockNumberAndIndex,
	minParamLen: 2,
	maxParamLen: 2,
	execFn: func(params []any) (any, *RPCProviderError) {
		blk, idx, err := extractBlkNumAndInt(params[0], params[1])

		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.TransactionByBlockNumberAndIndex(*blk, idx)
	},
}

var ETHGetTransactionByHash = &EthRPCExecShell{
	name:        Method_eth_getTransactionByHash,
	minParamLen: 1,
	maxParamLen: 1,
	execFn: func(params []any) (any, *RPCProviderError) {
		txHash, err := extractHash(params[0])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.TransactionByHash(*txHash)
	},
}

var ETHGetTransactionCount = &EthRPCExecShell{
	name:        Method_eth_getTransactionCount,
	minParamLen: 2,
	maxParamLen: 2,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		addr, blk, err := extractAddressAndBlock(params[0], params[1])
		if err != nil {
			return nil, ProviderInvalidParams
		}
		return rpcProvider.TransactionCount(*addr, *blk)
	},
}

var ETHGetTransactionReceipt = &EthRPCExecShell{
	name:        Method_eth_getTransactionReceipt,
	minParamLen: 1,
	maxParamLen: 1,
	execFn: func(params []any) (any, *RPCProviderError) {
		txHash, err := extractHash(params[0])

		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.TransactionReceipt(*txHash)
	},
}

var ETHGetUncleByBlockHashAndIndex = &EthRPCExecShell{
	name:        Method_eth_getUncleByBlockHashAndIndex,
	minParamLen: 2,
	maxParamLen: 2,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		blkHash, err := extractHash(params[0])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		idx, err := utils.HexParamToUint64(params[1])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.UncleByBlockHashAndIndex(*blkHash, idx)
	},
}

var ETHGetUncleByBlockNumberAndIndex = &EthRPCExecShell{
	name:        Method_eth_getUncleByBlockNumberAndIndex,
	minParamLen: 2,
	maxParamLen: 2,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		var blk EthBlockNumString
		if !blk.FromAny(params[0]) {
			return nil, ProviderInvalidParams
		}

		idx, err := utils.HexParamToUint64(params[1])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.UncleByBlockNumberAndIndex(blk, idx)
	},
}

var ETHGetUncleCountByBlockHash = &EthRPCExecShell{
	name:        Method_eth_getUncleCountByBlockHash,
	minParamLen: 1,
	maxParamLen: 1,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		txHash, err := extractHash(params[0])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.UncleCountByBlockHash(*txHash)
	},
}

var ETHGetUncleCountByBlockNumber = &EthRPCExecShell{
	name:        Method_eth_getUncleCountByBlockNumber,
	minParamLen: 1,
	maxParamLen: 1,
	defRet:      "0x0",
	execFn: func(params []any) (any, *RPCProviderError) {
		var blk EthBlockNumString

		if !blk.FromAny(params[0]) {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.UncleCountByBlockNumber(blk)
	},
}

var ETHHashRate = &EthRPCExecShell{
	name:   Method_eth_hashrate,
	defRet: "0",
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.HashRate()
	},
}

var ETHMining = &EthRPCExecShell{
	name:   Method_eth_mining,
	defRet: false,
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.Mining()
	},
}

var ETHSendRawTransaction = &EthRPCExecShell{
	name:        Method_eth_sendRawTransaction,
	minParamLen: 1,
	maxParamLen: 1,
	execFn: func(params []any) (any, *RPCProviderError) {
		var txData types.Data
		err := txData.FromParam(params[0])
		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.SendRawTransaction(txData)
	},
}

var ETHSendTransaction = &EthRPCExecShell{
	name:        Method_eth_sendTransaction,
	minParamLen: 1,
	maxParamLen: 1,
	execFn: func(params []any) (any, *RPCProviderError) {
		txJSON, _ := json.Marshal(params[0])
		tx := &EthBasicTransaction{}
		err := json.Unmarshal(txJSON, tx)

		if err != nil {
			return nil, ProviderInvalidParams
		}

		return rpcProvider.SendTransaction(*tx)
	},
}

var ETHSyncing = &EthRPCExecShell{
	name:   Method_eth_syncing,
	defRet: false,
	execFn: func([]any) (any, *RPCProviderError) {
		status, data, err := rpcProvider.Syncing()
		if err != nil {
			return nil, err
		}

		if data != nil {
			return data, nil
		}

		return status, err
	},
}

var NetVersion = &EthRPCExecShell{
	name:   Method_net_version,
	defRet: "unknown",
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.NetVersion()
	},
}

var Web3ClientVersion = &EthRPCExecShell{
	name:   Method_web3_clientVersion,
	defRet: "unknown",
	execFn: func([]any) (any, *RPCProviderError) {
		return rpcProvider.Web3ClientVersion()
	},
}