@asyncswap/eth-rpc 0.3.0

package/src/eth-api.ts

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

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./engine-api";
+export * from "./eth-api";

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 { };

package/src/types/debug/methods.d.ts

@@ -0,0 +1,11 @@
+declare global {
+	export enum DebugMethods {
+		debug_getRawHeader = "debug_getRawHeader",
+		debug_getRawBlock = "debug_getRawBlock",
+		debug_getRawTransaction = "debug_getRawTransaction",
+		debug_getRawReceipts = "debug_getRawReceipts",
+		debug_getBadBlocks = "debug_getBadBlocks",
+	}
+}
+
+export { };

package/src/types/engine/blob.d.ts

@@ -0,0 +1,12 @@
+declare global {
+	export interface BlobAndProofV1 {
+		blob: Bytes;
+		proof: Bytes48;
+	}
+	export interface BlobAndProofV2 {
+		blob: Bytes;
+		proofs: Bytes48[];
+	}
+}
+
+export { };

package/src/types/engine/forkchoice.d.ts

@@ -0,0 +1,32 @@
+declare global {
+	// forkchoice
+	export interface ForkchoiceStateV1 {
+		headBlockHash: Hash32;
+		safeBlockHash: Hash32;
+		finalizedBlockHash: Hash32;
+	}
+	export interface ForkchoiceUpdatedResponseV1 {
+		payloadStatus: RestrictedPayloadStatusV1;
+		payloadId?: Bytes8;
+	}
+	export interface PayloadAttributesV1 {
+		timestamp: Uint64;
+		prevRandao: Bytes32;
+		suggestedFeeRecipient: Address;
+	}
+	export interface PayloadAttributesV2 {
+		timestamp: Uint64;
+		prevRandao: Bytes32;
+		suggestedFeeRecipient: Address;
+		withdrawals: WithdrawalV1[];
+	}
+	export interface PayloadAttributesV3 {
+		timestamp: Uint64;
+		prevRandao: Bytes32;
+		suggestedFeeRecipient: Address;
+		withdrawals: WithdrawalV1[];
+		parentBeaconBlockRoot: Hash32;
+	}
+}
+
+export { };

package/src/types/engine/methods.d.ts

@@ -0,0 +1,42 @@
+declare global {
+	export enum EngineMethods {
+		// eth_methods
+		eth_blockNumber = "eth_blockNumber",
+		eth_call = "eth_call",
+		eth_chainId = "eth_chainId",
+		eth_getCode = "eth_getCode",
+		eth_getBlockByHash = "eth_getBlockByHash",
+		eth_getBlockByNumber = "eth_getBlockByNumber",
+		eth_getLogs = "eth_getLogs",
+		eth_sendRawTransaction = "eth_sendRawTransaction",
+		eth_syncing = "eth_syncing",
+		// engine/blob
+		engine_getBlobsV1 = "engine_getBlobsV1",
+		engine_getBlobsV2 = "engine_getBlobsV2",
+		engine_getBlobsV3 = "engine_getBlobsV3",
+		// engine/capabilities
+		engine_exchangeCapabilities = "engine_exchangeCapabilities",
+		// engine/forkchoice
+		engine_forkchoiceUpdatedV1 = "engine_forkchoiceUpdatedV1",
+		engine_forkchoiceUpdatedV2 = "engine_forkchoiceUpdatedV2",
+		engine_forkchoiceUpdatedV3 = "engine_forkchoiceUpdatedV3",
+		// engine/payload
+		engine_newPayloadV1 = "engine_newPayloadV1",
+		engine_newPayloadV2 = "engine_newPayloadV2",
+		engine_newPayloadV3 = "engine_newPayloadV3",
+		engine_newPayloadV4 = "engine_newPayloadV4",
+		engine_getPayloadV1 = "engine_getPayloadV1",
+		engine_getPayloadV2 = "engine_getPayloadV2",
+		engine_getPayloadV3 = "engine_getPayloadV3",
+		engine_getPayloadV4 = "engine_getPayloadV4",
+		engine_getPayloadV5 = "engine_getPayloadV5",
+		engine_getPayloadBodiesByHashV1 = "engine_getPayloadBodiesByHashV1",
+		engine_getPayloadBodiesByRangeV1 = "engine_getPayloadBodiesByRangeV1",
+		engine_newPayloadV5 = "engine_newPayloadV5",
+		engine_getPayloadV6 = "engine_getPayloadV6",
+		// engine/transition-configuration
+		engine_exchangeTransitionConfigurationV1 = "engine_exchangeTransitionConfigurationV1",
+	}
+}
+
+export { };

package/src/types/engine/payload.d.ts

@@ -0,0 +1,121 @@
+declare global {
+	export enum PAYLOAD_STATUS {
+		VALID = "VALID",
+		INVALID = "INVALID",
+		SYNCING = "SYNCING",
+		ACCEPTED = "ACCEPTED",
+		INVALID_BLOCK_HASH = "INVALID_BLOCK_HASH",
+	}
+	export interface PayloadStatusV1 {
+		status: PAYLOAD_STATUS;
+		latestValidHash?: Hash32;
+		validationError?: string;
+	}
+	export interface RestrictedPayloadStatusV1 {
+		status:
+		| PAYLOAD_STATUS.VALID
+		| PAYLOAD_STATUS.INVALID
+		| PAYLOAD_STATUS.SYNCING;
+		latestValidHash: Hash32;
+		validationError: string;
+	}
+	export interface PayloadStatusNoInvalidBlockHash {
+		status: Exclude<PAYLOAD_STATUS, PAYLOAD_STATUS.INVALID_BLOCK_HASH>;
+		latestValidHash: Hash32;
+		validationError: string;
+	}
+	export interface ExecutionPayloadV1 {
+		parentHash: Hash32;
+		feeRecipient: Address;
+		stateRoot: Hash32;
+		receiptsRoot: Hash32;
+		logsBloom: Bytes256;
+		prevRandao: Bytes32;
+		blockNumber: Uint64;
+		gasLimit: Uint64;
+		gasUsed: Uint64;
+		timestamp: Uint64;
+		extraData: Bytes32;
+		baseFeePerGas: Uint64;
+		blockHash: Hash32;
+		transactions: Bytes[];
+	}
+	export interface WithdrawalV1 {
+		index: Uint64;
+		validatorIndex: Uint64;
+		address: Address;
+		amount: Uint64;
+	}
+	export interface ExecutionPayloadV2 {
+		parentHash: Hash32;
+		feeRecipient: Address;
+		stateRoot: Hash32;
+		receiptsRoot: Hash32;
+		logsBloom: Bytes256;
+		prevRandao: Bytes32;
+		blockNumber: Uint64;
+		gasLimit: Uint64;
+		gasUsed: Uint64;
+		timestamp: Uint64;
+		extraData: Bytes32;
+		baseFeePerGas: Uint64;
+		blockHash: Hash32;
+		transactions: Bytes[];
+		withdrawals: WithdrawalV1[];
+	}
+	export interface ExecutionPayloadV3 {
+		parentHash: Hash32;
+		feeRecipient: Address;
+		stateRoot: Hash32;
+		receiptsRoot: Hash32;
+		logsBloom: Bytes256;
+		prevRandao: Bytes32;
+		blockNumber: Uint64;
+		gasLimit: Uint64;
+		gasUsed: Uint64;
+		timestamp: Uint64;
+		extraData: Bytes32;
+		baseFeePerGas: Uint64;
+		blockHash: Hash32;
+		transactions: Bytes[];
+		withdrawals: WithdrawalV1[];
+		blobGasUsed: Uint64;
+		excessBlobGas: Uint64;
+	}
+	export interface ExecutionPayloadV4 {
+		parentHash: Hash32;
+		feeRecipient: Address;
+		stateRoot: Hash32;
+		receiptsRoot: Hash32;
+		logsBloom: Bytes256;
+		prevRandao: Bytes32;
+		blockNumber: Uint64;
+		gasLimit: Uint64;
+		gasUsed: Uint64;
+		timestamp: Uint64;
+		extraData: Bytes32;
+		baseFeePerGas: Uint64;
+		blockHash: Hash32;
+		transactions: Bytes[];
+		withdrawals: WithdrawalV1[];
+		blobGasUsed: Uint64;
+		excessBlobGas: Uint64;
+		blockAccessList: Bytes;
+	}
+	export interface ExecutionPayloadBodyV1 {
+		transactions: Bytes[];
+		withdrawals?: WithdrawalV1[];
+	}
+	export interface BlobsBundleV1 {
+		commitments: Bytes48[];
+		proofs: Bytes48[];
+		blobs: Bytes[];
+	}
+	export interface BlobsBundleV2 {
+		commitments: Bytes48[];
+		proofs: Bytes48[];
+		blobs: Bytes[];
+	}
+}
+
+export { };

package/src/types/engine/transition-configuration.d.ts

@@ -0,0 +1,10 @@
+declare global {
+	// engine types
+	export interface TransitionConfigurationV1 {
+		terminalTotalDifficulty: Uint256;
+		terminalBlockHash: Hash32;
+		terminalBlockNumber: Uint64;
+	}
+}
+
+export { };

package/src/types/eth/methods.d.ts

@@ -0,0 +1,55 @@
+declare global {
+	export enum EthMethods {
+		// 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 { };