starknet 4.4.2 → 4.6.0

package/types/api/openrpc.d.ts

@@ -1,9 +1,11 @@
 /**
  * Starknet RPC version 0.1.0
- * starknet_api_openrpc version 0.31.0
  *
- * TypeScript Representation of OpenRpc protocol types | results
- * errors are not implemented here only results
+ * StarkNet Node API 0.31.0
+ * StarkNet Node Write API 0.3.0
+ * StarkNet Trace API 0.3.0
+ *
+ * TypeScript Representation of OpenRpc protocol types
  */
 /**
  * "type": "string",
@@ -12,12 +14,32 @@
  * "description": "A field element. Represented as up to 63 hex digits and leading 4 bits zeroed.",
  * "pattern": "^0x0[a-fA-F0-9]{1,63}$"
  */
-declare type FELT = string;
+export declare type FELT = string;
+export declare type ADDRESS = FELT;
+/**
+ * "title": "An integer number in hex format (0x...)",
+ * "pattern": "^0x[a-fA-F0-9]+$"
+ */
+declare type NUM_AS_HEX = string;
+declare type SIGNATURE = Array<FELT>;
+declare type ETH_ADDRESS = string;
 declare type BLOCK_NUMBER = number;
 declare type BLOCK_HASH = FELT;
 declare type TXN_HASH = FELT;
+declare type CHAIN_ID = string;
+declare type PROTOCOL_VERSION = string;
 declare type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
 declare type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'INVOKE' | 'L1_HANDLER';
+declare type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+declare enum BLOCK_TAG {
+    'latest' = 0,
+    'pending' = 1
+}
+declare type BLOCK_ID = {
+    block_hash: BLOCK_HASH;
+} | {
+    block_number: BLOCK_NUMBER;
+} | BLOCK_TAG;
 declare type MSG_TO_L1 = {
     to_address: FELT;
     payload: Array<FELT>;
@@ -31,36 +53,29 @@ declare type COMMON_RECEIPT_PROPERTIES = {
     transaction_hash: TXN_HASH;
     actual_fee: FELT;
     status: TXN_STATUS;
+    status_data?: string;
     block_hash: BLOCK_HASH;
     block_number: BLOCK_NUMBER;
-    type?: TXN_TYPE;
+};
+declare type MSG_TO_L2 = {
+    from_address: ETH_ADDRESS;
+    payload: FELT;
 };
 declare type INVOKE_TXN_RECEIPT_PROPERTIES = {
     messages_sent: MSG_TO_L1;
+    l1_origin_message?: MSG_TO_L2;
     events: EVENT;
 };
 declare type PENDING_COMMON_RECEIPT_PROPERTIES = {
     transaction_hash: TXN_HASH;
     actual_fee: FELT;
-    type?: TXN_TYPE;
 };
 declare type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
-declare type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
 declare type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
 declare type DEPLOY_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
 declare type PENDING_INVOKE_TXN_RECEIPT = PENDING_COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
 declare type PENDING_TXN_RECEIPT = PENDING_INVOKE_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
-declare type TXN_RECEIPT = INVOKE_TXN_RECEIPT | L1_HANDLER_TXN_RECEIPT | DECLARE_TXN_RECEIPT | DEPLOY_TXN_RECEIPT | PENDING_TXN_RECEIPT;
-export declare namespace RPC_1 {
-    type GetTransactionReceiptResponse = TXN_RECEIPT;
-    type Methods = {
-        starknet_getTransactionReceipt: {
-            QUERY: never;
-            REQUEST: any[];
-            RESPONSE: GetTransactionReceiptResponse;
-        };
-    };
-}
+declare type TXN_RECEIPT = INVOKE_TXN_RECEIPT | DECLARE_TXN_RECEIPT | DEPLOY_TXN_RECEIPT | PENDING_TXN_RECEIPT;
 declare type BLOCK_HEADER = {
     block_hash: BLOCK_HASH;
     parent_hash: BLOCK_HASH;
@@ -80,13 +95,6 @@ declare type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
     sequencer_address: FELT;
     parent_hash: BLOCK_HASH;
 };
-declare type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
-/**
- * "title": "An integer number in hex format (0x...)",
- * "pattern": "^0x[a-fA-F0-9]+$"
- */
-declare type NUM_AS_HEX = string;
-declare type SIGNATURE = Array<FELT>;
 declare type COMMON_TXN_PROPERTIES = {
     transaction_hash: TXN_HASH;
     max_fee: FELT;
@@ -95,7 +103,6 @@ declare type COMMON_TXN_PROPERTIES = {
     nonce: FELT;
     type: TXN_TYPE;
 };
-declare type ADDRESS = FELT;
 declare type FUNCTION_CALL = {
     contract_address: ADDRESS;
     entry_point_selector: FELT;
@@ -134,18 +141,371 @@ declare type CONTRACT_CLASS = {
         EXTERNAL: CONTRACT_ENTRY_POINT_LIST;
         L1_HANDLER: CONTRACT_ENTRY_POINT_LIST;
     };
+    abi?: any;
 };
 declare type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
 declare type CONTRACT_ENTRY_POINT = {
     offset: NUM_AS_HEX;
     selector: FELT;
 };
+declare type STORAGE_DIFF_ITEM = {
+    address: FELT;
+    key: FELT;
+    value: FELT;
+};
+declare type DECLARED_CONTRACT_ITEM = {
+    class_hash: FELT;
+};
+declare type DEPLOYED_CONTRACT_ITEM = {
+    address: FELT;
+    class_hash: FELT;
+};
+declare type STATE_UPDATE = {
+    block_hash: BLOCK_HASH;
+    new_root: FELT;
+    old_root: FELT;
+    state_diff: {
+        storage_diffs: Array<STORAGE_DIFF_ITEM>;
+        declared_contracts: Array<DECLARED_CONTRACT_ITEM>;
+        deployed_contracts: Array<DEPLOYED_CONTRACT_ITEM>;
+        nonces: Array<{
+            contract_address: ADDRESS;
+            nonce: FELT;
+        }>;
+    };
+};
+declare type STORAGE_KEY = string;
+declare type EVENT_FILTER = {
+    from_block?: BLOCK_ID;
+    to_block?: BLOCK_ID;
+    address?: ADDRESS;
+    keys?: Array<FELT>;
+};
+declare type RESULT_PAGE_REQUEST = {
+    page_size: number;
+    page_number: number;
+};
+declare type EMITTED_EVENT = EVENT & {
+    block_hash: BLOCK_HASH;
+    block_number: BLOCK_NUMBER;
+    transaction_hash: TXN_HASH;
+};
+declare type SYNC_STATUS = {
+    starting_block_hash: BLOCK_HASH;
+    starting_block_num: NUM_AS_HEX;
+    current_block_hash: BLOCK_HASH;
+    current_block_num: NUM_AS_HEX;
+    highest_block_hash: BLOCK_HASH;
+    highest_block_num: NUM_AS_HEX;
+};
+declare type FEE_ESTIMATE = {
+    gas_consumed: NUM_AS_HEX;
+    gas_price: NUM_AS_HEX;
+    overall_fee: NUM_AS_HEX;
+};
+declare enum CALL_TYPE {
+    'DELEGATE' = 0,
+    'CALL' = 1
+}
+declare enum ENTRY_POINT_TYPE {
+    'EXTERNAL' = 0,
+    'L1_HANDLER' = 1,
+    'CONSTRUCTOR' = 2
+}
+declare type FUNCTION_INVOCATION = FUNCTION_CALL & {
+    caller_address: FELT;
+    code_address: FELT;
+    entry_point_type: ENTRY_POINT_TYPE;
+    call_type: CALL_TYPE;
+    result: FELT;
+    calls: FUNCTION_INVOCATION;
+    events: EVENT;
+    messages: MSG_TO_L1;
+};
+declare type TRACE_ROOT = {
+    nonce: FELT;
+    signature: FELT;
+    function_invocation: FUNCTION_INVOCATION;
+};
 export declare namespace OPENRPC {
-    type GetBlockWithTxHashesResponse = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
-    type GetBlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
-    type GetStorageAtResponse = FELT;
-    type GetTransactionByHashResponse = TXN;
-    type GetTransactionByBlockIdAndIndex = TXN;
-    type GetClassResponse = CONTRACT_CLASS;
+    type BlockWithTxHashes = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
+    type BlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
+    type StateUpdate = STATE_UPDATE;
+    type Storage = FELT;
+    type Transaction = TXN;
+    type TransactionReceipt = TXN_RECEIPT;
+    type ContractClass = CONTRACT_CLASS;
+    type CallResponse = Array<FELT>;
+    type EstimatedFee = FEE_ESTIMATE;
+    type BlockNumber = BLOCK_NUMBER;
+    type BlockHashAndNumber = {
+        block_hash: BLOCK_HASH;
+        block_number: BLOCK_NUMBER;
+    };
+    type ChainId = CHAIN_ID;
+    type PendingTransactions = Array<TXN>;
+    type ProtocolVersion = PROTOCOL_VERSION;
+    type SyncingStatus = false | SYNC_STATUS;
+    type Events = {
+        events: Array<EMITTED_EVENT>;
+        page_number: number;
+        is_last_page: boolean;
+    };
+    type Nonce = FELT;
+    type Trace = TRACE_ROOT;
+    type Traces = Array<{
+        transaction_hash: FELT;
+        trace_root: TRACE_ROOT;
+    }>;
+    type TransactionHash = TXN_HASH;
+    type BlockHash = BLOCK_HASH;
+    type EventFilter = EVENT_FILTER;
+    type InvokedTransaction = {
+        transaction_hash: TXN_HASH;
+    };
+    type DeclaredTransaction = {
+        transaction_hash: TXN_HASH;
+        class_hash: FELT;
+    };
+    type DeployedTransaction = {
+        transaction_hash: TXN_HASH;
+        contract_address: FELT;
+    };
+    type Methods = {
+        starknet_getBlockWithTxHashes: {
+            params: {
+                block_id: BLOCK_ID;
+            };
+            result: BlockWithTxHashes;
+            errors: Errors.INVALID_BLOCK_ID;
+        };
+        starknet_getBlockWithTxs: {
+            params: {
+                block_id: BLOCK_ID;
+            };
+            result: BlockWithTxs;
+            errors: Errors.INVALID_BLOCK_ID;
+        };
+        starknet_getStateUpdate: {
+            params: {
+                block_id: BLOCK_ID;
+            };
+            result: StateUpdate;
+            errors: Errors.INVALID_BLOCK_ID;
+        };
+        starknet_getStorageAt: {
+            params: {
+                contract_address: ADDRESS;
+                key: STORAGE_KEY;
+                block_id: BLOCK_ID;
+            };
+            result: Storage;
+            errors: Errors.CONTRACT_NOT_FOUND | Errors.INVALID_BLOCK_ID;
+        };
+        starknet_getTransactionByHash: {
+            params: {
+                transaction_hash: TXN_HASH;
+            };
+            result: Transaction;
+            errors: Errors.INVALID_TXN_HASH;
+        };
+        starknet_getTransactionByBlockIdAndIndex: {
+            params: {
+                block_id: BLOCK_ID;
+                index: number;
+            };
+            result: Transaction;
+            errors: Errors.INVALID_BLOCK_ID | Errors.INVALID_TXN_INDEX;
+        };
+        starknet_getTransactionReceipt: {
+            params: {
+                transaction_hash: TXN_HASH;
+            };
+            result: TransactionReceipt;
+            errors: Errors.INVALID_TXN_HASH;
+        };
+        starknet_getClass: {
+            params: {
+                class_hash: FELT;
+            };
+            result: ContractClass;
+            errors: Errors.INVALID_CONTRACT_CLASS_HASH;
+        };
+        starknet_getClassHashAt: {
+            params: {
+                block_id: BLOCK_ID;
+                contract_address: ADDRESS;
+            };
+            result: FELT;
+            errors: Errors.INVALID_BLOCK_ID | Errors.CONTRACT_NOT_FOUND;
+        };
+        starknet_getClassAt: {
+            params: {
+                block_id: BLOCK_ID;
+                contract_address: ADDRESS;
+            };
+            result: ContractClass;
+            errors: Errors.INVALID_BLOCK_ID | Errors.CONTRACT_NOT_FOUND;
+        };
+        starknet_getBlockTransactionCount: {
+            params: {
+                block_id: BLOCK_ID;
+            };
+            result: number;
+            errors: Errors.INVALID_BLOCK_ID;
+        };
+        starknet_call: {
+            params: {
+                request: FUNCTION_CALL;
+                block_id: BLOCK_ID;
+            };
+            result: Array<FELT>;
+            errors: Errors.CONTRACT_NOT_FOUND | Errors.INVALID_MESSAGE_SELECTOR | Errors.INVALID_CALL_DATA | Errors.CONTRACT_ERROR | Errors.INVALID_BLOCK_ID;
+        };
+        starknet_estimateFee: {
+            params: {
+                request: INVOKE_TXN;
+                block_id: BLOCK_ID;
+            };
+            result: FEE_ESTIMATE;
+            errors: Errors.CONTRACT_NOT_FOUND | Errors.INVALID_MESSAGE_SELECTOR | Errors.INVALID_CALL_DATA | Errors.CONTRACT_ERROR | Errors.INVALID_BLOCK_ID;
+        };
+        starknet_blockNumber: {
+            result: BLOCK_NUMBER;
+            errors: Errors.NO_BLOCKS;
+        };
+        starknet_blockHashAndNumber: {
+            result: BLOCK_HASH & BLOCK_NUMBER;
+            errors: Errors.NO_BLOCKS;
+        };
+        starknet_chainId: {
+            result: CHAIN_ID;
+        };
+        starknet_pendingTransactions: {
+            result: PendingTransactions;
+        };
+        starknet_syncing: {
+            result: SyncingStatus;
+        };
+        starknet_getEvents: {
+            params: {
+                filter: EVENT_FILTER & RESULT_PAGE_REQUEST;
+            };
+            result: {
+                events: EMITTED_EVENT;
+                page_number: number;
+                is_last_page: boolean;
+            };
+            errors: Errors.PAGE_SIZE_TOO_BIG;
+        };
+        starknet_getNonce: {
+            params: {
+                contract_address: ADDRESS;
+            };
+            result: FELT;
+            errors: Errors.CONTRACT_NOT_FOUND;
+        };
+        starknet_addInvokeTransaction: {
+            params: {
+                function_invocation: FUNCTION_CALL;
+                signature: SIGNATURE;
+                max_fee: NUM_AS_HEX;
+                version: NUM_AS_HEX;
+            };
+            result: InvokedTransaction;
+        };
+        starknet_addDeclareTransaction: {
+            params: {
+                contract_class: CONTRACT_CLASS;
+                version: NUM_AS_HEX;
+            };
+            result: DeclaredTransaction;
+            errors: Errors.INVALID_CONTRACT_CLASS;
+        };
+        starknet_addDeployTransaction: {
+            params: {
+                contract_address_salt: FELT;
+                constructor_calldata: FELT;
+                contract_definition: CONTRACT_CLASS;
+            };
+            result: DeployedTransaction;
+            errors: Errors.INVALID_CONTRACT_CLASS;
+        };
+        starknet_traceTransaction: {
+            params: {
+                transaction_hash: TXN_HASH;
+            };
+            result: Trace;
+            errors: Errors.INVALID_TXN_HASH | Errors.NO_TRACE_AVAILABLE | Errors.INVALID_BLOCK_HASH | Errors.INVALID_TXN_HASH;
+        };
+        starknet_traceBlockTransactions: {
+            params: {
+                block_hash: BLOCK_HASH;
+            };
+            result: Traces;
+            errors: Errors.INVALID_BLOCK_HASH;
+        };
+    };
+}
+export declare namespace Errors {
+    interface FAILED_TO_RECEIVE_TXN {
+        code: 1;
+        message: 'Failed to write transaction';
+    }
+    interface CONTRACT_NOT_FOUND {
+        code: 20;
+        message: 'Contract not found';
+    }
+    interface INVALID_MESSAGE_SELECTOR {
+        code: 21;
+        message: 'Invalid message selector';
+    }
+    interface INVALID_CALL_DATA {
+        code: 22;
+        message: 'Invalid call data';
+    }
+    interface INVALID_BLOCK_ID {
+        code: 24;
+        message: 'Invalid block id';
+    }
+    interface INVALID_TXN_INDEX {
+        code: 27;
+        message: 'Invalid transaction index in a block';
+    }
+    interface INVALID_CONTRACT_CLASS_HASH {
+        code: 28;
+        message: 'The supplied contract class hash is invalid or unknown';
+    }
+    interface PAGE_SIZE_TOO_BIG {
+        code: 31;
+        message: 'Requested page size is too big';
+    }
+    interface NO_BLOCKS {
+        code: 32;
+        message: 'There are no blocks';
+    }
+    interface CONTRACT_ERROR {
+        code: 40;
+        message: 'Contract error';
+    }
+    interface INVALID_CONTRACT_CLASS {
+        code: 50;
+        message: 'Invalid contract class';
+    }
+    interface NO_TRACE_AVAILABLE {
+        code: 10;
+        message: 'No trace available for transaction';
+        data: {
+            status: 'RECEIVED' | 'REJECTED';
+        };
+    }
+    interface INVALID_BLOCK_HASH {
+        code: 24;
+        message: 'Invalid block hash';
+    }
+    interface INVALID_TXN_HASH {
+        code: 25;
+        message: 'Invalid transaction hash';
+    }
 }
 export {};

package/types/api/openrpc.js

@@ -1,9 +1,27 @@
 "use strict";
 /**
  * Starknet RPC version 0.1.0
- * starknet_api_openrpc version 0.31.0
  *
- * TypeScript Representation of OpenRpc protocol types | results
- * errors are not implemented here only results
+ * StarkNet Node API 0.31.0
+ * StarkNet Node Write API 0.3.0
+ * StarkNet Trace API 0.3.0
+ *
+ * TypeScript Representation of OpenRpc protocol types
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+var BLOCK_TAG;
+(function (BLOCK_TAG) {
+    BLOCK_TAG[BLOCK_TAG["latest"] = 0] = "latest";
+    BLOCK_TAG[BLOCK_TAG["pending"] = 1] = "pending";
+})(BLOCK_TAG || (BLOCK_TAG = {}));
+var CALL_TYPE;
+(function (CALL_TYPE) {
+    CALL_TYPE[CALL_TYPE["DELEGATE"] = 0] = "DELEGATE";
+    CALL_TYPE[CALL_TYPE["CALL"] = 1] = "CALL";
+})(CALL_TYPE || (CALL_TYPE = {}));
+var ENTRY_POINT_TYPE;
+(function (ENTRY_POINT_TYPE) {
+    ENTRY_POINT_TYPE[ENTRY_POINT_TYPE["EXTERNAL"] = 0] = "EXTERNAL";
+    ENTRY_POINT_TYPE[ENTRY_POINT_TYPE["L1_HANDLER"] = 1] = "L1_HANDLER";
+    ENTRY_POINT_TYPE[ENTRY_POINT_TYPE["CONSTRUCTOR"] = 2] = "CONSTRUCTOR";
+})(ENTRY_POINT_TYPE || (ENTRY_POINT_TYPE = {}));