starknet 8.1.2 → 8.2.0

package/dist/index.d.ts

@@ -620,6 +620,16 @@ type ByteArray = {
 type Calldata = string[] & {
     readonly __compiled__?: true;
 };
+/**
+ * "Abi Entry type"
+ * @example
+ * 'core::bytes_31::bytes31'
+ * 'core::bool'
+ * 'core::felt'
+ * 'core::uint256'
+ * 'core::uint512'
+ */
+type AbiEntryType = AbiEntry['type'];
 /**
  * Represents an integer in the range [0, 2^256)
  */
@@ -1840,9 +1850,9 @@ type TipAnalysisOptions = {
 declare function getTipStatsFromBlocks(provider: ProviderInterface, blockIdentifier?: BlockIdentifier, options?: TipAnalysisOptions): Promise<TipEstimate>;
 
 type TransactionStatusReceiptSets = {
-    success: SuccessfulTransactionReceiptResponse;
-    reverted: RevertedTransactionReceiptResponse;
-    error: Error;
+    SUCCEEDED: SuccessfulTransactionReceiptResponse;
+    REVERTED: RevertedTransactionReceiptResponse;
+    ERROR: Error;
 };
 type TransactionReceiptStatus = keyof TransactionStatusReceiptSets;
 type TransactionReceiptValue = TransactionStatusReceiptSets[TransactionReceiptStatus];
@@ -1853,14 +1863,31 @@ type TransactionReceiptCallbacksDefault = Partial<TransactionReceiptCallbacksDef
     _: () => void;
 };
 type TransactionReceiptCallbacks = TransactionReceiptCallbacksDefined | TransactionReceiptCallbacksDefault;
-type TransactionReceiptStatusFromMethod<T extends `is${Capitalize<TransactionReceiptStatus>}`> = T extends `is${infer R}` ? Uncapitalize<R> : never;
-type GetTransactionReceiptResponse<T extends TransactionReceiptStatus = TransactionReceiptStatus> = {
-    readonly statusReceipt: T;
-    readonly value: TransactionStatusReceiptSets[T];
+type SuccessfulTransactionReceiptResponseHelper = SuccessfulTransactionReceiptResponse & {
+    readonly statusReceipt: 'SUCCEEDED';
+    readonly value: SuccessfulTransactionReceiptResponse;
     match(callbacks: TransactionReceiptCallbacks): void;
-} & {
-    [key in `is${Capitalize<TransactionReceiptStatus>}`]: () => this is GetTransactionReceiptResponse<TransactionReceiptStatusFromMethod<key>>;
+    isSuccess(): this is SuccessfulTransactionReceiptResponseHelper;
+    isReverted(): this is RevertedTransactionReceiptResponseHelper;
+    isError(): this is ErrorReceiptResponseHelper;
+};
+type RevertedTransactionReceiptResponseHelper = RevertedTransactionReceiptResponse & {
+    readonly statusReceipt: 'REVERTED';
+    readonly value: RevertedTransactionReceiptResponse;
+    match(callbacks: TransactionReceiptCallbacks): void;
+    isSuccess(): this is SuccessfulTransactionReceiptResponseHelper;
+    isReverted(): this is RevertedTransactionReceiptResponseHelper;
+    isError(): this is ErrorReceiptResponseHelper;
 };
+type ErrorReceiptResponseHelper = {
+    readonly statusReceipt: 'ERROR';
+    readonly value: Error;
+    match(callbacks: TransactionReceiptCallbacks): void;
+    isSuccess(): this is SuccessfulTransactionReceiptResponseHelper;
+    isReverted(): this is RevertedTransactionReceiptResponseHelper;
+    isError(): this is ErrorReceiptResponseHelper;
+};
+type GetTransactionReceiptResponse = SuccessfulTransactionReceiptResponseHelper | RevertedTransactionReceiptResponseHelper | ErrorReceiptResponseHelper;
 
 declare abstract class ResponseParser {
     abstract parseGetBlockResponse(res: BlockWithTxHashes): GetBlockResponse;
@@ -2508,11 +2535,20 @@ declare const Uint: {
     readonly u16: "core::integer::u16";
     readonly u32: "core::integer::u32";
     readonly u64: "core::integer::u64";
+    readonly u96: "core::integer::u96";
     readonly u128: "core::integer::u128";
     readonly u256: "core::integer::u256";
     readonly u512: "core::integer::u512";
 };
 type Uint = ValuesType<typeof Uint>;
+declare const Int: {
+    readonly i8: "core::integer::i8";
+    readonly i16: "core::integer::i16";
+    readonly i32: "core::integer::i32";
+    readonly i64: "core::integer::i64";
+    readonly i128: "core::integer::i128";
+};
+type Int = ValuesType<typeof Int>;
 declare const Literal: {
     readonly ClassHash: "core::starknet::class_hash::ClassHash";
     readonly ContractAddress: "core::starknet::contract_address::ContractAddress";
@@ -2954,6 +2990,178 @@ declare abstract class AccountInterface extends ProviderInterface {
     abstract declareIfNot(contractPayload: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
 }
 
+/**
+ * Abi parser interface
+ */
+declare abstract class AbiParserInterface {
+    /**
+     * Helper to calculate inputs length from abi
+     * @param abiMethod FunctionAbi
+     * @return number
+     */
+    abstract methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    abstract getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Return Abi in legacy format
+     * @return Abi
+     */
+    abstract getLegacyFormat(): Abi;
+    /**
+     * Get request parser for the given abi type
+     * @param abiType AbiEntryType
+     * @returns Parser function
+     */
+    abstract getRequestParser(abiType: AbiEntryType): (val: unknown) => any;
+    /**
+     * Get response parser for the given abi type
+     * @param abiType AbiEntryType
+     * @returns Parser function
+     */
+    abstract getResponseParser(abiType: AbiEntryType): (responseIterator: Iterator<string>) => any;
+}
+
+/**
+ * Parsing map for parser, request and response parsers are separated
+ * Configure parsing strategy for each abi type
+ */
+type ParsingStrategy = {
+    request: Record<AbiEntryType, (val: unknown) => any>;
+    response: Record<AbiEntryType, (responseIterator: Iterator<string>) => any>;
+};
+/**
+ * More robust parsing strategy
+ * Configuration mapping - data-driven approach
+ * Configure parsing strategy for each abi type
+ */
+declare const hdParsingStrategy: {
+    readonly request: {
+        readonly [x: string]: (val: unknown) => string[];
+        readonly "core::bytes_31::bytes31": (val: unknown) => string[];
+        readonly "core::byte_array::ByteArray": (val: unknown) => string[];
+        readonly "core::felt252": (val: unknown) => string[];
+        readonly "core::integer::u256": (val: unknown) => string[];
+    };
+    readonly response: {
+        readonly [x: string]: ((responseIterator: Iterator<string>) => string) | ((responseIterator: Iterator<string>) => bigint);
+        readonly "core::bytes_31::bytes31": (responseIterator: Iterator<string>) => string;
+        readonly "core::byte_array::ByteArray": (responseIterator: Iterator<string>) => string;
+        readonly "core::felt252": (responseIterator: Iterator<string>) => bigint;
+        readonly "core::integer::u256": (responseIterator: Iterator<string>) => bigint;
+    };
+};
+/**
+ * Faster parsing strategy
+ * Configuration mapping - data-driven approach
+ * Configure parsing strategy for each abi type
+ */
+declare const fastParsingStrategy: ParsingStrategy;
+
+declare class AbiParser1 implements AbiParserInterface {
+    abi: Abi;
+    parsingStrategy: ParsingStrategy;
+    constructor(abi: Abi, parsingStrategy?: ParsingStrategy);
+    getRequestParser(abiType: AbiEntryType): (val: unknown) => any;
+    getResponseParser(abiType: AbiEntryType): (responseIterator: Iterator<string>) => any;
+    /**
+     * abi method inputs length without '_len' inputs
+     * cairo 0 reducer
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat(): Abi;
+}
+
+declare class AbiParser2 implements AbiParserInterface {
+    abi: Abi;
+    parsingStrategy: ParsingStrategy;
+    constructor(abi: Abi, parsingStrategy?: ParsingStrategy);
+    getRequestParser(abiType: AbiEntryType): (val: unknown) => any;
+    getResponseParser(abiType: AbiEntryType): (responseIterator: Iterator<string>) => any;
+    /**
+     * abi method inputs length
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat(): Abi;
+}
+
+/**
+ * Creates ABI parser
+ *
+ * @param {Abi} abi
+ * @returns {AbiParserInterface} abi parser interface
+ *
+ * @example
+ * const abiParser2 = createAbiParser([getInterfaceAbi('struct')]);
+ * // abiParser2 instanceof AbiParser2 === true
+ *
+ * const abiParser1 = createAbiParser([getFunctionAbi('struct')]);
+ * // abiParser1 instanceof AbiParser1 === true
+ */
+declare function createAbiParser(abi: Abi, parsingStrategy?: ParsingStrategy): AbiParserInterface;
+/**
+ * Retrieves ABI version
+ *
+ * @param {Abi} abi
+ * @returns {1 | 2 | 0} abi 1, 2 or 0 version
+ *
+ * @example
+ * // Example 1: Return ABI version 2
+ * const version = getAbiVersion([getInterfaceAbi()]);
+ * // version === 2
+ *
+ * // Example 2: Return ABI version 1
+ * const version = getAbiVersion([getInterfaceAbi('core::bool')]);
+ * // version === 1
+ *
+ * // Example 3: Return ABI version 0
+ * const version = getAbiVersion([getInterfaceAbi('felt')]);
+ * // version === 0
+ */
+declare function getAbiVersion(abi: Abi): 1 | 2 | 0;
+/**
+ * Checks if no constructor valid
+ *
+ * @param {string} method
+ * @param {RawArgs} argsCalldata
+ * @param {FunctionAbi} abiMethod
+ * @returns boolean
+ *
+ * @example
+ * const result1 = isNoConstructorValid('constructor', [])
+ * // result1 === true
+ * const result2 = isNoConstructorValid('test', ['test'])
+ * // result2 === false
+ */
+declare function isNoConstructorValid(method: string, argsCalldata: RawArgs, abiMethod?: FunctionAbi): boolean;
+
 type AsyncContractFunction<T = any> = (...args: ArgsOrCalldataWithOptions) => Promise<T>;
 type ContractFunction = (...args: ArgsOrCalldataWithOptions) => any;
 type CallResult = {
@@ -2972,6 +3180,10 @@ type CommonContractOptions = {
      * @default true
      */
     parseResponse?: boolean;
+    /**
+     * Custom parsing strategy for request/response processing
+     */
+    parsingStrategy?: ParsingStrategy;
 };
 type ContractOptions = {
     abi: Abi;
@@ -2996,6 +3208,11 @@ type ExecuteOptions = Pick<CommonContractOptions, 'parseRequest'> & {
      * Deployer contract salt
      */
     salt?: string;
+    /**
+     * Wait for transaction to be included in a block
+     * @default false
+     */
+    waitForTransaction?: boolean;
 } & Partial<UniversalDetails>;
 type CallOptions = CommonContractOptions & {
     formatResponse?: FormatResponse;
@@ -3008,7 +3225,9 @@ type ParsedEvent = {
     block_number?: BlockNumber;
     transaction_hash?: TransactionHash;
 };
-type ParsedEvents = Array<ParsedEvent>;
+type ParsedEvents = Array<ParsedEvent> & {
+    getByPath?(path: string): ParsedStruct | null;
+};
 /**
  * Advance formatting used to get js types data as result
  * @description https://starknetjs.com/docs/guides/define_call_message/#formatresponse
@@ -3050,7 +3269,7 @@ type DeployOnlyParams = FactoryParamsBase & {
     constructorCalldata?: RawArgs;
     abi?: Abi;
 };
-type FactoryParams = DeclareAndDeployParams | DeployOnlyParams;
+type FactoryParams = (DeclareAndDeployParams | DeployOnlyParams) & CommonContractOptions;
 
 type RPC_ERROR_SET = {
     FAILED_TO_RECEIVE_TXN: FAILED_TO_RECEIVE_TXN;
@@ -3237,7 +3456,18 @@ declare function arrayBufferToString(array: ArrayBuffer): string;
  * // result = Uint8Array(2) [ 72, 105 ]
  * ```
  */
-declare function utf8ToArray(str: string): Uint8Array;
+declare function utf8ToUint8Array(str: string): Uint8Array;
+/**
+ * @deprecated use utf8ToUint8Array instead
+ */
+declare const utf8ToArray: typeof utf8ToUint8Array;
+/**
+ * Convert utf8-string to bigint
+ *
+ * @param str The UTF-8 string to convert.
+ * @returns The converted bigint.
+ */
+declare function utf8ToBigInt(str: string): bigint;
 /**
  * Convert string to array buffer (browser and node compatible)
  *
@@ -3413,23 +3643,100 @@ declare const pascalToSnake: (text: string) => string;
  * ```
  */
 declare function concatenateArrayBuffer(uint8arrays: Uint8Array[]): Uint8Array;
+/**
+ * Convert hex string to Uint8Array
+ *
+ * @param {string} hex The hex string to convert (with or without '0x' prefix)
+ * @returns {Uint8Array} The converted byte array
+ * @throws {Error} If the string contains non-hexadecimal characters
+ *
+ * @example
+ * ```typescript
+ * const hexString = '0x48656c6c6f';
+ * const result = encode.hexStringToUint8Array(hexString);
+ * // result = Uint8Array(5) [ 72, 101, 108, 108, 111 ]
+ * ```
+ */
+declare function hexStringToUint8Array(hex: string): Uint8Array;
+/**
+ * Convert any string to Uint8Array
+ *
+ * Handles three types of strings:
+ * - Hex strings (e.g., '0x123f') - converts hex bytes to Uint8Array
+ * - Decimal strings (e.g., '124324332') - converts decimal number to bytes
+ * - Text strings (e.g., 'I am cool ☥') - converts UTF-8 text to bytes
+ *
+ * @param {string} str The string to convert
+ * @returns {Uint8Array} The converted byte array
+ *
+ * @example
+ * ```typescript
+ * // Hex string
+ * const hex = stringToUint8Array('0x48656c6c6f');
+ * // result = Uint8Array(5) [ 72, 101, 108, 108, 111 ]
+ *
+ * // Decimal string
+ * const decimal = stringToUint8Array('256');
+ * // result = Uint8Array(2) [ 1, 0 ]
+ *
+ * // Text string
+ * const text = stringToUint8Array('Hello ☥');
+ * // result = UTF-8 encoded bytes
+ * ```
+ */
+declare function stringToUint8Array(str: string): Uint8Array;
+/**
+ * Convert bigint to Uint8Array (big-endian)
+ *
+ * @param {bigint} value The bigint value to convert (must be non-negative)
+ * @returns {Uint8Array} The converted byte array in big-endian byte order
+ * @throws {Error} If value is negative
+ *
+ * @example
+ * ```typescript
+ * const value = 256n; // 0x0100
+ * const result = encode.bigIntToUint8Array(value);
+ * // result = Uint8Array([1, 0]) - big-endian, MSB first
+ * ```
+ */
+declare function bigIntToUint8Array(value: bigint): Uint8Array;
+/**
+ * Convert Uint8Array to bigint (big-endian)
+ *
+ * @param {Uint8Array} data The Uint8Array to convert (interpreted as big-endian)
+ * @returns {bigint} The converted bigint value
+ *
+ * @example
+ * ```typescript
+ * const data = new Uint8Array([1, 0]); // Big-endian representation
+ * const result = encode.uint8ArrayToBigInt(data);
+ * // result = 256n (0x0100)
+ * ```
+ */
+declare function uint8ArrayToBigInt(data: Uint8Array): bigint;
 
 declare const encode_IS_BROWSER: typeof IS_BROWSER;
 declare const encode_addHexPrefix: typeof addHexPrefix;
 declare const encode_arrayBufferToString: typeof arrayBufferToString;
 declare const encode_atobUniversal: typeof atobUniversal;
+declare const encode_bigIntToUint8Array: typeof bigIntToUint8Array;
 declare const encode_btoaUniversal: typeof btoaUniversal;
 declare const encode_buf2hex: typeof buf2hex;
 declare const encode_calcByteLength: typeof calcByteLength;
 declare const encode_concatenateArrayBuffer: typeof concatenateArrayBuffer;
+declare const encode_hexStringToUint8Array: typeof hexStringToUint8Array;
 declare const encode_padLeft: typeof padLeft;
 declare const encode_pascalToSnake: typeof pascalToSnake;
 declare const encode_removeHexPrefix: typeof removeHexPrefix;
 declare const encode_sanitizeBytes: typeof sanitizeBytes;
 declare const encode_sanitizeHex: typeof sanitizeHex;
+declare const encode_stringToUint8Array: typeof stringToUint8Array;
+declare const encode_uint8ArrayToBigInt: typeof uint8ArrayToBigInt;
 declare const encode_utf8ToArray: typeof utf8ToArray;
+declare const encode_utf8ToBigInt: typeof utf8ToBigInt;
+declare const encode_utf8ToUint8Array: typeof utf8ToUint8Array;
 declare namespace encode {
-  export { encode_IS_BROWSER as IS_BROWSER, encode_addHexPrefix as addHexPrefix, encode_arrayBufferToString as arrayBufferToString, encode_atobUniversal as atobUniversal, encode_btoaUniversal as btoaUniversal, encode_buf2hex as buf2hex, encode_calcByteLength as calcByteLength, encode_concatenateArrayBuffer as concatenateArrayBuffer, encode_padLeft as padLeft, encode_pascalToSnake as pascalToSnake, encode_removeHexPrefix as removeHexPrefix, encode_sanitizeBytes as sanitizeBytes, encode_sanitizeHex as sanitizeHex, encode_utf8ToArray as utf8ToArray };
+  export { encode_IS_BROWSER as IS_BROWSER, encode_addHexPrefix as addHexPrefix, encode_arrayBufferToString as arrayBufferToString, encode_atobUniversal as atobUniversal, encode_bigIntToUint8Array as bigIntToUint8Array, encode_btoaUniversal as btoaUniversal, encode_buf2hex as buf2hex, encode_calcByteLength as calcByteLength, encode_concatenateArrayBuffer as concatenateArrayBuffer, encode_hexStringToUint8Array as hexStringToUint8Array, encode_padLeft as padLeft, encode_pascalToSnake as pascalToSnake, encode_removeHexPrefix as removeHexPrefix, encode_sanitizeBytes as sanitizeBytes, encode_sanitizeHex as sanitizeHex, encode_stringToUint8Array as stringToUint8Array, encode_uint8ArrayToBigInt as uint8ArrayToBigInt, encode_utf8ToArray as utf8ToArray, encode_utf8ToBigInt as utf8ToBigInt, encode_utf8ToUint8Array as utf8ToUint8Array };
 }
 
 /**
@@ -3447,7 +3754,23 @@ declare const RANGE_FELT: {
     readonly min: bigint;
     readonly max: bigint;
 };
-declare const RANGE_I128: {
+declare const RANGE_U8: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_U16: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_U32: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_U64: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_U96: {
     readonly min: bigint;
     readonly max: bigint;
 };
@@ -3455,6 +3778,26 @@ declare const RANGE_U128: {
     readonly min: bigint;
     readonly max: bigint;
 };
+declare const RANGE_I8: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_I16: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_I32: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_I64: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+declare const RANGE_I128: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
 declare const LegacyUDC: {
     readonly ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf";
     readonly ENTRYPOINT: "deployContract";
@@ -3516,6 +3859,7 @@ declare const DEFAULT_GLOBAL_CONFIG: {
     defaultTipType: TipType;
     fetch: any;
     websocket: any;
+    buffer: any;
 };
 declare const RPC_DEFAULT_NODES: {
     readonly SN_MAIN: readonly ["https://starknet-mainnet.public.blastapi.io/rpc/"];
@@ -3534,6 +3878,9 @@ declare const SYSTEM_MESSAGES: {
     maxFeeInV3: string;
     declareNonSierra: string;
     unsupportedMethodForRpcVersion: string;
+    txEvictedFromMempool: string;
+    consensusFailed: string;
+    txFailsBlockBuildingValidation: string;
 };
 
 declare const constants_ADDR_BOUND: typeof ADDR_BOUND;
@@ -3551,7 +3898,16 @@ declare const constants_PAYMASTER_RPC_NODES: typeof PAYMASTER_RPC_NODES;
 declare const constants_PRIME: typeof PRIME;
 declare const constants_RANGE_FELT: typeof RANGE_FELT;
 declare const constants_RANGE_I128: typeof RANGE_I128;
+declare const constants_RANGE_I16: typeof RANGE_I16;
+declare const constants_RANGE_I32: typeof RANGE_I32;
+declare const constants_RANGE_I64: typeof RANGE_I64;
+declare const constants_RANGE_I8: typeof RANGE_I8;
 declare const constants_RANGE_U128: typeof RANGE_U128;
+declare const constants_RANGE_U16: typeof RANGE_U16;
+declare const constants_RANGE_U32: typeof RANGE_U32;
+declare const constants_RANGE_U64: typeof RANGE_U64;
+declare const constants_RANGE_U8: typeof RANGE_U8;
+declare const constants_RANGE_U96: typeof RANGE_U96;
 declare const constants_RPC_DEFAULT_NODES: typeof RPC_DEFAULT_NODES;
 declare const constants_SNIP9_V1_INTERFACE_ID: typeof SNIP9_V1_INTERFACE_ID;
 declare const constants_SNIP9_V2_INTERFACE_ID: typeof SNIP9_V2_INTERFACE_ID;
@@ -3562,7 +3918,7 @@ declare const constants_TEXT_TO_FELT_MAX_LEN: typeof TEXT_TO_FELT_MAX_LEN;
 declare const constants_UDC: typeof UDC;
 declare const constants_ZERO: typeof ZERO;
 declare namespace constants {
-  export { constants_ADDR_BOUND as ADDR_BOUND, constants_API_VERSION as API_VERSION, _BaseUrl as BaseUrl, constants_DEFAULT_GLOBAL_CONFIG as DEFAULT_GLOBAL_CONFIG, constants_HARDENING_4BYTES as HARDENING_4BYTES, constants_HARDENING_BYTE as HARDENING_BYTE, constants_IS_BROWSER as IS_BROWSER, constants_LegacyUDC as LegacyUDC, constants_MASK_250 as MASK_250, constants_MASK_31 as MASK_31, constants_MAX_STORAGE_ITEM_SIZE as MAX_STORAGE_ITEM_SIZE, _NetworkName as NetworkName, constants_OutsideExecutionCallerAny as OutsideExecutionCallerAny, constants_PAYMASTER_RPC_NODES as PAYMASTER_RPC_NODES, constants_PRIME as PRIME, constants_RANGE_FELT as RANGE_FELT, constants_RANGE_I128 as RANGE_I128, constants_RANGE_U128 as RANGE_U128, constants_RPC_DEFAULT_NODES as RPC_DEFAULT_NODES, constants_SNIP9_V1_INTERFACE_ID as SNIP9_V1_INTERFACE_ID, constants_SNIP9_V2_INTERFACE_ID as SNIP9_V2_INTERFACE_ID, constants_SYSTEM_MESSAGES as SYSTEM_MESSAGES, _StarknetChainId as StarknetChainId, type constants_SupportedCairoVersion as SupportedCairoVersion, _SupportedRpcVersion as SupportedRpcVersion, type constants_SupportedTransactionVersion as SupportedTransactionVersion, constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN, _TransactionHashPrefix as TransactionHashPrefix, constants_UDC as UDC, constants_ZERO as ZERO };
+  export { constants_ADDR_BOUND as ADDR_BOUND, constants_API_VERSION as API_VERSION, _BaseUrl as BaseUrl, constants_DEFAULT_GLOBAL_CONFIG as DEFAULT_GLOBAL_CONFIG, constants_HARDENING_4BYTES as HARDENING_4BYTES, constants_HARDENING_BYTE as HARDENING_BYTE, constants_IS_BROWSER as IS_BROWSER, constants_LegacyUDC as LegacyUDC, constants_MASK_250 as MASK_250, constants_MASK_31 as MASK_31, constants_MAX_STORAGE_ITEM_SIZE as MAX_STORAGE_ITEM_SIZE, _NetworkName as NetworkName, constants_OutsideExecutionCallerAny as OutsideExecutionCallerAny, constants_PAYMASTER_RPC_NODES as PAYMASTER_RPC_NODES, constants_PRIME as PRIME, constants_RANGE_FELT as RANGE_FELT, constants_RANGE_I128 as RANGE_I128, constants_RANGE_I16 as RANGE_I16, constants_RANGE_I32 as RANGE_I32, constants_RANGE_I64 as RANGE_I64, constants_RANGE_I8 as RANGE_I8, constants_RANGE_U128 as RANGE_U128, constants_RANGE_U16 as RANGE_U16, constants_RANGE_U32 as RANGE_U32, constants_RANGE_U64 as RANGE_U64, constants_RANGE_U8 as RANGE_U8, constants_RANGE_U96 as RANGE_U96, constants_RPC_DEFAULT_NODES as RPC_DEFAULT_NODES, constants_SNIP9_V1_INTERFACE_ID as SNIP9_V1_INTERFACE_ID, constants_SNIP9_V2_INTERFACE_ID as SNIP9_V2_INTERFACE_ID, constants_SYSTEM_MESSAGES as SYSTEM_MESSAGES, _StarknetChainId as StarknetChainId, type constants_SupportedCairoVersion as SupportedCairoVersion, _SupportedRpcVersion as SupportedRpcVersion, type constants_SupportedTransactionVersion as SupportedTransactionVersion, constants_TEXT_TO_FELT_MAX_LEN as TEXT_TO_FELT_MAX_LEN, _TransactionHashPrefix as TransactionHashPrefix, constants_UDC as UDC, constants_ZERO as ZERO };
 }
 
 declare class RpcChannel$1 {
@@ -4224,7 +4580,7 @@ declare class RpcError<BaseErrorT extends RPC_ERROR = RPC_ERROR> extends Library
         params: any;
     };
     constructor(baseError: BaseErrorT, method: string, params: any);
-    get code(): 1 | 66 | 10 | 31 | 20 | 32 | 40 | 33 | 21 | 24 | 27 | 28 | 29 | 34 | 41 | 42 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 67 | 68 | 100 | 150 | 151 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 163;
+    get code(): 1 | 66 | 10 | 31 | 20 | 21 | 24 | 27 | 28 | 29 | 32 | 33 | 34 | 40 | 41 | 42 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 67 | 68 | 100 | 150 | 151 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 163;
     /**
      * Verifies the underlying RPC error, also serves as a type guard for the _baseError_ property
      * @example
@@ -4882,6 +5238,8 @@ declare class Contract implements ContractInterface {
     address: string;
     providerOrAccount: ProviderOrAccount;
     classHash?: string;
+    parseRequest: boolean;
+    parseResponse: boolean;
     private structs;
     private events;
     readonly functions: {
@@ -4899,6 +5257,7 @@ declare class Contract implements ContractInterface {
     readonly [key: string]: AsyncContractFunction | any;
     private callData;
     withOptionsProps?: WithOptions;
+    private parsingStrategy?;
     /**
      * @param options
      *  - abi: Abi of the contract object (required)
@@ -4906,13 +5265,20 @@ declare class Contract implements ContractInterface {
      *  - providerOrAccount?: Provider or Account to attach to (fallback to defaultProvider)
      *  - parseRequest?: compile and validate arguments (optional, default true)
      *  - parseResponse?: Parse elements of the response array and structuring them into response object (optional, default true)
+     *  - parser?: Abi parser (optional, default createAbiParser(options.abi))
      */
     constructor(options: ContractOptions);
     withOptions(options: WithOptions): this;
     attach(address: string, abi?: Abi): void;
-    isDeployed(): Promise<Contract>;
+    isDeployed(): Promise<this>;
     call(method: string, args?: ArgsOrCalldata, { parseRequest, parseResponse, formatResponse, blockIdentifier, }?: CallOptions): Promise<CallResult>;
-    invoke(method: string, args?: ArgsOrCalldata, { parseRequest, signature, ...RestInvokeOptions }?: ExecuteOptions): Promise<InvokeFunctionResponse>;
+    invoke(method: string, args: ArgsOrCalldata, options: ExecuteOptions & {
+        waitForTransaction: true;
+    }): Promise<SuccessfulTransactionReceiptResponseHelper>;
+    invoke(method: string, args: ArgsOrCalldata, options: ExecuteOptions & {
+        waitForTransaction: false;
+    }): Promise<InvokeFunctionResponse>;
+    invoke(method: string, args?: ArgsOrCalldata, options?: ExecuteOptions): Promise<InvokeFunctionResponse>;
     estimate(method: string, args?: ArgsOrCalldata, estimateDetails?: UniversalDetails): Promise<EstimateFeeResponseOverhead>;
     populate(method: string, args?: RawArgs): Call;
     parseEvents(receipt: GetTransactionReceiptResponse): ParsedEvents;
@@ -5507,6 +5873,7 @@ declare namespace json {
  * ```
  */
 declare function isHex(hex: string): boolean;
+declare const isHexString: typeof isHex;
 /**
  * Convert BigNumberish to bigint
  *
@@ -5764,7 +6131,7 @@ declare function addPercent(number: BigNumberish, percent: number): bigint;
 declare function stringToSha256ToArrayBuff4(str: string): Uint8Array;
 /**
  * Checks if a given value is of BigNumberish type.
- * 234, 234n, "234", "0xea" are valid
+ * 234, 234n, "234", "0xea" are valid, exclude boolean and string
  * @param {unknown} input a value
  * @returns {boolean} true if type of input is `BigNumberish`
  * @example
@@ -5774,6 +6141,14 @@ declare function stringToSha256ToArrayBuff4(str: string): Uint8Array;
  *  ```
  */
 declare function isBigNumberish(input: unknown): input is BigNumberish;
+/**
+ * Expect the next value from an iterator
+ *
+ * @param iterator The iterator to get the next value from.
+ * @returns The next value from the iterator.
+ * @throws Error if the iterator is done.
+ */
+declare function getNext(iterator: Iterator<string>): string;
 
 declare const num_addPercent: typeof addPercent;
 declare const num_assertInRange: typeof assertInRange;
@@ -5783,10 +6158,12 @@ declare const num_cleanHex: typeof cleanHex;
 declare const num_getDecimalString: typeof getDecimalString;
 declare const num_getHexString: typeof getHexString;
 declare const num_getHexStringArray: typeof getHexStringArray;
+declare const num_getNext: typeof getNext;
 declare const num_hexToBytes: typeof hexToBytes;
 declare const num_hexToDecimalString: typeof hexToDecimalString;
 declare const num_isBigNumberish: typeof isBigNumberish;
 declare const num_isHex: typeof isHex;
+declare const num_isHexString: typeof isHexString;
 declare const num_isStringWholeNumber: typeof isStringWholeNumber;
 declare const num_stringToSha256ToArrayBuff4: typeof stringToSha256ToArrayBuff4;
 declare const num_toBigInt: typeof toBigInt;
@@ -5797,7 +6174,7 @@ declare const num_toHexString: typeof toHexString;
 declare const num_toStorageKey: typeof toStorageKey;
 declare const num_tryToBigInt: typeof tryToBigInt;
 declare namespace num {
-  export { num_addPercent as addPercent, num_assertInRange as assertInRange, num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray, num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray, num_cleanHex as cleanHex, num_getDecimalString as getDecimalString, num_getHexString as getHexString, num_getHexStringArray as getHexStringArray, num_hexToBytes as hexToBytes, num_hexToDecimalString as hexToDecimalString, num_isBigNumberish as isBigNumberish, num_isHex as isHex, num_isStringWholeNumber as isStringWholeNumber, num_stringToSha256ToArrayBuff4 as stringToSha256ToArrayBuff4, num_toBigInt as toBigInt, num_toCairoBool as toCairoBool, num_toHex as toHex, num_toHex64 as toHex64, num_toHexString as toHexString, num_toStorageKey as toStorageKey, num_tryToBigInt as tryToBigInt };
+  export { num_addPercent as addPercent, num_assertInRange as assertInRange, num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray, num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray, num_cleanHex as cleanHex, num_getDecimalString as getDecimalString, num_getHexString as getHexString, num_getHexStringArray as getHexStringArray, num_getNext as getNext, num_hexToBytes as hexToBytes, num_hexToDecimalString as hexToDecimalString, num_isBigNumberish as isBigNumberish, num_isHex as isHex, num_isHexString as isHexString, num_isStringWholeNumber as isStringWholeNumber, num_stringToSha256ToArrayBuff4 as stringToSha256ToArrayBuff4, num_toBigInt as toBigInt, num_toCairoBool as toCairoBool, num_toHex as toHex, num_toHex64 as toHex64, num_toHexString as toHexString, num_toStorageKey as toStorageKey, num_tryToBigInt as tryToBigInt };
 }
 
 /**
@@ -6464,7 +6841,7 @@ declare function isDecimalString(str: string): boolean;
  * // result = false
  * ```
  */
-declare function isText(val: any): boolean;
+declare function isText(val: any): val is string;
 /**
  * Test if value is short text
  * @param {any} val - The item to test
@@ -6499,6 +6876,7 @@ declare const isLongText: (val: any) => boolean;
  */
 declare function splitLongString(longStr: string): string[];
 /**
+ * @deprecated use Utf8 instead
  * Convert an ASCII short string to a hexadecimal string.
  * @param {string} str short string (ASCII string, 31 characters max)
  * @returns {string} hex-string with 248 bits max
@@ -6510,6 +6888,7 @@ declare function splitLongString(longStr: string): string[];
  */
 declare function encodeShortString(str: string): string;
 /**
+ * @deprecated use Utf8 instead
  * Convert a hexadecimal or decimal string to an ASCII string.
  * @param {string} str representing a 248 bit max number (ex. "0x1A4F64EA56" or "236942575435676423")
  * @returns {string} short string; 31 characters max
@@ -7250,7 +7629,7 @@ declare function getAbiEvents(abi: Abi): AbiEvents;
     }}]
  * ```
  */
-declare function parseEvents(providerReceivedEvents: EmittedEvent$1[], abiEvents: AbiEvents, abiStructs: AbiStructs, abiEnums: AbiEnums): ParsedEvents;
+declare function parseEvents(providerReceivedEvents: EmittedEvent$1[], abiEvents: AbiEvents, abiStructs: AbiStructs, abiEnums: AbiEnums, parser: AbiParserInterface): ParsedEvents;
 
 declare const index_getAbiEvents: typeof getAbiEvents;
 declare const index_isAbiEvent: typeof isAbiEvent;
@@ -7538,6 +7917,96 @@ declare class BatchClient<T extends {
     }>(method: M, params?: T[M]['params'], id?: string | number): Promise<TResponse>;
 }
 
+declare class CairoUint8 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint8;
+}
+
+declare class CairoUint16 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint16;
+}
+
+declare class CairoUint64 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint64;
+}
+
+declare class CairoUint96 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint96;
+}
+
+declare class CairoUint128 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint128;
+}
+
 /**
  * Singular class handling cairo u256 data type
  */
@@ -7552,24 +8021,19 @@ declare const UINT_256_HIGH_MIN = 0n;
 declare class CairoUint256 {
     low: bigint;
     high: bigint;
-    static abiSelector: string;
+    static abiSelector: "core::integer::u256";
     /**
      * Default constructor (Lib usage)
-     * @param bigNumberish BigNumberish value representing uin256
      */
-    constructor(bigNumberish: BigNumberish);
+    constructor(data: BigNumberish | Uint256 | unknown);
     /**
      * Direct props initialization (Api response)
      */
     constructor(low: BigNumberish, high: BigNumberish);
-    /**
-     * Initialization from Uint256 object
-     */
-    constructor(uint256: Uint256);
     /**
      * Validate if BigNumberish can be represented as Unit256
      */
-    static validate(bigNumberish: BigNumberish): bigint;
+    static validate(bigNumberish: BigNumberish | unknown): bigint;
     /**
      * Validate if low and high can be represented as Unit256
      */
@@ -7580,11 +8044,12 @@ declare class CairoUint256 {
     /**
      * Check if BigNumberish can be represented as Unit256
      */
-    static is(bigNumberish: BigNumberish): boolean;
+    static is(bigNumberish: BigNumberish | unknown): boolean;
     /**
      * Check if provided abi type is this data type
      */
-    static isAbiType(abiType: string): boolean;
+    static isAbiType(abiType: string): abiType is "core::integer::u256";
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint256;
     /**
      * Return bigint representation
      */
@@ -7626,21 +8091,16 @@ declare class CairoUint512 {
     static abiSelector: string;
     /**
      * Default constructor (Lib usage)
-     * @param bigNumberish BigNumberish value representing u512
      */
-    constructor(bigNumberish: BigNumberish);
+    constructor(bigNumberish: BigNumberish | Uint512 | unknown);
     /**
      * Direct props initialization (Api response)
      */
     constructor(limb0: BigNumberish, limb1: BigNumberish, limb2: BigNumberish, limb3: BigNumberish);
-    /**
-     * Initialization from Uint512 object
-     */
-    constructor(uint512: Uint512);
     /**
      * Validate if BigNumberish can be represented as Uint512
      */
-    static validate(bigNumberish: BigNumberish): bigint;
+    static validate(bigNumberish: BigNumberish | unknown): bigint;
     /**
      * Validate if limbs can be represented as Uint512
      */
@@ -7653,11 +8113,12 @@ declare class CairoUint512 {
     /**
      * Check if BigNumberish can be represented as Uint512
      */
-    static is(bigNumberish: BigNumberish): boolean;
+    static is(bigNumberish: BigNumberish | unknown): boolean;
     /**
      * Check if provided abi type is this data type
      */
     static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint512;
     /**
      * Return bigint representation
      */
@@ -7688,6 +8149,116 @@ declare class CairoUint512 {
     toApiRequest(): string[];
 }
 
+declare class CairoInt8 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoInt8;
+}
+
+declare class CairoInt16 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoInt16;
+}
+
+declare class CairoInt32 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoInt32;
+}
+
+declare class CairoInt64 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoInt64;
+}
+
+declare class CairoInt128 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean | unknown): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    /**
+     * For negative values field element representation as positive hex string.
+     * @returns cairo field arithmetic hex string
+     */
+    toHexString(): string;
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoInt128;
+}
+
 declare class CairoFixedArray {
     /**
      * JS array representing a Cairo fixed array.
@@ -7774,6 +8345,7 @@ declare class CairoFixedArray {
     compile(): Object;
     /**
      * Checks if the given Cairo type is a fixed-array type.
+     * structure: [string; number]
      *
      * @param {string} type - The type to check.
      * @returns - `true` if the type is a fixed array type, `false` otherwise.
@@ -7784,6 +8356,119 @@ declare class CairoFixedArray {
     static isTypeFixedArray(type: string): boolean;
 }
 
+declare class CairoBytes31 {
+    static MAX_BYTE_SIZE: 31;
+    data: Uint8Array;
+    static abiSelector: "core::bytes_31::bytes31";
+    constructor(data: string | Uint8Array | Buffer | unknown);
+    static __processData(data: Uint8Array | string | Buffer | unknown): Uint8Array;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    static validate(data: Uint8Array | string | Buffer | unknown): void;
+    static is(data: Uint8Array | string | Buffer): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoBytes31;
+}
+
+/**
+ * felt252 is the basic field element used in Cairo.
+ * It corresponds to an integer in the range 0 ≤ x < P where P is a very large prime number currently equal to 2^251 + 17⋅2^192 + 1.
+ * Any operation that uses felt252 will be computed modulo P.
+ * 63 hex symbols (31 bytes + 4 bits), 252 bits
+ */
+declare class CairoFelt252 {
+    /**
+     * byte representation of the felt252
+     */
+    data: Uint8Array;
+    static abiSelector: "core::felt252";
+    constructor(data: BigNumberish | boolean | unknown);
+    static __processData(data: BigNumberish | boolean): Uint8Array;
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    toApiRequest(): string[];
+    static validate(data: BigNumberish | boolean | unknown): void;
+    static is(data: BigNumberish | boolean | unknown): boolean;
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoFelt252;
+}
+
+declare class CairoUint32 {
+    data: bigint;
+    static abiSelector: string;
+    constructor(data: BigNumberish);
+    static __processData(data: BigNumberish): bigint;
+    toApiRequest(): string[];
+    toBigInt(): bigint;
+    decodeUtf8(): string;
+    toHexString(): string;
+    static validate(data: BigNumberish): void;
+    static is(data: BigNumberish): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoUint32;
+}
+
+declare class CairoByteArray {
+    /**
+     * entire dataset
+     */
+    data: CairoBytes31[];
+    /**
+     * cairo specific implementation helper
+     */
+    pending_word: CairoFelt252;
+    /**
+     * cairo specific implementation helper
+     */
+    pending_word_len: CairoUint32;
+    static abiSelector: "core::byte_array::ByteArray";
+    /**
+     * byteArray from typed components
+     */
+    constructor(data: CairoBytes31[], pendingWord: CairoFelt252, pendingWordLen: CairoUint32);
+    constructor(data: BigNumberish | Buffer | Uint8Array | unknown);
+    static __processData(inData: BigNumberish | Buffer | Uint8Array | unknown): {
+        data: CairoBytes31[];
+        pending_word: CairoFelt252;
+        pending_word_len: CairoUint32;
+    };
+    toApiRequest(): string[];
+    decodeUtf8(): string;
+    toBigInt(): bigint;
+    toHexString(): string;
+    toBuffer(): any;
+    static validate(data: Uint8Array | Buffer | BigNumberish | unknown): void;
+    /**
+     * Check if the provided data is a valid CairoByteArray
+     *
+     * @param data - The data to check
+     * @returns True if the data is a valid CairoByteArray, false otherwise
+     */
+    static is(data: any): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    /**
+     * Private helper to check if the CairoByteArray is properly initialized
+     */
+    private assertInitialized;
+    /**
+     * Private helper to reconstruct the full byte sequence from chunks and pending word
+     */
+    private reconstructBytes;
+    static factoryFromApiResponse(responseIterator: Iterator<string>): CairoByteArray;
+}
+
 /**
  * Format a hex number to '0x' and 64 characters, adding leading zeros if necessary.
  *
@@ -7849,26 +8534,6 @@ declare function getChecksumAddress(address: BigNumberish): string;
  */
 declare function validateChecksumAddress(address: string): boolean;
 
-declare abstract class AbiParserInterface {
-    /**
-     * Helper to calculate inputs length from abi
-     * @param abiMethod FunctionAbi
-     * @return number
-     */
-    abstract methodInputsLength(abiMethod: FunctionAbi): number;
-    /**
-     *
-     * @param name string
-     * @return FunctionAbi | undefined
-     */
-    abstract getMethod(name: string): FunctionAbi | undefined;
-    /**
-     * Return Abi in legacy format
-     * @return Abi
-     */
-    abstract getLegacyFormat(): Abi;
-}
-
 /**
  * Checks if the given name ends with "_len".
  *
@@ -7941,13 +8606,20 @@ declare const isTypeResult: (type: string) => boolean;
  * @returns - Returns true if the value is a valid Uint type, otherwise false.
  */
 declare const isTypeUint: (type: string) => boolean;
+/**
+ * Checks if the given value is a valid Int type.
+ *
+ * @param {string} type - The value to check.
+ * @returns - Returns true if the value is a valid Int type, otherwise false.
+ */
+declare const isTypeInt: (type: string) => boolean;
 /**
  * Checks if the given type is `uint256`.
  *
  * @param {string} type - The type to be checked.
  * @returns - Returns true if the type is `uint256`, otherwise false.
  */
-declare const isTypeUint256: (type: string) => boolean;
+declare const isTypeUint256: (type: string) => type is "core::integer::u256";
 /**
  * Checks if the given type is a literal type.
  *
@@ -7975,20 +8647,6 @@ declare const isTypeContractAddress: (type: string) => type is "core::starknet::
  * @returns - Returns true if the given type is 'core::starknet::eth_address::EthAddress', otherwise false.
  */
 declare const isTypeEthAddress: (type: string) => type is "core::starknet::eth_address::EthAddress";
-/**
- * Checks if the given type is 'core::bytes_31::bytes31'.
- *
- * @param {string} type - The type to check.
- * @returns - True if the type is 'core::bytes_31::bytes31', false otherwise.
- */
-declare const isTypeBytes31: (type: string) => type is "core::bytes_31::bytes31";
-/**
- * Checks if the given type is equal to the 'core::byte_array::ByteArray'.
- *
- * @param {string} type - The type to check.
- * @returns - True if the given type is equal to 'core::byte_array::ByteArray', false otherwise.
- */
-declare const isTypeByteArray: (type: string) => type is "core::byte_array::ByteArray";
 /**
  * Checks if the given type is equal to the u96 type
  *
@@ -8080,12 +8738,11 @@ declare const cairo_isCairo1Type: typeof isCairo1Type;
 declare const cairo_isLen: typeof isLen;
 declare const cairo_isTypeArray: typeof isTypeArray;
 declare const cairo_isTypeBool: typeof isTypeBool;
-declare const cairo_isTypeByteArray: typeof isTypeByteArray;
-declare const cairo_isTypeBytes31: typeof isTypeBytes31;
 declare const cairo_isTypeContractAddress: typeof isTypeContractAddress;
 declare const cairo_isTypeEnum: typeof isTypeEnum;
 declare const cairo_isTypeEthAddress: typeof isTypeEthAddress;
 declare const cairo_isTypeFelt: typeof isTypeFelt;
+declare const cairo_isTypeInt: typeof isTypeInt;
 declare const cairo_isTypeLiteral: typeof isTypeLiteral;
 declare const cairo_isTypeNamedTuple: typeof isTypeNamedTuple;
 declare const cairo_isTypeNonZero: typeof isTypeNonZero;
@@ -8101,7 +8758,7 @@ declare const cairo_tuple: typeof tuple;
 declare const cairo_uint256: typeof uint256;
 declare const cairo_uint512: typeof uint512;
 declare namespace cairo {
-  export { cairo_felt as felt, cairo_getAbiContractVersion as getAbiContractVersion, cairo_getArrayType as getArrayType, cairo_isCairo1Abi as isCairo1Abi, cairo_isCairo1Type as isCairo1Type, cairo_isLen as isLen, cairo_isTypeArray as isTypeArray, cairo_isTypeBool as isTypeBool, cairo_isTypeByteArray as isTypeByteArray, cairo_isTypeBytes31 as isTypeBytes31, cairo_isTypeContractAddress as isTypeContractAddress, cairo_isTypeEnum as isTypeEnum, cairo_isTypeEthAddress as isTypeEthAddress, cairo_isTypeFelt as isTypeFelt, cairo_isTypeLiteral as isTypeLiteral, cairo_isTypeNamedTuple as isTypeNamedTuple, cairo_isTypeNonZero as isTypeNonZero, cairo_isTypeOption as isTypeOption, cairo_isTypeResult as isTypeResult, cairo_isTypeSecp256k1Point as isTypeSecp256k1Point, cairo_isTypeStruct as isTypeStruct, cairo_isTypeTuple as isTypeTuple, cairo_isTypeU96 as isTypeU96, cairo_isTypeUint as isTypeUint, cairo_isTypeUint256 as isTypeUint256, cairo_tuple as tuple, cairo_uint256 as uint256, cairo_uint512 as uint512 };
+  export { cairo_felt as felt, cairo_getAbiContractVersion as getAbiContractVersion, cairo_getArrayType as getArrayType, cairo_isCairo1Abi as isCairo1Abi, cairo_isCairo1Type as isCairo1Type, cairo_isLen as isLen, cairo_isTypeArray as isTypeArray, cairo_isTypeBool as isTypeBool, cairo_isTypeContractAddress as isTypeContractAddress, cairo_isTypeEnum as isTypeEnum, cairo_isTypeEthAddress as isTypeEthAddress, cairo_isTypeFelt as isTypeFelt, cairo_isTypeInt as isTypeInt, cairo_isTypeLiteral as isTypeLiteral, cairo_isTypeNamedTuple as isTypeNamedTuple, cairo_isTypeNonZero as isTypeNonZero, cairo_isTypeOption as isTypeOption, cairo_isTypeResult as isTypeResult, cairo_isTypeSecp256k1Point as isTypeSecp256k1Point, cairo_isTypeStruct as isTypeStruct, cairo_isTypeTuple as isTypeTuple, cairo_isTypeU96 as isTypeU96, cairo_isTypeUint as isTypeUint, cairo_isTypeUint256 as isTypeUint256, cairo_tuple as tuple, cairo_uint256 as uint256, cairo_uint512 as uint512 };
 }
 
 /**
@@ -8193,14 +8850,20 @@ declare namespace byteArray {
  * );
  * // parsedField === ['1952805748']
  */
-declare function parseCalldataField(argsIterator: Iterator<any>, input: AbiEntry, structs: AbiStructs, enums: AbiEnums): string | string[];
+declare function parseCalldataField({ argsIterator, input, structs, enums, parser, }: {
+    argsIterator: Iterator<any>;
+    input: AbiEntry;
+    structs: AbiStructs;
+    enums: AbiEnums;
+    parser: AbiParserInterface;
+}): string | string[];
 
 declare class CallData {
     abi: Abi;
     parser: AbiParserInterface;
     protected readonly structs: AbiStructs;
     protected readonly enums: AbiEnums;
-    constructor(abi: Abi);
+    constructor(abi: Abi, parsingStrategy?: ParsingStrategy);
     /**
      * Validate arguments passed to the method as corresponding to the ones in the abi
      * @param type ValidateType - type of the method
@@ -8317,6 +8980,15 @@ declare function extractContractHashes(payload: DeclareContractPayload): Complet
 declare function contractClassResponseToLegacyCompiledContract(ccr: ContractClassResponse): LegacyCompiledContract;
 
 /**
+ * !! Main design decision:
+ * Class can't extend GetTransactionReceiptResponse because it is union type
+ * and it is not possible to extend union type in current typescript version
+ * So we have to use factory function to create 'data' return type and inject constructor
+ *
+ * ERROR case left but in library flow it is not possible as fetch would throw on error before it could be read by Helper
+ */
+/**
+ * @deprecated Use `createTransactionReceipt` instead
  * Utility that analyses transaction receipt response and provides helpers to process it
  * @example
  * ```typescript
@@ -8332,17 +9004,23 @@ declare function contractClassResponseToLegacyCompiledContract(ccr: ContractClas
  * }
  * ```
  */
-declare class ReceiptTx implements GetTransactionReceiptResponse {
+declare class ReceiptTx {
     readonly statusReceipt: TransactionReceiptStatus;
     readonly value: TransactionReceiptValue;
     constructor(receipt: GetTxReceiptResponseWithoutHelper);
-    match(callbacks: TransactionReceiptCallbacks): void;
-    isSuccess(): this is GetTransactionReceiptResponse<'success'>;
-    isReverted(): this is GetTransactionReceiptResponse<'reverted'>;
-    isError(): this is GetTransactionReceiptResponse<'error'>;
+    match: (callbacks: TransactionReceiptCallbacks) => void;
+    isSuccess: () => this is SuccessfulTransactionReceiptResponseHelper;
+    isReverted: () => this is RevertedTransactionReceiptResponseHelper;
+    isError: () => this is ErrorReceiptResponseHelper;
     static isSuccess(transactionReceipt: GetTxReceiptResponseWithoutHelper): transactionReceipt is SuccessfulTransactionReceiptResponse;
     static isReverted(transactionReceipt: GetTxReceiptResponseWithoutHelper): transactionReceipt is RevertedTransactionReceiptResponse;
 }
+/**
+ * Creates a transaction receipt response object with helpers
+ * @param receipt - The transaction receipt response from the provider
+ * @returns A transaction receipt response object with helpers
+ */
+declare function createTransactionReceipt(receipt: GetTxReceiptResponseWithoutHelper): GetTransactionReceiptResponse;
 
 /**
  * Convert strk to fri or fri to strk
@@ -8540,4 +9218,4 @@ declare class Logger {
  */
 declare const logger: Logger;
 
-export { type Abi, type AbiEntry, type AbiEnum, type AbiEnums, type AbiEvent, type AbiEvents, type AbiInterfaces, type AbiStruct, type AbiStructs, Account, AccountInterface, type AccountInvocationItem, type AccountInvocations, type AccountInvocationsFactoryDetails, type AccountOptions, type AllowArray, type ApiEstimateFeeResponse, type Args, type ArgsOrCalldata, type ArgsOrCalldataWithOptions, type ArraySignatureType, type AsyncContractFunction, type BLOCK_HASH, type BLOCK_NUMBER, BatchClient, type BatchClientOptions, type BigNumberish, type Block$1 as Block, type BlockIdentifier, type BlockNumber, BlockStatus, BlockTag, type BlockWithTxHashes, type Builtins, type ByteArray, type ByteCode, type CairoAssembly, type CairoContract, CairoCustomEnum, type CairoEnum, type CairoEnumRaw, type CairoEvent, type CairoEventDefinition, type CairoEventVariant, CairoFixedArray, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, CairoUint256, CairoUint512, type CairoVersion, type Call, type CallContractResponse, CallData, type CallDetails, type CallOptions, type CallResult, type Calldata, type CommonContractOptions, type CompiledContract, type CompiledSierra, type CompiledSierraCasm, type CompilerVersion, type CompleteDeclareContractPayload, type CompressedProgram, Contract, type ContractClass, type ContractClassIdentifier, type ContractClassPayload, type ContractClassResponse, type ContractEntryPointFields, type ContractFunction, ContractInterface, type ContractOptions, type ContractVersion, type DeclareAndDeployContractPayload, type DeclareContractPayload, type DeclareContractResponse, type DeclareContractTransaction, type DeclareDeployUDCResponse, type DeclareSignerDetails, type DeclareTransactionReceiptResponse, type DeclaredTransaction, type DeployAccountContractPayload, type DeployAccountContractTransaction, type DeployAccountSignerDetails, type DeployAccountTransactionReceiptResponse, type DeployAndInvokeTransaction, type DeployContractResponse, type DeployContractUDCResponse, type DeployTransaction, type DeployTransactionReceiptResponse, type DeployedAccountTransaction, Deployer, type DeployerCall, DeployerInterface, type Details, EDAMode, EDataAvailabilityMode, ETH_ADDRESS, ETransactionExecutionStatus, ETransactionStatus, ETransactionVersion, ETransactionVersion2, ETransactionVersion3, type EVENTS_CHUNK, type EmittedEvent, EntryPointType, type EntryPointsByType, type EstimateFeeBulk, type EstimateFeeResponseBulkOverhead, type EstimateFeeResponseOverhead, EthSigner, type Event$1 as Event, type EventEntry, type EventFilter, type ExecutableDeployAndInvokeTransaction, type ExecutableDeployTransaction, type ExecutableInvokeTransaction, type ExecutableUserInvoke, type ExecutableUserTransaction, type ExecuteOptions, type ExecutionParameters, type FEE_ESTIMATE, type FELT, type FactoryParams, type FeeEstimate, type FeeMode, type FormatResponse, type FunctionAbi, type GasPrices, type GetBlockResponse, type GetTransactionReceiptResponse, type GetTransactionResponse, type GetTxReceiptResponseWithoutHelper, type HexCalldata, type Hint, type InterfaceAbi, type Invocation, type Invocations, type InvocationsDetails, type InvocationsDetailsWithNonce, type InvocationsSignerDetails, type InvokeFunctionResponse, type InvokeTransaction, type InvokeTransactionReceiptResponse, type InvokedTransaction, type L1HandlerTransactionReceiptResponse, type L1_HANDLER_TXN, type LedgerPathCalculation, LedgerSigner111 as LedgerSigner, LedgerSigner111, LedgerSigner221, LedgerSigner231, type LegacyCompiledContract, type LegacyContractClass, type LegacyEvent, LibraryError, Literal, type LogLevel, LogLevelIndex, type Methods, type MultiDeployContractResponse, type MultiType, NON_ZERO_PREFIX, type Nonce, type OptionalPayload, type OutsideCall, type OutsideExecution, type OutsideExecutionOptions, OutsideExecutionTypesV1, OutsideExecutionTypesV2, OutsideExecutionVersion, type OutsideTransaction, type PENDING_DECLARE_TXN_RECEIPT, type PENDING_DEPLOY_ACCOUNT_TXN_RECEIPT, type PENDING_INVOKE_TXN_RECEIPT, type PENDING_L1_HANDLER_TXN_RECEIPT, type PENDING_STATE_UPDATE, type PRE_CONFIRMED_STATE_UPDATE, type PRICE_UNIT, type ParsedEvent, type ParsedEvents, type ParsedStruct, type PaymasterDetails, type PaymasterFeeEstimate, PaymasterInterface, type PaymasterOptions, PaymasterRpc, type PaymasterRpcOptions, type PaymasterTimeBounds, type PendingBlock, type PendingReceipt, type PendingStateUpdate, type PreConfirmedStateUpdate, type PreparedDeployAndInvokeTransaction, type PreparedDeployTransaction, type PreparedInvokeTransaction, type PreparedTransaction, type Program, RpcProvider as Provider, ProviderInterface, type ProviderOptions, type ProviderOrAccount, type PythonicHints, type RESOURCE_PRICE, index$4 as RPC, rpc_0_8_1 as RPC08, rpc_0_9_0 as RPC09, RPCResponseParser, type RPC_ERROR, type RPC_ERROR_SET, type RawArgs, type RawArgsArray, type RawArgsObject, type RawCalldata, type Receipt, ReceiptTx, type RequiredKeysOf, type ResourceBounds, type ResourceBoundsBN, type ResourceBoundsOverhead, ResponseParser, type RevertedTransactionReceiptResponse, RpcChannel, RpcError, RpcProvider, type RpcProviderOptions, type SIMULATION_FLAG, type STATE_UPDATE, type SierraContractClass, type SierraContractEntryPointFields, type SierraEntryPointsByType, type SierraProgramDebugInfo, type Signature, Signer, SignerInterface, type Simplify, type SimulateTransaction, type SimulateTransactionDetails, type SimulateTransactionOverhead, type SimulateTransactionOverheadResponse, type SimulateTransactionResponse, type SimulationFlags, type StarkProfile, type StateUpdate, type StateUpdateResponse, type Storage, Subscription, type SubscriptionBlockIdentifier, type SuccessfulTransactionReceiptResponse, type TXN_EXECUTION_STATUS, type TXN_HASH$1 as TXN_HASH, type TXN_STATUS, TimeoutError, type TipAnalysisOptions, type TipEstimate, type TipType, type TokenData, TransactionExecutionStatus, TransactionFinalityStatus, type TransactionReceipt, type TransactionReceiptCallbacks, type TransactionReceiptCallbacksDefault, type TransactionReceiptCallbacksDefined, type TransactionReceiptStatus, type TransactionReceiptValue, type TransactionStatus, type TransactionStatusReceiptSets, type TransactionTrace, TransactionType, type TransactionWithHash, type Tupled, type TypedContractV2, UINT_128_MAX, UINT_128_MIN, UINT_256_HIGH_MAX, UINT_256_HIGH_MIN, UINT_256_LOW_MAX, UINT_256_LOW_MIN, UINT_256_MAX, UINT_256_MIN, UINT_512_MAX, UINT_512_MIN, Uint, type Uint256, type Uint512, type UniversalDeployerContractPayload, type UniversalDetails, type UserInvoke, type UserTransaction, type V3DeclareSignerDetails, type V3DeployAccountSignerDetails, type V3InvocationsSignerDetails, type V3TransactionDetails, ValidateType, WalletAccount, WebSocketChannel, WebSocketNotConnectedError, type WebSocketOptions, type WeierstrassSignatureType, type WithOptions, addAddressPadding, byteArray, cairo, config, constants, contractClassResponseToLegacyCompiledContract, defaultDeployer, defaultPaymaster, defaultProvider, ec, encode, eth, index as events, extractContractHashes, getChecksumAddress, type getContractVersionOptions, type getEstimateFeeBulkOptions, getGasPrices, getLedgerPathBuffer111 as getLedgerPathBuffer, getLedgerPathBuffer111, getLedgerPathBuffer221, type getSimulateTransactionOptions, getTipStatsFromBlocks, index$3 as hash, isAccount, isPendingBlock, isPendingStateUpdate, isPendingTransaction, isRPC08Plus_ResourceBounds, isRPC08Plus_ResourceBoundsBN, isSierra, isSupportedSpecVersion, isV3Tx, isVersion, json, legacyDeployer, logger, merkle, num, outsideExecution, parseCalldataField, paymaster, provider, selector, shortString, src5, index$1 as stark, starknetId, toAnyPatchVersion, toApiVersion, index$2 as transaction, typedData, uint256$1 as uint256, units, v2 as v2hash, v3 as v3hash, validateAndParseAddress, validateChecksumAddress, verifyMessageInStarknet, type waitForTransactionOptions, connect as wallet };
+export { type Abi, type AbiEntry, type AbiEntryType, type AbiEnum, type AbiEnums, type AbiEvent, type AbiEvents, type AbiInterfaces, AbiParser1, AbiParser2, AbiParserInterface, type AbiStruct, type AbiStructs, Account, AccountInterface, type AccountInvocationItem, type AccountInvocations, type AccountInvocationsFactoryDetails, type AccountOptions, type AllowArray, type ApiEstimateFeeResponse, type Args, type ArgsOrCalldata, type ArgsOrCalldataWithOptions, type ArraySignatureType, type AsyncContractFunction, type BLOCK_HASH, type BLOCK_NUMBER, BatchClient, type BatchClientOptions, type BigNumberish, type Block$1 as Block, type BlockIdentifier, type BlockNumber, BlockStatus, BlockTag, type BlockWithTxHashes, type Builtins, type ByteArray, type ByteCode, type CairoAssembly, CairoByteArray, type CairoContract, CairoCustomEnum, type CairoEnum, type CairoEnumRaw, type CairoEvent, type CairoEventDefinition, type CairoEventVariant, CairoFixedArray, CairoInt128, CairoInt16, CairoInt32, CairoInt64, CairoInt8, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, CairoUint128, CairoUint16, CairoUint256, CairoUint512, CairoUint64, CairoUint8, CairoUint96, type CairoVersion, type Call, type CallContractResponse, CallData, type CallDetails, type CallOptions, type CallResult, type Calldata, type CommonContractOptions, type CompiledContract, type CompiledSierra, type CompiledSierraCasm, type CompilerVersion, type CompleteDeclareContractPayload, type CompressedProgram, Contract, type ContractClass, type ContractClassIdentifier, type ContractClassPayload, type ContractClassResponse, type ContractEntryPointFields, type ContractFunction, ContractInterface, type ContractOptions, type ContractVersion, type DeclareAndDeployContractPayload, type DeclareContractPayload, type DeclareContractResponse, type DeclareContractTransaction, type DeclareDeployUDCResponse, type DeclareSignerDetails, type DeclareTransactionReceiptResponse, type DeclaredTransaction, type DeployAccountContractPayload, type DeployAccountContractTransaction, type DeployAccountSignerDetails, type DeployAccountTransactionReceiptResponse, type DeployAndInvokeTransaction, type DeployContractResponse, type DeployContractUDCResponse, type DeployTransaction, type DeployTransactionReceiptResponse, type DeployedAccountTransaction, Deployer, type DeployerCall, DeployerInterface, type Details, EDAMode, EDataAvailabilityMode, ETH_ADDRESS, ETransactionExecutionStatus, ETransactionStatus, ETransactionVersion, ETransactionVersion2, ETransactionVersion3, type EVENTS_CHUNK, type EmittedEvent, EntryPointType, type EntryPointsByType, type ErrorReceiptResponseHelper, type EstimateFeeBulk, type EstimateFeeResponseBulkOverhead, type EstimateFeeResponseOverhead, EthSigner, type Event$1 as Event, type EventEntry, type EventFilter, type ExecutableDeployAndInvokeTransaction, type ExecutableDeployTransaction, type ExecutableInvokeTransaction, type ExecutableUserInvoke, type ExecutableUserTransaction, type ExecuteOptions, type ExecutionParameters, type FEE_ESTIMATE, type FELT, type FactoryParams, type FeeEstimate, type FeeMode, type FormatResponse, type FunctionAbi, type GasPrices, type GetBlockResponse, type GetTransactionReceiptResponse, type GetTransactionResponse, type GetTxReceiptResponseWithoutHelper, type HexCalldata, type Hint, Int, type InterfaceAbi, type Invocation, type Invocations, type InvocationsDetails, type InvocationsDetailsWithNonce, type InvocationsSignerDetails, type InvokeFunctionResponse, type InvokeTransaction, type InvokeTransactionReceiptResponse, type InvokedTransaction, type L1HandlerTransactionReceiptResponse, type L1_HANDLER_TXN, type LedgerPathCalculation, LedgerSigner111 as LedgerSigner, LedgerSigner111, LedgerSigner221, LedgerSigner231, type LegacyCompiledContract, type LegacyContractClass, type LegacyEvent, LibraryError, Literal, type LogLevel, LogLevelIndex, type Methods, type MultiDeployContractResponse, type MultiType, NON_ZERO_PREFIX, type Nonce, type OptionalPayload, type OutsideCall, type OutsideExecution, type OutsideExecutionOptions, OutsideExecutionTypesV1, OutsideExecutionTypesV2, OutsideExecutionVersion, type OutsideTransaction, type PENDING_DECLARE_TXN_RECEIPT, type PENDING_DEPLOY_ACCOUNT_TXN_RECEIPT, type PENDING_INVOKE_TXN_RECEIPT, type PENDING_L1_HANDLER_TXN_RECEIPT, type PENDING_STATE_UPDATE, type PRE_CONFIRMED_STATE_UPDATE, type PRICE_UNIT, type ParsedEvent, type ParsedEvents, type ParsedStruct, type ParsingStrategy, type PaymasterDetails, type PaymasterFeeEstimate, PaymasterInterface, type PaymasterOptions, PaymasterRpc, type PaymasterRpcOptions, type PaymasterTimeBounds, type PendingBlock, type PendingReceipt, type PendingStateUpdate, type PreConfirmedStateUpdate, type PreparedDeployAndInvokeTransaction, type PreparedDeployTransaction, type PreparedInvokeTransaction, type PreparedTransaction, type Program, RpcProvider as Provider, ProviderInterface, type ProviderOptions, type ProviderOrAccount, type PythonicHints, type RESOURCE_PRICE, index$4 as RPC, rpc_0_8_1 as RPC08, rpc_0_9_0 as RPC09, RPCResponseParser, type RPC_ERROR, type RPC_ERROR_SET, type RawArgs, type RawArgsArray, type RawArgsObject, type RawCalldata, type Receipt, ReceiptTx, type RequiredKeysOf, type ResourceBounds, type ResourceBoundsBN, type ResourceBoundsOverhead, ResponseParser, type RevertedTransactionReceiptResponse, type RevertedTransactionReceiptResponseHelper, RpcChannel, RpcError, RpcProvider, type RpcProviderOptions, type SIMULATION_FLAG, type STATE_UPDATE, type SierraContractClass, type SierraContractEntryPointFields, type SierraEntryPointsByType, type SierraProgramDebugInfo, type Signature, Signer, SignerInterface, type Simplify, type SimulateTransaction, type SimulateTransactionDetails, type SimulateTransactionOverhead, type SimulateTransactionOverheadResponse, type SimulateTransactionResponse, type SimulationFlags, type StarkProfile, type StateUpdate, type StateUpdateResponse, type Storage, Subscription, type SubscriptionBlockIdentifier, type SuccessfulTransactionReceiptResponse, type SuccessfulTransactionReceiptResponseHelper, type TXN_EXECUTION_STATUS, type TXN_HASH$1 as TXN_HASH, type TXN_STATUS, TimeoutError, type TipAnalysisOptions, type TipEstimate, type TipType, type TokenData, TransactionExecutionStatus, TransactionFinalityStatus, type TransactionReceipt, type TransactionReceiptCallbacks, type TransactionReceiptCallbacksDefault, type TransactionReceiptCallbacksDefined, type TransactionReceiptStatus, type TransactionReceiptValue, type TransactionStatus, type TransactionStatusReceiptSets, type TransactionTrace, TransactionType, type TransactionWithHash, type Tupled, type TypedContractV2, UINT_128_MAX, UINT_128_MIN, UINT_256_HIGH_MAX, UINT_256_HIGH_MIN, UINT_256_LOW_MAX, UINT_256_LOW_MIN, UINT_256_MAX, UINT_256_MIN, UINT_512_MAX, UINT_512_MIN, Uint, type Uint256, type Uint512, type UniversalDeployerContractPayload, type UniversalDetails, type UserInvoke, type UserTransaction, type V3DeclareSignerDetails, type V3DeployAccountSignerDetails, type V3InvocationsSignerDetails, type V3TransactionDetails, ValidateType, WalletAccount, WebSocketChannel, WebSocketNotConnectedError, type WebSocketOptions, type WeierstrassSignatureType, type WithOptions, addAddressPadding, byteArray, cairo, config, constants, contractClassResponseToLegacyCompiledContract, createAbiParser, createTransactionReceipt, defaultDeployer, defaultPaymaster, defaultProvider, ec, encode, eth, index as events, extractContractHashes, fastParsingStrategy, getAbiVersion, getChecksumAddress, type getContractVersionOptions, type getEstimateFeeBulkOptions, getGasPrices, getLedgerPathBuffer111 as getLedgerPathBuffer, getLedgerPathBuffer111, getLedgerPathBuffer221, type getSimulateTransactionOptions, getTipStatsFromBlocks, index$3 as hash, hdParsingStrategy, isAccount, isNoConstructorValid, isPendingBlock, isPendingStateUpdate, isPendingTransaction, isRPC08Plus_ResourceBounds, isRPC08Plus_ResourceBoundsBN, isSierra, isSupportedSpecVersion, isV3Tx, isVersion, json, legacyDeployer, logger, merkle, num, outsideExecution, parseCalldataField, paymaster, provider, selector, shortString, src5, index$1 as stark, starknetId, toAnyPatchVersion, toApiVersion, index$2 as transaction, typedData, uint256$1 as uint256, units, v2 as v2hash, v3 as v3hash, validateAndParseAddress, validateChecksumAddress, verifyMessageInStarknet, type waitForTransactionOptions, connect as wallet };