@asyncswap/eth-rpc 0.3.0 → 0.4.0

package/README.md

@@ -36,3 +36,23 @@ const payload = engine.engine_getPayloadV1("0x1");
 
 console.log(payload);
 ```
+
+## Builtin flashbots MEV rpc methods
+
+- [x] eth_sendBundle
+- [x] mev_sendBundle
+- [x] eth_callBundle
+- [x] eth_cancelBundle
+- [x] mev_simBundle
+- [x] eth_sendPrivateTransaction
+- [x] eth_sendPrivateRawTransaction
+- [x] eth_cancelPrivateTransaction
+- [x] flashbots_getFeeRefundTotalsByRecipient
+- [x] flashbots_getFeeRefundsByRecipient
+- [x] flashbots_getFeeRefundsByBundle
+- [x] flashbots_getFeeRefundsByBlock
+- [x] flashbots_setFeeRefundRecipient
+- [x] buildernet_getDelayedRefunds
+- [x] buildernet_getDelayedRefundTotalsByRecipient
+- [x] flashbots_getMevRefundTotalByRecipient
+- [x] flashbots_getMevRefundTotalBySender

package/example.ts

@@ -17,3 +17,8 @@ const engine = new EngineExecutionClient(engineUrl, process.env.JWT_TOKEN!);
 const payload = engine.engine_getPayloadV1("0x1");
 
 console.log(payload);
+
+import { EthFlashbotsClient } from "./src";
+
+const rpc = "https://relay.flashbots.net";
+const client = new EthFlashbotsClient(rpc);

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@asyncswap/eth-rpc",
 	"description": "A library for ethereum execution clients apis.",
 	"author": "Meek Msaki",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"license": "MIT",
 	"type": "module",
 	"main": "dist/index.js",
@@ -41,6 +41,6 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"@asyncswap/jsonrpc": "^0.3.0"
+		"@asyncswap/jsonrpc": "^0.4.0"
 	}
 }

package/src/engine-api.ts

@@ -1,147 +1,190 @@
-import { initializeRpcClient, JsonRpcClient } from "@asyncswap/jsonrpc";
+import { JsonRpcClient } from "@asyncswap/jsonrpc";
 
 export class EngineExecutionClient {
 	private client: JsonRpcClient;
+	private headers: Record<string, string>;
 
 	constructor(url: string, jwt_token: string) {
-		this.client = initializeRpcClient(url, jwt_token);
+		this.headers = {
+			Authorization: `Bearer ${jwt_token}`,
+		};
+		this.client = new JsonRpcClient(url);
 	}
 
 	// eth/transaction
 	async eth_sendRawTransaction(transaction: Bytes): Promise<Hash32> {
-		return await this.client.call(EngineMethods.eth_sendRawTransaction, [
-			transaction,
-		]);
+		return await this.client.call(
+			EngineMethods.eth_sendRawTransaction,
+			[transaction],
+			this.headers,
+		);
 	}
 	// eth/state
 	async eth_getCode(
 		address: Address,
 		block: BlockNumberOrTagOrHash,
 	): Promise<Bytes> {
-		return await this.client.call(EngineMethods.eth_getCode, [address, block]);
+		return await this.client.call(
+			EngineMethods.eth_getCode,
+			[address, block],
+			this.headers,
+		);
 	}
 	async eth_getLogs(filter: Filter): Promise<FilterResults> {
-		return await this.client.call(EngineMethods.eth_getLogs, [filter]);
+		return await this.client.call(
+			EngineMethods.eth_getLogs,
+			[filter],
+			this.headers,
+		);
 	}
 	// eth/execute
 	async eth_call(
 		transaction: GenericTransaction,
 		block: BlockNumberOrTagOrHash,
 	): Promise<Bytes> {
-		return this.client.call(EngineMethods.eth_call, [transaction, block]);
+		return this.client.call(
+			EngineMethods.eth_call,
+			[transaction, block],
+			this.headers,
+		);
 	}
 	// eth/client
 	async eth_chainId(): Promise<Uint> {
-		return await this.client.call(EngineMethods.eth_chainId, []);
+		return await this.client.call(EngineMethods.eth_chainId, [], this.headers);
 	}
 	async eth_syncing(): Promise<SyncingStatus> {
-		return await this.client.call(EngineMethods.eth_syncing, []);
+		return await this.client.call(EngineMethods.eth_syncing, [], this.headers);
 	}
 	async eth_blockNumber(): Promise<Uint> {
-		return await this.client.call(EngineMethods.eth_blockNumber, []);
+		return await this.client.call(
+			EngineMethods.eth_blockNumber,
+			[],
+			this.headers,
+		);
 	}
 	// eth/block
 	async eth_getBlockByHash(
 		blockHash: Hash32,
 		hydratedTransactions: boolean,
 	): Promise<NotFound | Block> {
-		return await this.client.call(EngineMethods.eth_getBlockByHash, [
-			blockHash,
-			hydratedTransactions,
-		]);
+		return await this.client.call(
+			EngineMethods.eth_getBlockByHash,
+			[blockHash, hydratedTransactions],
+			this.headers,
+		);
 	}
 	async eth_getBlockByNumber(
 		block: BlockNumberOrTag,
 		hydratedTransactions: boolean,
 	): Promise<NotFound | Block> {
-		return await this.client.call(EngineMethods.eth_getBlockByNumber, [
-			block,
-			hydratedTransactions,
-		]);
+		return await this.client.call(
+			EngineMethods.eth_getBlockByNumber,
+			[block, hydratedTransactions],
+			this.headers,
+		);
 	}
 	// engine/blob
 	async engine_getBlobsV1(
 		blobedVersionedHashes: Hash32[],
 	): Promise<BlobAndProofV1[]> {
-		return await this.client.call(EngineMethods.engine_getBlobsV1, [
-			blobedVersionedHashes,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getBlobsV1,
+			[blobedVersionedHashes],
+			this.headers,
+		);
 	}
 	async engine_getBlobsV2(
 		blobedVersionedHashes: Hash32[],
 	): Promise<BlobAndProofV2[]> {
-		return await this.client.call(EngineMethods.engine_getBlobsV2, [
-			blobedVersionedHashes,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getBlobsV2,
+			[blobedVersionedHashes],
+			this.headers,
+		);
 	}
 	async engine_getBlobsV3(
 		blobedVersionedHashes: Hash32[],
 	): Promise<Array<BlobAndProofV2[] | null> | null> {
-		return await this.client.call(EngineMethods.engine_getBlobsV3, [
-			blobedVersionedHashes,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getBlobsV3,
+			[blobedVersionedHashes],
+			this.headers,
+		);
 	}
 	// engine/capabilities
 	async engine_exchangeCapabilities(
 		consensusClientMethods: string[],
 	): Promise<string[]> {
-		return await this.client.call(EngineMethods.engine_exchangeCapabilities, [
-			consensusClientMethods,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_exchangeCapabilities,
+			[consensusClientMethods],
+			this.headers,
+		);
 	}
 	// engine/forkchoice
 	async engine_forkchoiceUpdatedV1(
 		forkchoiceState: ForkchoiceStateV1,
 		payloadAttribute: PayloadAttributesV1,
 	): Promise<ForkchoiceUpdatedResponseV1> {
-		return await this.client.call(EngineMethods.engine_forkchoiceUpdatedV1, [
-			forkchoiceState,
-			payloadAttribute,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_forkchoiceUpdatedV1,
+			[forkchoiceState, payloadAttribute],
+			this.headers,
+		);
 	}
 	async engine_forkchoiceUpdatedV2(
 		forkchoiceState: ForkchoiceStateV1,
 		payloadAttribute: PayloadAttributesV2,
 	): Promise<ForkchoiceUpdatedResponseV1> {
-		return await this.client.call(EngineMethods.engine_forkchoiceUpdatedV2, [
-			forkchoiceState,
-			payloadAttribute,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_forkchoiceUpdatedV2,
+			[forkchoiceState, payloadAttribute],
+			this.headers,
+		);
 	}
 	async engine_forkchoiceUpdatedV3(
 		forkchoiceState: ForkchoiceStateV1,
 		payloadAttribute: PayloadAttributesV3,
 	): Promise<ForkchoiceUpdatedResponseV1> {
-		return await this.client.call(EngineMethods.engine_forkchoiceUpdatedV3, [
-			forkchoiceState,
-			payloadAttribute,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_forkchoiceUpdatedV3,
+			[forkchoiceState, payloadAttribute],
+			this.headers,
+		);
 	}
 	// engine/payload
 	async engine_newPayloadV1(
 		executionPayload: ExecutionPayloadV1,
 	): Promise<PayloadStatusV1> {
-		return await this.client.call(EngineMethods.engine_newPayloadV1, [
-			executionPayload,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_newPayloadV1,
+			[executionPayload],
+			this.headers,
+		);
 	}
 	async engine_newPayloadV2(
 		executionPayload: ExecutionPayloadV1 | ExecutionPayloadV2,
 	): Promise<PayloadStatusNoInvalidBlockHash> {
-		return await this.client.call(EngineMethods.engine_newPayloadV2, [
-			executionPayload,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_newPayloadV2,
+			[executionPayload],
+			this.headers,
+		);
 	}
 	async engine_newPayloadV3(
 		executionPayload: ExecutionPayloadV3,
 		expectedBlobVersionedHashes: Hash32[],
 		rootOfTheParentBeaconBlock: Hash32,
 	): Promise<PayloadStatusNoInvalidBlockHash> {
-		return await this.client.call(EngineMethods.engine_newPayloadV3, [
-			executionPayload,
-			expectedBlobVersionedHashes,
-			rootOfTheParentBeaconBlock,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_newPayloadV3,
+			[
+				executionPayload,
+				expectedBlobVersionedHashes,
+				rootOfTheParentBeaconBlock,
+			],
+			this.headers,
+		);
 	}
 	async engine_newPayloadV4(
 		executionPayload: ExecutionPayloadV3,
@@ -149,25 +192,33 @@ export class EngineExecutionClient {
 		rootOfTheParentBeaconBlock: Hash32,
 		executionRequests: Bytes[],
 	): Promise<PayloadStatusNoInvalidBlockHash> {
-		return await this.client.call(EngineMethods.engine_newPayloadV4, [
-			executionPayload,
-			expectedBlobVersionedHashes,
-			rootOfTheParentBeaconBlock,
-			executionRequests,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_newPayloadV4,
+			[
+				executionPayload,
+				expectedBlobVersionedHashes,
+				rootOfTheParentBeaconBlock,
+				executionRequests,
+			],
+			this.headers,
+		);
 	}
 	async engine_getPayloadV1(payloadId: Bytes8): Promise<ExecutionPayloadV1> {
-		return await this.client.call(EngineMethods.engine_getPayloadV1, [
-			payloadId,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getPayloadV1,
+			[payloadId],
+			this.headers,
+		);
 	}
 	async engine_getPayloadV2(payloadId: Bytes8): Promise<{
 		executionPayload: ExecutionPayloadV1 | ExecutionPayloadV2;
 		blockValue: Uint256;
 	}> {
-		return await this.client.call(EngineMethods.engine_getPayloadV2, [
-			payloadId,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getPayloadV2,
+			[payloadId],
+			this.headers,
+		);
 	}
 	async engine_getPayloadV3(payloadId: Bytes8): Promise<{
 		executionPayload: ExecutionPayloadV3;
@@ -175,9 +226,11 @@ export class EngineExecutionClient {
 		blobsBundle: BlobsBundleV1;
 		shouldOverrideBuilder: boolean;
 	}> {
-		return await this.client.call(EngineMethods.engine_getPayloadV3, [
-			payloadId,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getPayloadV3,
+			[payloadId],
+			this.headers,
+		);
 	}
 	async engine_getPayloadV4(payloadId: Bytes8): Promise<{
 		executionPayload: ExecutionPayloadV3;
@@ -186,9 +239,11 @@ export class EngineExecutionClient {
 		shouldOverrideBuilder: boolean;
 		executionRequests: Bytes[];
 	}> {
-		return await this.client.call(EngineMethods.engine_getPayloadV4, [
-			payloadId,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getPayloadV4,
+			[payloadId],
+			this.headers,
+		);
 	}
 	async engine_getPayloadV5(payloadId: Bytes8): Promise<{
 		executionPayload: ExecutionPayloadV3;
@@ -197,9 +252,11 @@ export class EngineExecutionClient {
 		shouldOverrideBuilder: boolean;
 		executionRequests: Bytes[];
 	}> {
-		return await this.client.call(EngineMethods.engine_getPayloadV5, [
-			payloadId,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getPayloadV5,
+			[payloadId],
+			this.headers,
+		);
 	}
 	async engine_getPayloadBodiesByHashV1(
 		arrayOfBlockHashes: Hash32[],
@@ -207,6 +264,7 @@ export class EngineExecutionClient {
 		return await this.client.call(
 			EngineMethods.engine_getPayloadBodiesByHashV1,
 			[arrayOfBlockHashes],
+			this.headers,
 		);
 	}
 	async engine_getPayloadBodiesByRangeV1(
@@ -216,6 +274,7 @@ export class EngineExecutionClient {
 		return await this.client.call(
 			EngineMethods.engine_getPayloadBodiesByRangeV1,
 			[startingBlockNumber, numberOfBlocksToReturn],
+			this.headers,
 		);
 	}
 	async engine_newPayloadV5(
@@ -224,12 +283,16 @@ export class EngineExecutionClient {
 		parentBeaconBlockRoot: Hash32,
 		executionRequests: Bytes[],
 	): Promise<PayloadStatusNoInvalidBlockHash> {
-		return await this.client.call(EngineMethods.engine_newPayloadV5, [
-			executionPayload,
-			expectedBlobVersionedHashes,
-			parentBeaconBlockRoot,
-			executionRequests,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_newPayloadV5,
+			[
+				executionPayload,
+				expectedBlobVersionedHashes,
+				parentBeaconBlockRoot,
+				executionRequests,
+			],
+			this.headers,
+		);
 	}
 	async engine_getPayloadV6(payloadId: Bytes8): Promise<{
 		executionPayload: ExecutionPayloadV4;
@@ -238,9 +301,11 @@ export class EngineExecutionClient {
 		shouldOverrideBuilder: boolean;
 		executionRequests: Bytes[];
 	}> {
-		return await this.client.call(EngineMethods.engine_getPayloadV6, [
-			payloadId,
-		]);
+		return await this.client.call(
+			EngineMethods.engine_getPayloadV6,
+			[payloadId],
+			this.headers,
+		);
 	}
 	// engine/transition-configuration
 	async engine_exchangeTransitionConfigurationV1(
@@ -249,6 +314,7 @@ export class EngineExecutionClient {
 		return await this.client.call(
 			EngineMethods.engine_exchangeTransitionConfigurationV1,
 			[consensusClientConfiguration],
+			this.headers,
 		);
 	}
 }

package/src/eth-api.ts

@@ -1,17 +1,17 @@
-import { initializeRpcClient, JsonRpcClient } from "@asyncswap/jsonrpc";
+import { JsonRpcClient } from "@asyncswap/jsonrpc";
 
 export class EthExecutionClient {
-	private client: JsonRpcClient;
+	rpc: JsonRpcClient;
 
 	constructor(url: string) {
-		this.client = initializeRpcClient(url);
+		this.rpc = new JsonRpcClient(url);
 	}
 
 	// eth/transaction
 	async eth_getTransactionByHash(
 		transactionHash: Hash32,
 	): Promise<NotFound | TransactionInfo> {
-		return await this.client.call(EthMethods.eth_getTransactionByHash, [
+		return await this.rpc.call(EthMethods.eth_getTransactionByHash, [
 			transactionHash,
 		]);
 	}
@@ -19,7 +19,7 @@ export class EthExecutionClient {
 		blockHash: Hash32,
 		transactionIndex: Uint,
 	): Promise<NotFound | TransactionInfo> {
-		return await this.client.call(
+		return await this.rpc.call(
 			EthMethods.eth_getTransactionByBlockHashAndIndex,
 			[blockHash, transactionIndex],
 		);
@@ -27,19 +27,17 @@ export class EthExecutionClient {
 	async eth_getTransactionReceipt(
 		transactionHash: Hash32,
 	): Promise<NotFound | ReceiptInfo> {
-		return await this.client.call(EthMethods.eth_getTransactionReceipt, [
+		return await this.rpc.call(EthMethods.eth_getTransactionReceipt, [
 			transactionHash,
 		]);
 	}
 
 	// eth/submit
 	async eth_sendTransaction(transaction: GenericTransaction): Promise<Hash32> {
-		return await this.client.call(EthMethods.eth_sendTransaction, [
-			transaction,
-		]);
+		return await this.rpc.call(EthMethods.eth_sendTransaction, [transaction]);
 	}
 	async eth_sendRawTransaction(transaction: Bytes): Promise<Hash32> {
-		return await this.client.call(EthMethods.eth_sendRawTransaction, [
+		return await this.rpc.call(EthMethods.eth_sendRawTransaction, [
 			transaction,
 		]);
 	}
@@ -48,14 +46,14 @@ export class EthExecutionClient {
 		address: Address,
 		block: BlockNumberOrTagOrHash,
 	): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_getBalance, [address, block]);
+		return await this.rpc.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, [
+		return await this.rpc.call(EthMethods.eth_getStorageAt, [
 			address,
 			storageSlot,
 			block,
@@ -65,7 +63,7 @@ export class EthExecutionClient {
 		address: Address,
 		block: BlockNumberOrTagOrHash,
 	): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_getTransactionCount, [
+		return await this.rpc.call(EthMethods.eth_getTransactionCount, [
 			address,
 			block,
 		]);
@@ -74,14 +72,14 @@ export class EthExecutionClient {
 		address: Address,
 		block: BlockNumberOrTagOrHash,
 	): Promise<Bytes> {
-		return await this.client.call(EthMethods.eth_getCode, [address, block]);
+		return await this.rpc.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, [
+		return await this.rpc.call(EthMethods.eth_getProof, [
 			address,
 			storageKeys,
 			block,
@@ -89,56 +87,51 @@ export class EthExecutionClient {
 	}
 	// eth/sign
 	async eth_sign(address: Address, message: Bytes): Promise<Bytes65> {
-		return await this.client.call(EthMethods.eth_sign, [address, message]);
+		return await this.rpc.call(EthMethods.eth_sign, [address, message]);
 	}
 	async eth_signTransaction(transaction: GenericTransaction): Promise<Bytes> {
-		return await this.client.call(EthMethods.eth_signTransaction, [
-			transaction,
-		]);
+		return await this.rpc.call(EthMethods.eth_signTransaction, [transaction]);
 	}
 	// eth/filter
 	async eth_newFilter(filter: Filter): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_newFilter, [filter]);
+		return await this.rpc.call(EthMethods.eth_newFilter, [filter]);
 	}
 	async eth_newBlockFilter(): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_newBlockFilter, []);
+		return await this.rpc.call(EthMethods.eth_newBlockFilter, []);
 	}
 	async eth_newPendingTransactionFilter(): Promise<Uint> {
-		return await this.client.call(
-			EthMethods.eth_newPendingTransactionFilter,
-			[],
-		);
+		return await this.rpc.call(EthMethods.eth_newPendingTransactionFilter, []);
 	}
 	async eth_uninstallFilter(): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_uninstallFilter, []);
+		return await this.rpc.call(EthMethods.eth_uninstallFilter, []);
 	}
 	async eth_getFilterChanges(): Promise<FilterResults> {
-		return await this.client.call(EthMethods.eth_getFilterChanges, []);
+		return await this.rpc.call(EthMethods.eth_getFilterChanges, []);
 	}
 	async eth_getFilterLogs(filterIdentifier: Uint): Promise<FilterResults> {
-		return await this.client.call(EthMethods.eth_getFilterLogs, [
+		return await this.rpc.call(EthMethods.eth_getFilterLogs, [
 			filterIdentifier,
 		]);
 	}
 	async eth_getLogs(filter: Filter): Promise<FilterResults> {
-		return await this.client.call(EthMethods.eth_getLogs, [filter]);
+		return await this.rpc.call(EthMethods.eth_getLogs, [filter]);
 	}
 	// eth/feeMarket
 	async eth_gasPrice(): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_gasPrice, []);
+		return await this.rpc.call(EthMethods.eth_gasPrice, []);
 	}
 	async eth_blobBaseFee(): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_blobBaseFee, []);
+		return await this.rpc.call(EthMethods.eth_blobBaseFee, []);
 	}
 	async eth_maxPriorityFeePerGas(): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_maxPriorityFeePerGas, []);
+		return await this.rpc.call(EthMethods.eth_maxPriorityFeePerGas, []);
 	}
 	async eth_feeHistory(
 		blockCount: Uint,
 		newestBlock: BlockNumberOrTag,
 		rewardPercentiles: number[],
 	): Promise<FeeHistoryResults> {
-		return await this.client.call(EthMethods.eth_feeHistory, [
+		return await this.rpc.call(EthMethods.eth_feeHistory, [
 			blockCount,
 			newestBlock,
 			rewardPercentiles,
@@ -149,13 +142,13 @@ export class EthExecutionClient {
 		transaction: GenericTransaction,
 		block: BlockNumberOrTagOrHash,
 	): Promise<Bytes> {
-		return this.client.call(EthMethods.eth_call, [transaction, block]);
+		return this.rpc.call(EthMethods.eth_call, [transaction, block]);
 	}
 	async eth_estimateGas(
 		transaction: GenericTransaction,
 		block: BlockNumberOrTag,
 	): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_estimateGas, [
+		return await this.rpc.call(EthMethods.eth_estimateGas, [
 			transaction,
 			block,
 		]);
@@ -164,7 +157,7 @@ export class EthExecutionClient {
 		transaction: GenericTransaction,
 		block: BlockNumberOrTag,
 	): Promise<AccessListResult> {
-		return await this.client.call(EthMethods.eth_createAccessList, [
+		return await this.rpc.call(EthMethods.eth_createAccessList, [
 			transaction,
 			block,
 		]);
@@ -173,36 +166,33 @@ export class EthExecutionClient {
 		payload: EthSimulatePayload,
 		blockTag: BlockNumberOrTagOrHash,
 	): Promise<EthSimulateResult> {
-		return await this.client.call(EthMethods.eth_simulateV1, [
-			payload,
-			blockTag,
-		]);
+		return await this.rpc.call(EthMethods.eth_simulateV1, [payload, blockTag]);
 	}
 	// eth/client
 	async eth_chainId(): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_chainId, []);
+		return await this.rpc.call(EthMethods.eth_chainId, []);
 	}
 	async eth_syncing(): Promise<SyncingStatus> {
-		return await this.client.call(EthMethods.eth_syncing, []);
+		return await this.rpc.call(EthMethods.eth_syncing, []);
 	}
 	async eth_coinbase(): Promise<Address> {
-		return await this.client.call(EthMethods.eth_coinbase, []);
+		return await this.rpc.call(EthMethods.eth_coinbase, []);
 	}
 	async eth_accounts(): Promise<Addresses> {
-		return await this.client.call(EthMethods.eth_accounts, []);
+		return await this.rpc.call(EthMethods.eth_accounts, []);
 	}
 	async eth_blockNumber(): Promise<Uint> {
-		return await this.client.call(EthMethods.eth_blockNumber, []);
+		return await this.rpc.call(EthMethods.eth_blockNumber, []);
 	}
 	async net_version(): Promise<UintDecimal> {
-		return await this.client.call(EthMethods.net_version, []);
+		return await this.rpc.call(EthMethods.net_version, []);
 	}
 	// eth/block
 	async eth_getBlockByHash(
 		blockHash: Hash32,
 		hydratedTransactions: boolean,
 	): Promise<NotFound | Block> {
-		return await this.client.call(EthMethods.eth_getBlockByHash, [
+		return await this.rpc.call(EthMethods.eth_getBlockByHash, [
 			blockHash,
 			hydratedTransactions,
 		]);
@@ -211,7 +201,7 @@ export class EthExecutionClient {
 		block: BlockNumberOrTag,
 		hydratedTransactions: boolean,
 	): Promise<NotFound | Block> {
-		return await this.client.call(EthMethods.eth_getBlockByNumber, [
+		return await this.rpc.call(EthMethods.eth_getBlockByNumber, [
 			block,
 			hydratedTransactions,
 		]);
@@ -219,15 +209,14 @@ export class EthExecutionClient {
 	async eth_getBlockTransactionCountByHash(
 		blockHash: Hash32,
 	): Promise<NotFound | Uint> {
-		return await this.client.call(
-			EthMethods.eth_getBlockTransactionCountByHash,
-			[blockHash],
-		);
+		return await this.rpc.call(EthMethods.eth_getBlockTransactionCountByHash, [
+			blockHash,
+		]);
 	}
 	async eth_getBlockTransactionCountByNumber(
 		block: BlockNumberOrTag,
 	): Promise<NotFound | Uint> {
-		return await this.client.call(
+		return await this.rpc.call(
 			EthMethods.eth_getBlockTransactionCountByNumber,
 			[block],
 		);
@@ -235,41 +224,41 @@ export class EthExecutionClient {
 	async eth_getUncleCountByBlockHash(
 		blockHash: Hash32,
 	): Promise<NotFound | Uint> {
-		return await this.client.call(EthMethods.eth_getUncleCountByBlockHash, [
+		return await this.rpc.call(EthMethods.eth_getUncleCountByBlockHash, [
 			blockHash,
 		]);
 	}
 	async eth_getUncleCountByBlockNumber(
 		block: BlockNumberOrTag,
 	): Promise<NotFound | Uint> {
-		return await this.client.call(EthMethods.eth_getUncleCountByBlockNumber, [
+		return await this.rpc.call(EthMethods.eth_getUncleCountByBlockNumber, [
 			block,
 		]);
 	}
 	async eth_getBlockReceipts(
 		block: BlockNumberOrTagOrHash,
 	): Promise<NotFound | ReceiptInfo[]> {
-		return await this.client.call(EthMethods.eth_getBlockReceipts, [block]);
+		return await this.rpc.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]);
+		return await this.rpc.call(DebugMethods.debug_getRawHeader, [block]);
 	}
 	async debug_getRawBlock(block: BlockNumberOrTag): Promise<Bytes> {
 		// RPL-encoded block
-		return await this.client.call(DebugMethods.debug_getRawBlock, [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.client.call(DebugMethods.debug_getRawTransaction, [
+		return await this.rpc.call(DebugMethods.debug_getRawTransaction, [
 			transactionHash,
 		]);
 	}
 	async debug_getRawReceipts(block: BlockNumberOrTag): Promise<Bytes[]> {
-		return await this.client.call(DebugMethods.debug_getRawReceipts, [block]);
+		return await this.rpc.call(DebugMethods.debug_getRawReceipts, [block]);
 	}
 	async debug_getBadBlocks(): Promise<BadBlock[]> {
-		return await this.client.call(DebugMethods.debug_getBadBlocks, []);
+		return await this.rpc.call(DebugMethods.debug_getBadBlocks, []);
 	}
 }

package/src/index.ts

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

package/src/mev-api.ts

@@ -0,0 +1,155 @@
+import { EthExecutionClient } from "./eth-api";
+
+export class EthFlashbotsClient extends EthExecutionClient {
+	constructor(url: string) {
+		super(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],
+		);
+	}
+}

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

@@ -27,8 +27,8 @@ declare global {
 	export interface ExecutionPayloadV1 {
 		parentHash: Hash32;
 		feeRecipient: Address;
-		stateRoot: Hash32;
-		receiptsRoot: Hash32;
+		stateRoot: Bytes32;
+		receiptsRoot: Bytes32;
 		logsBloom: Bytes256;
 		prevRandao: Bytes32;
 		blockNumber: Uint64;
@@ -49,8 +49,8 @@ declare global {
 	export interface ExecutionPayloadV2 {
 		parentHash: Hash32;
 		feeRecipient: Address;
-		stateRoot: Hash32;
-		receiptsRoot: Hash32;
+		stateRoot: Bytes32;
+		receiptsRoot: Bytes32;
 		logsBloom: Bytes256;
 		prevRandao: Bytes32;
 		blockNumber: Uint64;
@@ -66,8 +66,8 @@ declare global {
 	export interface ExecutionPayloadV3 {
 		parentHash: Hash32;
 		feeRecipient: Address;
-		stateRoot: Hash32;
-		receiptsRoot: Hash32;
+		stateRoot: Bytes32;
+		receiptsRoot: Bytes32;
 		logsBloom: Bytes256;
 		prevRandao: Bytes32;
 		blockNumber: Uint64;
@@ -85,8 +85,8 @@ declare global {
 	export interface ExecutionPayloadV4 {
 		parentHash: Hash32;
 		feeRecipient: Address;
-		stateRoot: Hash32;
-		receiptsRoot: Hash32;
+		stateRoot: Bytes32;
+		receiptsRoot: Bytes32;
 		logsBloom: Bytes256;
 		prevRandao: Bytes32;
 		blockNumber: Uint64;

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

@@ -0,0 +1,35 @@
+declare global {
+	export enum FlashbotsMethods {
+		eth_sendBundle = "eth_sendBundle",
+		mev_sendBundle = "mev_sendBundle",
+		eth_callBundle = "eth_callBundle",
+		eth_cancelBundle = "eth_cancelBundle",
+		mev_simBundle = "mev_simBundle",
+		eth_sendPrivateTransaction = "eth_sendPrivateTransaction",
+		eth_sendPrivateRawTransaction = "eth_sendPrivateRawTransaction",
+		eth_cancelPrivateTransaction = "eth_cancelPrivateTransaction",
+
+		flashbots_getFeeRefundTotalsByRecipient = "flashbots_getFeeRefundTotalsByRecipient",
+		flashbots_getFeeRefundsByRecipient = "flashbots_getFeeRefundsByRecipient",
+		flashbots_getFeeRefundsByBlock = "flashbots_getFeeRefundsByBlock",
+		flashbots_getFeeRefundsByBundle = "flashbots_getFeeRefundsByBundle",
+		flashbots_setFeeRefundRecipient = "flashbots_setFeeRefundRecipient",
+		buildernet_getDelayedRefunds = "buildernet_getDelayedRefunds",
+		buildernet_getDelayedRefundTotalsByRecipient = "buildernet_getDelayedRefundTotalsByRecipient",
+		flashbots_getMevRefundTotalByRecipient = "flashbots_getMevRefundTotalByRecipient",
+		flashbots_getMevRefundTotalBySender = "flashbots_getMevRefundTotalBySender",
+	}
+	export enum BuilderNetMethods {
+		eth_sendBundle = "eth_sendBundle",
+		eth_sendRawTransaction = "eth_sendRawTransaction",
+		buildernet_getFeeRefundTotalsByRecipient = "buildernet_getFeeRefundTotalsByRecipient",
+		buildernet_getFeeRefundsByRecipient = "buildernet_getFeeRefundsByRecipient",
+		buildernet_getFeeRefundsByBlock = "buildernet_getFeeRefundsByBlock",
+		buildernet_getFeeRefundsByBundle = "buildernet_getFeeRefundsByBundle",
+		buildernet_setFeeRefundRecipient = "buildernet_setFeeRefundRecipient",
+		buildernet_getDelayedRefunds = "buildernet_getDelayedRefunds",
+		buildernet_getDelayedRefundTotalsByRecipient = "buildernet_getDelayedRefundTotalsByRecipient",
+	}
+}
+
+export { };

package/src/types/mev/types.d.ts

@@ -0,0 +1,231 @@
+declare global {
+	export type GetDelayedRefundTotalsByRecipientParams = {
+		recipient: Address;
+		blockRangeFrom?: Hex;
+		blockRangeTo?: Hex;
+	};
+	export type GetDelayedRefundTotalsByRecipientResult = {
+		pending: Hex;
+		received: Hex;
+		indexedUpTo: Hex;
+	};
+
+	export type GetDelayedRefundsParams = {
+		recipient: Address;
+		blockRangeFrom?: Hex;
+		blockRangeTo?: Hex;
+		cursor?: Hex;
+		hash?: Hash32;
+	};
+	export type GetDelayedRefundsResult = {
+		refunds: Refund[];
+		nextCursor: Hex;
+		indexedUpTo: Hex;
+	};
+	export type GetFeeRefundsByBlockParams = {
+		block_number: Hex;
+	};
+	export type GetFeeRefundsByBlockResult = unknown;
+	export type GetFeeRefundsByBundleParams = {
+		bundle_hash: Hex;
+	};
+	export type GetFeeRefundsByBundleResult = unknown;
+	export type GetFeeRefundsByRecipientParams = {
+		recipient: Address;
+		cursor?: Hex;
+	};
+	export type Refund = {
+		hash: Hex;
+		amount: Hex;
+		blockNumber: Hex;
+		status: "pending" | "received";
+		recipient: Address;
+	};
+	export type GetFeeRefundsByRecipientResult = {
+		refunds: Refund[];
+		cursor: string;
+	};
+	export type GetFeeRefundTotalsByRecipientParams = {
+		recipient: Address;
+	};
+	export type GetFeeRefundTotalsByRecipientResult = {
+		pending: Hex;
+		received: Hex;
+		maxBlockNumber: Hex;
+	};
+	export type EthCancelPrivateTransactioParams = {
+		txHash: Hex;
+	};
+	export type EthCancelPrivateTransactionResult = boolean;
+
+	export type EthSendPrivateRawTransactionParams = {
+		// String, raw signed transaction
+		tx: Hex;
+		preferences?: {
+			// Sends transactions to all registered block builders, sets MEV-Share revenue share to 50%
+			fast: boolean;
+			privacy?: {
+				hints?: BundleHints;
+				builders?: Builders[];
+			};
+			validity?: {
+				refund?: Array<{ address: Address; percent: number }>;
+			};
+		};
+	};
+	export type EthSendPrivateRawTransactionResult = Hash32;
+
+	export type EthSendPrivateTransactionParams = {
+		tx: Hex;
+		maxBlockNumber: Hex;
+		preferences?: {
+			// Sends transactions to all registered block builders, sets MEV-Share revenue share to 50%
+			fast: boolean;
+			privacy?: {
+				hints?: BundleHints;
+				builders?: Builders[];
+			};
+			validity?: {
+				refund?: Array<{ address: Address; percent: number }>;
+			};
+		};
+	};
+	export type EthSendPrivateTransactionResult = Hash32;
+	export type EthCancelBundleParams = {
+		replacementUuid: string;
+	};
+	export type EthCancelBundleResult = unknown;
+
+	export type EthSendBundleParams = {
+		txs: Hex[];
+		blockNumber: Hex | "0x" | null; // 0x | null or missing field for next block only
+		// Replacing: send bundle with same replacementUuid to override previous one
+		// Canceling: send bundle with same replacementUuid and empty list of transactions to cancel
+		replacementUuid?: string;
+		revertingTxHashes?: Hex[];
+		minBlockNumber?: Hex;
+		maxBlockNumber?: Hex;
+		minFlashblockNumber?: Hex;
+		maxFlashblockNumber?: Hex;
+		minTimestamp?: number;
+		maxTimestamp?: number;
+		builders?: Builders[];
+	};
+	export type EthCallBundleParams = {
+		txs: Hex[];
+		blockNumber: Hex;
+		stateBlockNumber: string | "latest";
+		timestamp: number;
+	};
+	export type MevSendBundleParams = {
+		version: "v0.1";
+		inclusion: Inclusion;
+		body: BundleBody;
+		validity?: BundleValidity;
+		privacy?: BundlePrivacy;
+	};
+	export type MevSimBundleParams = {
+		version: "beta-1";
+		inclusion: Inclusion;
+		body: BundleBody;
+		validity: BundleValidity;
+		privacy?: BundlePrivacy;
+		metadata?: BundleMetadata;
+		simOptions?: BundleSimOptions;
+	};
+	export type Inclusion = {
+		block: string;
+		maxBlock?: string;
+	};
+	export type BundleBody = Array<
+		| { hash: string } // tx hash
+		| { tx: string; canRevert: boolean } // signed tx
+		| { bundle: MevSendBundleParams[] }
+	>;
+	export type BundleValidity = {
+		refund?: Array<{ bodyIdx: number; percent: number }>;
+		refundConfig?: Array<{ address: string; percent: number }>;
+	};
+	export type BundlePrivacy = {
+		hints?: BundleHints[];
+		builders?: Builders[];
+	};
+	export type BundleMetadata = { originId?: string };
+	export type BundleSimOptions = {
+		parentBlock?: number | string; // Block used for simulation state. Defaults to latest block.
+		blockNumber?: number; // default = parentBlock.number + 1
+		coinbase?: string; // default = parentBlock.coinbase
+		timestamp?: number; // default = parentBlock.timestamp + 12
+		gasLimit?: number; // default = parentBlock.gasLimit
+		baseFee?: bigint; // default = parentBlock.baseFeePerGas
+		timeout?: number; // default = 5 (defined in seconds)
+	};
+	export type EthSendBundleResult = { bundleHash: Hex; smart: boolean };
+	export type MevSendBundleResult = { bundleHash: Hex };
+	export type BundleHints =
+		| "calldata"
+		| "contract_address"
+		| "logs"
+		| "function_selector"
+		| "hash"
+		| "tx_hash";
+
+	export type EthCallBundleResult = {
+		bundleGasPrice: Uint;
+		bundleHash: Hash32;
+		coinbaseDiff: Uint;
+		ethSentToCoinbase: Uint;
+		gasFees: Uint;
+		results: Array<{
+			coinbaseDiff: Uint;
+			ethSentToCoinbase: Uint;
+			fromAddress: Address;
+			gasFees: Uint;
+			gasPrice: Uint;
+			gasUsed: number;
+			toAddress: Address;
+			txHash: Hash32;
+			value: Hex;
+		}>;
+		stateBlockNumber: number;
+		totalGasUsed: number;
+	};
+	export type MevSimBundleResult = {
+		success: boolean;
+		error?: string;
+		stateBlock: Hex;
+		mevGasPrice: Hex;
+		profit: Hex;
+		refundableValue: Hex;
+		gasUsed: Hex;
+		logs?: Array<{
+			txLogs?: Log[];
+			bundleLogs?: MevSimBundleResult[];
+		}>;
+	};
+	export type Builders =
+		| "default"
+		| "flashbots"
+		| "f1b.io"
+		| "rsync"
+		| "beaverbuild.org"
+		| "builder0x69"
+		| "Titan"
+		| "EigenPhi"
+		| "boba-builder"
+		| "Gambit"
+		| "payload"
+		| "Loki"
+		| "BuildAI"
+		| "JetBuilder"
+		| "tbuilder"
+		| "penguinbuild"
+		| "bobthebuilder"
+		| "BTCS"
+		| "bloXroute"
+		| "Blockbeelder"
+		| "Quasar"
+		| "Eureka";
+}
+
+export { };