starknet 4.5.0 → 4.6.0

package/dist/provider/utils.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="bn.js" />
 import type { BlockNumber } from '../types';
 import { BigNumberish } from '../utils/number';
 /**
@@ -17,38 +16,15 @@ export declare function formatHash(hashValue: BigNumberish): string;
  */
 export declare function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string;
 export declare type BlockIdentifier = BlockNumber | BigNumberish;
-declare type BlockIdentifierObject = {
-    type: 'BLOCK_NUMBER';
-    data: BlockNumber;
-} | {
-    type: 'BLOCK_HASH';
-    data: BigNumberish;
-};
-export declare class BlockIdentifierClass {
-    blockIdentifier: BlockIdentifier;
-    constructor(blockIdentifier: BlockIdentifier);
-    getIdentifier(): string | import("bn.js") | {
-        block_hash: string;
-        block_number?: undefined;
-    } | {
-        block_number: number;
-        block_hash?: undefined;
-    } | null;
+export declare class Block {
+    hash: BlockIdentifier;
+    number: BlockIdentifier;
+    tag: BlockIdentifier;
+    private setIdentifier;
+    constructor(_identifier: BlockIdentifier);
+    get queryIdentifier(): any;
+    get identifier(): any;
+    set identifier(_identifier: BlockIdentifier);
+    valueOf: () => BlockIdentifier;
+    toString: () => BlockIdentifier;
 }
-/**
- * Identifies the block to be queried.
- *
- * @param blockIdentifier - block identifier
- * @returns block identifier object
- */
-export declare function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdentifierObject;
-/**
- * Gets the block identifier for API request
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L164-L173)
- *
- * @param blockIdentifier
- * @returns block identifier for API request
- */
-export declare function getFormattedBlockIdentifier(blockIdentifier?: BlockIdentifier): string;
-export {};

package/dist/provider/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.BlockIdentifierClass = exports.txIdentifier = exports.formatHash = void 0;
+exports.Block = exports.txIdentifier = exports.formatHash = void 0;
 var number_1 = require("../utils/number");
 /**
  *
@@ -29,67 +29,56 @@ function txIdentifier(txHash, txId) {
     return "transactionHash=".concat(hashString);
 }
 exports.txIdentifier = txIdentifier;
-var BlockIdentifierClass = /** @class */ (function () {
-    function BlockIdentifierClass(blockIdentifier) {
-        this.blockIdentifier = blockIdentifier;
+var Block = /** @class */ (function () {
+    function Block(_identifier) {
+        var _this = this;
+        this.hash = null;
+        this.number = null;
+        this.tag = null;
+        this.valueOf = function () { return _this.number; };
+        this.toString = function () { return _this.hash; };
+        this.setIdentifier = function (__identifier) {
+            if (typeof __identifier === 'string' && (0, number_1.isHex)(__identifier)) {
+                this.hash = __identifier;
+            }
+            else if (typeof __identifier === 'number') {
+                this.number = __identifier;
+            }
+            else {
+                this.tag = __identifier;
+            }
+        };
+        this.setIdentifier(_identifier);
     }
-    BlockIdentifierClass.prototype.getIdentifier = function () {
-        if (typeof this.blockIdentifier === 'string' && (0, number_1.isHex)(this.blockIdentifier)) {
-            return { block_hash: this.blockIdentifier };
-        }
-        if (typeof this.blockIdentifier === 'number') {
-            return { block_number: this.blockIdentifier };
-        }
-        return this.blockIdentifier;
-    };
-    return BlockIdentifierClass;
+    Object.defineProperty(Block.prototype, "queryIdentifier", {
+        get: function () {
+            if (this.number !== null) {
+                return "blockNumber=".concat(this.number);
+            }
+            if (this.hash !== null) {
+                return "blockHash=".concat(this.hash);
+            }
+            return "blockNumber=".concat(this.tag);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(Block.prototype, "identifier", {
+        get: function () {
+            if (this.number !== null) {
+                return { block_number: this.number };
+            }
+            if (this.hash !== null) {
+                return { block_hash: this.hash };
+            }
+            return this.tag;
+        },
+        set: function (_identifier) {
+            this.setIdentifier(_identifier);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return Block;
 }());
-exports.BlockIdentifierClass = BlockIdentifierClass;
-/**
- * Identifies the block to be queried.
- *
- * @param blockIdentifier - block identifier
- * @returns block identifier object
- */
-function getBlockIdentifier(blockIdentifier) {
-    if (blockIdentifier === null || blockIdentifier === 'latest') {
-        return { type: 'BLOCK_NUMBER', data: 'latest' }; // default to latest block
-    }
-    if (blockIdentifier === 'pending') {
-        return { type: 'BLOCK_NUMBER', data: 'pending' };
-    }
-    if (typeof blockIdentifier === 'number' || typeof blockIdentifier === 'bigint') {
-        return { type: 'BLOCK_NUMBER', data: blockIdentifier };
-    }
-    if (typeof blockIdentifier === 'string' && blockIdentifier.startsWith('0x')) {
-        return { type: 'BLOCK_HASH', data: blockIdentifier };
-    }
-    if (typeof blockIdentifier === 'string' && !Number.isNaN(parseInt(blockIdentifier, 10))) {
-        return { type: 'BLOCK_NUMBER', data: parseInt(blockIdentifier, 10) };
-    }
-    if (typeof blockIdentifier === 'string') {
-        throw new Error("Invalid block identifier: ".concat(blockIdentifier));
-    }
-    return { type: 'BLOCK_HASH', data: blockIdentifier };
-}
-exports.getBlockIdentifier = getBlockIdentifier;
-/**
- * Gets the block identifier for API request
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L164-L173)
- *
- * @param blockIdentifier
- * @returns block identifier for API request
- */
-function getFormattedBlockIdentifier(blockIdentifier) {
-    if (blockIdentifier === void 0) { blockIdentifier = null; }
-    var blockIdentifierObject = getBlockIdentifier(blockIdentifier);
-    if (blockIdentifierObject.type === 'BLOCK_NUMBER' && blockIdentifierObject.data === null) {
-        return '';
-    }
-    if (blockIdentifierObject.type === 'BLOCK_NUMBER') {
-        return "blockNumber=".concat(blockIdentifierObject.data);
-    }
-    return "blockHash=".concat((0, number_1.toHex)((0, number_1.toBN)(blockIdentifierObject.data)));
-}
-exports.getFormattedBlockIdentifier = getFormattedBlockIdentifier;
+exports.Block = Block;

package/dist/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/dist/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 = {}));