starknet 6.23.1 → 6.24.1

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [6.24.1](https://github.com/starknet-io/starknet.js/compare/v6.24.0...v6.24.1) (2025-03-20)
+
+### Bug Fixes
+
+- repair snip-12 enum type nested dependency ([#1289](https://github.com/starknet-io/starknet.js/issues/1289)) ([1cd4219](https://github.com/starknet-io/starknet.js/commit/1cd4219df5e61a676bc58ba8c8673269695fc2db))
+
+# [6.24.0](https://github.com/starknet-io/starknet.js/compare/v6.23.1...v6.24.0) (2025-03-12)
+
+### Features
+
+- add simulate and estimate fee utility methods for outside execution ([#1327](https://github.com/starknet-io/starknet.js/issues/1327)) ([3668b01](https://github.com/starknet-io/starknet.js/commit/3668b01c4f63969bb0770ee6120fe3eac72d0335))
+- implement cairo fixed array support ([#1310](https://github.com/starknet-io/starknet.js/issues/1310)) ([45df63e](https://github.com/starknet-io/starknet.js/commit/45df63e7bb7f7cb2de2e98900387b1c44a95f257))
+
 ## [6.23.1](https://github.com/starknet-io/starknet.js/compare/v6.23.0...v6.23.1) (2025-02-05)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -7279,7 +7279,7 @@ declare function getOutsideCall(call: Call): OutsideCall;
  */
 declare function getTypedData(chainId: string, options: OutsideExecutionOptions, nonce: BigNumberish, myCalls: Call[], version: OutsideExecutionVersion): TypedData;
 /**
- * Builds a CallData for the execute_from_outside() entrypoint.
+ * Builds a Calldata for the execute_from_outside() entrypoint.
  * @param {OutsideTransaction} outsideTransaction an object that contains all the data for a Outside Execution.
  * @returns {Calldata} The Calldata related to this Outside transaction
  * @example
@@ -7303,12 +7303,39 @@ declare function getTypedData(chainId: string, options: OutsideExecutionOptions,
  * ```
  */
 declare function buildExecuteFromOutsideCallData(outsideTransaction: OutsideTransaction): Calldata;
+/**
+ * Builds a Call for execute(), estimateFee() and simulateTransaction() functions.
+ * @param {AllowArray<OutsideTransaction>} outsideTransaction an object that contains all the data for an Outside Execution.
+ * @returns {Call[]} The Call related to this Outside transaction
+ * @example
+ * ```typescript
+ * const outsideTransaction: OutsideTransaction = {
+ *     outsideExecution: {
+ *      caller: '0x64b48806902a367c8598f4f95c305e8c1a1acba5f082d294a43793113115691',
+ *      nonce: '0x7d0b4b4fce4b236e63d2bb5fc321935d52935cd3b268248cf9cf29c496bd0ae',
+ *      execute_after: 500, execute_before: 600,
+ *      calls: [{ to: '0x678', selector: '0x890', calldata: [12, 13] }],
+ *    },
+ *    signature: ['0x123', '0x456'],
+ *    signerAddress: '0x3b278ebae434f283f9340587a7f2dd4282658ac8e03cb9b0956db23a0a83657',
+ *    version: EOutsideExecutionVersion.V2,
+ *  };
+ *
+ *  const result: Call[] = outsideExecution.buildExecuteFromOutsideCall(outsideTransaction);
+ * // result = [{contractAddress: '0x64b48806902a367c8598f4f95c305e8c1a1acba5f082d294a43793113115691',
+ * //   entrypoint: 'execute_from_outside_v2',
+ * //   calldata: [ ... ],
+ * // }]
+ * ```
+ */
+declare function buildExecuteFromOutsideCall(outsideTransaction: AllowArray<OutsideTransaction>): Call[];
 
+declare const outsideExecution_buildExecuteFromOutsideCall: typeof buildExecuteFromOutsideCall;
 declare const outsideExecution_buildExecuteFromOutsideCallData: typeof buildExecuteFromOutsideCallData;
 declare const outsideExecution_getOutsideCall: typeof getOutsideCall;
 declare const outsideExecution_getTypedData: typeof getTypedData;
 declare namespace outsideExecution {
-  export { outsideExecution_buildExecuteFromOutsideCallData as buildExecuteFromOutsideCallData, outsideExecution_getOutsideCall as getOutsideCall, outsideExecution_getTypedData as getTypedData };
+  export { outsideExecution_buildExecuteFromOutsideCall as buildExecuteFromOutsideCall, outsideExecution_buildExecuteFromOutsideCallData as buildExecuteFromOutsideCallData, outsideExecution_getOutsideCall as getOutsideCall, outsideExecution_getTypedData as getTypedData };
 }
 
 /**
@@ -7443,6 +7470,102 @@ declare class CairoUint512 {
     toApiRequest(): string[];
 }
 
+declare class CairoFixedArray {
+    /**
+     * JS array representing a Cairo fixed array.
+     */
+    readonly content: any[];
+    /**
+     * Cairo fixed array type.
+     */
+    readonly arrayType: string;
+    /**
+     * Create an instance representing a Cairo fixed Array.
+     * @param {any[]} content JS array representing a Cairo fixed array.
+     * @param {string} arrayType Cairo fixed array type.
+     */
+    constructor(content: any[], arrayType: string);
+    /**
+     * Retrieves the array size from the given type string representing a Cairo fixed array.
+     * @param {string} type - The Cairo fixed array type.
+     * @returns {number} The array size.
+     * @example
+     * ```typescript
+     * const result = CairoFixedArray.getFixedArraySize("[core::integer::u32; 8]");
+     * // result = 8
+     * ```
+     */
+    static getFixedArraySize(type: string): number;
+    /**
+     * Retrieves the Cairo fixed array size from the CairoFixedArray instance.
+     * @returns {number} The fixed array size.
+     * @example
+     * ```typescript
+     * const fArray = new CairoFixedArray([10,20,30], "[core::integer::u32; 3]");
+     * const result = fArray.getFixedArraySize();
+     * // result = 3
+     * ```
+     */
+    getFixedArraySize(): number;
+    /**
+     * Retrieve the Cairo content type from a Cairo fixed array type.
+     * @param {string} type - The type string.
+     * @returns {string} The fixed-array type.
+     * @example
+     * ```typescript
+     * const result = CairoFixedArray.getFixedArrayType("[core::integer::u32; 8]");
+     * // result = "core::integer::u32"
+     * ```
+     */
+    static getFixedArrayType: (type: string) => string;
+    /**
+     * Retrieve the Cairo content type of the Cairo fixed array.
+     * @returns {string} The fixed-array content type.
+     * @example
+     * ```typescript
+     * const fArray = new CairoFixedArray([10,20,30], "[core::integer::u32; 3]");
+     * const result = fArray.getFixedArrayType();
+     * // result = "core::integer::u32"
+     * ```
+     */
+    getFixedArrayType(): string;
+    /**
+     * Create an object from a Cairo fixed array.
+     * Be sure to have an array length conform to the ABI.
+     * To be used with CallData.compile().
+     * @param {Array<any>} input JS array representing a Cairo fixed array.
+     * @returns {Object} a specific struct representing a fixed Array.
+     * @example
+     * ```typescript
+     * const result = CairoFixedArray.compile([10,20,30]);
+     * // result = { '0': 10, '1': 20, '2': 30 }
+     * ```
+     */
+    static compile(input: Array<any>): Object;
+    /**
+     * Generate an object from the Cairo fixed array instance.
+     * To be used with CallData.compile().
+     * @returns a specific struct representing a fixed array.
+     * @example
+     * ```typescript
+     * const fArray = new CairoFixedArray([10,20,30], "[core::integer::u32; 3]");
+     * const result = fArray.compile();
+     * // result = { '0': 10, '1': 20, '2': 30 }
+     * ```
+     */
+    compile(): Object;
+    /**
+     * Checks if the given Cairo type is a fixed-array type.
+     *
+     * @param {string} type - The type to check.
+     * @returns - `true` if the type is a fixed array type, `false` otherwise.
+     * ```typescript
+     * const result = CairoFixedArray.isTypeFixedArray("[core::integer::u32; 8]");
+     * // result = true
+     */
+    static isTypeFixedArray(type: string): boolean;
+}
+
 /**
  * Format a hex number to '0x' and 64 characters, adding leading zeros if necessary.
  *
@@ -8168,4 +8291,4 @@ declare const logger: Logger;
 /** @deprecated prefer the 'num' naming */
 declare const number: typeof num;
 
-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 AllowArray, type Args, type ArgsOrCalldata, type ArgsOrCalldataWithOptions, type ArraySignatureType, type AsyncContractFunction, 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, CairoOption, CairoOptionVariant, CairoResult, CairoResultVariant, CairoUint256, CairoUint512, type CairoVersion, type Call, type CallContractResponse, CallData, type CallDetails, type CallOptions, type CallStruct, type Calldata, type CompiledContract, type CompiledSierra, type CompiledSierraCasm, type CompilerVersion, type CompleteDeclareContractPayload, type CompressedProgram, Contract, type ContractClass, type ContractClassIdentifier, type ContractClassPayload, type ContractClassResponse, type ContractEntryPointFields, ContractFactory, type ContractFactoryParams, type ContractFunction, ContractInterface, type ContractOptions, type ContractVersion, CustomError, type DeclareAndDeployContractPayload, type DeclareContractPayload, type DeclareContractResponse, type DeclareContractTransaction, type DeclareDeployUDCResponse, type DeclareSignerDetails, type DeclareTransactionReceiptResponse, type DeployAccountContractPayload, type DeployAccountContractTransaction, type DeployAccountSignerDetails, type DeployAccountTransactionReceiptResponse, type DeployContractResponse, type DeployContractUDCResponse, type DeployTransactionReceiptResponse, type Details, ETH_ADDRESS, EntryPointType, type EntryPointsByType, type EstimateFee, type EstimateFeeAction, type EstimateFeeBulk, type EstimateFeeDetails, type EstimateFeeResponse, type EstimateFeeResponseBulk, EthSigner, type EventEntry, type FeeEstimate, type FunctionAbi, type GetBlockResponse, type GetTransactionReceiptResponse, type GetTransactionResponse, type GetTxReceiptResponseWithoutHelper, type HexCalldata, type InterfaceAbi, type Invocation, type Invocations, type InvocationsDetails, type InvocationsDetailsWithNonce, type InvocationsSignerDetails, type InvokeFunctionResponse, type InvokeOptions, type InvokeTransactionReceiptResponse, type L1HandlerTransactionReceiptResponse, type LedgerPathCalculation, LedgerSigner111 as LedgerSigner, LedgerSigner111, LedgerSigner221, type LegacyCompiledContract, type LegacyContractClass, type LegacyEvent, LibraryError, Literal, type LogLevel, LogLevelIndex, type MessageToL1, type MultiDeployContractResponse, type MultiType, NON_ZERO_PREFIX, type Nonce, type OptionalPayload, type OutsideCall, type OutsideExecution, type OutsideExecutionOptions, OutsideExecutionTypesV1, OutsideExecutionTypesV2, OutsideExecutionVersion, type OutsideTransaction, type ParsedEvent, type ParsedEvents, type ParsedStruct, type PendingBlock, type PendingStateUpdate, type Program, RpcProvider as Provider, ProviderInterface, type ProviderOptions, type PythonicHints, index$3 as RPC, rpc_0_6 as RPC06, rpc_0_7 as RPC07, RPCResponseParser, type RPC_ERROR, type RPC_ERROR_SET, type RawArgs, type RawArgsArray, type RawArgsObject, type RawCalldata, ReceiptTx, type RejectedTransactionReceiptResponse, ResponseParser, type Result, type RevertedTransactionReceiptResponse, RpcChannel, RpcError, RpcProvider, type RpcProviderOptions, type SIMULATION_FLAG, type SierraContractClass, type SierraContractEntryPointFields, type SierraEntryPointsByType, type SierraProgramDebugInfo, type Signature, Signer, SignerInterface, type SimulateTransactionDetails, type SimulateTransactionResponse, type SimulatedTransaction, type SimulationFlags, type StarkProfile, type StateUpdate, type StateUpdateResponse, type Storage, type SuccessfulTransactionReceiptResponse, TransactionExecutionStatus, TransactionFinalityStatus, type TransactionReceipt, type TransactionReceiptCallbacks, type TransactionReceiptCallbacksDefault, type TransactionReceiptCallbacksDefined, type TransactionReceiptStatus, type TransactionReceiptUtilityInterface, type TransactionReceiptValue, TransactionStatus, type TransactionStatusReceiptSets, TransactionType, 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 UniversalSuggestedFee, type V2DeclareSignerDetails, type V2DeployAccountSignerDetails, type V2InvocationsSignerDetails, type V3DeclareSignerDetails, type V3DeployAccountSignerDetails, type V3InvocationsSignerDetails, type V3TransactionDetails, ValidateType, WalletAccount, type WeierstrassSignatureType, addAddressPadding, byteArray, cairo, config, constants, contractClassResponseToLegacyCompiledContract, defaultProvider, ec, encode, eth, index as events, extractContractHashes, fixProto, fixStack, getCalldata, getChecksumAddress, type getContractVersionOptions, type getEstimateFeeBulkOptions, getLedgerPathBuffer111 as getLedgerPathBuffer, getLedgerPathBuffer111, getLedgerPathBuffer221, type getSimulateTransactionOptions, index$1 as hash, isSierra, json, logger, merkle, num, number, outsideExecution, parseCalldataField, provider, selector, shortString, splitArgsAndOptions, src5, stark, starknetId, transaction, typedData, index$2 as types, uint256$1 as uint256, units, v2 as v2hash, v3 as v3hash, validateAndParseAddress, validateChecksumAddress, type waitForTransactionOptions, connect as wallet };
+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 AllowArray, type Args, type ArgsOrCalldata, type ArgsOrCalldataWithOptions, type ArraySignatureType, type AsyncContractFunction, 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 CallStruct, type Calldata, type CompiledContract, type CompiledSierra, type CompiledSierraCasm, type CompilerVersion, type CompleteDeclareContractPayload, type CompressedProgram, Contract, type ContractClass, type ContractClassIdentifier, type ContractClassPayload, type ContractClassResponse, type ContractEntryPointFields, ContractFactory, type ContractFactoryParams, type ContractFunction, ContractInterface, type ContractOptions, type ContractVersion, CustomError, type DeclareAndDeployContractPayload, type DeclareContractPayload, type DeclareContractResponse, type DeclareContractTransaction, type DeclareDeployUDCResponse, type DeclareSignerDetails, type DeclareTransactionReceiptResponse, type DeployAccountContractPayload, type DeployAccountContractTransaction, type DeployAccountSignerDetails, type DeployAccountTransactionReceiptResponse, type DeployContractResponse, type DeployContractUDCResponse, type DeployTransactionReceiptResponse, type Details, ETH_ADDRESS, EntryPointType, type EntryPointsByType, type EstimateFee, type EstimateFeeAction, type EstimateFeeBulk, type EstimateFeeDetails, type EstimateFeeResponse, type EstimateFeeResponseBulk, EthSigner, type EventEntry, type FeeEstimate, type FunctionAbi, type GetBlockResponse, type GetTransactionReceiptResponse, type GetTransactionResponse, type GetTxReceiptResponseWithoutHelper, type HexCalldata, type InterfaceAbi, type Invocation, type Invocations, type InvocationsDetails, type InvocationsDetailsWithNonce, type InvocationsSignerDetails, type InvokeFunctionResponse, type InvokeOptions, type InvokeTransactionReceiptResponse, type L1HandlerTransactionReceiptResponse, type LedgerPathCalculation, LedgerSigner111 as LedgerSigner, LedgerSigner111, LedgerSigner221, type LegacyCompiledContract, type LegacyContractClass, type LegacyEvent, LibraryError, Literal, type LogLevel, LogLevelIndex, type MessageToL1, type MultiDeployContractResponse, type MultiType, NON_ZERO_PREFIX, type Nonce, type OptionalPayload, type OutsideCall, type OutsideExecution, type OutsideExecutionOptions, OutsideExecutionTypesV1, OutsideExecutionTypesV2, OutsideExecutionVersion, type OutsideTransaction, type ParsedEvent, type ParsedEvents, type ParsedStruct, type PendingBlock, type PendingStateUpdate, type Program, RpcProvider as Provider, ProviderInterface, type ProviderOptions, type PythonicHints, index$3 as RPC, rpc_0_6 as RPC06, rpc_0_7 as RPC07, RPCResponseParser, type RPC_ERROR, type RPC_ERROR_SET, type RawArgs, type RawArgsArray, type RawArgsObject, type RawCalldata, ReceiptTx, type RejectedTransactionReceiptResponse, ResponseParser, type Result, type RevertedTransactionReceiptResponse, RpcChannel, RpcError, RpcProvider, type RpcProviderOptions, type SIMULATION_FLAG, type SierraContractClass, type SierraContractEntryPointFields, type SierraEntryPointsByType, type SierraProgramDebugInfo, type Signature, Signer, SignerInterface, type SimulateTransactionDetails, type SimulateTransactionResponse, type SimulatedTransaction, type SimulationFlags, type StarkProfile, type StateUpdate, type StateUpdateResponse, type Storage, type SuccessfulTransactionReceiptResponse, TransactionExecutionStatus, TransactionFinalityStatus, type TransactionReceipt, type TransactionReceiptCallbacks, type TransactionReceiptCallbacksDefault, type TransactionReceiptCallbacksDefined, type TransactionReceiptStatus, type TransactionReceiptUtilityInterface, type TransactionReceiptValue, TransactionStatus, type TransactionStatusReceiptSets, TransactionType, 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 UniversalSuggestedFee, type V2DeclareSignerDetails, type V2DeployAccountSignerDetails, type V2InvocationsSignerDetails, type V3DeclareSignerDetails, type V3DeployAccountSignerDetails, type V3InvocationsSignerDetails, type V3TransactionDetails, ValidateType, WalletAccount, type WeierstrassSignatureType, addAddressPadding, byteArray, cairo, config, constants, contractClassResponseToLegacyCompiledContract, defaultProvider, ec, encode, eth, index as events, extractContractHashes, fixProto, fixStack, getCalldata, getChecksumAddress, type getContractVersionOptions, type getEstimateFeeBulkOptions, getLedgerPathBuffer111 as getLedgerPathBuffer, getLedgerPathBuffer111, getLedgerPathBuffer221, type getSimulateTransactionOptions, index$1 as hash, isSierra, json, logger, merkle, num, number, outsideExecution, parseCalldataField, provider, selector, shortString, splitArgsAndOptions, src5, stark, starknetId, transaction, typedData, index$2 as types, uint256$1 as uint256, units, v2 as v2hash, v3 as v3hash, validateAndParseAddress, validateChecksumAddress, type waitForTransactionOptions, connect as wallet };

package/dist/index.global.js

@@ -3212,6 +3212,7 @@ var starknet = (() => {
     BlockStatus: () => BlockStatus,
     BlockTag: () => BlockTag,
     CairoCustomEnum: () => CairoCustomEnum,
+    CairoFixedArray: () => CairoFixedArray,
     CairoOption: () => CairoOption,
     CairoOptionVariant: () => CairoOptionVariant,
     CairoResult: () => CairoResult,
@@ -8601,6 +8602,151 @@ ${indent}}` : "}";
     return isCairo1Type(type) ? extractCairo1Tuple(type) : extractCairo0Tuple(type);
   }
 
+  // src/utils/cairoDataTypes/fixedArray.ts
+  var CairoFixedArray = class _CairoFixedArray {
+    /**
+     * JS array representing a Cairo fixed array.
+     */
+    content;
+    /**
+     * Cairo fixed array type.
+     */
+    arrayType;
+    /**
+     * Create an instance representing a Cairo fixed Array.
+     * @param {any[]} content JS array representing a Cairo fixed array.
+     * @param {string} arrayType Cairo fixed array type.
+     */
+    constructor(content, arrayType) {
+      assert(
+        _CairoFixedArray.isTypeFixedArray(arrayType),
+        `The type ${arrayType} is not a Cairo fixed array. Needs [type; length].`
+      );
+      try {
+        _CairoFixedArray.getFixedArrayType(arrayType);
+      } catch {
+        throw new Error(
+          `The type ${arrayType} do not includes any content type. Needs [type; length].`
+        );
+      }
+      try {
+        _CairoFixedArray.getFixedArraySize(arrayType);
+      } catch {
+        throw new Error(
+          `The type ${arrayType} type do not includes any length. Needs [type; length].`
+        );
+      }
+      assert(
+        _CairoFixedArray.getFixedArraySize(arrayType) === content.length,
+        `The ABI type ${arrayType} is expecting ${_CairoFixedArray.getFixedArraySize(arrayType)} items. ${content.length} items provided.`
+      );
+      this.content = content;
+      this.arrayType = arrayType;
+    }
+    /**
+     * Retrieves the array size from the given type string representing a Cairo fixed array.
+     * @param {string} type - The Cairo fixed array type.
+     * @returns {number} The array size.
+     * @example
+     * ```typescript
+     * const result = CairoFixedArray.getFixedArraySize("[core::integer::u32; 8]");
+     * // result = 8
+     * ```
+     */
+    static getFixedArraySize(type) {
+      const matchArray = type.match(/(?<=; )\d+(?=\])/);
+      if (matchArray === null)
+        throw new Error(`ABI type ${type} do not includes a valid number after ';' character.`);
+      return Number(matchArray[0]);
+    }
+    /**
+     * Retrieves the Cairo fixed array size from the CairoFixedArray instance.
+     * @returns {number} The fixed array size.
+     * @example
+     * ```typescript
+     * const fArray = new CairoFixedArray([10,20,30], "[core::integer::u32; 3]");
+     * const result = fArray.getFixedArraySize();
+     * // result = 3
+     * ```
+     */
+    getFixedArraySize() {
+      return _CairoFixedArray.getFixedArraySize(this.arrayType);
+    }
+    /**
+     * Retrieve the Cairo content type from a Cairo fixed array type.
+     * @param {string} type - The type string.
+     * @returns {string} The fixed-array type.
+     * @example
+     * ```typescript
+     * const result = CairoFixedArray.getFixedArrayType("[core::integer::u32; 8]");
+     * // result = "core::integer::u32"
+     * ```
+     */
+    static getFixedArrayType = (type) => {
+      const matchArray = type.match(/(?<=\[).+(?=;)/);
+      if (matchArray === null)
+        throw new Error(`ABI type ${type} do not includes a valid type of data.`);
+      return matchArray[0];
+    };
+    /**
+     * Retrieve the Cairo content type of the Cairo fixed array.
+     * @returns {string} The fixed-array content type.
+     * @example
+     * ```typescript
+     * const fArray = new CairoFixedArray([10,20,30], "[core::integer::u32; 3]");
+     * const result = fArray.getFixedArrayType();
+     * // result = "core::integer::u32"
+     * ```
+     */
+    getFixedArrayType() {
+      return _CairoFixedArray.getFixedArrayType(this.arrayType);
+    }
+    /**
+     * Create an object from a Cairo fixed array.
+     * Be sure to have an array length conform to the ABI.
+     * To be used with CallData.compile().
+     * @param {Array<any>} input JS array representing a Cairo fixed array.
+     * @returns {Object} a specific struct representing a fixed Array.
+     * @example
+     * ```typescript
+     * const result = CairoFixedArray.compile([10,20,30]);
+     * // result = { '0': 10, '1': 20, '2': 30 }
+     * ```
+     */
+    static compile(input) {
+      return input.reduce((acc, item, idx) => {
+        acc[idx] = item;
+        return acc;
+      }, {});
+    }
+    /**
+     * Generate an object from the Cairo fixed array instance.
+     * To be used with CallData.compile().
+     * @returns a specific struct representing a fixed array.
+     * @example
+     * ```typescript
+     * const fArray = new CairoFixedArray([10,20,30], "[core::integer::u32; 3]");
+     * const result = fArray.compile();
+     * // result = { '0': 10, '1': 20, '2': 30 }
+     * ```
+     */
+    compile() {
+      return _CairoFixedArray.compile(this.content);
+    }
+    /**
+     * Checks if the given Cairo type is a fixed-array type.
+     *
+     * @param {string} type - The type to check.
+     * @returns - `true` if the type is a fixed array type, `false` otherwise.
+     * ```typescript
+     * const result = CairoFixedArray.isTypeFixedArray("[core::integer::u32; 8]");
+     * // result = true
+     */
+    static isTypeFixedArray(type) {
+      return /^\[.*;\s.*\]$/.test(type) && /(?<=\[).+(?=;)/.test(type) && /(?<=; )\d+(?=\])/.test(type);
+    }
+  };
+
   // src/utils/calldata/propertyOrder.ts
   function errorU256(key) {
     return Error(
@@ -8614,6 +8760,9 @@ ${indent}}` : "}";
   }
   function orderPropsByAbi(unorderedObject, abiOfObject, structs, enums) {
     const orderInput = (unorderedItem, abiType) => {
+      if (CairoFixedArray.isTypeFixedArray(abiType)) {
+        return orderFixedArray(unorderedItem, abiType);
+      }
       if (isTypeArray(abiType)) {
         return orderArray(unorderedItem, abiType);
       }
@@ -8688,6 +8837,24 @@ ${indent}}` : "}";
       }
       return myArray.map((myElem) => orderInput(myElem, typeInArray));
     }
+    function orderFixedArray(input, abiParam) {
+      const typeInFixedArray = CairoFixedArray.getFixedArrayType(abiParam);
+      const arraySize = CairoFixedArray.getFixedArraySize(abiParam);
+      if (Array.isArray(input)) {
+        if (arraySize !== input.length) {
+          throw new Error(
+            `ABI type ${abiParam}: array provided do not includes  ${arraySize} items. ${input.length} items provided.`
+          );
+        }
+        return input.map((myElem) => orderInput(myElem, typeInFixedArray));
+      }
+      if (arraySize !== Object.keys(input).length) {
+        throw new Error(
+          `ABI type ${abiParam}: object provided do not includes  ${arraySize} properties. ${Object.keys(input).length} items provided.`
+        );
+      }
+      return orderInput(input, typeInFixedArray);
+    }
     function orderTuple(unorderedObject2, abiParam) {
       const typeList = extractTupleMemberTypes(abiParam);
       const orderedObject2 = typeList.reduce((orderedObject, abiTypeCairoX, index) => {
@@ -8823,6 +8990,25 @@ ${indent}}` : "}";
     if (element === void 0) {
       throw Error(`Missing parameter for type ${type}`);
     }
+    if (CairoFixedArray.isTypeFixedArray(type)) {
+      const arrayType = CairoFixedArray.getFixedArrayType(type);
+      let values = [];
+      if (Array.isArray(element)) {
+        const array = new CairoFixedArray(element, type);
+        values = array.content;
+      } else if (typeof element === "object") {
+        values = Object.values(element);
+        assert(
+          values.length === CairoFixedArray.getFixedArraySize(type),
+          `ABI type ${type}: object provided do not includes  ${CairoFixedArray.getFixedArraySize(type)} items. ${values.length} items provided.`
+        );
+      } else {
+        throw new Error(`ABI type ${type}: not an Array representing a cairo.fixedArray() provided.`);
+      }
+      return values.reduce((acc, it) => {
+        return acc.concat(parseCalldataValue(it, arrayType, structs, enums));
+      }, []);
+    }
     if (Array.isArray(element)) {
       const result = [];
       result.push(felt(element.length));
@@ -8950,7 +9136,13 @@ ${indent}}` : "}";
     const { name, type } = input;
     let { value } = argsIterator.next();
     switch (true) {
-      // Array
+      // Fixed array
+      case CairoFixedArray.isTypeFixedArray(type):
+        if (!Array.isArray(value) && !(typeof value === "object")) {
+          throw Error(`ABI expected parameter ${name} to be an array or an object, got ${value}`);
+        }
+        return parseCalldataValue(value, input.type, structs, enums);
+      // Normal Array
       case isTypeArray(type):
         if (!Array.isArray(value) && !isText(value)) {
           throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
@@ -9046,6 +9238,15 @@ ${indent}}` : "}";
       };
       return stringFromByteArray(myByteArray);
     }
+    if (CairoFixedArray.isTypeFixedArray(element.type)) {
+      const parsedDataArr = [];
+      const el = { name: "", type: CairoFixedArray.getFixedArrayType(element.type) };
+      const arraySize = CairoFixedArray.getFixedArraySize(element.type);
+      while (parsedDataArr.length < arraySize) {
+        parsedDataArr.push(parseResponseValue(responseIterator, el, structs, enums));
+      }
+      return parsedDataArr;
+    }
     if (isTypeArray(element.type)) {
       const parsedDataArr = [];
       const el = { name: "", type: getArrayType(element.type) };
@@ -9131,6 +9332,8 @@ ${indent}}` : "}";
         return parseResponseValue(responseIterator, output, structs, enums);
       case (enums && isTypeEnum(type, enums)):
         return parseResponseValue(responseIterator, output, structs, enums);
+      case CairoFixedArray.isTypeFixedArray(type):
+        return parseResponseValue(responseIterator, output, structs, enums);
       case isTypeArray(type):
         if (isCairo1Type(type)) {
           return parseResponseValue(responseIterator, output, structs, enums);
@@ -9333,12 +9536,28 @@ ${indent}}` : "}";
   var validateTuple = (parameter, input) => {
     assert(isObject2(parameter), `Validate: arg ${input.name} should be a tuple (defined as object)`);
   };
-  var validateArray = (parameter, input, structs, enums) => {
-    const baseType = getArrayType(input.type);
-    if (isTypeFelt(baseType) && isLongText(parameter)) {
+  var validateArray = (parameterArray, input, structs, enums) => {
+    const isNormalArray = isTypeArray(input.type);
+    const baseType = isNormalArray ? getArrayType(input.type) : CairoFixedArray.getFixedArrayType(input.type);
+    if (isNormalArray && isTypeFelt(baseType) && isLongText(parameterArray)) {
       return;
     }
-    assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+    let parameter = [];
+    if (isNormalArray) {
+      assert(Array.isArray(parameterArray), `Validate: arg ${input.name} should be an Array`);
+      parameter = parameterArray;
+    } else {
+      switch (true) {
+        case Array.isArray(parameterArray):
+          parameter = parameterArray;
+          break;
+        case typeof parameterArray === "object":
+          parameter = Object.values(parameterArray);
+          break;
+        default:
+          throw new Error(`Validate: arg ${input.name} should be an Array or an object.`);
+      }
+    }
     switch (true) {
       case isTypeFelt(baseType):
         parameter.forEach((param) => validateFelt(param, input));
@@ -9428,7 +9647,7 @@ ${indent}}` : "}";
         case isTypeByteArray(input.type):
           validateByteArray(parameter, input);
           break;
-        case isTypeArray(input.type):
+        case (isTypeArray(input.type) || CairoFixedArray.isTypeFixedArray(input.type)):
           validateArray(parameter, input, structs, enums);
           break;
         case isTypeStruct(input.type, structs):
@@ -16693,30 +16912,35 @@ ${JSON.stringify(data, null, 2)}`;
     return type.type === "merkletree";
   }
   function getDependencies(types, type, dependencies = [], contains = "", revision = TypedDataRevision.LEGACY) {
+    let dependencyTypes = [type];
     if (type[type.length - 1] === "*") {
-      type = type.slice(0, -1);
+      dependencyTypes = [type.slice(0, -1)];
     } else if (revision === TypedDataRevision.ACTIVE) {
       if (type === "enum") {
-        type = contains;
+        dependencyTypes = [contains];
       } else if (type.match(/^\(.*\)$/)) {
-        type = type.slice(1, -1);
-      }
-    }
-    if (dependencies.includes(type) || !types[type]) {
-      return dependencies;
-    }
-    return [
-      type,
-      ...types[type].reduce(
-        (previous, t) => [
-          ...previous,
-          ...getDependencies(types, t.type, previous, t.contains, revision).filter(
-            (dependency) => !previous.includes(dependency)
+        dependencyTypes = type.slice(1, -1).split(",").map((depType) => depType[depType.length - 1] === "*" ? depType.slice(0, -1) : depType);
+      }
+    }
+    return dependencyTypes.filter((t) => !dependencies.includes(t) && types[t]).reduce(
+      // This comment prevents prettier from rolling everything here into a single line.
+      (p, depType) => [
+        ...p,
+        ...[
+          depType,
+          ...types[depType].reduce(
+            (previous, t) => [
+              ...previous,
+              ...getDependencies(types, t.type, previous, t.contains, revision).filter(
+                (dependency) => !previous.includes(dependency)
+              )
+            ],
+            []
           )
-        ],
-        []
-      )
-    ];
+        ].filter((dependency) => !p.includes(dependency))
+      ],
+      []
+    );
   }
   function getMerkleTreeType(types, ctx) {
     if (ctx.parent && ctx.key) {
@@ -19198,6 +19422,7 @@ ${JSON.stringify(data, null, 2)}`;
   // src/utils/outsideExecution.ts
   var outsideExecution_exports = {};
   __export(outsideExecution_exports, {
+    buildExecuteFromOutsideCall: () => buildExecuteFromOutsideCall,
     buildExecuteFromOutsideCallData: () => buildExecuteFromOutsideCallData,
     getOutsideCall: () => getOutsideCall,
     getTypedData: () => getTypedData
@@ -19269,6 +19494,25 @@ ${JSON.stringify(data, null, 2)}`;
       signature: formattedSignature
     });
   }
+  function buildExecuteFromOutsideCall(outsideTransaction) {
+    const myOutsideTransactions = Array.isArray(outsideTransaction) ? outsideTransaction : [outsideTransaction];
+    const multiCall = myOutsideTransactions.map((outsideTx) => {
+      let entrypoint;
+      if (outsideTx.version === "1" /* V1 */) {
+        entrypoint = "execute_from_outside";
+      } else if (outsideTx.version === "2" /* V2 */) {
+        entrypoint = "execute_from_outside_v2";
+      } else {
+        throw new Error("Unsupported OutsideExecution version");
+      }
+      return {
+        contractAddress: toHex(outsideTx.signerAddress),
+        entrypoint,
+        calldata: buildExecuteFromOutsideCallData(outsideTx)
+      };
+    });
+    return multiCall;
+  }
 
   // src/utils/src5.ts
   var src5_exports = {};
@@ -19826,22 +20070,7 @@ ${JSON.stringify(data, null, 2)}`;
      * ```
      */
     async executeFromOutside(outsideTransaction, opts) {
-      const myOutsideTransactions = Array.isArray(outsideTransaction) ? outsideTransaction : [outsideTransaction];
-      const multiCall = myOutsideTransactions.map((outsideTx) => {
-        let entrypoint;
-        if (outsideTx.version === "1" /* V1 */) {
-          entrypoint = "execute_from_outside";
-        } else if (outsideTx.version === "2" /* V2 */) {
-          entrypoint = "execute_from_outside_v2";
-        } else {
-          throw new Error("Unsupported OutsideExecution version");
-        }
-        return {
-          contractAddress: toHex(outsideTx.signerAddress),
-          entrypoint,
-          calldata: buildExecuteFromOutsideCallData(outsideTx)
-        };
-      });
+      const multiCall = buildExecuteFromOutsideCall(outsideTransaction);
       return this.execute(multiCall, opts);
     }
     /*