starknet 5.4.2 → 5.6.0

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+# [5.6.0](https://github.com/0xs34n/starknet.js/compare/v5.5.0...v5.6.0) (2023-04-19)
+
+### Bug Fixes
+
+- optional param in contract invoke ([da094e4](https://github.com/0xs34n/starknet.js/commit/da094e4172ed43ce93604e92adbba2a5ecb1498e))
+
+### Features
+
+- cairo 1 bool ([52fed30](https://github.com/0xs34n/starknet.js/commit/52fed30f04b70bcce80f829dba6975101f6f3644))
+- cairo1 array, fix invoke response, hash separate test ([4637cd7](https://github.com/0xs34n/starknet.js/commit/4637cd74481ba85b3164ddb93c258b9ca8b9b949))
+- felt252 implementation ([3d20ea4](https://github.com/0xs34n/starknet.js/commit/3d20ea44b49d1c7ba90d8a46a307f54e737c3285))
+- uint validate and parsing supprot ([c1acd29](https://github.com/0xs34n/starknet.js/commit/c1acd298d63758ba27fc20bcb4b0c00cca82078f))
+
+# [5.5.0](https://github.com/0xs34n/starknet.js/compare/v5.4.2...v5.5.0) (2023-04-10)
+
+### Bug Fixes
+
+- update DeclareAndDeploy with cairo 1 declare ([71072cf](https://github.com/0xs34n/starknet.js/commit/71072cffadb8ac118780cec21cb8c4f83e74d7ae))
+
+### Features
+
+- response parsing and types ([09a46af](https://github.com/0xs34n/starknet.js/commit/09a46af02e88376dc49e0aa39468fded99b94ee2))
+
 ## [5.4.2](https://github.com/0xs34n/starknet.js/compare/v5.4.1...v5.4.2) (2023-04-04)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -222,6 +222,7 @@ declare type FunctionAbi = {
     name: string;
     outputs: AbiEntry[];
     stateMutability?: 'view';
+    state_mutability?: string;
     type: FunctionAbiType;
 };
 declare type AbiStructs = {
@@ -269,7 +270,8 @@ declare type CairoAssembly = {
     prime: string;
     compiler_version: string;
     bytecode: ByteCode;
-    hints: Hints;
+    hints: any[];
+    pythonic_hints: PythonicHints;
     entry_points_by_type: EntryPointsByType;
 };
 declare type SierraContractClass = {
@@ -284,7 +286,7 @@ declare type CompiledSierra = SierraContractClass;
 declare type CompiledSierraCasm = CairoAssembly;
 /** SUBTYPES */
 declare type ByteCode = string[];
-declare type Hints = [number, string[]][];
+declare type PythonicHints = [number, string[]][];
 declare type SierraProgramDebugInfo = {
     type_names: [number, string][];
     libfunc_names: [number, string][];
@@ -460,7 +462,7 @@ declare type Overrides = {
     maxFee?: BigNumberish;
     nonce?: BigNumberish;
     signature?: Signature;
-    parseRequest: Boolean;
+    parseRequest?: Boolean;
 };
 
 interface InvocationsSignerDetails extends Required<InvocationsDetails> {
@@ -485,7 +487,7 @@ declare type AsyncContractFunction<T = any> = (...args: Array<any>) => Promise<T
 declare type ContractFunction = (...args: Array<any>) => any;
 declare type Result = {
     [key: string]: any;
-};
+} | Result[] | bigint | string | boolean;
 
 declare type BlockIdentifier = BlockNumber | BigNumberish;
 
@@ -509,8 +511,8 @@ declare type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJ
 declare type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'DEPLOY_ACCOUNT' | 'INVOKE' | 'L1_HANDLER';
 declare type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
 declare enum BLOCK_TAG {
-    'latest' = 0,
-    'pending' = 1
+    latest = "latest",
+    pending = "pending"
 }
 declare type BLOCK_ID = {
     block_hash: BLOCK_HASH;
@@ -1892,7 +1894,9 @@ declare abstract class ProviderInterface {
     /**
      * Wait for the transaction to be accepted
      * @param txHash - transaction hash
-     * @param retryInterval - retry interval
+     * @param options
+     * - (optional) retryInterval: number | undefined;
+     * - (optional) successStates: TransactionStatus[] | undefined;
      * @return GetTransactionReceiptResponse
      */
     abstract waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<GetTransactionReceiptResponse>;
@@ -2723,14 +2727,16 @@ declare class Contract implements ContractInterface {
     };
     readonly [key: string]: AsyncContractFunction | any;
     private callData;
+    private version;
     /**
      * Contract class to handle contract methods
      *
      * @param abi - Abi of the contract object
      * @param address (optional) - address to connect to
      * @param providerOrAccount (optional) - Provider or Account to attach to
+     * @param cairoVersion (optional) - default '0', for Cairo 1 set '1'
      */
-    constructor(abi: Abi, address: string, providerOrAccount?: ProviderInterface | AccountInterface);
+    constructor(abi: Abi, address: string, providerOrAccount?: ProviderInterface | AccountInterface, cairoVersion?: string);
     attach(address: string): void;
     connect(providerOrAccount: ProviderInterface | AccountInterface): void;
     deployed(): Promise<Contract>;
@@ -3009,20 +3015,20 @@ declare const UINT_256_MAX: bigint;
 declare function isUint256(bn: BigNumberish): boolean;
 declare function bnToUint256(bignumber: BigNumberish): Uint256;
 
-type uint256_Uint256 = Uint256;
-declare const uint256_uint256ToBN: typeof uint256ToBN;
-declare const uint256_UINT_128_MAX: typeof UINT_128_MAX;
-declare const uint256_UINT_256_MAX: typeof UINT_256_MAX;
-declare const uint256_isUint256: typeof isUint256;
-declare const uint256_bnToUint256: typeof bnToUint256;
-declare namespace 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;
+declare const uint256$1_bnToUint256: typeof bnToUint256;
+declare namespace uint256$1 {
   export {
-    uint256_Uint256 as Uint256,
-    uint256_uint256ToBN as uint256ToBN,
-    uint256_UINT_128_MAX as UINT_128_MAX,
-    uint256_UINT_256_MAX as UINT_256_MAX,
-    uint256_isUint256 as isUint256,
-    uint256_bnToUint256 as bnToUint256,
+    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_bnToUint256 as bnToUint256,
   };
 }
 
@@ -3100,6 +3106,133 @@ declare function validateChecksumAddress(address: string): boolean;
 declare function isUrl(s?: string): boolean;
 declare function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string): string;
 
+declare enum Uint {
+    u8 = "core::integer::u8",
+    u16 = "core::integer::u16",
+    u32 = "core::integer::u32",
+    u64 = "core::integer::u64",
+    u128 = "core::integer::u128",
+    u256 = "core::integer::u256"
+}
+declare const isLen: (name: string) => boolean;
+declare const isTypeFelt: (type: string) => boolean;
+declare const isTypeArray: (type: string) => boolean;
+declare const isTypeTuple: (type: string) => boolean;
+declare const isTypeNamedTuple: (type: string) => boolean;
+declare const isTypeStruct: (type: string, structs: AbiStructs) => boolean;
+declare const isTypeUint: (type: string) => boolean;
+declare const isTypeBool: (type: string) => boolean;
+declare const isTypeContractAddress: (type: string) => boolean;
+declare const isCairo1Type: (type: string) => boolean;
+declare const getArrayType: (type: string) => string;
+/**
+ * named tuple are described as js object {}
+ * struct types are described as js object {}
+ * array types are described as js array []
+ */
+/**
+ * Uint256 cairo type (helper for common struct type)
+ */
+declare const uint256: (it: BigNumberish) => Uint256;
+/**
+ * unnamed tuple cairo type (helper same as common struct type)
+ */
+declare const tuple: (...args: (BigNumberish | object)[]) => {
+    [x: number]: object | BigNumberish;
+    length: number;
+    toString(): string;
+    toLocaleString(): string;
+    pop(): object | BigNumberish | undefined;
+    push(...items: (object | BigNumberish)[]): number;
+    concat(...items: ConcatArray<object | BigNumberish>[]): (object | BigNumberish)[];
+    concat(...items: (object | BigNumberish | ConcatArray<object | BigNumberish>)[]): (object | BigNumberish)[];
+    join(separator?: string | undefined): string;
+    reverse(): (object | BigNumberish)[];
+    shift(): object | BigNumberish | undefined;
+    slice(start?: number | undefined, end?: number | undefined): (object | BigNumberish)[];
+    sort(compareFn?: ((a: object | BigNumberish, b: object | BigNumberish) => number) | undefined): (object | BigNumberish)[];
+    splice(start: number, deleteCount?: number | undefined): (object | BigNumberish)[];
+    splice(start: number, deleteCount: number, ...items: (object | BigNumberish)[]): (object | BigNumberish)[];
+    unshift(...items: (object | BigNumberish)[]): number;
+    indexOf(searchElement: object | BigNumberish, fromIndex?: number | undefined): number;
+    lastIndexOf(searchElement: object | BigNumberish, fromIndex?: number | undefined): number;
+    every<S extends object | BigNumberish>(predicate: (value: object | BigNumberish, index: number, array: (object | BigNumberish)[]) => value is S, thisArg?: any): this is S[];
+    every(predicate: (value: object | BigNumberish, index: number, array: (object | BigNumberish)[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: object | BigNumberish, index: number, array: (object | BigNumberish)[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: object | BigNumberish, index: number, array: (object | BigNumberish)[]) => void, thisArg?: any): void;
+    map<U>(callbackfn: (value: object | BigNumberish, index: number, array: (object | BigNumberish)[]) => U, thisArg?: any): U[];
+    filter<S_1 extends object | BigNumberish>(predicate: (value: object | BigNumberish, index: number, array: (object | BigNumberish)[]) => value is S_1, thisArg?: any): S_1[];
+    filter(predicate: (value: object | BigNumberish, index: number, array: (object | BigNumberish)[]) => unknown, thisArg?: any): (object | BigNumberish)[];
+    reduce(callbackfn: (previousValue: object | BigNumberish, currentValue: object | BigNumberish, currentIndex: number, array: (object | BigNumberish)[]) => object | BigNumberish): object | BigNumberish;
+    reduce(callbackfn: (previousValue: object | BigNumberish, currentValue: object | BigNumberish, currentIndex: number, array: (object | BigNumberish)[]) => object | BigNumberish, initialValue: object | BigNumberish): object | BigNumberish;
+    reduce<U_1>(callbackfn: (previousValue: U_1, currentValue: object | BigNumberish, currentIndex: number, array: (object | BigNumberish)[]) => U_1, initialValue: U_1): U_1;
+    reduceRight(callbackfn: (previousValue: object | BigNumberish, currentValue: object | BigNumberish, currentIndex: number, array: (object | BigNumberish)[]) => object | BigNumberish): object | BigNumberish;
+    reduceRight(callbackfn: (previousValue: object | BigNumberish, currentValue: object | BigNumberish, currentIndex: number, array: (object | BigNumberish)[]) => object | BigNumberish, initialValue: object | BigNumberish): object | BigNumberish;
+    reduceRight<U_2>(callbackfn: (previousValue: U_2, currentValue: object | BigNumberish, currentIndex: number, array: (object | BigNumberish)[]) => U_2, initialValue: U_2): U_2;
+    find<S_2 extends object | BigNumberish>(predicate: (this: void, value: object | BigNumberish, index: number, obj: (object | BigNumberish)[]) => value is S_2, thisArg?: any): S_2 | undefined;
+    find(predicate: (value: object | BigNumberish, index: number, obj: (object | BigNumberish)[]) => unknown, thisArg?: any): object | BigNumberish | undefined;
+    findIndex(predicate: (value: object | BigNumberish, index: number, obj: (object | BigNumberish)[]) => unknown, thisArg?: any): number;
+    fill(value: object | BigNumberish, start?: number | undefined, end?: number | undefined): (object | BigNumberish)[];
+    copyWithin(target: number, start: number, end?: number | undefined): (object | BigNumberish)[];
+    entries(): IterableIterator<[number, object | BigNumberish]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<object | BigNumberish>;
+    includes(searchElement: object | BigNumberish, fromIndex?: number | undefined): boolean;
+    flatMap<U_3, This = undefined>(callback: (this: This, value: object | BigNumberish, index: number, array: (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<object | BigNumberish>;
+    [Symbol.unscopables](): {
+        copyWithin: boolean;
+        entries: boolean;
+        fill: boolean;
+        find: boolean;
+        findIndex: boolean;
+        keys: boolean;
+        values: boolean;
+    };
+    at(index: number): object | BigNumberish | undefined;
+};
+/**
+ * felt cairo type
+ */
+declare function felt(it: BigNumberish): string;
+
+type cairo_Uint = Uint;
+declare const cairo_Uint: typeof Uint;
+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_isTypeNamedTuple: typeof isTypeNamedTuple;
+declare const cairo_isTypeStruct: typeof isTypeStruct;
+declare const cairo_isTypeUint: typeof isTypeUint;
+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 namespace cairo {
+  export {
+    cairo_Uint as Uint,
+    cairo_isLen as isLen,
+    cairo_isTypeFelt as isTypeFelt,
+    cairo_isTypeArray as isTypeArray,
+    cairo_isTypeTuple as isTypeTuple,
+    cairo_isTypeNamedTuple as isTypeNamedTuple,
+    cairo_isTypeStruct as isTypeStruct,
+    cairo_isTypeUint as isTypeUint,
+    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,
+  };
+}
+
 declare class CallData {
     abi: Abi;
     protected readonly structs: AbiStructs;
@@ -3132,7 +3265,7 @@ declare class CallData {
      * @param response  - response from the method
      * @return - parsed response corresponding to the abi
      */
-    parse(method: string, response: string[]): object;
+    parse(method: string, response: string[]): Result;
     /**
      * Format cairo method response data to native js values based on provided format schema
      * @param method - cairo method name
@@ -3152,4 +3285,4 @@ declare class CallData {
 /** @deprecated prefer the 'num' naming */
 declare const number: typeof num;
 
-export { Abi, AbiEntry, AbiStructs, Account, AccountInterface, AllowArray, Args, ArraySignatureType, AsyncContractFunction, BlockNumber, BlockTag, Builtins, ByteCode, CairoAssembly, CairoContract, CairoVersion, Call, CallContractResponse, CallData, CallDetails, CallL1Handler, CallOptions, CallStruct, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompiledSierra, CompiledSierraCasm, CompleteDeclareContractPayload, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractEntryPointFields, ContractFactory, ContractFunction, ContractInterface, CustomError, DeclareAndDeployContractPayload, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareDeployUDCResponse, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, DeployContractUDCResponse, DeployedContractItem, Details, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeBulk, EstimateFeeDetails, EstimateFeeResponse, EstimateFeeResponseBulk, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, Hints, HttpError, Invocation, InvocationBulk, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeTransactionReceiptResponse, InvokeTransactionResponse, LegacyCompiledContract, LegacyContractClass, LibraryError, MessageToL1, MessageToL2, MultiDeployContractResponse, Nonce, Overrides, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, RPC, RawArgs, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerHttpMethod, SequencerIdentifier, SequencerProvider, SequencerProviderOptions, SierraContractClass, SierraContractEntryPointFields, SierraEntryPointsByType, SierraProgramDebugInfo, Signature, Signer, SignerInterface, StateUpdateResponse, Status, Storage, Struct, StructAbi, TransactionBulk, TransactionSimulation, TransactionSimulationResponse, TransactionStatus, TransactionTraceResponse, TransactionType, Tupled, UniversalDeployerContractPayload, WeierstrassSignatureType, addAddressPadding, buildUrl, constants, defaultProvider, ec, encode, fixProto, fixStack, getChecksumAddress, hash, isUrl, json, merkle, num, number, shortString, stark, transaction, index as typedData, uint256, validateAndParseAddress, validateChecksumAddress, waitForTransactionOptions };
+export { Abi, AbiEntry, AbiStructs, Account, AccountInterface, AllowArray, Args, ArraySignatureType, AsyncContractFunction, BlockNumber, BlockTag, Builtins, ByteCode, CairoAssembly, CairoContract, CairoVersion, Call, CallContractResponse, CallData, CallDetails, CallL1Handler, CallOptions, CallStruct, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompiledSierra, CompiledSierraCasm, CompleteDeclareContractPayload, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractEntryPointFields, ContractFactory, ContractFunction, ContractInterface, CustomError, DeclareAndDeployContractPayload, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareDeployUDCResponse, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, DeployContractUDCResponse, DeployedContractItem, Details, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeBulk, EstimateFeeDetails, EstimateFeeResponse, EstimateFeeResponseBulk, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, HttpError, Invocation, InvocationBulk, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeTransactionReceiptResponse, InvokeTransactionResponse, LegacyCompiledContract, LegacyContractClass, LibraryError, MessageToL1, MessageToL2, MultiDeployContractResponse, Nonce, Overrides, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, PythonicHints, RPC, RawArgs, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerHttpMethod, SequencerIdentifier, SequencerProvider, SequencerProviderOptions, SierraContractClass, SierraContractEntryPointFields, SierraEntryPointsByType, SierraProgramDebugInfo, Signature, Signer, SignerInterface, StateUpdateResponse, Status, Storage, Struct, StructAbi, TransactionBulk, TransactionSimulation, TransactionSimulationResponse, TransactionStatus, TransactionTraceResponse, TransactionType, Tupled, UniversalDeployerContractPayload, WeierstrassSignatureType, addAddressPadding, buildUrl, cairo, constants, defaultProvider, ec, encode, fixProto, fixStack, getChecksumAddress, hash, isUrl, json, merkle, num, number, shortString, stark, transaction, index as typedData, uint256$1 as uint256, validateAndParseAddress, validateChecksumAddress, waitForTransactionOptions };

package/dist/index.global.js

@@ -630,6 +630,7 @@ var starknet = (() => {
     TransactionType: () => TransactionType,
     addAddressPadding: () => addAddressPadding,
     buildUrl: () => buildUrl,
+    cairo: () => cairo_exports,
     constants: () => constants_exports,
     defaultProvider: () => defaultProvider,
     ec: () => ec_exports,
@@ -5309,6 +5310,26 @@ var starknet = (() => {
     ]
   ];
 
+  // src/utils/calldata/cairo.ts
+  var cairo_exports = {};
+  __export(cairo_exports, {
+    Uint: () => Uint,
+    felt: () => felt,
+    getArrayType: () => getArrayType,
+    isCairo1Type: () => isCairo1Type,
+    isLen: () => isLen,
+    isTypeArray: () => isTypeArray,
+    isTypeBool: () => isTypeBool,
+    isTypeContractAddress: () => isTypeContractAddress,
+    isTypeFelt: () => isTypeFelt,
+    isTypeNamedTuple: () => isTypeNamedTuple,
+    isTypeStruct: () => isTypeStruct,
+    isTypeTuple: () => isTypeTuple,
+    isTypeUint: () => isTypeUint,
+    tuple: () => tuple,
+    uint256: () => uint256
+  });
+
   // src/utils/num.ts
   var num_exports = {};
   __export(num_exports, {
@@ -5464,8 +5485,8 @@ var starknet = (() => {
     isUint256: () => isUint256,
     uint256ToBN: () => uint256ToBN
   });
-  function uint256ToBN(uint256) {
-    return (toBigInt(uint256.high) << 128n) + toBigInt(uint256.low);
+  function uint256ToBN(uint2562) {
+    return (toBigInt(uint2562.high) << 128n) + toBigInt(uint2562.low);
   }
   var UINT_128_MAX = (1n << 128n) - 1n;
   var UINT_256_MAX = (1n << 256n) - 1n;
@@ -5483,13 +5504,41 @@ var starknet = (() => {
   }
 
   // src/utils/calldata/cairo.ts
+  var Uint = /* @__PURE__ */ ((Uint2) => {
+    Uint2["u8"] = "core::integer::u8";
+    Uint2["u16"] = "core::integer::u16";
+    Uint2["u32"] = "core::integer::u32";
+    Uint2["u64"] = "core::integer::u64";
+    Uint2["u128"] = "core::integer::u128";
+    Uint2["u256"] = "core::integer::u256";
+    return Uint2;
+  })(Uint || {});
   var isLen = (name) => /_len$/.test(name);
-  var isTypeFelt = (type) => type === "felt";
-  var isTypeFeltArray = (type) => type === "felt*";
-  var isTypeArray = (type) => /\*/.test(type);
+  var isTypeFelt = (type) => type === "felt" || type === "core::felt252";
+  var isTypeArray = (type) => /\*/.test(type) || type.includes("core::array::Array::");
   var isTypeTuple = (type) => /^\(.*\)$/i.test(type);
   var isTypeNamedTuple = (type) => /\(.*\)/i.test(type) && type.includes(":");
   var isTypeStruct = (type, structs) => type in structs;
+  var isTypeUint = (type) => Object.values(Uint).includes(type);
+  var isTypeBool = (type) => type === "core::bool";
+  var isTypeContractAddress = (type) => type === "core::starknet::contract_address::ContractAddress";
+  var isCairo1Type = (type) => type.includes("core::");
+  var getArrayType = (type) => {
+    if (isCairo1Type(type)) {
+      return type.substring(type.indexOf("<") + 1, type.indexOf(">"));
+    }
+    return type.replace("*", "");
+  };
+  var uint256 = (it) => {
+    const bn = BigInt(it);
+    if (!isUint256(bn))
+      throw new Error("Number is too large");
+    return {
+      low: (bn & UINT_128_MAX).toString(10),
+      high: (bn >> 128n).toString(10)
+    };
+  };
+  var tuple = (...args) => ({ ...args });
   function felt(it) {
     if (isBigInt(it) || typeof it === "number" && Number.isInteger(it)) {
       return it.toString();
@@ -11335,6 +11384,12 @@ var starknet = (() => {
         }
       };
     }
+    parseSierraContractClassResponse(res) {
+      return {
+        ...res,
+        abi: JSON.parse(res.abi)
+      };
+    }
   };
 
   // src/utils/url.ts
@@ -11542,16 +11597,24 @@ var starknet = (() => {
     }
     async getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
       return this.fetchEndpoint("get_full_contract", { blockIdentifier, contractAddress }).then(
-        parseContract
+        (res) => {
+          if (isSierra(res)) {
+            return this.responseParser.parseSierraContractClassResponse(res);
+          }
+          return parseContract(res);
+        }
       );
     }
     async getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
       return this.fetchEndpoint("get_class_hash_at", { blockIdentifier, contractAddress });
     }
     async getClassByHash(classHash, blockIdentifier = this.blockIdentifier) {
-      return this.fetchEndpoint("get_class_by_hash", { classHash, blockIdentifier }).then(
-        parseContract
-      );
+      return this.fetchEndpoint("get_class_by_hash", { classHash, blockIdentifier }).then((res) => {
+        if (isSierra(res)) {
+          return this.responseParser.parseSierraContractClassResponse(res);
+        }
+        return parseContract(res);
+      });
     }
     async getCompiledClassByClassHash(classHash, blockIdentifier = this.blockIdentifier) {
       return this.fetchEndpoint("get_compiled_class_by_class_hash", { classHash, blockIdentifier });
@@ -11984,7 +12047,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       result
     };
   }
-  function extractTupleMemberTypes(type) {
+  function extractCairo0Tuple(type) {
     const cleanType = type.replace(/\s/g, "").slice(1, -1);
     const { subTuple, result } = parseSubTuple(cleanType);
     let recomposed = result.split(",").map((it) => {
@@ -11997,6 +12060,16 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     }
     return recomposed;
   }
+  function extractCairo1Tuple(type) {
+    const cleanType = type.replace(/\s/g, "").slice(1, -1);
+    return cleanType.split(",");
+  }
+  function extractTupleMemberTypes(type) {
+    if (isCairo1Type(type)) {
+      return extractCairo1Tuple(type);
+    }
+    return extractCairo0Tuple(type);
+  }
 
   // src/utils/calldata/requestParser.ts
   function parseTuple(element, typeStr) {
@@ -12055,16 +12128,21 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         }
         const result = [];
         result.push(felt(value.length));
+        const arrayType = getArrayType(input.type);
         return value.reduce((acc, el) => {
-          if (isTypeFeltArray(type)) {
+          if (isTypeFelt(arrayType) || isTypeUint(arrayType) || isTypeContractAddress(arrayType)) {
             acc.push(felt(el));
+          } else if (isTypeBool(arrayType) && typeof el === "boolean") {
+            acc.push(el.toString());
           } else {
-            acc.push(...parseCalldataValue(el, type.replace("*", ""), structs));
+            acc.push(...parseCalldataValue(el, arrayType, structs));
           }
           return acc;
         }, result);
       case (isTypeStruct(type, structs) || isTypeTuple(type)):
         return parseCalldataValue(value, type, structs);
+      case isTypeBool(type):
+        return value;
       default:
         return felt(value);
     }
@@ -12097,8 +12175,20 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       case isLen(name):
         temp = responseIterator.next().value;
         return BigInt(temp);
+      case isTypeBool(type):
+        temp = responseIterator.next().value;
+        return Boolean(BigInt(temp));
       case isTypeArray(type):
         const parsedDataArr = [];
+        if (isCairo1Type(type)) {
+          responseIterator.next();
+          let it = responseIterator.next();
+          while (!it.done) {
+            parsedDataArr.push(BigInt(it.value));
+            it = responseIterator.next();
+          }
+          return parsedDataArr;
+        }
         if (parsedResult && parsedResult[`${name}_len`]) {
           const arrLen = parsedResult[`${name}_len`];
           while (parsedDataArr.length < arrLen) {
@@ -12120,7 +12210,66 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   var validateFelt = (parameter, input) => {
     assert2(
       typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
-      `Validate: arg ${input.name} should be a felt (string, number, BigNumber)`
+      `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
+    );
+  };
+  var validateUint = (parameter, input) => {
+    if (typeof parameter === "number") {
+      assert2(
+        parameter <= Number.MAX_SAFE_INTEGER,
+        `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
+      );
+    }
+    assert2(
+      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
+      `Validate: arg ${input.name} of cairo type ${input.type} should be type (String, Number or BigInt)`
+    );
+    const param = toBigInt(parameter);
+    switch (input.type) {
+      case "core::integer::u8" /* u8 */:
+        assert2(
+          param >= 0n && param <= 255n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
+        );
+        break;
+      case "core::integer::u16" /* u16 */:
+        assert2(
+          param >= 0n && param <= 65535n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
+        );
+        break;
+      case "core::integer::u32" /* u32 */:
+        assert2(
+          param >= 0n && param <= 4294967295n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
+        );
+        break;
+      case "core::integer::u64" /* u64 */:
+        assert2(
+          param >= 0n && param <= 2n ** 64n - 1n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^64-1]`
+        );
+        break;
+      case "core::integer::u128" /* u128 */:
+        assert2(
+          param >= 0n && param <= 2n ** 128n - 1n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 2^128-1]`
+        );
+        break;
+      case "core::integer::u256" /* u256 */:
+        assert2(
+          param >= 0n && param <= 2n ** 256n - 1n,
+          `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
+        );
+        break;
+      default:
+        break;
+    }
+  };
+  var validateBool = (parameter, input) => {
+    assert2(
+      typeof parameter === "boolean",
+      `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
     );
   };
   var validateStruct = (parameter, input, structs) => {
@@ -12142,7 +12291,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     );
   };
   var validateArray = (parameter, input, structs) => {
-    const baseType = input.type.replace("*", "");
+    const baseType = getArrayType(input.type);
     if (isTypeFelt(baseType) && isLongText(parameter))
       return;
     assert2(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
@@ -12158,6 +12307,12 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
           (it) => validateStruct(it, { name: input.name, type: baseType }, structs)
         );
         break;
+      case isTypeUint(baseType):
+        parameter.forEach((param) => validateUint(param, input));
+        break;
+      case isTypeBool(baseType):
+        parameter.forEach((param) => validateBool(param, input));
+        break;
       default:
         throw new Error(
           `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
@@ -12173,6 +12328,14 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         case isTypeFelt(input.type):
           validateFelt(parameter, input);
           break;
+        case isTypeUint(input.type):
+          validateUint(parameter, input);
+          break;
+        case isTypeBool(input.type):
+          validateBool(parameter, input);
+          break;
+        case isTypeContractAddress(input.type):
+          break;
         case isTypeStruct(input.type, structs):
           validateStruct(parameter, input, structs);
           break;
@@ -12202,7 +12365,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         const invocableFunctionNames = this.abi.filter((abi) => {
           if (abi.type !== "function")
             return false;
-          const isView = abi.stateMutability === "view";
+          const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
           return type === "INVOKE" ? !isView : isView;
         }).map((abi) => abi.name);
         assert2(
@@ -12261,13 +12424,15 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     parse(method, response) {
       const { outputs } = this.abi.find((abi) => abi.name === method);
       const responseIterator = response.flat()[Symbol.iterator]();
-      return outputs.flat().reduce((acc, output2) => {
-        acc[output2.name] = responseParser(responseIterator, output2, this.structs, acc);
-        if (acc[output2.name] && acc[`${output2.name}_len`]) {
-          delete acc[`${output2.name}_len`];
+      const parsed = outputs.flat().reduce((acc, output2, idx) => {
+        const propName = output2.name ?? idx;
+        acc[propName] = responseParser(responseIterator, output2, this.structs, acc);
+        if (acc[propName] && acc[`${propName}_len`]) {
+          delete acc[`${propName}_len`];
         }
         return acc;
       }, {});
+      return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
     }
     format(method, response, format) {
       const parsed = this.parse(method, response);
@@ -12324,7 +12489,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     };
   }
   function buildDefault(contract, functionAbi) {
-    if (functionAbi.stateMutability === "view") {
+    if (functionAbi.stateMutability === "view" || functionAbi.state_mutability === "view") {
       return buildCall(contract, functionAbi);
     }
     return buildInvoke(contract, functionAbi);
@@ -12339,13 +12504,20 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       return contract.estimate(functionAbi.name, args);
     };
   }
+  var detectCairoVersion = (abi) => {
+    if (!abi)
+      return "0";
+    return abi.find((it) => "state_mutability" in it) ? "1" : "0";
+  };
   var Contract = class {
-    constructor(abi, address, providerOrAccount = defaultProvider) {
+    constructor(abi, address, providerOrAccount = defaultProvider, cairoVersion = detectCairoVersion(abi)) {
+      this.version = "0";
       this.address = address && address.toLowerCase();
       this.providerOrAccount = providerOrAccount;
       this.callData = new CallData(abi);
       this.structs = CallData.getAbiStruct(abi);
       this.abi = abi;
+      this.version = cairoVersion;
       const options = { enumerable: true, value: {}, writable: false };
       Object.defineProperties(this, {
         functions: { enumerable: true, value: {}, writable: false },
@@ -13194,8 +13366,8 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       return parseUDCEvent(txReceipt);
     }
     async declareAndDeploy(payload, details) {
-      const { contract, constructorCalldata, salt, unique } = payload;
-      const { transaction_hash, class_hash } = await this.declare({ contract }, details);
+      const { constructorCalldata, salt, unique } = payload;
+      const { transaction_hash, class_hash } = await this.declare(payload, details);
       const declare = await this.waitForTransaction(transaction_hash, {
         successStates: ["ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */]
       });