@asyncswap/eth-rpc 0.4.2 → 0.4.3

package/src/eth-api.ts

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

package/src/mev-api.ts

@@ -1,155 +1,28 @@
-import { EthExecutionClient } from "./eth-api";
+import { JsonRpcClient } from "@asyncswap/jsonrpc";
+
+export type FlashbotsRpcMethods<
+	T extends Record<string, { params: unknown[]; result: unknown }>,
+> = {
+		[M in keyof T]: (...params: T[M]["params"]) => Promise<T[M]["result"]>;
+	};
+
+export class FlashbotsClient {
+	rpc: JsonRpcClient;
+	private headers: Record<string, string> = {};
 
-export class EthFlashbotsClient extends EthExecutionClient {
 	constructor(url: string) {
-		super(url);
-	}
+		this.rpc = new JsonRpcClient(url);
 
-	getFlashbotsHeader(
-		address: Address,
-		signature: Bytes32,
-	): Record<string, string> {
-		return {
-			"X-Flashbots-Signature": `${address}:${signature}`,
-		};
-	}
-	async eth_sendBundle(
-		sendBundleParams: EthSendBundleParams,
-		signature?: Bytes32,
-		sender?: Address,
-	): Promise<EthSendBundleResult> {
-		if (signature && sender) {
-			return this.rpc.call(
-				FlashbotsMethods.eth_sendBundle,
-				[sendBundleParams],
-				this.getFlashbotsHeader(sender, signature),
-			);
-		}
-		return await this.rpc.call(FlashbotsMethods.eth_sendBundle, [
-			sendBundleParams,
-		]);
-	}
-	async eth_callBundle(
-		callBundleParams: EthCallBundleParams,
-	): Promise<EthCallBundleResult> {
-		return await this.rpc.call(FlashbotsMethods.eth_callBundle, [
-			callBundleParams,
-		]);
-	}
-	async mev_sendBundle(
-		sendBundleParams: MevSendBundleParams,
-	): Promise<MevSendBundleResult> {
-		return await this.rpc.call(FlashbotsMethods.mev_sendBundle, [
-			sendBundleParams,
-		]);
-	}
-	async mev_simBundle(
-		simBundleParams: MevSimBundleParams,
-		parentBlock?: { parentBlock: Hash32 },
-	): Promise<MevSimBundleResult> {
-		return await this.rpc.call(FlashbotsMethods.mev_simBundle, [
-			simBundleParams,
-			parentBlock,
-		]);
-	}
-	async eth_cancelBundle(
-		cancelParams: EthCancelBundleParams,
-	): Promise<EthCancelBundleResult> {
-		return await this.rpc.call(FlashbotsMethods.eth_cancelBundle, [
-			cancelParams,
-		]);
-	}
-	async eth_sendPrivateTransaction(
-		sendPrivateTransactionParams: EthSendPrivateTransactionParams,
-	): Promise<EthSendPrivateTransactionResult> {
-		return await this.rpc.call(FlashbotsMethods.eth_sendPrivateTransaction, [
-			sendPrivateTransactionParams,
-		]);
-	}
-	async eth_sendPrivateRawTransaction(
-		sendPrivateRawTransactionParams: EthSendPrivateRawTransactionParams,
-	): Promise<EthSendPrivateRawTransactionResult> {
-		return await this.rpc.call(FlashbotsMethods.eth_sendPrivateRawTransaction, [
-			sendPrivateRawTransactionParams,
-		]);
-	}
-	async eth_cancelPrivateTransaction(
-		cancelPrivateTransactionParams: EthCancelPrivateTransactioParams,
-	): Promise<EthCancelPrivateTransactionResult> {
-		return await this.rpc.call(FlashbotsMethods.eth_cancelPrivateTransaction, [
-			cancelPrivateTransactionParams,
-		]);
-	}
-	async flashbots_getFeeRefundTotalsByRecipient(
-		params: GetFeeRefundTotalsByRecipientParams,
-	): Promise<GetFeeRefundTotalsByRecipientResult> {
-		return await this.rpc.call(
-			FlashbotsMethods.flashbots_getFeeRefundTotalsByRecipient,
-			[params],
-		);
-	}
-	async flashbots_getFeeRefundsByRecipient(
-		params: GetFeeRefundsByRecipientParams,
-	): Promise<GetFeeRefundsByRecipientResult> {
-		return await this.rpc.call(
-			FlashbotsMethods.flashbots_getFeeRefundsByRecipient,
-			[params],
-		);
-	}
-	async flashbots_getFeeRefundsByBundle(
-		params: GetFeeRefundsByBundleParams,
-	): Promise<GetFeeRefundsByBundleResult> {
-		return await this.rpc.call(
-			FlashbotsMethods.flashbots_getFeeRefundsByBundle,
-			[params],
-		);
-	}
-	async flashbots_getFeeRefundsByBlock(
-		params: GetFeeRefundsByBlockParams,
-	): Promise<GetFeeRefundsByBlockResult> {
-		return await this.rpc.call(
-			FlashbotsMethods.flashbots_getFeeRefundsByBlock,
-			[params],
-		);
-	}
-	async flashbots_setFeeRefundRecipient(
-		user: Address,
-		delegate: Address,
-	): Promise<{ from: Address; to: Address }> {
-		return await this.rpc.call(
-			FlashbotsMethods.flashbots_setFeeRefundRecipient,
-			[user, delegate],
-		);
-	}
-	async buildernet_getDelayedRefunds(
-		params: GetDelayedRefundsParams,
-	): Promise<GetDelayedRefundsResult> {
-		return await this.rpc.call(FlashbotsMethods.buildernet_getDelayedRefunds, [
-			params,
-		]);
-	}
-	async buildernet_getDelayedRefundTotalsByRecipient(
-		params: GetDelayedRefundTotalsByRecipientParams,
-	): Promise<GetDelayedRefundTotalsByRecipientResult> {
-		return await this.rpc.call(
-			FlashbotsMethods.buildernet_getDelayedRefundTotalsByRecipient,
-			[params],
-		);
-	}
-	async flashbots_getMevRefundTotalByRecipient(
-		user: Address,
-	): Promise<{ total: Hex }> {
-		return await this.rpc.call(
-			FlashbotsMethods.flashbots_getMevRefundTotalByRecipient,
-			[user],
-		);
-	}
-	async flashbots_getMevRefundTotalBySender(
-		sender: Address,
-	): Promise<{ total: Hex }> {
-		return await this.rpc.call(
-			FlashbotsMethods.flashbots_getMevRefundTotalBySender,
-			[sender],
-		);
+		return new Proxy(this, {
+			get: (_, method: string) => {
+				return (...params: unknown[]) =>
+					this.rpc.call(this.rpc.buildRequest(method, params), this.headers);
+			},
+		});
 	}
+
+	// "X-Flashbots-Signature": `${sender}:${signature}`,
 }
+
+export interface FlashbotsClient
+	extends FlashbotsRpcMethods<FlashbotsMethodsSpec> { }

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

@@ -1,11 +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 type DebugMethods = {
+		debug_getRawHeader: { params: [BlockNumberOrTag]; result: Bytes };
+		debug_getRawBlock: { params: [BlockNumberOrTag]; result: Bytes };
+		debug_getRawTransaction: { params: [Hash32]; result: Bytes };
+		debug_getRawReceipts: { params: [BlockNumberOrTag]; result: Bytes[] };
+		debug_getBadBlocks: { params: []; result: BadBlock[] };
+	};
 }
 
 export { };

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

@@ -1,42 +1,124 @@
 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",
+	export type EngineMethodsSpec = {
+		eth_blockNumber: { params: []; result: Uint };
+		eth_call: {
+			params: [GenericTransaction, BlockNumberOrTagOrHash];
+			result: Bytes;
+		};
+		eth_chainId: { params: []; result: Uint };
+		eth_getCode: { params: [Address, BlockNumberOrTagOrHash]; result: Bytes };
+		eth_getBlockByHash: { params: [Hash32, boolean]; result: NotFound | Block };
+		eth_getBlockByNumber: {
+			params: [BlockNumberOrTag, boolean];
+			result: NotFound | Block;
+		};
+		eth_getLogs: { params: [Filter]; result: FilterResults };
+		eth_sendRawTransaction: { params: [Bytes]; result: Hash32 };
+		eth_syncing: { params: []; result: SyncingStatus };
 		// engine/blob
-		engine_getBlobsV1 = "engine_getBlobsV1",
-		engine_getBlobsV2 = "engine_getBlobsV2",
-		engine_getBlobsV3 = "engine_getBlobsV3",
+		engine_getBlobsV1: { params: [Hash32[]]; result: BlobAndProofV1[] };
+		engine_getBlobsV2: { params: [Hash32[]]; result: BlobAndProofV2[] };
+		engine_getBlobsV3: {
+			params: [Hash32[]];
+			result: Array<BlobAndProofV2[] | null> | null;
+		};
 		// engine/capabilities
-		engine_exchangeCapabilities = "engine_exchangeCapabilities",
+		engine_exchangeCapabilities: { params: [string[]]; result: string[] };
 		// engine/forkchoice
-		engine_forkchoiceUpdatedV1 = "engine_forkchoiceUpdatedV1",
-		engine_forkchoiceUpdatedV2 = "engine_forkchoiceUpdatedV2",
-		engine_forkchoiceUpdatedV3 = "engine_forkchoiceUpdatedV3",
+		engine_forkchoiceUpdatedV1: {
+			params: [ForkchoiceStateV1, PayloadAttributesV1];
+			result: ForkchoiceUpdatedResponseV1;
+		};
+		engine_forkchoiceUpdatedV2: {
+			params: [ForkchoiceStateV1, PayloadAttributesV2];
+			result: ForkchoiceUpdatedResponseV1;
+		};
+		engine_forkchoiceUpdatedV3: {
+			params: [ForkchoiceStateV1, PayloadAttributesV3];
+			result: ForkchoiceUpdatedResponseV1;
+		};
 		// 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_newPayloadV1: {
+			params: [ExecutionPayloadV1];
+			result: PayloadStatusV1;
+		};
+		engine_newPayloadV2: {
+			params: [ExecutionPayloadV1 | ExecutionPayloadV2];
+			result: PayloadStatusNoInvalidBlockHash;
+		};
+		engine_newPayloadV3: {
+			params: [ExecutionPayloadV3, Hash32[], Hash32];
+			result: PayloadStatusNoInvalidBlockHash;
+		};
+		engine_newPayloadV4: {
+			params: [ExecutionPayloadV3, Hash32[], Hash32, Bytes[]];
+			result: PayloadStatusNoInvalidBlockHash;
+		};
+		engine_getPayloadV1: { params: [Bytes8]; result: ExecutionPayloadV1 };
+		engine_getPayloadV2: {
+			params: [Bytes8];
+			result: {
+				executionPayload: ExecutionPayloadV1 | ExecutionPayloadV2;
+				blockValue: Uint256;
+			};
+		};
+		engine_getPayloadV3: {
+			params: [Bytes8];
+			result: {
+				executionPayload: ExecutionPayloadV3;
+				blockValue: Uint256;
+				blobsBundle: BlobsBundleV1;
+				shouldOverrideBuilder: boolean;
+			};
+		};
+		engine_getPayloadV4: {
+			params: [Bytes8];
+			result: {
+				executionPayload: ExecutionPayloadV3;
+				blockValue: Uint256;
+				blobsBundle: BlobsBundleV1;
+				shouldOverrideBuilder: boolean;
+				executionRequests: Bytes[];
+			};
+		};
+		engine_getPayloadV5: {
+			params: [Bytes8];
+			result: {
+				executionPayload: ExecutionPayloadV3;
+				blockValue: Uint256;
+				blobsBundle: BlobsBundleV2;
+				shouldOverrideBuilder: boolean;
+				executionRequests: Bytes[];
+			};
+		};
+		engine_getPayloadBodiesByHashV1: {
+			params: [Hash32[]];
+			result: ExecutionPayloadBodyV1[];
+		};
+		engine_getPayloadBodiesByRangeV1: {
+			params: [Uint64, Uint64];
+			result: ExecutionPayloadBodyV1[];
+		};
+		engine_newPayloadV5: {
+			params: [ExecutionPayloadV4, Hash32[], Hash32, Bytes[]];
+			result: PayloadStatusNoInvalidBlockHash;
+		};
+		engine_getPayloadV6: {
+			params: [Bytes8];
+			result: {
+				executionPayload: ExecutionPayloadV4;
+				blockValue: Uint256;
+				blobsBundle: BlobsBundleV2;
+				shouldOverrideBuilder: boolean;
+				executionRequests: Bytes[];
+			};
+		};
 		// engine/transition-configuration
-		engine_exchangeTransitionConfigurationV1 = "engine_exchangeTransitionConfigurationV1",
-	}
+		engine_exchangeTransitionConfigurationV1: {
+			params: [TransitionConfigurationV1];
+			result: TransitionConfigurationV1;
+		};
+	};
 }
 
 export { };