starknet 6.9.0 → 6.10.1

package/dist/utils/cairoDataTypes/uint512.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Singular class handling cairo u512 data type
+ */
+import { BigNumberish, type Uint512 } from '../../types';
+export declare const UINT_512_MAX: bigint;
+export declare const UINT_512_MIN = 0n;
+export declare const UINT_128_MIN = 0n;
+export declare class CairoUint512 {
+    limb0: bigint;
+    limb1: bigint;
+    limb2: bigint;
+    limb3: bigint;
+    static abiSelector: string;
+    /**
+     * Default constructor (Lib usage)
+     * @param bigNumberish BigNumberish value representing u512
+     */
+    constructor(bigNumberish: BigNumberish);
+    /**
+     * Direct props initialization (Api response)
+     */
+    constructor(limb0: BigNumberish, limb1: BigNumberish, limb2: BigNumberish, limb3: BigNumberish);
+    /**
+     * Initialization from Uint512 object
+     */
+    constructor(uint512: Uint512);
+    /**
+     * Validate if BigNumberish can be represented as Uint512
+     */
+    static validate(bigNumberish: BigNumberish): bigint;
+    /**
+     * Validate if limbs can be represented as Uint512
+     */
+    static validateProps(limb0: BigNumberish, limb1: BigNumberish, limb2: BigNumberish, limb3: BigNumberish): {
+        limb0: bigint;
+        limb1: bigint;
+        limb2: bigint;
+        limb3: bigint;
+    };
+    /**
+     * Check if BigNumberish can be represented as Uint512
+     */
+    static is(bigNumberish: BigNumberish): boolean;
+    /**
+     * Check if provided abi type is this data type
+     */
+    static isAbiType(abiType: string): boolean;
+    /**
+     * Return bigint representation
+     */
+    toBigInt(): bigint;
+    /**
+     * Return Uint512 structure with HexString props
+     * limbx: HexString
+     */
+    toUint512HexString(): {
+        limb0: string;
+        limb1: string;
+        limb2: string;
+        limb3: string;
+    };
+    /**
+     * Return Uint512 structure with DecimalString props
+     * limbx DecString
+     */
+    toUint512DecimalString(): {
+        limb0: string;
+        limb1: string;
+        limb2: string;
+        limb3: string;
+    };
+    /**
+     * Return api requests representation witch is felt array
+     */
+    toApiRequest(): string[];
+}

package/dist/utils/cairoDataTypes/uint512.mjs

@@ -0,0 +1,123 @@
+import { addHexPrefix } from "../encode.mjs";
+import { CairoFelt } from "./felt.mjs";
+import { UINT_128_MAX } from "./uint256.mjs";
+export const UINT_512_MAX = (1n << 512n) - 1n;
+export const UINT_512_MIN = 0n;
+export const UINT_128_MIN = 0n;
+export class CairoUint512 {
+  limb0;
+  limb1;
+  limb2;
+  limb3;
+  static abiSelector = "core::integer::u512";
+  constructor(...arr) {
+    if (typeof arr[0] === "object" && arr.length === 1 && "limb0" in arr[0] && "limb1" in arr[0] && "limb2" in arr[0] && "limb3" in arr[0]) {
+      const props = CairoUint512.validateProps(
+        arr[0].limb0,
+        arr[0].limb1,
+        arr[0].limb2,
+        arr[0].limb3
+      );
+      this.limb0 = props.limb0;
+      this.limb1 = props.limb1;
+      this.limb2 = props.limb2;
+      this.limb3 = props.limb3;
+    } else if (arr.length === 1) {
+      const bigInt = CairoUint512.validate(arr[0]);
+      this.limb0 = bigInt & UINT_128_MAX;
+      this.limb1 = (bigInt & UINT_128_MAX << 128n) >> 128n;
+      this.limb2 = (bigInt & UINT_128_MAX << 256n) >> 256n;
+      this.limb3 = bigInt >> 384n;
+    } else if (arr.length === 4) {
+      const props = CairoUint512.validateProps(arr[0], arr[1], arr[2], arr[3]);
+      this.limb0 = props.limb0;
+      this.limb1 = props.limb1;
+      this.limb2 = props.limb2;
+      this.limb3 = props.limb3;
+    } else {
+      throw Error("Incorrect Uint512 constructor parameters");
+    }
+  }
+  /**
+   * Validate if BigNumberish can be represented as Uint512
+   */
+  static validate(bigNumberish) {
+    const bigInt = BigInt(bigNumberish);
+    if (bigInt < UINT_512_MIN) throw Error("bigNumberish is smaller than UINT_512_MIN.");
+    if (bigInt > UINT_512_MAX) throw Error("bigNumberish is bigger than UINT_512_MAX.");
+    return bigInt;
+  }
+  /**
+   * Validate if limbs can be represented as Uint512
+   */
+  static validateProps(limb0, limb1, limb2, limb3) {
+    const l0 = BigInt(limb0);
+    const l1 = BigInt(limb1);
+    const l2 = BigInt(limb2);
+    const l3 = BigInt(limb3);
+    [l0, l1, l2, l3].forEach((value, index) => {
+      if (value < UINT_128_MIN || value > UINT_128_MAX) {
+        throw Error(`limb${index} is not in the range of a u128 number`);
+      }
+    });
+    return { limb0: l0, limb1: l1, limb2: l2, limb3: l3 };
+  }
+  /**
+   * Check if BigNumberish can be represented as Uint512
+   */
+  static is(bigNumberish) {
+    try {
+      CairoUint512.validate(bigNumberish);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Check if provided abi type is this data type
+   */
+  static isAbiType(abiType) {
+    return abiType === CairoUint512.abiSelector;
+  }
+  /**
+   * Return bigint representation
+   */
+  toBigInt() {
+    return (this.limb3 << 384n) + (this.limb2 << 256n) + (this.limb1 << 128n) + this.limb0;
+  }
+  /**
+   * Return Uint512 structure with HexString props
+   * limbx: HexString
+   */
+  toUint512HexString() {
+    return {
+      limb0: addHexPrefix(this.limb0.toString(16)),
+      limb1: addHexPrefix(this.limb1.toString(16)),
+      limb2: addHexPrefix(this.limb2.toString(16)),
+      limb3: addHexPrefix(this.limb3.toString(16))
+    };
+  }
+  /**
+   * Return Uint512 structure with DecimalString props
+   * limbx DecString
+   */
+  toUint512DecimalString() {
+    return {
+      limb0: this.limb0.toString(10),
+      limb1: this.limb1.toString(10),
+      limb2: this.limb2.toString(10),
+      limb3: this.limb3.toString(10)
+    };
+  }
+  /**
+   * Return api requests representation witch is felt array
+   */
+  toApiRequest() {
+    return [
+      CairoFelt(this.limb0),
+      CairoFelt(this.limb1),
+      CairoFelt(this.limb2),
+      CairoFelt(this.limb3)
+    ];
+  }
+}

package/dist/utils/calldata/byteArray.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.byteArrayFromString = byteArrayFromString;
+exports.stringFromByteArray = stringFromByteArray;
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+function stringFromByteArray(myByteArray) {
+  const pending_word = BigInt(myByteArray.pending_word) === 0n ? "" : (0, _shortString.decodeShortString)((0, _num.toHex)(myByteArray.pending_word));
+  return myByteArray.data.reduce((cumuledString, encodedString) => {
+    const add = BigInt(encodedString) === 0n ? "" : (0, _shortString.decodeShortString)((0, _num.toHex)(encodedString));
+    return cumuledString + add;
+  }, "") + pending_word;
+}
+function byteArrayFromString(targetString) {
+  const shortStrings = (0, _shortString.splitLongString)(targetString);
+  const remainder = shortStrings[shortStrings.length - 1];
+  const shortStringsEncoded = shortStrings.map(_shortString.encodeShortString);
+  const [pendingWord, pendingWordLength] = remainder === void 0 || remainder.length === 31 ? ["0x00", 0] : [shortStringsEncoded.pop(), remainder.length];
+  return {
+    data: shortStringsEncoded.length === 0 ? [] : shortStringsEncoded,
+    pending_word: pendingWord,
+    pending_word_len: pendingWordLength
+  };
+}

package/dist/utils/calldata/byteArray.d.ts

@@ -0,0 +1,32 @@
+import { ByteArray } from '../../types/lib';
+/**
+ * convert a Cairo ByteArray to a JS string
+ * @param myByteArray Cairo representation of a LongString
+ * @returns a JS string
+ * @example
+ * ```typescript
+ * const myByteArray = {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ * const result: String = stringFromByteArray(myByteArray); // ABCDEFGHI
+ * ```
+ */
+export declare function stringFromByteArray(myByteArray: ByteArray): string;
+/**
+ * convert a JS string to a Cairo ByteArray
+ * @param targetString a JS string
+ * @returns Cairo representation of a LongString
+ * @example
+ * ```typescript
+ * const myByteArray: ByteArray = byteArrayFromString("ABCDEFGHI");
+ * ```
+ * Result is :
+ * {
+ *    data: [],
+ *    pending_word: '0x414243444546474849',
+ *    pending_word_len: 9
+ * }
+ */
+export declare function byteArrayFromString(targetString: string): ByteArray;

package/dist/utils/calldata/byteArray.mjs

@@ -0,0 +1,20 @@
+import { toHex } from "../num.mjs";
+import { decodeShortString, encodeShortString, splitLongString } from "../shortString.mjs";
+export function stringFromByteArray(myByteArray) {
+  const pending_word = BigInt(myByteArray.pending_word) === 0n ? "" : decodeShortString(toHex(myByteArray.pending_word));
+  return myByteArray.data.reduce((cumuledString, encodedString) => {
+    const add = BigInt(encodedString) === 0n ? "" : decodeShortString(toHex(encodedString));
+    return cumuledString + add;
+  }, "") + pending_word;
+}
+export function byteArrayFromString(targetString) {
+  const shortStrings = splitLongString(targetString);
+  const remainder = shortStrings[shortStrings.length - 1];
+  const shortStringsEncoded = shortStrings.map(encodeShortString);
+  const [pendingWord, pendingWordLength] = remainder === void 0 || remainder.length === 31 ? ["0x00", 0] : [shortStringsEncoded.pop(), remainder.length];
+  return {
+    data: shortStringsEncoded.length === 0 ? [] : shortStringsEncoded,
+    pending_word: pendingWord,
+    pending_word_len: pendingWordLength
+  };
+}

package/dist/utils/calldata/cairo.cjs

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.felt = felt;
+exports.getAbiContractVersion = getAbiContractVersion;
+exports.getArrayType = void 0;
+exports.isCairo1Abi = isCairo1Abi;
+exports.isTypeNamedTuple = exports.isTypeLiteral = exports.isTypeFelt = exports.isTypeEthAddress = exports.isTypeEnum = exports.isTypeContractAddress = exports.isTypeBytes31 = exports.isTypeByteArray = exports.isTypeBool = exports.isTypeArray = exports.isLen = exports.isCairo1Type = void 0;
+exports.isTypeNonZero = isTypeNonZero;
+exports.uint512 = exports.uint256 = exports.tuple = exports.isTypeUint256 = exports.isTypeUint = exports.isTypeTuple = exports.isTypeStruct = exports.isTypeSecp256k1Point = exports.isTypeResult = exports.isTypeOption = void 0;
+var _types = require("../../types/index.cjs");
+var _felt = require("../cairoDataTypes/felt.cjs");
+var _uint = require("../cairoDataTypes/uint256.cjs");
+var _uint2 = require("../cairoDataTypes/uint512.cjs");
+const isLen = name => /_len$/.test(name);
+exports.isLen = isLen;
+const isTypeFelt = type => type === "felt" || type === "core::felt252";
+exports.isTypeFelt = isTypeFelt;
+const isTypeArray = type => /\*/.test(type) || type.startsWith("core::array::Array::") || type.startsWith("core::array::Span::");
+exports.isTypeArray = isTypeArray;
+const isTypeTuple = type => /^\(.*\)$/i.test(type);
+exports.isTypeTuple = isTypeTuple;
+const isTypeNamedTuple = type => /\(.*\)/i.test(type) && type.includes(":");
+exports.isTypeNamedTuple = isTypeNamedTuple;
+const isTypeStruct = (type, structs) => type in structs;
+exports.isTypeStruct = isTypeStruct;
+const isTypeEnum = (type, enums) => type in enums;
+exports.isTypeEnum = isTypeEnum;
+const isTypeOption = type => type.startsWith("core::option::Option::");
+exports.isTypeOption = isTypeOption;
+const isTypeResult = type => type.startsWith("core::result::Result::");
+exports.isTypeResult = isTypeResult;
+const isTypeUint = type => Object.values(_types.Uint).includes(type);
+exports.isTypeUint = isTypeUint;
+const isTypeUint256 = type => _uint.CairoUint256.isAbiType(type);
+exports.isTypeUint256 = isTypeUint256;
+const isTypeLiteral = type => Object.values(_types.Literal).includes(type);
+exports.isTypeLiteral = isTypeLiteral;
+const isTypeBool = type => type === "core::bool";
+exports.isTypeBool = isTypeBool;
+const isTypeContractAddress = type => type === "core::starknet::contract_address::ContractAddress";
+exports.isTypeContractAddress = isTypeContractAddress;
+const isTypeEthAddress = type => type === "core::starknet::eth_address::EthAddress";
+exports.isTypeEthAddress = isTypeEthAddress;
+const isTypeBytes31 = type => type === "core::bytes_31::bytes31";
+exports.isTypeBytes31 = isTypeBytes31;
+const isTypeByteArray = type => type === "core::byte_array::ByteArray";
+exports.isTypeByteArray = isTypeByteArray;
+const isTypeSecp256k1Point = type => type === "core::starknet::secp256k1::Secp256k1Point";
+exports.isTypeSecp256k1Point = isTypeSecp256k1Point;
+const isCairo1Type = type => type.includes("::");
+exports.isCairo1Type = isCairo1Type;
+const getArrayType = type => {
+  if (isCairo1Type(type)) {
+    return type.substring(type.indexOf("<") + 1, type.lastIndexOf(">"));
+  }
+  return type.replace("*", "");
+};
+exports.getArrayType = getArrayType;
+function isCairo1Abi(abi) {
+  const {
+    cairo
+  } = getAbiContractVersion(abi);
+  if (cairo === void 0) {
+    throw Error("Unable to determine Cairo version");
+  }
+  return cairo === "1";
+}
+function isTypeNonZero(type) {
+  return type.startsWith("core::zeroable::NonZero::");
+}
+function getAbiContractVersion(abi) {
+  if (abi.find(it => it.type === "interface")) {
+    return {
+      cairo: "1",
+      compiler: "2"
+    };
+  }
+  const testFunction = abi.find(it => it.type === "function" && (it.inputs.length || it.outputs.length));
+  if (!testFunction) {
+    return {
+      cairo: void 0,
+      compiler: void 0
+    };
+  }
+  const io = testFunction.inputs.length ? testFunction.inputs : testFunction.outputs;
+  if (isCairo1Type(io[0].type)) {
+    return {
+      cairo: "1",
+      compiler: "1"
+    };
+  }
+  return {
+    cairo: "0",
+    compiler: "0"
+  };
+}
+const uint256 = it => {
+  return new _uint.CairoUint256(it).toUint256DecimalString();
+};
+exports.uint256 = uint256;
+const uint512 = it => {
+  return new _uint2.CairoUint512(it).toUint512DecimalString();
+};
+exports.uint512 = uint512;
+const tuple = (...args) => ({
+  ...args
+});
+exports.tuple = tuple;
+function felt(it) {
+  return (0, _felt.CairoFelt)(it);
+}

package/dist/utils/calldata/cairo.d.ts

@@ -0,0 +1,196 @@
+import { Abi, AbiEnums, AbiStructs, BigNumberish, ContractVersion, Uint256, Uint512 } from '../../types';
+/**
+ * Checks if the given name ends with "_len".
+ *
+ * @param {string} name - The name to be checked.
+ * @returns - True if the name ends with "_len", false otherwise.
+ */
+export declare const isLen: (name: string) => boolean;
+/**
+ * Checks if a given type is felt.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is felt, false otherwise.
+ */
+export declare const isTypeFelt: (type: string) => boolean;
+/**
+ * Checks if the given type is an array type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - `true` if the type is an array type, `false` otherwise.
+ */
+export declare const isTypeArray: (type: string) => boolean;
+/**
+ * Checks if the given type is a tuple type.
+ *
+ * @param {string} type - The type to be checked.
+ * @returns - `true` if the type is a tuple type, otherwise `false`.
+ */
+export declare const isTypeTuple: (type: string) => boolean;
+/**
+ * Checks whether a given type is a named tuple.
+ *
+ * @param {string} type - The type to be checked.
+ * @returns - True if the type is a named tuple, false otherwise.
+ */
+export declare const isTypeNamedTuple: (type: string) => boolean;
+/**
+ * Checks if a given type is a struct.
+ *
+ * @param {string} type - The type to check for existence.
+ * @param {AbiStructs} structs - The collection of structs to search in.
+ * @returns - True if the type exists in the structs, false otherwise.
+ */
+export declare const isTypeStruct: (type: string, structs: AbiStructs) => boolean;
+/**
+ * Checks if a given type is an enum.
+ *
+ * @param {string} type - The type to check.
+ * @param {AbiEnums} enums - The enumeration to search in.
+ * @returns - True if the type exists in the enumeration, otherwise false.
+ */
+export declare const isTypeEnum: (type: string, enums: AbiEnums) => boolean;
+/**
+ * Determines if the given type is an Option type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is an Option type, false otherwise.
+ */
+export declare const isTypeOption: (type: string) => boolean;
+/**
+ * Checks whether a given type starts with 'core::result::Result::'.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type starts with 'core::result::Result::', false otherwise.
+ */
+export declare const isTypeResult: (type: string) => boolean;
+/**
+ * Checks if the given value is a valid Uint type.
+ *
+ * @param {string} type - The value to check.
+ * @returns - Returns true if the value is a valid Uint type, otherwise false.
+ */
+export declare const isTypeUint: (type: string) => boolean;
+/**
+ * Checks if the given type is `uint256`.
+ *
+ * @param {string} type - The type to be checked.
+ * @returns - Returns true if the type is `uint256`, otherwise false.
+ */
+export declare const isTypeUint256: (type: string) => boolean;
+/**
+ * Checks if the given type is a literal type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is a literal type, false otherwise.
+ */
+export declare const isTypeLiteral: (type: string) => boolean;
+/**
+ * Checks if the given type is a boolean type.
+ *
+ * @param {string} type - The type to be checked.
+ * @returns - Returns true if the type is a boolean type, otherwise false.
+ */
+export declare const isTypeBool: (type: string) => boolean;
+/**
+ * Checks if the provided type is equal to 'core::starknet::contract_address::ContractAddress'.
+ * @param {string} type - The type to be checked.
+ * @returns - true if the type matches 'core::starknet::contract_address::ContractAddress', false otherwise.
+ */
+export declare const isTypeContractAddress: (type: string) => boolean;
+/**
+ * Determines if the given type is an Ethereum address type.
+ *
+ * @param {string} type - The type to check.
+ * @returns - Returns true if the given type is 'core::starknet::eth_address::EthAddress', otherwise false.
+ */
+export declare const isTypeEthAddress: (type: string) => boolean;
+/**
+ * Checks if the given type is 'core::bytes_31::bytes31'.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the type is 'core::bytes_31::bytes31', false otherwise.
+ */
+export declare const isTypeBytes31: (type: string) => boolean;
+/**
+ * Checks if the given type is equal to the 'core::byte_array::ByteArray'.
+ *
+ * @param {string} type - The type to check.
+ * @returns - True if the given type is equal to 'core::byte_array::ByteArray', false otherwise.
+ */
+export declare const isTypeByteArray: (type: string) => boolean;
+export declare const isTypeSecp256k1Point: (type: string) => boolean;
+export declare const isCairo1Type: (type: string) => boolean;
+/**
+ * Retrieves the array type from the given type string.
+ *
+ * Works also for core::zeroable::NonZero type.
+ * @param {string} type - The type string.
+ * @returns - The array type.
+ */
+export declare const getArrayType: (type: string) => string;
+/**
+ * Test if an ABI comes from a Cairo 1 contract
+ * @param abi representing the interface of a Cairo contract
+ * @returns TRUE if it is an ABI from a Cairo1 contract
+ * @example
+ * ```typescript
+ * const isCairo1: boolean = isCairo1Abi(myAbi: Abi);
+ * ```
+ */
+export declare function isCairo1Abi(abi: Abi): boolean;
+/**
+ * Checks if the given type is a NonZero type.
+ *
+ * @param {string} type The type to check.
+ * @returns `true` if the type is NonZero type, `false` otherwise.
+ * @example
+ * ```typescript
+ * const result = cairo.isTypeNonZero("core::zeroable::NonZero::<u8>");
+ * //result = true
+ * ```
+ */
+export declare function isTypeNonZero(type: string): boolean;
+/**
+ * Return ContractVersion (Abi version) based on Abi
+ * or undefined for unknown version
+ * @param abi
+ * @returns string
+ */
+export declare function getAbiContractVersion(abi: Abi): ContractVersion;
+/**
+ * named tuple cairo type is described as js object {}
+ * struct cairo type are described as js object {}
+ * array cairo type are described as js array []
+ */
+/**
+ * Create Uint256 Cairo type (helper for common struct type)
+ * @example
+ * ```typescript
+ * uint256('892349863487563453485768723498');
+ * ```
+ */
+export declare const uint256: (it: BigNumberish) => Uint256;
+/**
+ * Create Uint512 Cairo type (helper for common struct type)
+ * @param it BigNumberish representation of a 512 bits unsigned number
+ * @returns Uint512 struct
+ * @example
+ * ```typescript
+ * uint512('345745685892349863487563453485768723498');
+ * ```
+ */
+export declare const uint512: (it: BigNumberish) => Uint512;
+/**
+ * Create unnamed tuple Cairo type (helper same as common struct type)
+ * @example
+ * ```typescript
+ * tuple(1, '0x101', 16);
+ * ```
+ */
+export declare const tuple: (...args: (BigNumberish | object | boolean)[]) => Record<number, BigNumberish | object | boolean>;
+/**
+ * Create felt Cairo type (cairo type helper)
+ * @returns format: felt-string
+ */
+export declare function felt(it: BigNumberish): string;

package/dist/utils/calldata/cairo.mjs

@@ -0,0 +1,68 @@
+import {
+  Literal,
+  Uint
+} from "../../types/index.mjs";
+import { CairoFelt } from "../cairoDataTypes/felt.mjs";
+import { CairoUint256 } from "../cairoDataTypes/uint256.mjs";
+import { CairoUint512 } from "../cairoDataTypes/uint512.mjs";
+export const isLen = (name) => /_len$/.test(name);
+export const isTypeFelt = (type) => type === "felt" || type === "core::felt252";
+export const isTypeArray = (type) => /\*/.test(type) || type.startsWith("core::array::Array::") || type.startsWith("core::array::Span::");
+export const isTypeTuple = (type) => /^\(.*\)$/i.test(type);
+export const isTypeNamedTuple = (type) => /\(.*\)/i.test(type) && type.includes(":");
+export const isTypeStruct = (type, structs) => type in structs;
+export const isTypeEnum = (type, enums) => type in enums;
+export const isTypeOption = (type) => type.startsWith("core::option::Option::");
+export const isTypeResult = (type) => type.startsWith("core::result::Result::");
+export const isTypeUint = (type) => Object.values(Uint).includes(type);
+export const isTypeUint256 = (type) => CairoUint256.isAbiType(type);
+export const isTypeLiteral = (type) => Object.values(Literal).includes(type);
+export const isTypeBool = (type) => type === "core::bool";
+export const isTypeContractAddress = (type) => type === "core::starknet::contract_address::ContractAddress";
+export const isTypeEthAddress = (type) => type === "core::starknet::eth_address::EthAddress";
+export const isTypeBytes31 = (type) => type === "core::bytes_31::bytes31";
+export const isTypeByteArray = (type) => type === "core::byte_array::ByteArray";
+export const isTypeSecp256k1Point = (type) => type === "core::starknet::secp256k1::Secp256k1Point";
+export const isCairo1Type = (type) => type.includes("::");
+export const getArrayType = (type) => {
+  if (isCairo1Type(type)) {
+    return type.substring(type.indexOf("<") + 1, type.lastIndexOf(">"));
+  }
+  return type.replace("*", "");
+};
+export function isCairo1Abi(abi) {
+  const { cairo } = getAbiContractVersion(abi);
+  if (cairo === void 0) {
+    throw Error("Unable to determine Cairo version");
+  }
+  return cairo === "1";
+}
+export function isTypeNonZero(type) {
+  return type.startsWith("core::zeroable::NonZero::");
+}
+export function getAbiContractVersion(abi) {
+  if (abi.find((it) => it.type === "interface")) {
+    return { cairo: "1", compiler: "2" };
+  }
+  const testFunction = abi.find(
+    (it) => it.type === "function" && (it.inputs.length || it.outputs.length)
+  );
+  if (!testFunction) {
+    return { cairo: void 0, compiler: void 0 };
+  }
+  const io = testFunction.inputs.length ? testFunction.inputs : testFunction.outputs;
+  if (isCairo1Type(io[0].type)) {
+    return { cairo: "1", compiler: "1" };
+  }
+  return { cairo: "0", compiler: "0" };
+}
+export const uint256 = (it) => {
+  return new CairoUint256(it).toUint256DecimalString();
+};
+export const uint512 = (it) => {
+  return new CairoUint512(it).toUint512DecimalString();
+};
+export const tuple = (...args) => ({ ...args });
+export function felt(it) {
+  return CairoFelt(it);
+}