@msaki/eth-rpc 0.1.0 → 0.2.0

package/src/eth-methods.ts

@@ -1,202 +1,295 @@
-import { JsonRpcClient, initializeRpcClient } from "@msaki/jsonrpc";
-export type * as EthSchema from "./types";
-import type { EthSchema } from ".";
+import { initializeRpcClient, JsonRpcClient } from "@msaki/jsonrpc";
 
 export enum Methods {
-  // eth/transaction
-  eth_getTransactionByHash = "eth_getTransactionByHash",
-  eth_getTransactionByBlockHashAndIndex = "eth_getTransactionByBlockHashAndIndex",
-  eth_getTransactionReceipt = "eth_getTransactionReceipt",
-  // eth/submit
-  eth_sendTransaction = "eth_sendTransaction",
-  eth_sendRawTransaction = "eth_sendRawTransaction",
-  // eth/state
-  eth_getBalance = "eth_getBalance",
-  eth_getStorageAt = "eth_getStorageAt",
-  eth_getTransactionCount = "eth_getTransactionCount",
-  eth_getCode = "eth_getCode",
-  eth_getProof = "eth_getProof",
-  // eth/sign
-  eth_sign = "eth_sign",
-  eth_signTransaction = "eth_signTransaction",
-  // eth/filter
-  eth_newFilter = "eth_newFilter",
-  eth_newBlockFilter = "eth_newBlockFilter",
-  eth_newPendingTransactionFilter = "eth_newPendingTransactionFilter",
-  eth_uninstallFilter = "eth_uninstallFilter",
-  eth_getFilterChanges = "eth_getFilterChanges",
-  eth_getFilterLogs = "eth_getFilterLogs",
-  eth_getLogs = "eth_getLogs",
+	// eth/transaction
+	eth_getTransactionByHash = "eth_getTransactionByHash",
+	eth_getTransactionByBlockHashAndIndex = "eth_getTransactionByBlockHashAndIndex",
+	eth_getTransactionReceipt = "eth_getTransactionReceipt",
+	// eth/submit
+	eth_sendTransaction = "eth_sendTransaction",
+	eth_sendRawTransaction = "eth_sendRawTransaction",
+	// eth/state
+	eth_getBalance = "eth_getBalance",
+	eth_getStorageAt = "eth_getStorageAt",
+	eth_getTransactionCount = "eth_getTransactionCount",
+	eth_getCode = "eth_getCode",
+	eth_getProof = "eth_getProof",
+	// eth/sign
+	eth_sign = "eth_sign",
+	eth_signTransaction = "eth_signTransaction",
+	// eth/filter
+	eth_newFilter = "eth_newFilter",
+	eth_newBlockFilter = "eth_newBlockFilter",
+	eth_newPendingTransactionFilter = "eth_newPendingTransactionFilter",
+	eth_uninstallFilter = "eth_uninstallFilter",
+	eth_getFilterChanges = "eth_getFilterChanges",
+	eth_getFilterLogs = "eth_getFilterLogs",
+	eth_getLogs = "eth_getLogs",
+	// eth/feeMarket
+	eth_gasPrice = "eth_gasPrice",
+	eth_blobBaseFee = "eth_blobBaseFee",
+	eth_maxPriorityFeePerGas = "eth_maxPriorityFeePerGas",
+	eth_feeHistory = "eth_feeHistory",
+	// eth/execute
+	eth_call = "eth_call",
+	eth_estimateGas = "eth_estimateGas",
+	eth_createAccessList = "eth_createAccessList",
+	eth_simulateV1 = "eth_simulateV1",
+	// eth/client
+	eth_chainId = "eth_chainId",
+	eth_syncing = "eth_syncing",
+	eth_coinbase = "eth_coinbase",
+	eth_accounts = "eth_accounts",
+	eth_blockNumber = "eth_blockNumber",
+	net_version = "net_version",
+	// eth/block
+	eth_getBlockByHash = "eth_getBlockByHash",
+	eth_getBlockByNumber = "eth_getBlockByNumber",
+	eth_getBlockTransactionCountByHash = "eth_getBlockTransactionCountByHash",
+	eth_getBlockTransactionCountByNumber = "eth_getBlockTransactionCountByNumber",
+	eth_getUncleCountByBlockHash = "eth_getUncleCountByBlockHash",
+	eth_getUncleCountByBlockNumber = "eth_getUncleCountByBlockNumber",
+	eth_getBlockReceipts = "eth_getBlockReceipts",
 }
 
 export class EthExecutionClient {
-  private client: JsonRpcClient;
+	private client: JsonRpcClient;
 
-  constructor(url: string) {
-    this.client = initializeRpcClient(url)
-  }
+	constructor(url: string) {
+		this.client = initializeRpcClient(url);
+	}
 
-  // eth/transaction
-  async eth_getTransactionByHash(
-    transactioHash: EthSchema.Hash32
-  ): Promise<EthSchema.NotFound | EthSchema.TransactionInfo> {
-    return await this.client.call(
-      Methods.eth_getTransactionByHash,
-      [transactioHash]
-    );
-  }
-  async eth_getTransactionByBlockHashAndIndex(
-    blockHash: EthSchema.Hash32,
-    transactionIndex: EthSchema.Uint
-  ): Promise<EthSchema.NotFound | EthSchema.TransactionInfo> {
-    return await this.client.call(
-      Methods.eth_getTransactionByBlockHashAndIndex,
-      [blockHash, transactionIndex]
-    );
-  }
-  async eth_getTransactionReceipt(
-    transactionHash: EthSchema.Hash32,
-  ): Promise<EthSchema.NotFound | EthSchema.ReceiptInfo> {
-    return await this.client.call(
-      Methods.eth_getTransactionReceipt,
-      [transactionHash]
-    );
-  }
+	// eth/transaction
+	async eth_getTransactionByHash(
+		transactioHash: Hash32,
+	): Promise<NotFound | TransactionInfo> {
+		return await this.client.call(Methods.eth_getTransactionByHash, [
+			transactioHash,
+		]);
+	}
+	async eth_getTransactionByBlockHashAndIndex(
+		blockHash: Hash32,
+		transactionIndex: Uint,
+	): Promise<NotFound | TransactionInfo> {
+		return await this.client.call(
+			Methods.eth_getTransactionByBlockHashAndIndex,
+			[blockHash, transactionIndex],
+		);
+	}
+	async eth_getTransactionReceipt(
+		transactionHash: Hash32,
+	): Promise<NotFound | ReceiptInfo> {
+		return await this.client.call(Methods.eth_getTransactionReceipt, [
+			transactionHash,
+		]);
+	}
 
-  // eth/submit
-  async eth_sendTransaction(
-    transaction: EthSchema.GenericTransaction
-  ): Promise<EthSchema.Hash32> {
-    return await this.client.call(
-      Methods.eth_sendTransaction,
-      [transaction]
-    )
-  }
-  async eth_sendRawTransaction(
-    transaction: EthSchema.Bytes
-  ): Promise<EthSchema.Hash32> {
-    return await this.client.call(
-      Methods.eth_sendRawTransaction,
-      [transaction]
-    )
-  }
-  // eth/state
-  async eth_getBalance(
-    address: EthSchema.Address,
-    block: EthSchema.BlockNumberOrTagOrHash
-  ): Promise<EthSchema.Uint> {
-    return await this.client.call(
-      Methods.eth_getBalance,
-      [address, block]
-    )
-  }
-  async eth_getStorageAt(
-    address: EthSchema.Address,
-    storageSlot: EthSchema.Bytes32,
-    block: EthSchema.BlockNumberOrTagOrHash
-  ): Promise<EthSchema.Bytes> {
-    return await this.client.call(
-      Methods.eth_getStorageAt,
-      [address, storageSlot, block]
-    )
-  }
-  async eth_getTransactionCount(
-    address: EthSchema.Address,
-    block: EthSchema.BlockNumberOrTagOrHash
-  ): Promise<EthSchema.Uint> {
-    return await this.client.call(
-      Methods.eth_getTransactionCount,
-      [address, block]
-    )
-  }
-  async eth_getCode(
-    address: EthSchema.Address,
-    block: EthSchema.BlockNumberOrTagOrHash
-  ): Promise<EthSchema.Bytes> {
-    return await this.client.call(
-      Methods.eth_getCode,
-      [address, block]
-    )
-  }
-  async eth_getProof(
-    address: EthSchema.Address,
-    storageKeys: EthSchema.Bytes32[],
-    block: EthSchema.BlockNumberOrTagOrHash,
-  ): Promise<EthSchema.AccountProof> {
-    return await this.client.call(
-      Methods.eth_getProof,
-      [address, storageKeys, block]
-    )
-  }
-  // eth/sign
-  async eth_sign(
-    address: EthSchema.Address,
-    message: EthSchema.Bytes
-  ): Promise<EthSchema.Bytes65> {
-    return await this.client.call(
-      Methods.eth_sign,
-      [address, message]
-    )
-  }
-  async eth_signTransaction(
-    transaction: EthSchema.GenericTransaction
-  ): Promise<EthSchema.Bytes> {
-    return await this.client.call(
-      Methods.eth_signTransaction,
-      [transaction]
-    )
-  }
-  // eth/filter
-  async eth_newFilter(
-    filter: EthSchema.Filter
-  ): Promise<EthSchema.Uint> {
-    return await this.client.call(
-      Methods.eth_newFilter,
-      [filter],
-    )
-  }
-  async eth_newBlockFilter(
-  ): Promise<EthSchema.Uint> {
-    return await this.client.call(
-      Methods.eth_newBlockFilter,
-      [],
-    )
-  }
-  async eth_newPendingTransactionFilter(
-  ): Promise<EthSchema.Uint> {
-    return await this.client.call(
-      Methods.eth_newPendingTransactionFilter,
-      []
-    )
-  }
-  async eth_uninstallFilter(
-  ): Promise<EthSchema.Uint> {
-    return await this.client.call(
-      Methods.eth_uninstallFilter,
-      []
-    )
-  }
-  async eth_getFilterChanges(
-  ): Promise<EthSchema.FilterResults> {
-    return await this.client.call(
-      Methods.eth_getFilterChanges,
-      []
-    )
-  }
-  async eth_getFilterLogs(
-    filterIdentifier: EthSchema.Uint
-  ): Promise<EthSchema.FilterResults> {
-    return await this.client.call(
-      Methods.eth_getFilterLogs,
-      [filterIdentifier]
-    )
-  }
-  async eth_getLogs(
-    filter: EthSchema.Filter
-  ): Promise<EthSchema.FilterResults> {
-    return await this.client.call(
-      Methods.eth_getLogs,
-      [filter]
-    )
-  }
+	// eth/submit
+	async eth_sendTransaction(transaction: GenericTransaction): Promise<Hash32> {
+		return await this.client.call(Methods.eth_sendTransaction, [transaction]);
+	}
+	async eth_sendRawTransaction(transaction: Bytes): Promise<Hash32> {
+		return await this.client.call(Methods.eth_sendRawTransaction, [
+			transaction,
+		]);
+	}
+	// eth/state
+	async eth_getBalance(
+		address: Address,
+		block: BlockNumberOrTagOrHash,
+	): Promise<Uint> {
+		return await this.client.call(Methods.eth_getBalance, [address, block]);
+	}
+	async eth_getStorageAt(
+		address: Address,
+		storageSlot: Bytes32,
+		block: BlockNumberOrTagOrHash,
+	): Promise<Bytes> {
+		return await this.client.call(Methods.eth_getStorageAt, [
+			address,
+			storageSlot,
+			block,
+		]);
+	}
+	async eth_getTransactionCount(
+		address: Address,
+		block: BlockNumberOrTagOrHash,
+	): Promise<Uint> {
+		return await this.client.call(Methods.eth_getTransactionCount, [
+			address,
+			block,
+		]);
+	}
+	async eth_getCode(
+		address: Address,
+		block: BlockNumberOrTagOrHash,
+	): Promise<Bytes> {
+		return await this.client.call(Methods.eth_getCode, [address, block]);
+	}
+	async eth_getProof(
+		address: Address,
+		storageKeys: Bytes32[],
+		block: BlockNumberOrTagOrHash,
+	): Promise<AccountProof> {
+		return await this.client.call(Methods.eth_getProof, [
+			address,
+			storageKeys,
+			block,
+		]);
+	}
+	// eth/sign
+	async eth_sign(address: Address, message: Bytes): Promise<Bytes65> {
+		return await this.client.call(Methods.eth_sign, [address, message]);
+	}
+	async eth_signTransaction(transaction: GenericTransaction): Promise<Bytes> {
+		return await this.client.call(Methods.eth_signTransaction, [transaction]);
+	}
+	// eth/filter
+	async eth_newFilter(filter: Filter): Promise<Uint> {
+		return await this.client.call(Methods.eth_newFilter, [filter]);
+	}
+	async eth_newBlockFilter(): Promise<Uint> {
+		return await this.client.call(Methods.eth_newBlockFilter, []);
+	}
+	async eth_newPendingTransactionFilter(): Promise<Uint> {
+		return await this.client.call(Methods.eth_newPendingTransactionFilter, []);
+	}
+	async eth_uninstallFilter(): Promise<Uint> {
+		return await this.client.call(Methods.eth_uninstallFilter, []);
+	}
+	async eth_getFilterChanges(): Promise<FilterResults> {
+		return await this.client.call(Methods.eth_getFilterChanges, []);
+	}
+	async eth_getFilterLogs(filterIdentifier: Uint): Promise<FilterResults> {
+		return await this.client.call(Methods.eth_getFilterLogs, [
+			filterIdentifier,
+		]);
+	}
+	async eth_getLogs(filter: Filter): Promise<FilterResults> {
+		return await this.client.call(Methods.eth_getLogs, [filter]);
+	}
+	// eth/feeMarket
+	async eth_gasPrice(): Promise<Uint> {
+		return await this.client.call(Methods.eth_gasPrice, []);
+	}
+	async eth_blobBaseFee(): Promise<Uint> {
+		return await this.client.call(Methods.eth_blobBaseFee, []);
+	}
+	async eth_maxPriorityFeePerGas(): Promise<Uint> {
+		return await this.client.call(Methods.eth_maxPriorityFeePerGas, []);
+	}
+	async eth_feeHistory(
+		blockCount: Uint,
+		newestBlock: BlockNumberOrTag,
+		rewardPercentiles: number[],
+	): Promise<FeeHistoryResults> {
+		return await this.client.call(Methods.eth_feeHistory, [
+			blockCount,
+			newestBlock,
+			rewardPercentiles,
+		]);
+	}
+	// eth/execute
+	async eth_call(
+		transaction: GenericTransaction,
+		block: BlockNumberOrTagOrHash,
+	): Promise<Bytes> {
+		return this.client.call(Methods.eth_call, [transaction, block]);
+	}
+	async eth_estimateGas(
+		transaction: GenericTransaction,
+		block: BlockNumberOrTag,
+	): Promise<Uint> {
+		return await this.client.call(Methods.eth_estimateGas, [
+			transaction,
+			block,
+		]);
+	}
+	async eth_createAccessList(
+		transaction: GenericTransaction,
+		block: BlockNumberOrTag,
+	): Promise<AccessListResult> {
+		return await this.client.call(Methods.eth_createAccessList, [
+			transaction,
+			block,
+		]);
+	}
+	async eth_simulateV1(
+		payload: EthSimulatePayload,
+		blockTag: BlockNumberOrTagOrHash,
+	): Promise<EthSimulateResult> {
+		return await this.client.call(Methods.eth_simulateV1, [payload, blockTag]);
+	}
+	// eth/client
+	async eth_chainId(): Promise<Uint> {
+		return await this.client.call(Methods.eth_chainId, []);
+	}
+	async eth_syncing(): Promise<SyncingStatus> {
+		return await this.client.call(Methods.eth_syncing, []);
+	}
+	async eth_coinbase(): Promise<Address> {
+		return await this.client.call(Methods.eth_coinbase, []);
+	}
+	async eth_accounts(): Promise<Addresses> {
+		return await this.client.call(Methods.eth_accounts, []);
+	}
+	async eth_blockNumber(): Promise<Uint> {
+		return await this.client.call(Methods.eth_blockNumber, []);
+	}
+	async net_version(): Promise<UintDecimal> {
+		return await this.client.call(Methods.net_version, []);
+	}
+	// eth/block
+	async eth_getBlockByHash(
+		blockHash: Hash32,
+		hydratedTransactions: boolean,
+	): Promise<NotFound | Block> {
+		return await this.client.call(Methods.eth_getBlockByHash, [
+			blockHash,
+			hydratedTransactions,
+		]);
+	}
+	async eth_getBlockByNumber(
+		block: BlockNumberOrTag,
+		hydratedTransactions: boolean,
+	): Promise<NotFound | Block> {
+		return await this.client.call(Methods.eth_getBlockByNumber, [
+			block,
+			hydratedTransactions,
+		]);
+	}
+	async eth_getBlockTransactionCountByHash(
+		blockHash: Hash32,
+	): Promise<NotFound | Uint> {
+		return await this.client.call(Methods.eth_getBlockTransactionCountByHash, [
+			blockHash,
+		]);
+	}
+	async eth_getBlockTransactionCountByNumber(
+		block: BlockNumberOrTag,
+	): Promise<NotFound | Uint> {
+		return await this.client.call(
+			Methods.eth_getBlockTransactionCountByNumber,
+			[block],
+		);
+	}
+	async eth_getUncleCountByBlockHash(
+		blockHash: Hash32,
+	): Promise<NotFound | Uint> {
+		return await this.client.call(Methods.eth_getUncleCountByBlockHash, [
+			blockHash,
+		]);
+	}
+	async eth_getUncleCountByBlockNumber(
+		block: BlockNumberOrTag,
+	): Promise<NotFound | Uint> {
+		return await this.client.call(Methods.eth_getUncleCountByBlockNumber, [
+			block,
+		]);
+	}
+	async eth_getBlockReceipts(
+		block: BlockNumberOrTagOrHash,
+	): Promise<NotFound | ReceiptInfo> {
+		return await this.client.call(Methods.eth_getBlockReceipts, [block]);
+	}
 }

package/src/index.ts

@@ -1,3 +1,2 @@
-export * from "./types";
-export * from "./eth-methods";
 export * from "./beacon-methods";
+export * from "./eth-methods";

package/src/types/base.d.ts

@@ -0,0 +1,23 @@
+declare global {
+	// base.yaml
+	export type Hex = `0x${string}`;
+	export type Address = `0x${string}`;
+	export type Addresses = Address[];
+	export type Byte = Hex;
+	export type Bytes = Hex;
+	export type Bytes32 = Hex;
+	export type Bytes8 = Hex;
+	export type Bytes48 = Hex;
+	export type Bytes96 = Hex;
+	export type Bytes256 = Hex;
+	export type Bytes65 = Hex;
+	export type Ratio = number;
+	export type Uint = Hex;
+	export type Uint64 = Hex;
+	export type Uint256 = Hex;
+	export type UintDecimal = string; // e.g '1'
+	export type Hash32 = Hex;
+	export type NotFound = null;
+}
+
+export { };

package/src/types/block.d.ts

@@ -0,0 +1,46 @@
+declare global {
+	// block.yaml
+	export type BlockTag =
+		| "earliest"
+		| "finalized"
+		| "safe"
+		| "latest"
+		| "pending";
+	export type BlockNumberOrTag = Hex | BlockTag;
+	export type BlockNumberOrTagOrHash = BlockNumberOrTag | Hex;
+	export interface Block {
+		hash: Hash32;
+		parentHash: Hash32;
+		sha3Uncles: Hash32;
+		miner: Address;
+		stateRoot: Hash32;
+		transactionsRoot: Hash32;
+		receiptsRoot: Hash32;
+		logsBloom: Bytes256;
+		number: Uint;
+		gasLimit: Uint;
+		gasUsed: Uint;
+		timestamp: Uint;
+		extraData: Bytes;
+		mixHash: Hash32;
+		nonce: Bytes8;
+		size: Uint;
+		transactions: Hash32[] | TransactionInfo[];
+		uncles: Hash32[];
+		requestedHash?: Hash32;
+		baseFeePerGas?: Uint;
+		withdrawalsRoot?: Hash32;
+		blobGasUsed?: Uint;
+		excessBlobGas?: Uint;
+		parentBeaconBlockRoot?: Hash32;
+		withdrawals?: Withdrawal[];
+		difficulty?: Uint;
+	}
+	export interface BadBlock {
+		block: Block;
+		hash: Hash32;
+		rlp: Bytes;
+	}
+}
+
+export { };

package/src/types/client.d.ts

@@ -0,0 +1,11 @@
+declare global {
+	// client.yaml
+	export type SyncingStatus = Syncing | false;
+	export interface Syncing {
+		startingBlock?: Uint;
+		currentBlock?: Uint;
+		highestBlock?: Uint;
+	}
+}
+
+export { };