@msaki/eth-rpc 0.2.0 → 0.2.2

package/package.json

@@ -1,7 +1,8 @@
 {
 	"name": "@msaki/eth-rpc",
+	"description": "A library for ethereum execution clients apis.",
 	"author": "Meek Msaki",
-	"version": "0.2.0",
+	"version": "0.2.2",
 	"license": "MIT",
 	"type": "module",
 	"main": "dist/index.js",
@@ -11,11 +12,23 @@
 		"dist",
 		"src"
 	],
+	"keywords": [
+		"eth",
+		"rpc",
+		"ethereum",
+		"engine-api",
+		"execution-apis",
+		"consensus"
+	],
+	"homepage": "https://github.com/mmsaki/eth-libs/tree/main/packages/eth-rpc",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/mmsaki/libs.git",
+		"url": "git+https://github.com/mmsaki/eth-libs.git",
 		"directory": "packages/eth-rpc"
 	},
+	"bugs": {
+		"url": "https://github.com/mmsaki/eth-libs/issues"
+	},
 	"publishConfig": {
 		"access": "public",
 		"directory": "dist"

package/src/engine-api.ts

@@ -0,0 +1,254 @@
+import { initializeRpcClient, JsonRpcClient } from "@msaki/jsonrpc";
+
+export class EngineExecutionClient {
+	private client: JsonRpcClient;
+
+	constructor(url: string, jwt_token: string) {
+		this.client = initializeRpcClient(url, jwt_token);
+	}
+
+	// eth/transaction
+	async eth_sendRawTransaction(transaction: Bytes): Promise<Hash32> {
+		return await this.client.call(EngineMethods.eth_sendRawTransaction, [
+			transaction,
+		]);
+	}
+	// eth/state
+	async eth_getCode(
+		address: Address,
+		block: BlockNumberOrTagOrHash,
+	): Promise<Bytes> {
+		return await this.client.call(EngineMethods.eth_getCode, [address, block]);
+	}
+	async eth_getLogs(filter: Filter): Promise<FilterResults> {
+		return await this.client.call(EngineMethods.eth_getLogs, [filter]);
+	}
+	// eth/execute
+	async eth_call(
+		transaction: GenericTransaction,
+		block: BlockNumberOrTagOrHash,
+	): Promise<Bytes> {
+		return this.client.call(EngineMethods.eth_call, [transaction, block]);
+	}
+	// eth/client
+	async eth_chainId(): Promise<Uint> {
+		return await this.client.call(EngineMethods.eth_chainId, []);
+	}
+	async eth_syncing(): Promise<SyncingStatus> {
+		return await this.client.call(EngineMethods.eth_syncing, []);
+	}
+	async eth_blockNumber(): Promise<Uint> {
+		return await this.client.call(EngineMethods.eth_blockNumber, []);
+	}
+	// eth/block
+	async eth_getBlockByHash(
+		blockHash: Hash32,
+		hydratedTransactions: boolean,
+	): Promise<NotFound | Block> {
+		return await this.client.call(EngineMethods.eth_getBlockByHash, [
+			blockHash,
+			hydratedTransactions,
+		]);
+	}
+	async eth_getBlockByNumber(
+		block: BlockNumberOrTag,
+		hydratedTransactions: boolean,
+	): Promise<NotFound | Block> {
+		return await this.client.call(EngineMethods.eth_getBlockByNumber, [
+			block,
+			hydratedTransactions,
+		]);
+	}
+	// engine/blob
+	async engine_getBlobsV1(
+		blobedVersionedHashes: Hash32[],
+	): Promise<BlobAndProofV1[]> {
+		return await this.client.call(EngineMethods.engine_getBlobsV1, [
+			blobedVersionedHashes,
+		]);
+	}
+	async engine_getBlobsV2(
+		blobedVersionedHashes: Hash32[],
+	): Promise<BlobAndProofV2[]> {
+		return await this.client.call(EngineMethods.engine_getBlobsV2, [
+			blobedVersionedHashes,
+		]);
+	}
+	async engine_getBlobsV3(
+		blobedVersionedHashes: Hash32[],
+	): Promise<Array<BlobAndProofV2[] | null> | null> {
+		return await this.client.call(EngineMethods.engine_getBlobsV2, [
+			blobedVersionedHashes,
+		]);
+	}
+	// engine/capabilities
+	async engine_exchangeCapabilities(
+		consensusClientMethods: string[],
+	): Promise<string[]> {
+		return await this.client.call(EngineMethods.engine_exchangeCapabilities, [
+			consensusClientMethods,
+		]);
+	}
+	// engine/forkchoice
+	async engine_forkchoiceUpdatedV1(
+		forkchoiceState: ForkchoiceStateV1,
+		payloadAttribute: PayloadAttributesV1,
+	): Promise<ForkchoiceUpdatedResponseV1> {
+		return await this.client.call(EngineMethods.engine_forkchoiceUpdatedV1, [
+			forkchoiceState,
+			payloadAttribute,
+		]);
+	}
+	async engine_forkchoiceUpdatedV2(
+		forkchoiceState: ForkchoiceStateV1,
+		payloadAttribute: PayloadAttributesV2,
+	): Promise<ForkchoiceUpdatedResponseV1> {
+		return await this.client.call(EngineMethods.engine_forkchoiceUpdatedV2, [
+			forkchoiceState,
+			payloadAttribute,
+		]);
+	}
+	async engine_forkchoiceUpdatedV3(
+		forkchoiceState: ForkchoiceStateV1,
+		payloadAttribute: PayloadAttributesV3,
+	): Promise<ForkchoiceUpdatedResponseV1> {
+		return await this.client.call(EngineMethods.engine_forkchoiceUpdatedV3, [
+			forkchoiceState,
+			payloadAttribute,
+		]);
+	}
+	// engine/payload
+	async engine_newPayloadV1(
+		executionPayload: ExecutionPayloadV1,
+	): Promise<PayloadStatusV1> {
+		return await this.client.call(EngineMethods.engine_newPayloadV1, [
+			executionPayload,
+		]);
+	}
+	async engine_newPayloadV2(
+		executionPayload: ExecutionPayloadV1 | ExecutionPayloadV2,
+	): Promise<PayloadStatusNoInvalidBlockHash> {
+		return await this.client.call(EngineMethods.engine_newPayloadV2, [
+			executionPayload,
+		]);
+	}
+	async engine_newPayloadV3(
+		executionPayload: ExecutionPayloadV3,
+		expectedBlobVersionedHashes: Hash32[],
+		rootOfTheParentBeaconBlock: Hash32,
+	): Promise<PayloadStatusNoInvalidBlockHash> {
+		return await this.client.call(EngineMethods.engine_newPayloadV3, [
+			executionPayload,
+			expectedBlobVersionedHashes,
+			rootOfTheParentBeaconBlock,
+		]);
+	}
+	async engine_newPayloadV4(
+		executionPayload: ExecutionPayloadV3,
+		expectedBlobVersionedHashes: Hash32[],
+		rootOfTheParentBeaconBlock: Hash32,
+		executionRequests: Bytes[],
+	): Promise<PayloadStatusNoInvalidBlockHash> {
+		return await this.client.call(EngineMethods.engine_newPayloadV4, [
+			executionPayload,
+			expectedBlobVersionedHashes,
+			rootOfTheParentBeaconBlock,
+			executionRequests,
+		]);
+	}
+	async engine_getPayloadV1(payloadId: Bytes8): Promise<ExecutionPayloadV1> {
+		return await this.client.call(EngineMethods.engine_getPayloadV1, [
+			payloadId,
+		]);
+	}
+	async engine_getPayloadV2(payloadId: Bytes8): Promise<{
+		executionPayload: ExecutionPayloadV1 | ExecutionPayloadV2;
+		blockValue: Uint256;
+	}> {
+		return await this.client.call(EngineMethods.engine_getPayloadV2, [
+			payloadId,
+		]);
+	}
+	async engine_getPayloadV3(payloadId: Bytes8): Promise<{
+		executionPayload: ExecutionPayloadV3;
+		blockValue: Uint256;
+		blobsBundle: BlobsBundleV1;
+		shouldOverrideBuilder: boolean;
+	}> {
+		return await this.client.call(EngineMethods.engine_getPayloadV3, [
+			payloadId,
+		]);
+	}
+	async engine_getPayloadV4(payloadId: Bytes8): Promise<{
+		executionPayload: ExecutionPayloadV3;
+		blockValue: Uint256;
+		blobsBundle: BlobsBundleV1;
+		shouldOverrideBuilder: boolean;
+		executionRequests: Bytes[];
+	}> {
+		return await this.client.call(EngineMethods.engine_getPayloadV4, [
+			payloadId,
+		]);
+	}
+	async engine_getPayloadV5(payloadId: Bytes8): Promise<{
+		executionPayload: ExecutionPayloadV3;
+		blockValue: Uint256;
+		blobsBundle: BlobsBundleV2;
+		shouldOverrideBuilder: boolean;
+		executionRequests: Bytes[];
+	}> {
+		return await this.client.call(EngineMethods.engine_getPayloadV5, [
+			payloadId,
+		]);
+	}
+	async engine_getPayloadBodiesByHashV1(
+		arrayOfBlockHashes: Hash32[],
+	): Promise<ExecutionPayloadBodyV1[]> {
+		return await this.client.call(
+			EngineMethods.engine_getPayloadBodiesByHashV1,
+			[arrayOfBlockHashes],
+		);
+	}
+	async engine_getPayloadBodiesByRangeV1(
+		startingBlockNumber: Uint64,
+		numberOfBlocksToReturn: Uint64,
+	): Promise<ExecutionPayloadBodyV1[]> {
+		return await this.client.call(
+			EngineMethods.engine_getPayloadBodiesByRangeV1,
+			[startingBlockNumber, numberOfBlocksToReturn],
+		);
+	}
+	async engine_newPayloadV5(
+		executionPayload: ExecutionPayloadV4,
+		expectedBlobVersionedHashes: Hash32[],
+		parentBeaconBlockRoot: Hash32,
+		executionRequests: Bytes[],
+	): Promise<PayloadStatusNoInvalidBlockHash> {
+		return await this.client.call(EngineMethods.engine_newPayloadV5, [
+			executionPayload,
+			expectedBlobVersionedHashes,
+			parentBeaconBlockRoot,
+			executionRequests,
+		]);
+	}
+	async engine_getPayloadV6(payloadId: Bytes8): Promise<{
+		executionPayload: ExecutionPayloadV4;
+		blockValue: Uint256;
+		blobsBundle: BlobsBundleV2;
+		shouldOverrideBuilder: boolean;
+		executionRequests: Bytes[];
+	}> {
+		return await this.client.call(EngineMethods.engine_getPayloadV6, [
+			payloadId,
+		]);
+	}
+	// engine/transition-configuration
+	async engine_exchangeTransitionConfigurationV1(
+		consensusClientConfiguration: TransitionConfigurationV1,
+	): Promise<TransitionConfigurationV1> {
+		return await this.client.call(
+			EngineMethods.engine_exchangeTransitionConfigurationV1,
+			[consensusClientConfiguration],
+		);
+	}
+}

package/src/eth-api.ts

@@ -0,0 +1,275 @@
+import { initializeRpcClient, JsonRpcClient } from "@msaki/jsonrpc";
+
+export class EthExecutionClient {
+	private client: JsonRpcClient;
+
+	constructor(url: string) {
+		this.client = initializeRpcClient(url);
+	}
+
+	// eth/transaction
+	async eth_getTransactionByHash(
+		transactioHash: Hash32,
+	): Promise<NotFound | TransactionInfo> {
+		return await this.client.call(EthMethods.eth_getTransactionByHash, [
+			transactioHash,
+		]);
+	}
+	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 trnasactions
+		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

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

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/{forkchoice.d.ts → engine/forkchoice.d.ts}

@@ -27,14 +27,6 @@ declare global {
 		withdrawals: WithdrawalV1[];
 		parentBeaconBlockRoot: Hash32;
 	}
-	export interface BlobAndProofV1 {
-		blob: Bytes;
-		proof: Bytes48;
-	}
-	export interface BlobAndProofV2 {
-		blob: Bytes;
-		proofs: Bytes48[];
-	}
 }
 
 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.d.ts → engine/payload.d.ts}

@@ -1,10 +1,4 @@
 declare global {
-	// engine types
-	export interface TransitionConfigurationV1 {
-		terminalTotalDifficulty: Uint256;
-		terminalBlockHash: Hash32;
-		terminalBlockNumber: Uint64;
-	}
 	export enum PAYLOAD_STATUS {
 		VALID = "VALID",
 		INVALID = "INVALID",

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