starknet 6.9.0 → 6.10.1

package/dist/types/api/rpcspec_0_6/errors.d.ts

@@ -0,0 +1,128 @@
+export interface FAILED_TO_RECEIVE_TXN {
+    code: 1;
+    message: 'Failed to write transaction';
+}
+export interface NO_TRACE_AVAILABLE {
+    code: 10;
+    message: 'No trace available for transaction';
+    data: {
+        status: 'RECEIVED' | 'REJECTED';
+    };
+}
+export interface CONTRACT_NOT_FOUND {
+    code: 20;
+    message: 'Contract not found';
+}
+export interface INVALID_MESSAGE_SELECTOR {
+    code: 21;
+    message: 'Invalid message selector';
+}
+export interface INVALID_CALL_DATA {
+    code: 22;
+    message: 'Invalid call data';
+}
+export interface BLOCK_NOT_FOUND {
+    code: 24;
+    message: 'Block not found';
+}
+export interface INVALID_BLOCK_HASH {
+    code: 26;
+    message: 'Invalid block hash';
+}
+export interface INVALID_TXN_INDEX {
+    code: 27;
+    message: 'Invalid transaction index in a block';
+}
+export interface CLASS_HASH_NOT_FOUND {
+    code: 28;
+    message: 'Class hash not found';
+}
+export interface TXN_HASH_NOT_FOUND {
+    code: 29;
+    message: 'Transaction hash not found';
+}
+export interface PAGE_SIZE_TOO_BIG {
+    code: 31;
+    message: 'Requested page size is too big';
+}
+export interface NO_BLOCKS {
+    code: 32;
+    message: 'There are no blocks';
+}
+export interface INVALID_CONTINUATION_TOKEN {
+    code: 33;
+    message: 'The supplied continuation token is invalid or unknown';
+}
+export interface TOO_MANY_KEYS_IN_FILTER {
+    code: 34;
+    message: 'Too many keys provided in a filter';
+}
+export interface CONTRACT_ERROR {
+    code: 40;
+    message: 'Contract error';
+    data: {
+        revert_error: string;
+    };
+}
+export interface TRANSACTION_EXECUTION_ERROR {
+    code: 41;
+    message: 'Transaction execution error';
+    data: {
+        transaction_index: number;
+        execution_error: string;
+    };
+}
+export interface CLASS_ALREADY_DECLARED {
+    code: 51;
+    message: 'Class already declared';
+}
+export interface INVALID_TRANSACTION_NONCE {
+    code: 52;
+    message: 'Invalid transaction nonce';
+}
+export interface INSUFFICIENT_MAX_FEE {
+    code: 53;
+    message: 'Max fee is smaller than the minimal transaction cost (validation plus fee transfer)';
+}
+export interface INSUFFICIENT_ACCOUNT_BALANCE {
+    code: 54;
+    message: "Account balance is smaller than the transaction's max_fee";
+}
+export interface VALIDATION_FAILURE {
+    code: 55;
+    message: 'Account validation failed';
+    data: string;
+}
+export interface COMPILATION_FAILED {
+    code: 56;
+    message: 'Compilation failed';
+}
+export interface CONTRACT_CLASS_SIZE_IS_TOO_LARGE {
+    code: 57;
+    message: 'Contract class size it too large';
+}
+export interface NON_ACCOUNT {
+    code: 58;
+    message: 'Sender address in not an account contract';
+}
+export interface DUPLICATE_TX {
+    code: 59;
+    message: 'A transaction with the same hash already exists in the mempool';
+}
+export interface COMPILED_CLASS_HASH_MISMATCH {
+    code: 60;
+    message: 'the compiled class hash did not match the one supplied in the transaction';
+}
+export interface UNSUPPORTED_TX_VERSION {
+    code: 61;
+    message: 'the transaction version is not supported';
+}
+export interface UNSUPPORTED_CONTRACT_CLASS_VERSION {
+    code: 62;
+    message: 'the contract class version is not supported';
+}
+export interface UNEXPECTED_ERROR {
+    code: 63;
+    message: 'An unexpected error occurred';
+    data: string;
+}

package/dist/types/api/rpcspec_0_6/index.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Methods: true,
+  ABI: true,
+  Errors: true,
+  SPEC: true
+};
+Object.defineProperty(exports, "ABI", {
+  enumerable: true,
+  get: function () {
+    return _contract.ABI;
+  }
+});
+exports.Errors = void 0;
+Object.defineProperty(exports, "Methods", {
+  enumerable: true,
+  get: function () {
+    return _methods.Methods;
+  }
+});
+exports.SPEC = void 0;
+var _methods = require("./methods.cjs");
+var _contract = require("./contract.cjs");
+var _Errors = _interopRequireWildcard(require("./errors.cjs"));
+exports.Errors = _Errors;
+var _SPEC = _interopRequireWildcard(require("./components.cjs"));
+exports.SPEC = _SPEC;
+var _nonspec = require("./nonspec.cjs");
+Object.keys(_nonspec).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _nonspec[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nonspec[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/dist/types/api/rpcspec_0_6/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * version 0.6.0
+ */
+export { Methods } from './methods';
+export { ABI } from './contract';
+export * as Errors from './errors';
+export * as SPEC from './components';
+export * from './nonspec';

package/dist/types/api/rpcspec_0_6/index.mjs

@@ -0,0 +1,5 @@
+export { Methods } from "./methods.mjs";
+export { ABI } from "./contract.mjs";
+export * as Errors from "./errors.mjs";
+export * as SPEC from "./components.mjs";
+export * from "./nonspec.mjs";

package/dist/types/api/rpcspec_0_6/methods.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/api/rpcspec_0_6/methods.d.ts

@@ -0,0 +1,207 @@
+import { ADDRESS, BLOCK_ID, BLOCK_NUMBER, BROADCASTED_DECLARE_TXN, BROADCASTED_DEPLOY_ACCOUNT_TXN, BROADCASTED_INVOKE_TXN, BROADCASTED_TXN, CHAIN_ID, EVENT_FILTER, FELT, FUNCTION_CALL, MSG_FROM_L1, RESULT_PAGE_REQUEST, SIMULATION_FLAG, SIMULATION_FLAG_FOR_ESTIMATE_FEE, STORAGE_KEY, TXN_HASH } from './components';
+import * as Errors from './errors';
+import { BlockHashAndNumber, BlockTransactionsTraces, BlockWithTxHashes, BlockWithTxs, ContractClass, DeclaredTransaction, DeployedAccountTransaction, Events, FeeEstimate, InvokedTransaction, Nonce, SimulateTransactionResponse, StateUpdate, Syncing, TransactionReceipt, TransactionStatus, TransactionTrace, TransactionWithHash } from './nonspec';
+export type Methods = ReadMethods & WriteMethods & TraceMethods;
+type ReadMethods = {
+    starknet_specVersion: {
+        params: [];
+        result: string;
+    };
+    starknet_getBlockWithTxHashes: {
+        params: {
+            block_id: BLOCK_ID;
+        };
+        result: BlockWithTxHashes;
+        errors: Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_getBlockWithTxs: {
+        params: {
+            block_id: BLOCK_ID;
+        };
+        result: BlockWithTxs;
+        errors: Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_getStateUpdate: {
+        params: {
+            block_id: BLOCK_ID;
+        };
+        result: StateUpdate;
+        errors: Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_getStorageAt: {
+        params: {
+            contract_address: ADDRESS;
+            key: STORAGE_KEY;
+            block_id: BLOCK_ID;
+        };
+        result: FELT;
+        errors: Errors.CONTRACT_NOT_FOUND | Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_getTransactionStatus: {
+        params: {
+            transaction_hash: TXN_HASH;
+        };
+        result: TransactionStatus;
+        errors: Errors.TXN_HASH_NOT_FOUND;
+    };
+    starknet_getTransactionByHash: {
+        params: {
+            transaction_hash: TXN_HASH;
+        };
+        result: TransactionWithHash;
+        errors: Errors.TXN_HASH_NOT_FOUND;
+    };
+    starknet_getTransactionByBlockIdAndIndex: {
+        params: {
+            block_id: BLOCK_ID;
+            index: number;
+        };
+        result: TransactionWithHash;
+        errors: Errors.BLOCK_NOT_FOUND | Errors.INVALID_TXN_INDEX;
+    };
+    starknet_getTransactionReceipt: {
+        params: {
+            transaction_hash: TXN_HASH;
+        };
+        result: TransactionReceipt;
+        errors: Errors.TXN_HASH_NOT_FOUND;
+    };
+    starknet_getClass: {
+        params: {
+            block_id: BLOCK_ID;
+            class_hash: FELT;
+        };
+        result: ContractClass;
+        errors: Errors.BLOCK_NOT_FOUND | Errors.CLASS_HASH_NOT_FOUND;
+    };
+    starknet_getClassHashAt: {
+        params: {
+            block_id: BLOCK_ID;
+            contract_address: ADDRESS;
+        };
+        result: FELT;
+        errors: Errors.BLOCK_NOT_FOUND | Errors.CONTRACT_NOT_FOUND;
+    };
+    starknet_getClassAt: {
+        params: {
+            block_id: BLOCK_ID;
+            contract_address: ADDRESS;
+        };
+        result: ContractClass;
+        errors: Errors.BLOCK_NOT_FOUND | Errors.CONTRACT_NOT_FOUND;
+    };
+    starknet_getBlockTransactionCount: {
+        params: {
+            block_id: BLOCK_ID;
+        };
+        result: number;
+        errors: Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_call: {
+        params: {
+            request: FUNCTION_CALL;
+            block_id: BLOCK_ID;
+        };
+        result: FELT[];
+        errors: Errors.CONTRACT_NOT_FOUND | Errors.CONTRACT_ERROR | Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_estimateFee: {
+        params: {
+            request: BROADCASTED_TXN[];
+            simulation_flags?: [SIMULATION_FLAG_FOR_ESTIMATE_FEE] | [];
+            block_id: BLOCK_ID;
+        };
+        result: FeeEstimate[];
+        errors: Errors.TRANSACTION_EXECUTION_ERROR | Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_estimateMessageFee: {
+        params: {
+            message: MSG_FROM_L1;
+            block_id: BLOCK_ID;
+        };
+        result: FeeEstimate;
+        errors: Errors.CONTRACT_ERROR | Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_blockNumber: {
+        params: [];
+        result: BLOCK_NUMBER;
+        errors: Errors.NO_BLOCKS;
+    };
+    starknet_blockHashAndNumber: {
+        params: [];
+        result: BlockHashAndNumber;
+        errors: Errors.NO_BLOCKS;
+    };
+    starknet_chainId: {
+        params: [];
+        result: CHAIN_ID;
+    };
+    starknet_syncing: {
+        params: [];
+        result: Syncing;
+    };
+    starknet_getEvents: {
+        params: {
+            filter: EVENT_FILTER & RESULT_PAGE_REQUEST;
+        };
+        result: Events;
+        errors: Errors.PAGE_SIZE_TOO_BIG | Errors.INVALID_CONTINUATION_TOKEN | Errors.BLOCK_NOT_FOUND | Errors.TOO_MANY_KEYS_IN_FILTER;
+    };
+    starknet_getNonce: {
+        params: {
+            block_id: BLOCK_ID;
+            contract_address: ADDRESS;
+        };
+        result: Nonce;
+        errors: Errors.BLOCK_NOT_FOUND | Errors.CONTRACT_NOT_FOUND;
+    };
+};
+type WriteMethods = {
+    starknet_addInvokeTransaction: {
+        params: {
+            invoke_transaction: BROADCASTED_INVOKE_TXN;
+        };
+        result: InvokedTransaction;
+        errors: Errors.INSUFFICIENT_ACCOUNT_BALANCE | Errors.INSUFFICIENT_MAX_FEE | Errors.INVALID_TRANSACTION_NONCE | Errors.VALIDATION_FAILURE | Errors.NON_ACCOUNT | Errors.DUPLICATE_TX | Errors.UNSUPPORTED_TX_VERSION | Errors.UNEXPECTED_ERROR;
+    };
+    starknet_addDeclareTransaction: {
+        params: {
+            declare_transaction: BROADCASTED_DECLARE_TXN;
+        };
+        result: DeclaredTransaction;
+        errors: Errors.CLASS_ALREADY_DECLARED | Errors.COMPILATION_FAILED | Errors.COMPILED_CLASS_HASH_MISMATCH | Errors.INSUFFICIENT_ACCOUNT_BALANCE | Errors.INSUFFICIENT_MAX_FEE | Errors.INVALID_TRANSACTION_NONCE | Errors.VALIDATION_FAILURE | Errors.NON_ACCOUNT | Errors.DUPLICATE_TX | Errors.CONTRACT_CLASS_SIZE_IS_TOO_LARGE | Errors.UNSUPPORTED_TX_VERSION | Errors.UNSUPPORTED_CONTRACT_CLASS_VERSION | Errors.UNEXPECTED_ERROR;
+    };
+    starknet_addDeployAccountTransaction: {
+        params: {
+            deploy_account_transaction: BROADCASTED_DEPLOY_ACCOUNT_TXN;
+        };
+        result: DeployedAccountTransaction;
+        errors: Errors.INSUFFICIENT_ACCOUNT_BALANCE | Errors.INSUFFICIENT_MAX_FEE | Errors.INVALID_TRANSACTION_NONCE | Errors.VALIDATION_FAILURE | Errors.NON_ACCOUNT | Errors.CLASS_HASH_NOT_FOUND | Errors.DUPLICATE_TX | Errors.UNSUPPORTED_TX_VERSION | Errors.UNEXPECTED_ERROR;
+    };
+};
+type TraceMethods = {
+    starknet_traceTransaction: {
+        params: {
+            transaction_hash: TXN_HASH;
+        };
+        result: TransactionTrace;
+        errors: Errors.TXN_HASH_NOT_FOUND | Errors.NO_TRACE_AVAILABLE;
+    };
+    starknet_traceBlockTransactions: {
+        params: {
+            block_id: BLOCK_ID;
+        };
+        result: BlockTransactionsTraces;
+        errors: Errors.BLOCK_NOT_FOUND;
+    };
+    starknet_simulateTransactions: {
+        params: {
+            block_id: BLOCK_ID;
+            transactions: Array<BROADCASTED_TXN>;
+            simulation_flags: Array<SIMULATION_FLAG>;
+        };
+        result: SimulateTransactionResponse;
+        errors: Errors.BLOCK_NOT_FOUND | Errors.TRANSACTION_EXECUTION_ERROR;
+    };
+};
+export {};

package/dist/types/api/rpcspec_0_6/nonspec.cjs

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ETransactionVersion3 = exports.ETransactionVersion2 = exports.ETransactionVersion = exports.ETransactionType = exports.ETransactionStatus = exports.ETransactionFinalityStatus = exports.ETransactionExecutionStatus = exports.ESimulationFlag = exports.EDataAvailabilityMode = exports.EDAMode = exports.EBlockTag = void 0;
+const ETransactionType = exports.ETransactionType = {
+  DECLARE: "DECLARE",
+  DEPLOY: "DEPLOY",
+  DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+  INVOKE: "INVOKE",
+  L1_HANDLER: "L1_HANDLER"
+};
+const ESimulationFlag = exports.ESimulationFlag = {
+  SKIP_VALIDATE: "SKIP_VALIDATE",
+  SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
+};
+const ETransactionStatus = exports.ETransactionStatus = {
+  RECEIVED: "RECEIVED",
+  REJECTED: "REJECTED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+const ETransactionFinalityStatus = exports.ETransactionFinalityStatus = {
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+const ETransactionExecutionStatus = exports.ETransactionExecutionStatus = {
+  SUCCEEDED: "SUCCEEDED",
+  REVERTED: "REVERTED"
+};
+const EBlockTag = exports.EBlockTag = {
+  PENDING: "pending",
+  LATEST: "latest"
+};
+const EDataAvailabilityMode = exports.EDataAvailabilityMode = {
+  L1: "L1",
+  L2: "L2"
+};
+const EDAMode = exports.EDAMode = {
+  L1: 0,
+  L2: 1
+};
+const ETransactionVersion = exports.ETransactionVersion = {
+  V0: "0x0",
+  V1: "0x1",
+  V2: "0x2",
+  V3: "0x3",
+  F0: "0x100000000000000000000000000000000",
+  F1: "0x100000000000000000000000000000001",
+  F2: "0x100000000000000000000000000000002",
+  F3: "0x100000000000000000000000000000003"
+};
+const ETransactionVersion2 = exports.ETransactionVersion2 = {
+  V0: "0x0",
+  V1: "0x1",
+  V2: "0x2",
+  F0: "0x100000000000000000000000000000000",
+  F1: "0x100000000000000000000000000000001",
+  F2: "0x100000000000000000000000000000002"
+};
+const ETransactionVersion3 = exports.ETransactionVersion3 = {
+  V3: "0x3",
+  F3: "0x100000000000000000000000000000003"
+};

package/dist/types/api/rpcspec_0_6/nonspec.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Types that are not in spec but required for UX
+ */
+import { ADDRESS, BLOCK_HASH, BLOCK_NUMBER, BLOCK_WITH_TXS, BLOCK_WITH_TX_HASHES, BROADCASTED_TXN, CHAIN_ID, CONTRACT_CLASS, CONTRACT_STORAGE_DIFF_ITEM, DEPRECATED_CONTRACT_CLASS, EMITTED_EVENT, EVENT, EVENTS_CHUNK, EVENT_FILTER, FEE_ESTIMATE, FEE_PAYMENT, FELT, MSG_FROM_L1, NONCE_UPDATE, PENDING_BLOCK_WITH_TXS, PENDING_BLOCK_WITH_TX_HASHES, PENDING_STATE_UPDATE, PENDING_TXN_RECEIPT, PRICE_UNIT, REPLACED_CLASS, RESOURCE_BOUNDS_MAPPING, RESULT_PAGE_REQUEST, SIMULATION_FLAG, STATE_UPDATE, SYNC_STATUS, TRANSACTION_TRACE, TXN, TXN_EXECUTION_STATUS, TXN_HASH, TXN_RECEIPT, TXN_STATUS } from './components';
+import { ValuesType } from '../../helpers/valuesType';
+export type ContractClass = CONTRACT_CLASS | DEPRECATED_CONTRACT_CLASS;
+export type SimulateTransaction = {
+    transaction_trace: TRANSACTION_TRACE;
+    fee_estimation: FEE_ESTIMATE;
+};
+export type SimulateTransactionResponse = SimulateTransaction[];
+export type FeeEstimate = FEE_ESTIMATE;
+export type TransactionWithHash = TXN & {
+    transaction_hash: TXN_HASH;
+};
+export type BlockHashAndNumber = {
+    block_hash: BLOCK_HASH;
+    block_number: BLOCK_NUMBER;
+};
+export type BlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
+export type BlockWithTxHashes = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
+export type StateUpdate = STATE_UPDATE | PENDING_STATE_UPDATE;
+export type BlockTransactionsTraces = {
+    transaction_hash: FELT;
+    trace_root: TRANSACTION_TRACE;
+}[];
+export type Syncing = false | SYNC_STATUS;
+export type Events = EVENTS_CHUNK;
+export type EmittedEvent = EMITTED_EVENT;
+export type Event = EVENT;
+export type InvokedTransaction = {
+    transaction_hash: TXN_HASH;
+};
+export type DeclaredTransaction = {
+    transaction_hash: TXN_HASH;
+    class_hash: FELT;
+};
+export type DeployedAccountTransaction = {
+    transaction_hash: TXN_HASH;
+    contract_address: FELT;
+};
+export type ContractAddress = ADDRESS;
+export type Felt = FELT;
+export type Nonce = FELT;
+export type TransactionHash = TXN_HASH;
+export type TransactionTrace = TRANSACTION_TRACE;
+export type BlockHash = BLOCK_HASH;
+export type TransactionReceipt = TXN_RECEIPT | PENDING_TXN_RECEIPT;
+export type Receipt = TXN_RECEIPT;
+export type PendingReceipt = PENDING_TXN_RECEIPT;
+export type EventFilter = EVENT_FILTER & RESULT_PAGE_REQUEST;
+export type SimulationFlags = Array<SIMULATION_FLAG>;
+export type L1Message = MSG_FROM_L1;
+export type BaseTransaction = BROADCASTED_TXN;
+export type ChainId = CHAIN_ID;
+export type Transaction = TXN;
+export type TransactionStatus = {
+    finality_status: TXN_STATUS;
+    execution_status?: TXN_EXECUTION_STATUS;
+};
+export type ResourceBounds = RESOURCE_BOUNDS_MAPPING;
+export type FeePayment = FEE_PAYMENT;
+export type PriceUnit = PRICE_UNIT;
+export type StorageDiffs = Array<CONTRACT_STORAGE_DIFF_ITEM>;
+export type DeprecatedDeclaredClasses = Array<FELT>;
+export type NonceUpdates = NONCE_UPDATE[];
+export type ReplacedClasses = REPLACED_CLASS[];
+export declare const ETransactionType: {
+    readonly DECLARE: "DECLARE";
+    readonly DEPLOY: "DEPLOY";
+    readonly DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT";
+    readonly INVOKE: "INVOKE";
+    readonly L1_HANDLER: "L1_HANDLER";
+};
+export type ETransactionType = ValuesType<typeof ETransactionType>;
+export declare const ESimulationFlag: {
+    readonly SKIP_VALIDATE: "SKIP_VALIDATE";
+    readonly SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE";
+};
+export type ESimulationFlag = ValuesType<typeof ESimulationFlag>;
+export declare const ETransactionStatus: {
+    readonly RECEIVED: "RECEIVED";
+    readonly REJECTED: "REJECTED";
+    readonly ACCEPTED_ON_L2: "ACCEPTED_ON_L2";
+    readonly ACCEPTED_ON_L1: "ACCEPTED_ON_L1";
+};
+export type ETransactionStatus = ValuesType<typeof ETransactionStatus>;
+export declare const ETransactionFinalityStatus: {
+    readonly ACCEPTED_ON_L2: "ACCEPTED_ON_L2";
+    readonly ACCEPTED_ON_L1: "ACCEPTED_ON_L1";
+};
+export type ETransactionFinalityStatus = ValuesType<typeof ETransactionFinalityStatus>;
+export declare const ETransactionExecutionStatus: {
+    readonly SUCCEEDED: "SUCCEEDED";
+    readonly REVERTED: "REVERTED";
+};
+export type ETransactionExecutionStatus = ValuesType<typeof ETransactionExecutionStatus>;
+export declare const EBlockTag: {
+    readonly PENDING: "pending";
+    readonly LATEST: "latest";
+};
+export type EBlockTag = ValuesType<typeof EBlockTag>;
+export declare const EDataAvailabilityMode: {
+    readonly L1: "L1";
+    readonly L2: "L2";
+};
+export type EDataAvailabilityMode = ValuesType<typeof EDataAvailabilityMode>;
+export declare const EDAMode: {
+    readonly L1: 0;
+    readonly L2: 1;
+};
+export type EDAMode = ValuesType<typeof EDAMode>;
+/**
+ * V_ Transaction versions HexString
+ * F_ Fee Transaction Versions HexString (2 ** 128 + TRANSACTION_VERSION)
+ */
+export declare const ETransactionVersion: {
+    readonly V0: "0x0";
+    readonly V1: "0x1";
+    readonly V2: "0x2";
+    readonly V3: "0x3";
+    readonly F0: "0x100000000000000000000000000000000";
+    readonly F1: "0x100000000000000000000000000000001";
+    readonly F2: "0x100000000000000000000000000000002";
+    readonly F3: "0x100000000000000000000000000000003";
+};
+export type ETransactionVersion = ValuesType<typeof ETransactionVersion>;
+/**
+ * Old Transaction Versions
+ */
+export declare const ETransactionVersion2: {
+    readonly V0: "0x0";
+    readonly V1: "0x1";
+    readonly V2: "0x2";
+    readonly F0: "0x100000000000000000000000000000000";
+    readonly F1: "0x100000000000000000000000000000001";
+    readonly F2: "0x100000000000000000000000000000002";
+};
+export type ETransactionVersion2 = ValuesType<typeof ETransactionVersion2>;
+/**
+ * V3 Transaction Versions
+ */
+export declare const ETransactionVersion3: {
+    readonly V3: "0x3";
+    readonly F3: "0x100000000000000000000000000000003";
+};
+export type ETransactionVersion3 = ValuesType<typeof ETransactionVersion3>;

package/dist/types/api/rpcspec_0_6/nonspec.mjs

@@ -0,0 +1,59 @@
+export const ETransactionType = {
+  DECLARE: "DECLARE",
+  DEPLOY: "DEPLOY",
+  DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+  INVOKE: "INVOKE",
+  L1_HANDLER: "L1_HANDLER"
+};
+export const ESimulationFlag = {
+  SKIP_VALIDATE: "SKIP_VALIDATE",
+  SKIP_FEE_CHARGE: "SKIP_FEE_CHARGE"
+};
+export const ETransactionStatus = {
+  RECEIVED: "RECEIVED",
+  REJECTED: "REJECTED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+export const ETransactionFinalityStatus = {
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+export const ETransactionExecutionStatus = {
+  SUCCEEDED: "SUCCEEDED",
+  REVERTED: "REVERTED"
+};
+export const EBlockTag = {
+  PENDING: "pending",
+  LATEST: "latest"
+};
+export const EDataAvailabilityMode = {
+  L1: "L1",
+  L2: "L2"
+};
+export const EDAMode = {
+  L1: 0,
+  L2: 1
+};
+export const ETransactionVersion = {
+  V0: "0x0",
+  V1: "0x1",
+  V2: "0x2",
+  V3: "0x3",
+  F0: "0x100000000000000000000000000000000",
+  F1: "0x100000000000000000000000000000001",
+  F2: "0x100000000000000000000000000000002",
+  F3: "0x100000000000000000000000000000003"
+};
+export const ETransactionVersion2 = {
+  V0: "0x0",
+  V1: "0x1",
+  V2: "0x2",
+  F0: "0x100000000000000000000000000000000",
+  F1: "0x100000000000000000000000000000001",
+  F2: "0x100000000000000000000000000000002"
+};
+export const ETransactionVersion3 = {
+  V3: "0x3",
+  F3: "0x100000000000000000000000000000003"
+};

package/dist/types/cairoEnum.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/cairoEnum.d.ts

@@ -0,0 +1,2 @@
+import { CairoCustomEnum, CairoOption, CairoResult } from '../utils/calldata/enum';
+export type CairoEnum = CairoCustomEnum | CairoOption<any> | CairoResult<any, any>;