starknet 5.10.1 → 5.11.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import * as _noble_curves_abstract_weierstrass from '@noble/curves/abstract/weierstrass';
+import * as weierstrass from '@noble/curves/abstract/weierstrass';
 import * as poseidon from '@noble/curves/abstract/poseidon';
 import * as microStarknet from 'micro-starknet';
 
@@ -19,26 +19,26 @@ declare function sanitizeHex(hex: string): string;
 declare function utf8ToArray(str: string): Uint8Array;
 
 declare const encode_IS_BROWSER: typeof IS_BROWSER;
+declare const encode_addHexPrefix: typeof addHexPrefix;
 declare const encode_arrayBufferToString: typeof arrayBufferToString;
 declare const encode_btoaUniversal: typeof btoaUniversal;
 declare const encode_buf2hex: typeof buf2hex;
-declare const encode_removeHexPrefix: typeof removeHexPrefix;
-declare const encode_addHexPrefix: typeof addHexPrefix;
-declare const encode_padLeft: typeof padLeft;
 declare const encode_calcByteLength: typeof calcByteLength;
+declare const encode_padLeft: typeof padLeft;
+declare const encode_removeHexPrefix: typeof removeHexPrefix;
 declare const encode_sanitizeBytes: typeof sanitizeBytes;
 declare const encode_sanitizeHex: typeof sanitizeHex;
 declare const encode_utf8ToArray: typeof utf8ToArray;
 declare namespace encode {
   export {
     encode_IS_BROWSER as IS_BROWSER,
+    encode_addHexPrefix as addHexPrefix,
     encode_arrayBufferToString as arrayBufferToString,
     encode_btoaUniversal as btoaUniversal,
     encode_buf2hex as buf2hex,
-    encode_removeHexPrefix as removeHexPrefix,
-    encode_addHexPrefix as addHexPrefix,
-    encode_padLeft as padLeft,
     encode_calcByteLength as calcByteLength,
+    encode_padLeft as padLeft,
+    encode_removeHexPrefix as removeHexPrefix,
     encode_sanitizeBytes as sanitizeBytes,
     encode_sanitizeHex as sanitizeHex,
     encode_utf8ToArray as utf8ToArray,
@@ -88,12 +88,20 @@ declare const BETA = "6F21413EFBE40DE150E596D72F7A8C5609AD26C15C915C1F4CDFCB99CE
 declare const MAX_ECDSA_VAL = "800000000000000000000000000000000000000000000000000000000000000";
 declare const CONSTANT_POINTS: string[][];
 
-declare const constants_ZERO: typeof ZERO;
-declare const constants_MASK_250: typeof MASK_250;
-declare const constants_MASK_251: typeof MASK_251;
+declare const constants_ALPHA: typeof ALPHA;
 declare const constants_API_VERSION: typeof API_VERSION;
+declare const constants_BETA: typeof BETA;
 type constants_BaseUrl = BaseUrl;
 declare const constants_BaseUrl: typeof BaseUrl;
+declare const constants_CONSTANT_POINTS: typeof CONSTANT_POINTS;
+declare const constants_EC_ORDER: typeof EC_ORDER;
+declare const constants_FIELD_GEN: typeof FIELD_GEN;
+declare const constants_FIELD_PRIME: typeof FIELD_PRIME;
+declare const constants_FIELD_SIZE: typeof FIELD_SIZE;
+declare const constants_IS_BROWSER: typeof IS_BROWSER;
+declare const constants_MASK_250: typeof MASK_250;
+declare const constants_MASK_251: typeof MASK_251;
+declare const constants_MAX_ECDSA_VAL: typeof MAX_ECDSA_VAL;
 type constants_NetworkName = NetworkName;
 declare const constants_NetworkName: typeof NetworkName;
 type constants_StarknetChainId = StarknetChainId;
@@ -101,46 +109,39 @@ declare const constants_StarknetChainId: typeof StarknetChainId;
 type constants_TransactionHashPrefix = TransactionHashPrefix;
 declare const constants_TransactionHashPrefix: typeof TransactionHashPrefix;
 declare const constants_UDC: typeof UDC;
-declare const constants_FIELD_PRIME: typeof FIELD_PRIME;
-declare const constants_FIELD_GEN: typeof FIELD_GEN;
-declare const constants_FIELD_SIZE: typeof FIELD_SIZE;
-declare const constants_EC_ORDER: typeof EC_ORDER;
-declare const constants_ALPHA: typeof ALPHA;
-declare const constants_BETA: typeof BETA;
-declare const constants_MAX_ECDSA_VAL: typeof MAX_ECDSA_VAL;
-declare const constants_CONSTANT_POINTS: typeof CONSTANT_POINTS;
-declare const constants_IS_BROWSER: typeof IS_BROWSER;
+declare const constants_ZERO: typeof ZERO;
 declare namespace constants {
   export {
-    constants_ZERO as ZERO,
-    constants_MASK_250 as MASK_250,
-    constants_MASK_251 as MASK_251,
+    constants_ALPHA as ALPHA,
     constants_API_VERSION as API_VERSION,
+    constants_BETA as BETA,
     constants_BaseUrl as BaseUrl,
+    constants_CONSTANT_POINTS as CONSTANT_POINTS,
+    constants_EC_ORDER as EC_ORDER,
+    constants_FIELD_GEN as FIELD_GEN,
+    constants_FIELD_PRIME as FIELD_PRIME,
+    constants_FIELD_SIZE as FIELD_SIZE,
+    constants_IS_BROWSER as IS_BROWSER,
+    constants_MASK_250 as MASK_250,
+    constants_MASK_251 as MASK_251,
+    constants_MAX_ECDSA_VAL as MAX_ECDSA_VAL,
     constants_NetworkName as NetworkName,
     constants_StarknetChainId as StarknetChainId,
     constants_TransactionHashPrefix as TransactionHashPrefix,
     constants_UDC as UDC,
-    constants_FIELD_PRIME as FIELD_PRIME,
-    constants_FIELD_GEN as FIELD_GEN,
-    constants_FIELD_SIZE as FIELD_SIZE,
-    constants_EC_ORDER as EC_ORDER,
-    constants_ALPHA as ALPHA,
-    constants_BETA as BETA,
-    constants_MAX_ECDSA_VAL as MAX_ECDSA_VAL,
-    constants_CONSTANT_POINTS as CONSTANT_POINTS,
-    constants_IS_BROWSER as IS_BROWSER,
+    constants_ZERO as ZERO,
   };
 }
 
+declare const ec_weierstrass: typeof weierstrass;
 declare namespace ec {
   export {
     microStarknet as starkCurve,
-    _noble_curves_abstract_weierstrass as weierstrass,
+    ec_weierstrass as weierstrass,
   };
 }
 
-declare type BigNumberish = string | number | bigint;
+type BigNumberish = string | number | bigint;
 declare function isHex(hex: string): boolean;
 declare function toBigInt(value: BigNumberish): bigint;
 declare function isBigInt(value: any): value is bigint;
@@ -168,41 +169,41 @@ declare const toCairoBool: (value: boolean) => string;
 declare function hexToBytes(value: string): Uint8Array;
 
 type num_BigNumberish = BigNumberish;
-declare const num_isHex: typeof isHex;
-declare const num_toBigInt: typeof toBigInt;
-declare const num_isBigInt: typeof isBigInt;
-declare const num_toHex: typeof toHex;
-declare const num_hexToDecimalString: typeof hexToDecimalString;
-declare const num_cleanHex: typeof cleanHex;
 declare const num_assertInRange: typeof assertInRange;
 declare const num_bigNumberishArrayToDecimalStringArray: typeof bigNumberishArrayToDecimalStringArray;
 declare const num_bigNumberishArrayToHexadecimalStringArray: typeof bigNumberishArrayToHexadecimalStringArray;
-declare const num_isStringWholeNumber: typeof isStringWholeNumber;
-declare const num_toHexString: typeof toHexString;
+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_toCairoBool: typeof toCairoBool;
 declare const num_hexToBytes: typeof hexToBytes;
+declare const num_hexToDecimalString: typeof hexToDecimalString;
+declare const num_isBigInt: typeof isBigInt;
+declare const num_isHex: typeof isHex;
+declare const num_isStringWholeNumber: typeof isStringWholeNumber;
+declare const num_toBigInt: typeof toBigInt;
+declare const num_toCairoBool: typeof toCairoBool;
+declare const num_toHex: typeof toHex;
+declare const num_toHexString: typeof toHexString;
 declare namespace num {
   export {
     num_BigNumberish as BigNumberish,
-    num_isHex as isHex,
-    num_toBigInt as toBigInt,
-    num_isBigInt as isBigInt,
-    num_toHex as toHex,
-    num_hexToDecimalString as hexToDecimalString,
-    num_cleanHex as cleanHex,
     num_assertInRange as assertInRange,
     num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray,
     num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray,
-    num_isStringWholeNumber as isStringWholeNumber,
-    num_toHexString as toHexString,
+    num_cleanHex as cleanHex,
     num_getDecimalString as getDecimalString,
     num_getHexString as getHexString,
     num_getHexStringArray as getHexStringArray,
-    num_toCairoBool as toCairoBool,
     num_hexToBytes as hexToBytes,
+    num_hexToDecimalString as hexToDecimalString,
+    num_isBigInt as isBigInt,
+    num_isHex as isHex,
+    num_isStringWholeNumber as isStringWholeNumber,
+    num_toBigInt as toBigInt,
+    num_toCairoBool as toCairoBool,
+    num_toHex as toHex,
+    num_toHexString as toHexString,
   };
 }
 
@@ -216,26 +217,26 @@ declare const UINT_256_MAX: bigint;
 declare function isUint256(bn: BigNumberish): boolean;
 declare function bnToUint256(bignumber: BigNumberish): Uint256;
 
-type uint256$1_Uint256 = Uint256;
-declare const uint256$1_uint256ToBN: typeof uint256ToBN;
 declare const uint256$1_UINT_128_MAX: typeof UINT_128_MAX;
 declare const uint256$1_UINT_256_MAX: typeof UINT_256_MAX;
-declare const uint256$1_isUint256: typeof isUint256;
+type uint256$1_Uint256 = Uint256;
 declare const uint256$1_bnToUint256: typeof bnToUint256;
+declare const uint256$1_isUint256: typeof isUint256;
+declare const uint256$1_uint256ToBN: typeof uint256ToBN;
 declare namespace uint256$1 {
   export {
-    uint256$1_Uint256 as Uint256,
-    uint256$1_uint256ToBN as uint256ToBN,
     uint256$1_UINT_128_MAX as UINT_128_MAX,
     uint256$1_UINT_256_MAX as UINT_256_MAX,
-    uint256$1_isUint256 as isUint256,
+    uint256$1_Uint256 as Uint256,
     uint256$1_bnToUint256 as bnToUint256,
+    uint256$1_isUint256 as isUint256,
+    uint256$1_uint256ToBN as uint256ToBN,
   };
 }
 
 /** ABI */
-declare type Abi = Array<FunctionAbi | EventAbi | StructAbi>;
-declare type AbiEntry = {
+type Abi = Array<FunctionAbi | EventAbi | StructAbi>;
+type AbiEntry = {
     name: string;
     type: 'felt' | 'felt*' | string;
 };
@@ -244,7 +245,7 @@ declare enum FunctionAbiType {
     'l1_handler' = 1,
     'constructor' = 2
 }
-declare type FunctionAbi = {
+type FunctionAbi = {
     inputs: AbiEntry[];
     name: string;
     outputs: AbiEntry[];
@@ -252,10 +253,10 @@ declare type FunctionAbi = {
     state_mutability?: string;
     type: FunctionAbiType;
 };
-declare type AbiStructs = {
+type AbiStructs = {
     [name: string]: StructAbi;
 };
-declare type StructAbi = {
+type StructAbi = {
     members: (AbiEntry & {
         offset: number;
     })[];
@@ -263,26 +264,26 @@ declare type StructAbi = {
     size: number;
     type: 'struct';
 };
-declare type EventAbi = any;
+type EventAbi = any;
 
 /** LEGACY CONTRACT */
-declare type LegacyContractClass = {
+type LegacyContractClass = {
     program: CompressedProgram;
     entry_points_by_type: EntryPointsByType;
     abi: Abi;
 };
-declare type LegacyCompiledContract = Omit<LegacyContractClass, 'program'> & {
+type LegacyCompiledContract = Omit<LegacyContractClass, 'program'> & {
     program: Program;
 };
 /** SUBTYPES */
-declare type Builtins = string[];
-declare type CompressedProgram = string;
-declare type EntryPointsByType = {
+type Builtins = string[];
+type CompressedProgram = string;
+type EntryPointsByType = {
     CONSTRUCTOR: ContractEntryPointFields[];
     EXTERNAL: ContractEntryPointFields[];
     L1_HANDLER: ContractEntryPointFields[];
 };
-declare type ContractEntryPointFields = {
+type ContractEntryPointFields = {
     selector: string;
     offset: string;
     builtins?: Builtins;
@@ -293,7 +294,7 @@ interface Program extends Record<string, any> {
 }
 
 /** SYSTEM TYPES */
-declare type CairoAssembly = {
+type CairoAssembly = {
     prime: string;
     compiler_version: string;
     bytecode: ByteCode;
@@ -301,7 +302,7 @@ declare type CairoAssembly = {
     pythonic_hints: PythonicHints;
     entry_points_by_type: EntryPointsByType;
 };
-declare type SierraContractClass = {
+type SierraContractClass = {
     sierra_program: ByteCode;
     sierra_program_debug_info: SierraProgramDebugInfo;
     contract_class_version: string;
@@ -309,55 +310,55 @@ declare type SierraContractClass = {
     abi: Abi;
 };
 /** COMPILED CONTRACT */
-declare type CompiledSierra = SierraContractClass;
-declare type CompiledSierraCasm = CairoAssembly;
+type CompiledSierra = SierraContractClass;
+type CompiledSierraCasm = CairoAssembly;
 /** SUBTYPES */
-declare type ByteCode = string[];
-declare type PythonicHints = [number, string[]][];
-declare type SierraProgramDebugInfo = {
+type ByteCode = string[];
+type PythonicHints = [number, string[]][];
+type SierraProgramDebugInfo = {
     type_names: [number, string][];
     libfunc_names: [number, string][];
     user_func_names: [number, string][];
 };
-declare type SierraEntryPointsByType = {
+type SierraEntryPointsByType = {
     CONSTRUCTOR: SierraContractEntryPointFields[];
     EXTERNAL: SierraContractEntryPointFields[];
     L1_HANDLER: SierraContractEntryPointFields[];
 };
-declare type SierraContractEntryPointFields = {
+type SierraContractEntryPointFields = {
     selector: string;
     function_idx: number;
 };
 
-declare type ContractClass = LegacyContractClass | SierraContractClass;
-declare type CompiledContract = LegacyCompiledContract | CompiledSierra;
-declare type CairoContract = ContractClass | CompiledContract;
+type ContractClass = LegacyContractClass | SierraContractClass;
+type CompiledContract = LegacyCompiledContract | CompiledSierra;
+type CairoContract = ContractClass | CompiledContract;
 declare enum EntryPointType {
     EXTERNAL = "EXTERNAL",
     L1_HANDLER = "L1_HANDLER",
     CONSTRUCTOR = "CONSTRUCTOR"
 }
 
-declare type WeierstrassSignatureType = _noble_curves_abstract_weierstrass.SignatureType;
-declare type ArraySignatureType = string[];
-declare type Signature = ArraySignatureType | WeierstrassSignatureType;
+type WeierstrassSignatureType = weierstrass.SignatureType;
+type ArraySignatureType = string[];
+type Signature = ArraySignatureType | WeierstrassSignatureType;
 /**
  * BigNumberish array
  * use CallData.compile() to convert to Calldata
  */
-declare type RawCalldata = BigNumberish[];
+type RawCalldata = BigNumberish[];
 /**
  * Hexadecimal-string array
  */
-declare type HexCalldata = string[];
-declare type AllowArray<T> = T | T[];
-declare type RawArgs = RawArgsObject | RawArgsArray;
-declare type RawArgsObject = {
+type HexCalldata = string[];
+type AllowArray<T> = T | T[];
+type RawArgs = RawArgsObject | RawArgsArray;
+type RawArgsObject = {
     [inputName: string]: MultiType | MultiType[] | RawArgs;
 };
-declare type RawArgsArray = Array<MultiType | MultiType[] | RawArgs>;
-declare type MultiType = BigNumberish | Uint256 | object | boolean;
-declare type UniversalDeployerContractPayload = {
+type RawArgsArray = Array<MultiType | MultiType[] | RawArgs>;
+type MultiType = BigNumberish | Uint256 | object | boolean;
+type UniversalDeployerContractPayload = {
     classHash: BigNumberish;
     salt?: string;
     unique?: boolean;
@@ -366,51 +367,51 @@ declare type UniversalDeployerContractPayload = {
 /**
  * @deprecated deprecated due to no direct deploy, unused - can be removed
  */
-declare type DeployContractPayload = {
+type DeployContractPayload = {
     contract: CompiledContract | string;
     constructorCalldata?: RawCalldata;
     addressSalt?: string;
 };
-declare type DeployAccountContractPayload = {
+type DeployAccountContractPayload = {
     classHash: string;
     constructorCalldata?: RawArgs;
     addressSalt?: BigNumberish;
     contractAddress?: string;
 };
-declare type DeployAccountContractTransaction = Omit<DeployAccountContractPayload, 'contractAddress'> & {
+type DeployAccountContractTransaction = Omit<DeployAccountContractPayload, 'contractAddress'> & {
     signature?: Signature;
 };
-declare type DeclareContractPayload = {
+type DeclareContractPayload = {
     contract: CompiledContract | string;
     classHash?: string;
     casm?: CompiledSierraCasm;
     compiledClassHash?: string;
 };
-declare type CompleteDeclareContractPayload = {
+type CompleteDeclareContractPayload = {
     contract: CompiledContract | string;
     classHash: string;
     casm?: CompiledSierraCasm;
     compiledClassHash?: string;
 };
-declare type DeclareAndDeployContractPayload = Omit<UniversalDeployerContractPayload, 'classHash'> & DeclareContractPayload;
-declare type DeclareContractTransaction = {
+type DeclareAndDeployContractPayload = Omit<UniversalDeployerContractPayload, 'classHash'> & DeclareContractPayload;
+type DeclareContractTransaction = {
     contractDefinition: ContractClass;
     senderAddress: string;
     signature?: Signature;
     compiledClassHash?: string;
 };
-declare type CallDetails = {
+type CallDetails = {
     contractAddress: string;
     calldata?: RawArgs;
 };
-declare type Invocation = CallDetails & {
+type Invocation = CallDetails & {
     signature?: Signature;
 };
-declare type Call = CallDetails & {
+type Call = CallDetails & {
     entrypoint: string;
 };
-declare type CairoVersion = '0' | '1';
-declare type InvocationsDetails = {
+type CairoVersion = '0' | '1';
+type InvocationsDetails = {
     nonce?: BigNumberish;
     maxFee?: BigNumberish;
     version?: BigNumberish;
@@ -418,13 +419,13 @@ declare type InvocationsDetails = {
 /**
  * Contain all additional details params
  */
-declare type Details = {
+type Details = {
     nonce: BigNumberish;
     maxFee: BigNumberish;
     version: BigNumberish;
     chainId: StarknetChainId;
 };
-declare type InvocationsDetailsWithNonce = InvocationsDetails & {
+type InvocationsDetailsWithNonce = InvocationsDetails & {
     nonce: BigNumberish;
 };
 declare enum TransactionStatus {
@@ -435,7 +436,7 @@ declare enum TransactionStatus {
     ACCEPTED_ON_L1 = "ACCEPTED_ON_L1",
     REJECTED = "REJECTED"
 }
-declare type TransactionBulk = Array<({
+type TransactionBulk = Array<({
     type: 'DECLARE';
 } & {
     payload: DeclareContractPayload;
@@ -452,7 +453,7 @@ declare type TransactionBulk = Array<({
 } & {
     payload: AllowArray<Call>;
 })>;
-declare type InvocationBulk = Array<(({
+type InvocationBulk = Array<(({
     type: 'DECLARE';
 } & DeclareContractTransaction) | ({
     type: 'DEPLOY_ACCOUNT';
@@ -461,30 +462,30 @@ declare type InvocationBulk = Array<(({
 } & Invocation)) & InvocationsDetailsWithNonce & {
     blockIdentifier: BlockNumber | BigNumberish;
 }>;
-declare type Status = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+type Status = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
 declare enum TransactionType {
     INVOKE = "INVOKE_FUNCTION",
     DECLARE = "DECLARE",
     DEPLOY = "DEPLOY",
     DEPLOY_ACCOUNT = "DEPLOY_ACCOUNT"
 }
-declare type Tupled = {
+type Tupled = {
     element: any;
     type: string;
 };
-declare type BlockTag = 'pending' | 'latest';
-declare type BlockNumber = BlockTag | null | number;
-declare type Struct = {
+type BlockTag = 'pending' | 'latest';
+type BlockNumber = BlockTag | null | number;
+type Struct = {
     type: 'struct';
     [k: string]: BigNumberish;
 };
-declare type Args = {
+type Args = {
     [inputName: string]: BigNumberish | BigNumberish[] | ParsedStruct | ParsedStruct[];
 };
-declare type ParsedStruct = {
+type ParsedStruct = {
     [key: string]: BigNumberish | ParsedStruct;
 };
-declare type waitForTransactionOptions = {
+type waitForTransactionOptions = {
     retryInterval?: number;
     successStates?: Array<TransactionStatus>;
 };
@@ -508,28 +509,28 @@ interface DeclareSignerDetails {
     nonce: BigNumberish;
     compiledClassHash?: string;
 }
-declare type DeployAccountSignerDetails = Required<DeployAccountContractPayload> & Required<InvocationsDetails> & {
+type DeployAccountSignerDetails = Required<DeployAccountContractPayload> & Required<InvocationsDetails> & {
     contractAddress: BigNumberish;
     chainId: StarknetChainId;
 };
 
-declare type BlockIdentifier = BlockNumber | BigNumberish;
+type BlockIdentifier = BlockNumber | BigNumberish;
 
-declare type AsyncContractFunction<T = any> = (...args: ArgsOrCalldataWithOptions) => Promise<T>;
-declare type ContractFunction = (...args: ArgsOrCalldataWithOptions) => any;
-declare type Result = {
+type AsyncContractFunction<T = any> = (...args: ArgsOrCalldataWithOptions) => Promise<T>;
+type ContractFunction = (...args: ArgsOrCalldataWithOptions) => any;
+type Result = {
     [key: string]: any;
 } | Result[] | bigint | string | boolean;
 /**
  * Compiled calldata ready to be sent
  * decimal-string array
  */
-declare type Calldata = string[] & {
+type Calldata = string[] & {
     readonly __compiled__?: boolean;
 };
-declare type ArgsOrCalldata = RawArgsArray | [Calldata] | Calldata;
-declare type ArgsOrCalldataWithOptions = ArgsOrCalldata & ContractOptions;
-declare type ContractOptions = {
+type ArgsOrCalldata = RawArgsArray | [Calldata] | Calldata;
+type ArgsOrCalldataWithOptions = ArgsOrCalldata & ContractOptions;
+type ContractOptions = {
     blockIdentifier?: BlockIdentifier;
     parseRequest?: boolean;
     parseResponse?: boolean;
@@ -541,8 +542,8 @@ declare type ContractOptions = {
     signature?: Signature;
     addressSalt?: string;
 };
-declare type CallOptions = Pick<ContractOptions, 'blockIdentifier' | 'parseRequest' | 'parseResponse' | 'formatResponse'>;
-declare type InvokeOptions = Pick<ContractOptions, 'maxFee' | 'nonce' | 'signature' | 'parseRequest'>;
+type CallOptions = Pick<ContractOptions, 'blockIdentifier' | 'parseRequest' | 'parseResponse' | 'formatResponse'>;
+type InvokeOptions = Pick<ContractOptions, 'maxFee' | 'nonce' | 'signature' | 'parseRequest'>;
 
 /**
  * Starknet RPC version 0.2.1
@@ -553,35 +554,35 @@ declare type InvokeOptions = Pick<ContractOptions, 'maxFee' | 'nonce' | 'signatu
  *
  * TypeScript Representation of OpenRpc protocol types
  */
-declare type FELT = string;
-declare type ADDRESS = FELT;
-declare type NUM_AS_HEX = string;
-declare type SIGNATURE = Array<FELT>;
-declare type BLOCK_NUMBER = number;
-declare type BLOCK_HASH = FELT;
-declare type TXN_HASH = FELT;
-declare type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
-declare type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'DEPLOY_ACCOUNT' | 'INVOKE' | 'L1_HANDLER';
-declare type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+type FELT = string;
+type ADDRESS = FELT;
+type NUM_AS_HEX = string;
+type SIGNATURE = Array<FELT>;
+type BLOCK_NUMBER = number;
+type BLOCK_HASH = FELT;
+type TXN_HASH = FELT;
+type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'DEPLOY_ACCOUNT' | 'INVOKE' | 'L1_HANDLER';
+type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
 declare enum BLOCK_TAG {
     latest = "latest",
     pending = "pending"
 }
-declare type BLOCK_ID = {
+type BLOCK_ID = {
     block_hash: BLOCK_HASH;
 } | {
     block_number: BLOCK_NUMBER;
 } | BLOCK_TAG;
-declare type MSG_TO_L1 = {
+type MSG_TO_L1 = {
     to_address: FELT;
     payload: Array<FELT>;
 };
-declare type EVENT = {
+type EVENT = {
     from_address: FELT;
     keys: Array<FELT>;
     data: Array<FELT>;
 };
-declare type COMMON_RECEIPT_PROPERTIES = {
+type COMMON_RECEIPT_PROPERTIES = {
     transaction_hash: TXN_HASH;
     actual_fee: FELT;
     status: TXN_STATUS;
@@ -591,25 +592,25 @@ declare type COMMON_RECEIPT_PROPERTIES = {
     messages_sent: Array<MSG_TO_L1>;
     events: Array<EVENT>;
 };
-declare type PENDING_COMMON_RECEIPT_PROPERTIES = {
+type PENDING_COMMON_RECEIPT_PROPERTIES = {
     transaction_hash: TXN_HASH;
     actual_fee: FELT;
     type?: TXN_TYPE;
     messages_sent: Array<MSG_TO_L1>;
     events: Array<EVENT>;
 };
-declare type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
-declare type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
-declare type DEPLOY_TXN_RECEIPT = {
+type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DEPLOY_TXN_RECEIPT = {
     contract_address: FELT;
 } & COMMON_RECEIPT_PROPERTIES;
-declare type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
-declare type PENDING_DEPLOY_TXN_RECEIPT = {
+type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type PENDING_DEPLOY_TXN_RECEIPT = {
     contract_address: FELT;
 } & PENDING_COMMON_RECEIPT_PROPERTIES;
-declare type PENDING_TXN_RECEIPT = PENDING_DEPLOY_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
-declare type TXN_RECEIPT = INVOKE_TXN_RECEIPT | L1_HANDLER_TXN_RECEIPT | DECLARE_TXN_RECEIPT | DEPLOY_TXN_RECEIPT | DEPLOY_ACCOUNT_TXN_RECEIPT | PENDING_TXN_RECEIPT;
-declare type BLOCK_HEADER = {
+type PENDING_TXN_RECEIPT = PENDING_DEPLOY_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
+type TXN_RECEIPT = INVOKE_TXN_RECEIPT | L1_HANDLER_TXN_RECEIPT | DECLARE_TXN_RECEIPT | DEPLOY_TXN_RECEIPT | DEPLOY_ACCOUNT_TXN_RECEIPT | PENDING_TXN_RECEIPT;
+type BLOCK_HEADER = {
     block_hash: BLOCK_HASH;
     parent_hash: BLOCK_HASH;
     block_number: BLOCK_NUMBER;
@@ -617,91 +618,91 @@ declare type BLOCK_HEADER = {
     timestamp: number;
     sequencer_address: FELT;
 };
-declare type BLOCK_BODY_WITH_TX_HASHES = {
+type BLOCK_BODY_WITH_TX_HASHES = {
     transactions: Array<TXN_HASH>;
 };
-declare type BLOCK_WITH_TX_HASHES = {
+type BLOCK_WITH_TX_HASHES = {
     status: BLOCK_STATUS;
 } & BLOCK_HEADER & BLOCK_BODY_WITH_TX_HASHES;
-declare type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
+type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
     timestamp: number;
     sequencer_address: FELT;
     parent_hash: BLOCK_HASH;
 };
-declare type COMMON_TXN_PROPERTIES = {
+type COMMON_TXN_PROPERTIES = {
     transaction_hash?: TXN_HASH;
 } & BROADCASTED_TXN_COMMON_PROPERTIES;
-declare type FUNCTION_CALL = {
+type FUNCTION_CALL = {
     contract_address?: ADDRESS;
     entry_point_selector?: FELT;
     calldata?: Array<FELT>;
 };
-declare type INVOKE_TXN = COMMON_TXN_PROPERTIES & (INVOKE_TXN_V0 | INVOKE_TXN_V1);
-declare type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
+type INVOKE_TXN = COMMON_TXN_PROPERTIES & (INVOKE_TXN_V0 | INVOKE_TXN_V1);
+type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
     class_hash: FELT;
     sender_address: ADDRESS;
 };
-declare type DEPLOY_TXN = {
+type DEPLOY_TXN = {
     transaction_hash: TXN_HASH;
     class_hash: FELT;
 } & DEPLOY_TXN_PROPERTIES;
-declare type DEPLOY_ACCOUNT_TXN = COMMON_TXN_PROPERTIES & DEPLOY_ACCOUNT_TXN_PROPERTIES;
-declare type DEPLOY_ACCOUNT_TXN_PROPERTIES = {
+type DEPLOY_ACCOUNT_TXN = COMMON_TXN_PROPERTIES & DEPLOY_ACCOUNT_TXN_PROPERTIES;
+type DEPLOY_ACCOUNT_TXN_PROPERTIES = {
     contract_address_salt: FELT;
     constructor_calldata: Array<FELT>;
     class_hash: FELT;
 };
-declare type DEPLOY_ACCOUNT_TXN_RECEIPT = DEPLOY_TXN_RECEIPT;
-declare type TXN = INVOKE_TXN | L1_HANDLER_TXN | DECLARE_TXN | DEPLOY_TXN | DEPLOY_ACCOUNT_TXN;
+type DEPLOY_ACCOUNT_TXN_RECEIPT = DEPLOY_TXN_RECEIPT;
+type TXN = INVOKE_TXN | L1_HANDLER_TXN | DECLARE_TXN | DEPLOY_TXN | DEPLOY_ACCOUNT_TXN;
 declare enum L1_HANDLER {
     'L1_HANDLER' = 0
 }
-declare type L1_HANDLER_TXN = {
+type L1_HANDLER_TXN = {
     transaction_hash: TXN_HASH;
     version: NUM_AS_HEX;
     type: L1_HANDLER;
     nonce: NUM_AS_HEX;
 } & FUNCTION_CALL;
-declare type BROADCASTED_DEPLOY_ACCOUNT_TXN = BROADCASTED_TXN_COMMON_PROPERTIES & DEPLOY_ACCOUNT_TXN_PROPERTIES;
-declare type BROADCASTED_TXN = BROADCASTED_INVOKE_TXN | BROADCASTED_DECLARE_TXN | BROADCASTED_DEPLOY_TXN | BROADCASTED_DEPLOY_ACCOUNT_TXN;
-declare type BROADCASTED_INVOKE_TXN = BROADCASTED_TXN_COMMON_PROPERTIES & (INVOKE_TXN_V0 | INVOKE_TXN_V1);
-declare type BROADCASTED_TXN_COMMON_PROPERTIES = {
+type BROADCASTED_DEPLOY_ACCOUNT_TXN = BROADCASTED_TXN_COMMON_PROPERTIES & DEPLOY_ACCOUNT_TXN_PROPERTIES;
+type BROADCASTED_TXN = BROADCASTED_INVOKE_TXN | BROADCASTED_DECLARE_TXN | BROADCASTED_DEPLOY_TXN | BROADCASTED_DEPLOY_ACCOUNT_TXN;
+type BROADCASTED_INVOKE_TXN = BROADCASTED_TXN_COMMON_PROPERTIES & (INVOKE_TXN_V0 | INVOKE_TXN_V1);
+type BROADCASTED_TXN_COMMON_PROPERTIES = {
     type: TXN_TYPE;
     max_fee: FELT;
     version: NUM_AS_HEX;
     signature: SIGNATURE;
     nonce: FELT;
 };
-declare type BROADCASTED_DECLARE_TXN = {
+type BROADCASTED_DECLARE_TXN = {
     contract_class: CONTRACT_CLASS;
     sender_address: ADDRESS;
 } & BROADCASTED_TXN_COMMON_PROPERTIES;
-declare type BROADCASTED_DEPLOY_TXN = {
+type BROADCASTED_DEPLOY_TXN = {
     contract_class: CONTRACT_CLASS;
 } & DEPLOY_TXN_PROPERTIES;
-declare type DEPLOY_TXN_PROPERTIES = {
+type DEPLOY_TXN_PROPERTIES = {
     version: NUM_AS_HEX;
     type: TXN_TYPE;
     contract_address_salt: FELT;
     constructor_calldata: Array<FELT>;
 };
-declare type INVOKE_TXN_V0 = FUNCTION_CALL;
-declare type INVOKE_TXN_V1 = {
+type INVOKE_TXN_V0 = FUNCTION_CALL;
+type INVOKE_TXN_V1 = {
     sender_address: ADDRESS;
     calldata: Array<FELT>;
 };
-declare type BLOCK_BODY_WITH_TXS = {
+type BLOCK_BODY_WITH_TXS = {
     transactions: Array<TXN>;
 };
-declare type BLOCK_WITH_TXS = {
+type BLOCK_WITH_TXS = {
     status: BLOCK_STATUS;
 } & BLOCK_HEADER & BLOCK_BODY_WITH_TXS;
-declare type PENDING_BLOCK_WITH_TXS = BLOCK_BODY_WITH_TXS & {
+type PENDING_BLOCK_WITH_TXS = BLOCK_BODY_WITH_TXS & {
     timestamp: number;
     sequencer_address: FELT;
     parent_hash: BLOCK_HASH;
 };
-declare type CONTRACT_CLASS = {
+type CONTRACT_CLASS = {
     program: string;
     entry_points_by_type: {
         CONSTRUCTOR: CONTRACT_ENTRY_POINT_LIST;
@@ -710,8 +711,8 @@ declare type CONTRACT_CLASS = {
     };
     abi?: CONTRACT_ABI;
 };
-declare type CONTRACT_ABI = Array<CONTRACT_ABI_ENTRY>;
-declare type CONTRACT_ABI_ENTRY = FUNCTION_ABI_ENTRY | EVENT_ABI_ENTRY | STRUCT_ABI_ENTRY;
+type CONTRACT_ABI = Array<CONTRACT_ABI_ENTRY>;
+type CONTRACT_ABI_ENTRY = FUNCTION_ABI_ENTRY | EVENT_ABI_ENTRY | STRUCT_ABI_ENTRY;
 declare enum STRUCT_ABI_TYPE {
     'struct' = 0
 }
@@ -723,46 +724,46 @@ declare enum FUNCTION_ABI_TYPE {
     'l1_handler' = 1,
     'constructor' = 2
 }
-declare type STRUCT_ABI_ENTRY = STRUCT_ABI_TYPE & {
+type STRUCT_ABI_ENTRY = STRUCT_ABI_TYPE & {
     name: string;
     size: number;
     members: Array<STRUCT_MEMBER>;
 };
-declare type STRUCT_MEMBER = {
+type STRUCT_MEMBER = {
     offset: number;
 } & TYPED_PARAMETER;
-declare type EVENT_ABI_ENTRY = {
+type EVENT_ABI_ENTRY = {
     name: string;
     keys: Array<TYPED_PARAMETER>;
     data: Array<TYPED_PARAMETER>;
 } & EVENT_ABI_TYPE;
-declare type FUNCTION_ABI_ENTRY = {
+type FUNCTION_ABI_ENTRY = {
     type: FUNCTION_ABI_TYPE;
     name: string;
     inputs: Array<TYPED_PARAMETER>;
     outputs: Array<TYPED_PARAMETER>;
 };
-declare type TYPED_PARAMETER = {
+type TYPED_PARAMETER = {
     name: string;
     type: string;
 };
-declare type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
-declare type CONTRACT_ENTRY_POINT = {
+type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
+type CONTRACT_ENTRY_POINT = {
     offset: NUM_AS_HEX;
     selector: FELT;
 };
-declare type CONTRACT_STORAGE_DIFF_ITEM = {
+type CONTRACT_STORAGE_DIFF_ITEM = {
     address: FELT;
     storage_entries: {
         key: FELT;
         value: FELT;
     }[];
 };
-declare type DEPLOYED_CONTRACT_ITEM = {
+type DEPLOYED_CONTRACT_ITEM = {
     address: FELT;
     class_hash: FELT;
 };
-declare type STATE_UPDATE = {
+type STATE_UPDATE = {
     block_hash: BLOCK_HASH;
     new_root: FELT;
     old_root: FELT;
@@ -776,23 +777,23 @@ declare type STATE_UPDATE = {
         }>;
     };
 };
-declare type STORAGE_KEY = string;
-declare type EVENT_FILTER = {
+type STORAGE_KEY = string;
+type EVENT_FILTER = {
     from_block: BLOCK_ID;
     to_block: BLOCK_ID;
     address: ADDRESS;
     keys: Array<FELT>;
 };
-declare type RESULT_PAGE_REQUEST = {
+type RESULT_PAGE_REQUEST = {
     continuation_token?: string;
     chunk_size: number;
 };
-declare type EMITTED_EVENT = EVENT & {
+type EMITTED_EVENT = EVENT & {
     block_hash: BLOCK_HASH;
     block_number: BLOCK_NUMBER;
     transaction_hash: TXN_HASH;
 };
-declare type SYNC_STATUS = {
+type SYNC_STATUS = {
     starting_block_hash: BLOCK_HASH;
     starting_block_num: NUM_AS_HEX;
     current_block_hash: BLOCK_HASH;
@@ -800,7 +801,7 @@ declare type SYNC_STATUS = {
     highest_block_hash: BLOCK_HASH;
     highest_block_num: NUM_AS_HEX;
 };
-declare type FEE_ESTIMATE = {
+type FEE_ESTIMATE = {
     gas_consumed: NUM_AS_HEX;
     gas_price: NUM_AS_HEX;
     overall_fee: NUM_AS_HEX;
@@ -814,7 +815,7 @@ declare enum ENTRY_POINT_TYPE {
     'L1_HANDLER' = 1,
     'CONSTRUCTOR' = 2
 }
-declare type FUNCTION_INVOCATION = FUNCTION_CALL & {
+type FUNCTION_INVOCATION = FUNCTION_CALL & {
     caller_address: FELT;
     code_address: FELT;
     entry_point_type: ENTRY_POINT_TYPE;
@@ -824,8 +825,8 @@ declare type FUNCTION_INVOCATION = FUNCTION_CALL & {
     events: Array<EVENT>;
     messages: MSG_TO_L1;
 };
-declare type NESTED_CALL = FUNCTION_INVOCATION;
-declare type TRACE_ROOT = {
+type NESTED_CALL = FUNCTION_INVOCATION;
+type TRACE_ROOT = {
     nonce: FELT;
     signature: FELT;
     function_invocation: FUNCTION_INVOCATION;
@@ -1163,7 +1164,7 @@ declare namespace RPC {
     type DeployedTransaction = OPENRPC.DeployedTransaction;
     type Methods = OPENRPC.Methods;
     type Storage = OPENRPC.Storage;
-    enum TransactionType {
+    declare enum TransactionType {
         DECLARE = "DECLARE",
         DEPLOY = "DEPLOY",
         DEPLOY_ACCOUNT = "DEPLOY_ACCOUNT",
@@ -1178,7 +1179,7 @@ declare namespace RPC {
     }>;
 }
 
-declare type GetTransactionStatusResponse = {
+type GetTransactionStatusResponse = {
     tx_status: TransactionStatus;
     block_hash?: string;
     tx_failure_reason?: {
@@ -1186,11 +1187,11 @@ declare type GetTransactionStatusResponse = {
         error_message: string;
     };
 };
-declare type GetContractAddressesResponse = {
+type GetContractAddressesResponse = {
     Starknet: string;
     GpsStatementVerifier: string;
 };
-declare type FunctionInvocation = {
+type FunctionInvocation = {
     caller_address: string;
     contract_address: string;
     calldata: RawCalldata;
@@ -1204,7 +1205,7 @@ declare type FunctionInvocation = {
     events: Array<any>;
     messages: Array<any>;
 };
-declare type ExecutionResources = {
+type ExecutionResources = {
     n_steps: number;
     builtin_instance_counter: {
         pedersen_builtin: number;
@@ -1216,23 +1217,23 @@ declare type ExecutionResources = {
     };
     n_memory_holes: number;
 };
-declare type TransactionTraceResponse = {
+type TransactionTraceResponse = {
     validate_invocation?: FunctionInvocation;
     function_invocation?: FunctionInvocation;
     fee_transfer_invocation?: FunctionInvocation;
     signature: string[];
 };
-declare type CallL1Handler = {
+type CallL1Handler = {
     from_address: string;
     to_address: string;
     entry_point_selector: string;
     payload: Array<string>;
 };
-declare type DeployedContractItem = {
+type DeployedContractItem = {
     address: string;
     class_hash: string;
 };
-declare type SequencerIdentifier = {
+type SequencerIdentifier = {
     blockHash: string;
 } | {
     blockNumber: BlockNumber;
@@ -1609,7 +1610,7 @@ interface GetBlockResponse {
 interface GetCodeResponse {
     bytecode: ByteCode;
 }
-declare type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
 interface CommonTransactionResponse {
     transaction_hash?: string;
     version?: string;
@@ -1631,7 +1632,7 @@ interface DeclareTransactionResponse extends CommonTransactionResponse {
     contract_class?: any;
     sender_address?: string;
 }
-declare type GetTransactionReceiptResponse = InvokeTransactionReceiptResponse | DeclareTransactionReceiptResponse;
+type GetTransactionReceiptResponse = InvokeTransactionReceiptResponse | DeclareTransactionReceiptResponse;
 interface CommonTransactionReceiptResponse {
     transaction_hash: string;
     status?: Status;
@@ -1657,7 +1658,7 @@ interface InvokeTransactionReceiptResponse extends CommonTransactionReceiptRespo
     events?: Array<Event>;
     l1_origin_message?: MessageToL2;
 }
-declare type DeclareTransactionReceiptResponse = CommonTransactionReceiptResponse;
+type DeclareTransactionReceiptResponse = CommonTransactionReceiptResponse;
 interface EstimateFeeResponse {
     overall_fee: bigint;
     gas_consumed?: bigint;
@@ -1671,10 +1672,10 @@ interface DeclareContractResponse {
     transaction_hash: string;
     class_hash: string;
 }
-declare type CallContractResponse = {
+type CallContractResponse = {
     result: Array<string>;
 };
-declare type EstimateFeeAction = {
+type EstimateFeeAction = {
     type: TransactionType.INVOKE;
     payload: AllowArray<Call>;
 } | {
@@ -1687,9 +1688,9 @@ declare type EstimateFeeAction = {
     type: TransactionType.DEPLOY;
     payload: UniversalDeployerContractPayload;
 };
-declare type EstimateFeeResponseBulk = Array<EstimateFeeResponse>;
-declare type Storage = Sequencer.Storage;
-declare type Nonce = Sequencer.Nonce;
+type EstimateFeeResponseBulk = Array<EstimateFeeResponse>;
+type Storage = Sequencer.Storage;
+type Nonce = Sequencer.Nonce;
 interface TransactionSimulationResponse {
     trace: TransactionTraceResponse;
     fee_estimation: EstimateFeeResponse;
@@ -1712,7 +1713,7 @@ interface StateUpdateResponse {
 interface EstimateFee extends EstimateFeeResponse {
     suggestedMaxFee: bigint;
 }
-declare type EstimateFeeBulk = Array<EstimateFee>;
+type EstimateFeeBulk = Array<EstimateFee>;
 interface EstimateFeeDetails {
     nonce?: BigNumberish;
     blockIdentifier?: BlockIdentifier;
@@ -1722,11 +1723,11 @@ interface DeployContractResponse {
     contract_address: string;
     transaction_hash: string;
 }
-declare type MultiDeployContractResponse = {
+type MultiDeployContractResponse = {
     contract_address: Array<string>;
     transaction_hash: string;
 };
-declare type DeployContractUDCResponse = {
+type DeployContractUDCResponse = {
     contract_address: string;
     transaction_hash: string;
     address: string;
@@ -1737,7 +1738,7 @@ declare type DeployContractUDCResponse = {
     calldata: Array<string>;
     salt: string;
 };
-declare type DeclareDeployUDCResponse = {
+type DeclareDeployUDCResponse = {
     declare: {
         class_hash: BigNumberish;
     } & Partial<DeclareTransactionReceiptResponse>;
@@ -1978,7 +1979,7 @@ declare abstract class ProviderInterface {
     abstract getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<StateUpdateResponse>;
 }
 
-declare type RpcProviderOptions = {
+type RpcProviderOptions = {
     nodeUrl: string;
     retries?: number;
     headers?: object;
@@ -2060,8 +2061,8 @@ declare class RpcProvider implements ProviderInterface {
     getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
 }
 
-declare type SequencerHttpMethod = 'POST' | 'GET';
-declare type SequencerProviderOptions = {
+type SequencerHttpMethod = 'POST' | 'GET';
+type SequencerProviderOptions = {
     headers?: Record<string, string>;
     blockIdentifier?: BlockIdentifier;
 } & ({
@@ -2198,7 +2199,7 @@ declare class HttpError extends LibraryError {
 
 declare const defaultProvider: Provider;
 
-declare type StarkNetMerkleType = {
+type StarkNetMerkleType = {
     name: string;
     type: 'merkletree';
     contains: string;
@@ -2209,7 +2210,7 @@ declare type StarkNetMerkleType = {
  * Note that the `uint` and `int` aliases like in Solidity, and fixed point numbers are not supported by the EIP-712
  * standard.
  */
-declare type StarkNetType = {
+type StarkNetType = {
     name: string;
     type: string;
 } | StarkNetMerkleType;
@@ -2301,34 +2302,34 @@ declare const getStructHash: <T extends TypedData>(types: T["types"], type: stri
  */
 declare const getMessageHash: (typedData: TypedData, account: BigNumberish) => string;
 
-declare const index_prepareSelector: typeof prepareSelector;
-declare const index_isMerkleTreeType: typeof isMerkleTreeType;
-declare const index_getDependencies: typeof getDependencies;
-declare const index_encodeType: typeof encodeType;
-declare const index_getTypeHash: typeof getTypeHash;
-declare const index_encodeValue: typeof encodeValue;
-declare const index_encodeData: typeof encodeData;
-declare const index_getStructHash: typeof getStructHash;
-declare const index_getMessageHash: typeof getMessageHash;
+type index_StarkNetDomain = StarkNetDomain;
 type index_StarkNetMerkleType = StarkNetMerkleType;
 type index_StarkNetType = StarkNetType;
-type index_StarkNetDomain = StarkNetDomain;
 type index_TypedData = TypedData;
+declare const index_encodeData: typeof encodeData;
+declare const index_encodeType: typeof encodeType;
+declare const index_encodeValue: typeof encodeValue;
+declare const index_getDependencies: typeof getDependencies;
+declare const index_getMessageHash: typeof getMessageHash;
+declare const index_getStructHash: typeof getStructHash;
+declare const index_getTypeHash: typeof getTypeHash;
+declare const index_isMerkleTreeType: typeof isMerkleTreeType;
+declare const index_prepareSelector: typeof prepareSelector;
 declare namespace index {
   export {
-    index_prepareSelector as prepareSelector,
-    index_isMerkleTreeType as isMerkleTreeType,
-    index_getDependencies as getDependencies,
-    index_encodeType as encodeType,
-    index_getTypeHash as getTypeHash,
-    index_encodeValue as encodeValue,
-    index_encodeData as encodeData,
-    index_getStructHash as getStructHash,
-    index_getMessageHash as getMessageHash,
+    index_StarkNetDomain as StarkNetDomain,
     index_StarkNetMerkleType as StarkNetMerkleType,
     index_StarkNetType as StarkNetType,
-    index_StarkNetDomain as StarkNetDomain,
     index_TypedData as TypedData,
+    index_encodeData as encodeData,
+    index_encodeType as encodeType,
+    index_encodeValue as encodeValue,
+    index_getDependencies as getDependencies,
+    index_getMessageHash as getMessageHash,
+    index_getStructHash as getStructHash,
+    index_getTypeHash as getTypeHash,
+    index_isMerkleTreeType as isMerkleTreeType,
+    index_prepareSelector as prepareSelector,
   };
 }
 
@@ -2396,8 +2397,8 @@ declare class Signer implements SignerInterface {
     getPubKey(): Promise<string>;
     signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
     signTransaction(transactions: Call[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
-    signDeployAccountTransaction({ classHash, contractAddress, constructorCalldata, addressSalt, maxFee, version, chainId, nonce, }: DeployAccountSignerDetails): Promise<_noble_curves_abstract_weierstrass.SignatureType>;
-    signDeclareTransaction({ classHash, senderAddress, chainId, maxFee, version, nonce, compiledClassHash, }: DeclareSignerDetails): Promise<_noble_curves_abstract_weierstrass.SignatureType>;
+    signDeployAccountTransaction({ classHash, contractAddress, constructorCalldata, addressSalt, maxFee, version, chainId, nonce, }: DeployAccountSignerDetails): Promise<Signature>;
+    signDeclareTransaction({ classHash, senderAddress, chainId, maxFee, version, nonce, compiledClassHash, }: DeclareSignerDetails): Promise<Signature>;
 }
 
 declare abstract class AccountInterface extends ProviderInterface {
@@ -2897,49 +2898,49 @@ declare function computeSierraContractClassHash(sierra: CompiledSierra): string;
  */
 declare function computeContractClassHash(contract: CompiledContract | string): string;
 
-declare const hash_transactionVersion: typeof transactionVersion;
-declare const hash_transactionVersion_2: typeof transactionVersion_2;
-declare const hash_feeTransactionVersion: typeof feeTransactionVersion;
-declare const hash_computeHashOnElements: typeof computeHashOnElements;
-declare const hash_calculateTransactionHashCommon: typeof calculateTransactionHashCommon;
-declare const hash_calculateDeployTransactionHash: typeof calculateDeployTransactionHash;
+declare const hash_calculateContractAddressFromHash: typeof calculateContractAddressFromHash;
 declare const hash_calculateDeclareTransactionHash: typeof calculateDeclareTransactionHash;
 declare const hash_calculateDeployAccountTransactionHash: typeof calculateDeployAccountTransactionHash;
+declare const hash_calculateDeployTransactionHash: typeof calculateDeployTransactionHash;
 declare const hash_calculateTransactionHash: typeof calculateTransactionHash;
-declare const hash_calculateContractAddressFromHash: typeof calculateContractAddressFromHash;
-declare const hash_formatSpaces: typeof formatSpaces;
-declare const hash_computeLegacyContractClassHash: typeof computeLegacyContractClassHash;
+declare const hash_calculateTransactionHashCommon: typeof calculateTransactionHashCommon;
 declare const hash_computeCompiledClassHash: typeof computeCompiledClassHash;
-declare const hash_computeSierraContractClassHash: typeof computeSierraContractClassHash;
 declare const hash_computeContractClassHash: typeof computeContractClassHash;
-declare const hash_poseidon: typeof poseidon;
+declare const hash_computeHashOnElements: typeof computeHashOnElements;
+declare const hash_computeLegacyContractClassHash: typeof computeLegacyContractClassHash;
+declare const hash_computeSierraContractClassHash: typeof computeSierraContractClassHash;
+declare const hash_feeTransactionVersion: typeof feeTransactionVersion;
+declare const hash_formatSpaces: typeof formatSpaces;
+declare const hash_getSelector: typeof getSelector;
+declare const hash_getSelectorFromName: typeof getSelectorFromName;
 declare const hash_keccakBn: typeof keccakBn;
+declare const hash_poseidon: typeof poseidon;
 declare const hash_starknetKeccak: typeof starknetKeccak;
-declare const hash_getSelectorFromName: typeof getSelectorFromName;
-declare const hash_getSelector: typeof getSelector;
+declare const hash_transactionVersion: typeof transactionVersion;
+declare const hash_transactionVersion_2: typeof transactionVersion_2;
 declare namespace hash {
   export {
-    computeHintedClassHash as default,
-    hash_transactionVersion as transactionVersion,
-    hash_transactionVersion_2 as transactionVersion_2,
-    hash_feeTransactionVersion as feeTransactionVersion,
-    hash_computeHashOnElements as computeHashOnElements,
-    hash_calculateTransactionHashCommon as calculateTransactionHashCommon,
-    hash_calculateDeployTransactionHash as calculateDeployTransactionHash,
+    hash_calculateContractAddressFromHash as calculateContractAddressFromHash,
     hash_calculateDeclareTransactionHash as calculateDeclareTransactionHash,
     hash_calculateDeployAccountTransactionHash as calculateDeployAccountTransactionHash,
+    hash_calculateDeployTransactionHash as calculateDeployTransactionHash,
     hash_calculateTransactionHash as calculateTransactionHash,
-    hash_calculateContractAddressFromHash as calculateContractAddressFromHash,
-    hash_formatSpaces as formatSpaces,
-    hash_computeLegacyContractClassHash as computeLegacyContractClassHash,
+    hash_calculateTransactionHashCommon as calculateTransactionHashCommon,
     hash_computeCompiledClassHash as computeCompiledClassHash,
-    hash_computeSierraContractClassHash as computeSierraContractClassHash,
     hash_computeContractClassHash as computeContractClassHash,
-    hash_poseidon as poseidon,
+    hash_computeHashOnElements as computeHashOnElements,
+    hash_computeLegacyContractClassHash as computeLegacyContractClassHash,
+    hash_computeSierraContractClassHash as computeSierraContractClassHash,
+    computeHintedClassHash as default,
+    hash_feeTransactionVersion as feeTransactionVersion,
+    hash_formatSpaces as formatSpaces,
+    hash_getSelector as getSelector,
+    hash_getSelectorFromName as getSelectorFromName,
     hash_keccakBn as keccakBn,
+    hash_poseidon as poseidon,
     hash_starknetKeccak as starknetKeccak,
-    hash_getSelectorFromName as getSelectorFromName,
-    hash_getSelector as getSelector,
+    hash_transactionVersion as transactionVersion,
+    hash_transactionVersion_2 as transactionVersion_2,
   };
 }
 
@@ -3001,20 +3002,20 @@ declare const fromCallsToExecuteCalldata_cairo1: (calls: Call[]) => Calldata;
  */
 declare const getExecuteCalldata: (calls: Call[], cairoVersion?: CairoVersion) => Calldata;
 
-declare const transaction_transformCallsToMulticallArrays: typeof transformCallsToMulticallArrays;
 declare const transaction_fromCallsToExecuteCalldata: typeof fromCallsToExecuteCalldata;
 declare const transaction_fromCallsToExecuteCalldataWithNonce: typeof fromCallsToExecuteCalldataWithNonce;
-declare const transaction_transformCallsToMulticallArrays_cairo1: typeof transformCallsToMulticallArrays_cairo1;
 declare const transaction_fromCallsToExecuteCalldata_cairo1: typeof fromCallsToExecuteCalldata_cairo1;
 declare const transaction_getExecuteCalldata: typeof getExecuteCalldata;
+declare const transaction_transformCallsToMulticallArrays: typeof transformCallsToMulticallArrays;
+declare const transaction_transformCallsToMulticallArrays_cairo1: typeof transformCallsToMulticallArrays_cairo1;
 declare namespace transaction {
   export {
-    transaction_transformCallsToMulticallArrays as transformCallsToMulticallArrays,
     transaction_fromCallsToExecuteCalldata as fromCallsToExecuteCalldata,
     transaction_fromCallsToExecuteCalldataWithNonce as fromCallsToExecuteCalldataWithNonce,
-    transaction_transformCallsToMulticallArrays_cairo1 as transformCallsToMulticallArrays_cairo1,
     transaction_fromCallsToExecuteCalldata_cairo1 as fromCallsToExecuteCalldata_cairo1,
     transaction_getExecuteCalldata as getExecuteCalldata,
+    transaction_transformCallsToMulticallArrays as transformCallsToMulticallArrays,
+    transaction_transformCallsToMulticallArrays_cairo1 as transformCallsToMulticallArrays_cairo1,
   };
 }
 
@@ -3034,21 +3035,21 @@ declare function signatureToHexArray(sig?: Signature): ArraySignatureType;
 declare function estimatedFeeToMaxFee(estimatedFee: BigNumberish, overhead?: number): bigint;
 
 declare const stark_compressProgram: typeof compressProgram;
-declare const stark_randomAddress: typeof randomAddress;
-declare const stark_makeAddress: typeof makeAddress;
+declare const stark_estimatedFeeToMaxFee: typeof estimatedFeeToMaxFee;
 declare const stark_formatSignature: typeof formatSignature;
+declare const stark_makeAddress: typeof makeAddress;
+declare const stark_randomAddress: typeof randomAddress;
 declare const stark_signatureToDecimalArray: typeof signatureToDecimalArray;
 declare const stark_signatureToHexArray: typeof signatureToHexArray;
-declare const stark_estimatedFeeToMaxFee: typeof estimatedFeeToMaxFee;
 declare namespace stark {
   export {
     stark_compressProgram as compressProgram,
-    stark_randomAddress as randomAddress,
-    stark_makeAddress as makeAddress,
+    stark_estimatedFeeToMaxFee as estimatedFeeToMaxFee,
     stark_formatSignature as formatSignature,
+    stark_makeAddress as makeAddress,
+    stark_randomAddress as randomAddress,
     stark_signatureToDecimalArray as signatureToDecimalArray,
     stark_signatureToHexArray as signatureToHexArray,
-    stark_estimatedFeeToMaxFee as estimatedFeeToMaxFee,
   };
 }
 
@@ -3111,26 +3112,26 @@ declare function encodeShortString(str: string): string;
  */
 declare function decodeShortString(str: string): string;
 
+declare const shortString_decodeShortString: typeof decodeShortString;
+declare const shortString_encodeShortString: typeof encodeShortString;
 declare const shortString_isASCII: typeof isASCII;
-declare const shortString_isShortString: typeof isShortString;
 declare const shortString_isDecimalString: typeof isDecimalString;
-declare const shortString_isText: typeof isText;
-declare const shortString_isShortText: typeof isShortText;
 declare const shortString_isLongText: typeof isLongText;
+declare const shortString_isShortString: typeof isShortString;
+declare const shortString_isShortText: typeof isShortText;
+declare const shortString_isText: typeof isText;
 declare const shortString_splitLongString: typeof splitLongString;
-declare const shortString_encodeShortString: typeof encodeShortString;
-declare const shortString_decodeShortString: typeof decodeShortString;
 declare namespace shortString {
   export {
+    shortString_decodeShortString as decodeShortString,
+    shortString_encodeShortString as encodeShortString,
     shortString_isASCII as isASCII,
-    shortString_isShortString as isShortString,
     shortString_isDecimalString as isDecimalString,
-    shortString_isText as isText,
-    shortString_isShortText as isShortText,
     shortString_isLongText as isLongText,
+    shortString_isShortString as isShortString,
+    shortString_isShortText as isShortText,
+    shortString_isText as isText,
     shortString_splitLongString as splitLongString,
-    shortString_encodeShortString as encodeShortString,
-    shortString_decodeShortString as decodeShortString,
   };
 }
 
@@ -3142,17 +3143,17 @@ declare const enum StarknetIdContract {
 }
 declare function getStarknetIdContract(chainId: StarknetChainId): string;
 
-declare const starknetId_useDecoded: typeof useDecoded;
-declare const starknetId_useEncoded: typeof useEncoded;
 type starknetId_StarknetIdContract = StarknetIdContract;
 declare const starknetId_StarknetIdContract: typeof StarknetIdContract;
 declare const starknetId_getStarknetIdContract: typeof getStarknetIdContract;
+declare const starknetId_useDecoded: typeof useDecoded;
+declare const starknetId_useEncoded: typeof useEncoded;
 declare namespace starknetId {
   export {
-    starknetId_useDecoded as useDecoded,
-    starknetId_useEncoded as useEncoded,
     starknetId_StarknetIdContract as StarknetIdContract,
     starknetId_getStarknetIdContract as getStarknetIdContract,
+    starknetId_useDecoded as useDecoded,
+    starknetId_useEncoded as useEncoded,
   };
 }
 
@@ -3201,61 +3202,7 @@ declare const uint256: (it: BigNumberish) => Uint256;
 /**
  * unnamed tuple cairo type (helper same as common struct type)
  */
-declare const tuple: (...args: (BigNumberish | object | boolean)[]) => {
-    [x: number]: boolean | object | BigNumberish;
-    length: number;
-    toString(): string;
-    toLocaleString(): string;
-    pop(): boolean | object | BigNumberish | undefined;
-    push(...items: (boolean | object | BigNumberish)[]): number;
-    concat(...items: ConcatArray<boolean | object | BigNumberish>[]): (boolean | object | BigNumberish)[];
-    concat(...items: (boolean | object | BigNumberish | ConcatArray<boolean | object | BigNumberish>)[]): (boolean | object | BigNumberish)[];
-    join(separator?: string | undefined): string;
-    reverse(): (boolean | object | BigNumberish)[];
-    shift(): boolean | object | BigNumberish | undefined;
-    slice(start?: number | undefined, end?: number | undefined): (boolean | object | BigNumberish)[];
-    sort(compareFn?: ((a: boolean | object | BigNumberish, b: boolean | object | BigNumberish) => number) | undefined): (boolean | object | BigNumberish)[];
-    splice(start: number, deleteCount?: number | undefined): (boolean | object | BigNumberish)[];
-    splice(start: number, deleteCount: number, ...items: (boolean | object | BigNumberish)[]): (boolean | object | BigNumberish)[];
-    unshift(...items: (boolean | object | BigNumberish)[]): number;
-    indexOf(searchElement: boolean | object | BigNumberish, fromIndex?: number | undefined): number;
-    lastIndexOf(searchElement: boolean | object | BigNumberish, fromIndex?: number | undefined): number;
-    every<S extends boolean | object | BigNumberish>(predicate: (value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => value is S, thisArg?: any): this is S[];
-    every(predicate: (value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => unknown, thisArg?: any): boolean;
-    some(predicate: (value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => unknown, thisArg?: any): boolean;
-    forEach(callbackfn: (value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => void, thisArg?: any): void;
-    map<U>(callbackfn: (value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => U, thisArg?: any): U[];
-    filter<S_1 extends boolean | object | BigNumberish>(predicate: (value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => value is S_1, thisArg?: any): S_1[];
-    filter(predicate: (value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => unknown, thisArg?: any): (boolean | object | BigNumberish)[];
-    reduce(callbackfn: (previousValue: boolean | object | BigNumberish, currentValue: boolean | object | BigNumberish, currentIndex: number, array: (boolean | object | BigNumberish)[]) => boolean | object | BigNumberish): boolean | object | BigNumberish;
-    reduce(callbackfn: (previousValue: boolean | object | BigNumberish, currentValue: boolean | object | BigNumberish, currentIndex: number, array: (boolean | object | BigNumberish)[]) => boolean | object | BigNumberish, initialValue: boolean | object | BigNumberish): boolean | object | BigNumberish;
-    reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: boolean | object | BigNumberish, currentIndex: number, array: (boolean | object | BigNumberish)[]) => U_1, initialValue: U_1): U_1;
-    reduceRight(callbackfn: (previousValue: boolean | object | BigNumberish, currentValue: boolean | object | BigNumberish, currentIndex: number, array: (boolean | object | BigNumberish)[]) => boolean | object | BigNumberish): boolean | object | BigNumberish;
-    reduceRight(callbackfn: (previousValue: boolean | object | BigNumberish, currentValue: boolean | object | BigNumberish, currentIndex: number, array: (boolean | object | BigNumberish)[]) => boolean | object | BigNumberish, initialValue: boolean | object | BigNumberish): boolean | object | BigNumberish;
-    reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: boolean | object | BigNumberish, currentIndex: number, array: (boolean | object | BigNumberish)[]) => U_2, initialValue: U_2): U_2;
-    find<S_2 extends boolean | object | BigNumberish>(predicate: (this: void, value: boolean | object | BigNumberish, index: number, obj: (boolean | object | BigNumberish)[]) => value is S_2, thisArg?: any): S_2 | undefined;
-    find(predicate: (value: boolean | object | BigNumberish, index: number, obj: (boolean | object | BigNumberish)[]) => unknown, thisArg?: any): boolean | object | BigNumberish | undefined;
-    findIndex(predicate: (value: boolean | object | BigNumberish, index: number, obj: (boolean | object | BigNumberish)[]) => unknown, thisArg?: any): number;
-    fill(value: boolean | object | BigNumberish, start?: number | undefined, end?: number | undefined): (boolean | object | BigNumberish)[];
-    copyWithin(target: number, start: number, end?: number | undefined): (boolean | object | BigNumberish)[];
-    entries(): IterableIterator<[number, boolean | object | BigNumberish]>;
-    keys(): IterableIterator<number>;
-    values(): IterableIterator<boolean | object | BigNumberish>;
-    includes(searchElement: boolean | object | BigNumberish, fromIndex?: number | undefined): boolean;
-    flatMap<U_3, This = undefined>(callback: (this: This, value: boolean | object | BigNumberish, index: number, array: (boolean | object | BigNumberish)[]) => U_3 | readonly U_3[], thisArg?: This | undefined): U_3[];
-    flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
-    [Symbol.iterator](): IterableIterator<boolean | object | BigNumberish>;
-    [Symbol.unscopables](): {
-        copyWithin: boolean;
-        entries: boolean;
-        fill: boolean;
-        find: boolean;
-        findIndex: boolean;
-        keys: boolean;
-        values: boolean;
-    };
-    at(index: number): boolean | object | BigNumberish | undefined;
-};
+declare const tuple: (...args: (BigNumberish | object | boolean)[]) => Record<number, BigNumberish | object | boolean>;
 /**
  * felt cairo type
  */
@@ -3263,39 +3210,39 @@ declare function felt(it: BigNumberish): string;
 
 type cairo_Uint = Uint;
 declare const cairo_Uint: typeof Uint;
+declare const cairo_felt: typeof felt;
+declare const cairo_getArrayType: typeof getArrayType;
+declare const cairo_isCairo1Type: typeof isCairo1Type;
 declare const cairo_isLen: typeof isLen;
-declare const cairo_isTypeFelt: typeof isTypeFelt;
 declare const cairo_isTypeArray: typeof isTypeArray;
-declare const cairo_isTypeTuple: typeof isTypeTuple;
+declare const cairo_isTypeBool: typeof isTypeBool;
+declare const cairo_isTypeContractAddress: typeof isTypeContractAddress;
+declare const cairo_isTypeFelt: typeof isTypeFelt;
 declare const cairo_isTypeNamedTuple: typeof isTypeNamedTuple;
 declare const cairo_isTypeStruct: typeof isTypeStruct;
+declare const cairo_isTypeTuple: typeof isTypeTuple;
 declare const cairo_isTypeUint: typeof isTypeUint;
 declare const cairo_isTypeUint256: typeof isTypeUint256;
-declare const cairo_isTypeBool: typeof isTypeBool;
-declare const cairo_isTypeContractAddress: typeof isTypeContractAddress;
-declare const cairo_isCairo1Type: typeof isCairo1Type;
-declare const cairo_getArrayType: typeof getArrayType;
-declare const cairo_uint256: typeof uint256;
 declare const cairo_tuple: typeof tuple;
-declare const cairo_felt: typeof felt;
+declare const cairo_uint256: typeof uint256;
 declare namespace cairo {
   export {
     cairo_Uint as Uint,
+    cairo_felt as felt,
+    cairo_getArrayType as getArrayType,
+    cairo_isCairo1Type as isCairo1Type,
     cairo_isLen as isLen,
-    cairo_isTypeFelt as isTypeFelt,
     cairo_isTypeArray as isTypeArray,
-    cairo_isTypeTuple as isTypeTuple,
+    cairo_isTypeBool as isTypeBool,
+    cairo_isTypeContractAddress as isTypeContractAddress,
+    cairo_isTypeFelt as isTypeFelt,
     cairo_isTypeNamedTuple as isTypeNamedTuple,
     cairo_isTypeStruct as isTypeStruct,
+    cairo_isTypeTuple as isTypeTuple,
     cairo_isTypeUint as isTypeUint,
     cairo_isTypeUint256 as isTypeUint256,
-    cairo_isTypeBool as isTypeBool,
-    cairo_isTypeContractAddress as isTypeContractAddress,
-    cairo_isCairo1Type as isCairo1Type,
-    cairo_getArrayType as getArrayType,
-    cairo_uint256 as uint256,
     cairo_tuple as tuple,
-    cairo_felt as felt,
+    cairo_uint256 as uint256,
   };
 }
 
@@ -3314,10 +3261,17 @@ declare class CallData {
      * Compile contract callData with abi
      * Parse the calldata by using input fields from the abi for that method
      * @param method string - method name
-     * @param args ArgsOrCalldata - arguments passed to the method
+     * @param args RawArgs - arguments passed to the method. Can be an array of arguments (in the order of abi definition), or an object constructed in conformity with abi (in this case, the parameter can be in a wrong order).
      * @return Calldata - parsed arguments in format that contract is expecting
-     */
-    compile(method: string, args: ArgsOrCalldata): Calldata;
+     * @example
+     * ```typescript
+     * const calldata = myCallData.compile("constructor",["0x34a",[1,3n]]);
+     * ```
+     * ```typescript
+     * const calldata2 = myCallData.compile("constructor",{list:[1,3n],balance:"0x34"}); // wrong order is valid
+     * ```
+     */
+    compile(method: string, argsCalldata: RawArgs): Calldata;
     /**
      * Compile contract callData without abi
      * @param rawArgs RawArgs representing cairo method arguments or string array of compiled data