starknet 5.9.2 → 5.10.1

package/dist/index.global.js

@@ -702,492 +702,821 @@ var starknet = (() => {
     }
   }
 
-  // src/utils/hash.ts
-  var hash_exports = {};
-  __export(hash_exports, {
-    calculateContractAddressFromHash: () => calculateContractAddressFromHash,
-    calculateDeclareTransactionHash: () => calculateDeclareTransactionHash,
-    calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash,
-    calculateDeployTransactionHash: () => calculateDeployTransactionHash,
-    calculateTransactionHash: () => calculateTransactionHash,
-    calculateTransactionHashCommon: () => calculateTransactionHashCommon,
-    computeCompiledClassHash: () => computeCompiledClassHash,
-    computeContractClassHash: () => computeContractClassHash,
-    computeHashOnElements: () => computeHashOnElements2,
-    computeLegacyContractClassHash: () => computeLegacyContractClassHash,
-    computeSierraContractClassHash: () => computeSierraContractClassHash,
-    default: () => computeHintedClassHash,
-    feeTransactionVersion: () => feeTransactionVersion,
-    formatSpaces: () => formatSpaces,
-    getSelector: () => getSelector,
-    getSelectorFromName: () => getSelectorFromName,
-    keccakBn: () => keccakBn,
-    poseidon: () => poseidon_exports,
-    starknetKeccak: () => starknetKeccak,
-    transactionVersion: () => transactionVersion,
-    transactionVersion_2: () => transactionVersion_2
+  // src/utils/num.ts
+  var num_exports = {};
+  __export(num_exports, {
+    assertInRange: () => assertInRange,
+    bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
+    bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
+    cleanHex: () => cleanHex,
+    getDecimalString: () => getDecimalString,
+    getHexString: () => getHexString,
+    getHexStringArray: () => getHexStringArray,
+    hexToBytes: () => hexToBytes2,
+    hexToDecimalString: () => hexToDecimalString,
+    isBigInt: () => isBigInt,
+    isHex: () => isHex,
+    isStringWholeNumber: () => isStringWholeNumber,
+    toBigInt: () => toBigInt,
+    toCairoBool: () => toCairoBool,
+    toHex: () => toHex,
+    toHexString: () => toHexString
   });
 
-  // node_modules/micro-starknet/lib/esm/index.js
-  var esm_exports = {};
-  __export(esm_exports, {
-    CURVE: () => CURVE,
-    Fp251: () => Fp251,
-    Fp253: () => Fp253,
-    ProjectivePoint: () => ProjectivePoint,
-    Signature: () => Signature,
-    _poseidonMDS: () => _poseidonMDS,
-    _starkCurve: () => _starkCurve,
-    computeHashOnElements: () => computeHashOnElements,
-    ethSigToPrivate: () => ethSigToPrivate,
-    getAccountPath: () => getAccountPath,
-    getPublicKey: () => getPublicKey,
-    getSharedSecret: () => getSharedSecret,
-    getStarkKey: () => getStarkKey,
-    grindKey: () => grindKey,
-    hashChain: () => hashChain,
-    keccak: () => keccak,
-    pedersen: () => pedersen,
-    poseidonBasic: () => poseidonBasic,
-    poseidonCreate: () => poseidonCreate,
-    poseidonHash: () => poseidonHash,
-    poseidonHashFunc: () => poseidonHashFunc,
-    poseidonHashMany: () => poseidonHashMany,
-    poseidonHashSingle: () => poseidonHashSingle,
-    poseidonSmall: () => poseidonSmall,
-    sign: () => sign,
-    utils: () => utils,
-    verify: () => verify
+  // node_modules/@noble/curves/esm/abstract/utils.js
+  var utils_exports = {};
+  __export(utils_exports, {
+    bitGet: () => bitGet,
+    bitLen: () => bitLen,
+    bitMask: () => bitMask,
+    bitSet: () => bitSet,
+    bytesToHex: () => bytesToHex,
+    bytesToNumberBE: () => bytesToNumberBE,
+    bytesToNumberLE: () => bytesToNumberLE,
+    concatBytes: () => concatBytes,
+    createHmacDrbg: () => createHmacDrbg,
+    ensureBytes: () => ensureBytes,
+    equalBytes: () => equalBytes,
+    hexToBytes: () => hexToBytes,
+    hexToNumber: () => hexToNumber,
+    numberToBytesBE: () => numberToBytesBE,
+    numberToBytesLE: () => numberToBytesLE,
+    numberToHexUnpadded: () => numberToHexUnpadded,
+    numberToVarBytesBE: () => numberToVarBytesBE,
+    utf8ToBytes: () => utf8ToBytes,
+    validateObject: () => validateObject
   });
-
-  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_assert.js
-  function number(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-      throw new Error(`Wrong positive integer: ${n}`);
+  var _0n = BigInt(0);
+  var _1n = BigInt(1);
+  var _2n = BigInt(2);
+  var u8a = (a) => a instanceof Uint8Array;
+  var hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex(bytes2) {
+    if (!u8a(bytes2))
+      throw new Error("Uint8Array expected");
+    let hex = "";
+    for (let i = 0; i < bytes2.length; i++) {
+      hex += hexes[bytes2[i]];
+    }
+    return hex;
   }
-  function bool(b) {
-    if (typeof b !== "boolean")
-      throw new Error(`Expected boolean, not ${b}`);
+  function numberToHexUnpadded(num) {
+    const hex = num.toString(16);
+    return hex.length & 1 ? `0${hex}` : hex;
   }
-  function bytes(b, ...lengths) {
-    if (!(b instanceof Uint8Array))
-      throw new TypeError("Expected Uint8Array");
-    if (lengths.length > 0 && !lengths.includes(b.length))
-      throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+  function hexToNumber(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    return BigInt(hex === "" ? "0" : `0x${hex}`);
   }
-  function hash(hash2) {
-    if (typeof hash2 !== "function" || typeof hash2.create !== "function")
-      throw new Error("Hash should be wrapped by utils.wrapConstructor");
-    number(hash2.outputLen);
-    number(hash2.blockLen);
+  function hexToBytes(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    if (hex.length % 2)
+      throw new Error("hex string is invalid: unpadded " + hex.length);
+    const array = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < array.length; i++) {
+      const j = i * 2;
+      const hexByte = hex.slice(j, j + 2);
+      const byte = Number.parseInt(hexByte, 16);
+      if (Number.isNaN(byte) || byte < 0)
+        throw new Error("invalid byte sequence");
+      array[i] = byte;
+    }
+    return array;
   }
-  function exists(instance, checkFinished = true) {
-    if (instance.destroyed)
-      throw new Error("Hash instance has been destroyed");
-    if (checkFinished && instance.finished)
-      throw new Error("Hash#digest() has already been called");
+  function bytesToNumberBE(bytes2) {
+    return hexToNumber(bytesToHex(bytes2));
   }
-  function output(out, instance) {
-    bytes(out);
-    const min = instance.outputLen;
-    if (out.length < min) {
-      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+  function bytesToNumberLE(bytes2) {
+    if (!u8a(bytes2))
+      throw new Error("Uint8Array expected");
+    return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
+  }
+  var numberToBytesBE = (n, len) => hexToBytes(n.toString(16).padStart(len * 2, "0"));
+  var numberToBytesLE = (n, len) => numberToBytesBE(n, len).reverse();
+  var numberToVarBytesBE = (n) => hexToBytes(numberToHexUnpadded(n));
+  function ensureBytes(title, hex, expectedLength) {
+    let res;
+    if (typeof hex === "string") {
+      try {
+        res = hexToBytes(hex);
+      } catch (e) {
+        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+      }
+    } else if (u8a(hex)) {
+      res = Uint8Array.from(hex);
+    } else {
+      throw new Error(`${title} must be hex string or Uint8Array`);
     }
+    const len = res.length;
+    if (typeof expectedLength === "number" && len !== expectedLength)
+      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+    return res;
   }
-  var assert2 = {
-    number,
-    bool,
-    bytes,
-    hash,
-    exists,
-    output
-  };
-  var assert_default = assert2;
-
-  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_u64.js
-  var U32_MASK64 = BigInt(2 ** 32 - 1);
-  var _32n = BigInt(32);
-  function fromBig(n, le = false) {
-    if (le)
-      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
-    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+  function concatBytes(...arrs) {
+    const r = new Uint8Array(arrs.reduce((sum, a) => sum + a.length, 0));
+    let pad = 0;
+    arrs.forEach((a) => {
+      if (!u8a(a))
+        throw new Error("Uint8Array expected");
+      r.set(a, pad);
+      pad += a.length;
+    });
+    return r;
   }
-  function split(lst, le = false) {
-    let Ah = new Uint32Array(lst.length);
-    let Al = new Uint32Array(lst.length);
-    for (let i = 0; i < lst.length; i++) {
-      const { h, l } = fromBig(lst[i], le);
-      [Ah[i], Al[i]] = [h, l];
+  function equalBytes(b1, b2) {
+    if (b1.length !== b2.length)
+      return false;
+    for (let i = 0; i < b1.length; i++)
+      if (b1[i] !== b2[i])
+        return false;
+    return true;
+  }
+  function utf8ToBytes(str) {
+    if (typeof str !== "string") {
+      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     }
-    return [Ah, Al];
+    return new TextEncoder().encode(str);
   }
-  var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
-  var shrSH = (h, l, s) => h >>> s;
-  var shrSL = (h, l, s) => h << 32 - s | l >>> s;
-  var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
-  var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
-  var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
-  var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
-  var rotr32H = (h, l) => l;
-  var rotr32L = (h, l) => h;
-  var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
-  var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
-  var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
-  var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
-  function add(Ah, Al, Bh, Bl) {
-    const l = (Al >>> 0) + (Bl >>> 0);
-    return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+  function bitLen(n) {
+    let len;
+    for (len = 0; n > 0n; n >>= _1n, len += 1)
+      ;
+    return len;
   }
-  var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
-  var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
-  var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
-  var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
-  var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
-  var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
-  var u64 = {
-    fromBig,
-    split,
-    toBig,
-    shrSH,
-    shrSL,
-    rotrSH,
-    rotrSL,
-    rotrBH,
-    rotrBL,
-    rotr32H,
-    rotr32L,
-    rotlSH,
-    rotlSL,
-    rotlBH,
-    rotlBL,
-    add,
-    add3L,
-    add3H,
-    add4L,
-    add4H,
-    add5H,
-    add5L
+  var bitGet = (n, pos) => n >> BigInt(pos) & 1n;
+  var bitSet = (n, pos, value) => n | (value ? _1n : _0n) << BigInt(pos);
+  var bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;
+  var u8n = (data) => new Uint8Array(data);
+  var u8fr = (arr) => Uint8Array.from(arr);
+  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+    if (typeof hashLen !== "number" || hashLen < 2)
+      throw new Error("hashLen must be a number");
+    if (typeof qByteLen !== "number" || qByteLen < 2)
+      throw new Error("qByteLen must be a number");
+    if (typeof hmacFn !== "function")
+      throw new Error("hmacFn must be a function");
+    let v = u8n(hashLen);
+    let k = u8n(hashLen);
+    let i = 0;
+    const reset = () => {
+      v.fill(1);
+      k.fill(0);
+      i = 0;
+    };
+    const h = (...b) => hmacFn(k, v, ...b);
+    const reseed = (seed = u8n()) => {
+      k = h(u8fr([0]), seed);
+      v = h();
+      if (seed.length === 0)
+        return;
+      k = h(u8fr([1]), seed);
+      v = h();
+    };
+    const gen2 = () => {
+      if (i++ >= 1e3)
+        throw new Error("drbg: tried 1000 values");
+      let len = 0;
+      const out = [];
+      while (len < qByteLen) {
+        v = h();
+        const sl = v.slice();
+        out.push(sl);
+        len += v.length;
+      }
+      return concatBytes(...out);
+    };
+    const genUntil = (seed, pred) => {
+      reset();
+      reseed(seed);
+      let res = void 0;
+      while (!(res = pred(gen2())))
+        reseed();
+      reset();
+      return res;
+    };
+    return genUntil;
+  }
+  var validatorFns = {
+    bigint: (val) => typeof val === "bigint",
+    function: (val) => typeof val === "function",
+    boolean: (val) => typeof val === "boolean",
+    string: (val) => typeof val === "string",
+    isSafeInteger: (val) => Number.isSafeInteger(val),
+    array: (val) => Array.isArray(val),
+    field: (val, object) => object.Fp.isValid(val),
+    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
   };
-  var u64_default = u64;
-
-  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/crypto.js
-  var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+  function validateObject(object, validators, optValidators = {}) {
+    const checkField = (fieldName, type, isOptional) => {
+      const checkVal = validatorFns[type];
+      if (typeof checkVal !== "function")
+        throw new Error(`Invalid validator "${type}", expected function`);
+      const val = object[fieldName];
+      if (isOptional && val === void 0)
+        return;
+      if (!checkVal(val, object)) {
+        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
+      }
+    };
+    for (const [fieldName, type] of Object.entries(validators))
+      checkField(fieldName, type, false);
+    for (const [fieldName, type] of Object.entries(optValidators))
+      checkField(fieldName, type, true);
+    return object;
+  }
 
-  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/utils.js
-  var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-  var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-  var rotr = (word, shift) => word << 32 - shift | word >>> shift;
-  var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-  if (!isLE)
-    throw new Error("Non little-endian hardware is not supported");
-  var hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-  function utf8ToBytes(str) {
-    if (typeof str !== "string") {
-      throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
-    }
-    return new TextEncoder().encode(str);
+  // src/utils/encode.ts
+  var encode_exports = {};
+  __export(encode_exports, {
+    IS_BROWSER: () => IS_BROWSER,
+    addHexPrefix: () => addHexPrefix,
+    arrayBufferToString: () => arrayBufferToString,
+    btoaUniversal: () => btoaUniversal,
+    buf2hex: () => buf2hex,
+    calcByteLength: () => calcByteLength,
+    padLeft: () => padLeft,
+    removeHexPrefix: () => removeHexPrefix,
+    sanitizeBytes: () => sanitizeBytes,
+    sanitizeHex: () => sanitizeHex,
+    utf8ToArray: () => utf8ToArray
+  });
+  var IS_BROWSER = typeof window !== "undefined";
+  var STRING_ZERO = "0";
+  function arrayBufferToString(array) {
+    return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), "");
   }
-  function toBytes(data) {
-    if (typeof data === "string")
-      data = utf8ToBytes(data);
-    if (!(data instanceof Uint8Array))
-      throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
-    return data;
+  function btoaUniversal(b) {
+    return IS_BROWSER ? btoa(arrayBufferToString(b)) : Buffer.from(b).toString("base64");
   }
-  function concatBytes(...arrays) {
-    if (!arrays.every((a) => a instanceof Uint8Array))
-      throw new Error("Uint8Array list expected");
-    if (arrays.length === 1)
-      return arrays[0];
-    const length = arrays.reduce((a, arr) => a + arr.length, 0);
-    const result = new Uint8Array(length);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-      const arr = arrays[i];
-      result.set(arr, pad);
-      pad += arr.length;
+  function buf2hex(buffer) {
+    return [...buffer].map((x) => x.toString(16).padStart(2, "0")).join("");
+  }
+  function removeHexPrefix(hex) {
+    return hex.replace(/^0x/i, "");
+  }
+  function addHexPrefix(hex) {
+    return `0x${removeHexPrefix(hex)}`;
+  }
+  function padString(str, length, left, padding = STRING_ZERO) {
+    const diff = length - str.length;
+    let result = str;
+    if (diff > 0) {
+      const pad = padding.repeat(diff);
+      result = left ? pad + str : str + pad;
     }
     return result;
   }
-  var Hash = class {
-    clone() {
-      return this._cloneInto();
-    }
-  };
-  function wrapConstructor(hashConstructor) {
-    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
-    const tmp = hashConstructor();
-    hashC.outputLen = tmp.outputLen;
-    hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashConstructor();
-    return hashC;
+  function padLeft(str, length, padding = STRING_ZERO) {
+    return padString(str, length, true, padding);
   }
-  function wrapConstructorWithOpts(hashCons) {
-    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
-    const tmp = hashCons({});
-    hashC.outputLen = tmp.outputLen;
-    hashC.blockLen = tmp.blockLen;
-    hashC.create = (opts) => hashCons(opts);
-    return hashC;
+  function calcByteLength(length, byteSize = 8) {
+    const remainder = length % byteSize;
+    return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
   }
-  function randomBytes(bytesLength = 32) {
-    if (crypto && typeof crypto.getRandomValues === "function") {
-      return crypto.getRandomValues(new Uint8Array(bytesLength));
+  function sanitizeBytes(str, byteSize = 8, padding = STRING_ZERO) {
+    return padLeft(str, calcByteLength(str.length, byteSize), padding);
+  }
+  function sanitizeHex(hex) {
+    hex = removeHexPrefix(hex);
+    hex = sanitizeBytes(hex, 2);
+    if (hex) {
+      hex = addHexPrefix(hex);
     }
-    throw new Error("crypto.getRandomValues must be defined");
+    return hex;
+  }
+  function utf8ToArray(str) {
+    return new TextEncoder().encode(str);
   }
 
-  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/sha3.js
-  var [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
-  var _0n = BigInt(0);
-  var _1n = BigInt(1);
-  var _2n = BigInt(2);
-  var _7n = BigInt(7);
-  var _256n = BigInt(256);
-  var _0x71n = BigInt(113);
-  for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
-    [x, y] = [y, (2 * x + 3 * y) % 5];
-    SHA3_PI.push(2 * (5 * y + x));
-    SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
-    let t = _0n;
-    for (let j = 0; j < 7; j++) {
-      R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
-      if (R & _2n)
-        t ^= _1n << (_1n << BigInt(j)) - _1n;
-    }
-    _SHA3_IOTA.push(t);
+  // src/utils/num.ts
+  function isHex(hex) {
+    return /^0x[0-9a-f]*$/i.test(hex);
   }
-  var [SHA3_IOTA_H, SHA3_IOTA_L] = u64_default.split(_SHA3_IOTA, true);
-  var rotlH = (h, l, s) => s > 32 ? u64_default.rotlBH(h, l, s) : u64_default.rotlSH(h, l, s);
-  var rotlL = (h, l, s) => s > 32 ? u64_default.rotlBL(h, l, s) : u64_default.rotlSL(h, l, s);
-  function keccakP(s, rounds = 24) {
-    const B = new Uint32Array(5 * 2);
-    for (let round = 24 - rounds; round < 24; round++) {
-      for (let x = 0; x < 10; x++)
-        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-      for (let x = 0; x < 10; x += 2) {
-        const idx1 = (x + 8) % 10;
-        const idx0 = (x + 2) % 10;
-        const B0 = B[idx0];
-        const B1 = B[idx0 + 1];
-        const Th = rotlH(B0, B1, 1) ^ B[idx1];
-        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
-        for (let y = 0; y < 50; y += 10) {
-          s[x + y] ^= Th;
-          s[x + y + 1] ^= Tl;
-        }
-      }
-      let curH = s[2];
-      let curL = s[3];
-      for (let t = 0; t < 24; t++) {
-        const shift = SHA3_ROTL[t];
-        const Th = rotlH(curH, curL, shift);
-        const Tl = rotlL(curH, curL, shift);
-        const PI = SHA3_PI[t];
-        curH = s[PI];
-        curL = s[PI + 1];
-        s[PI] = Th;
-        s[PI + 1] = Tl;
-      }
-      for (let y = 0; y < 50; y += 10) {
-        for (let x = 0; x < 10; x++)
-          B[x] = s[y + x];
-        for (let x = 0; x < 10; x++)
-          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
-      }
-      s[0] ^= SHA3_IOTA_H[round];
-      s[1] ^= SHA3_IOTA_L[round];
-    }
-    B.fill(0);
+  function toBigInt(value) {
+    return BigInt(value);
   }
-  var Keccak = class extends Hash {
-    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-      super();
-      this.blockLen = blockLen;
-      this.suffix = suffix;
-      this.outputLen = outputLen;
-      this.enableXOF = enableXOF;
-      this.rounds = rounds;
-      this.pos = 0;
-      this.posOut = 0;
-      this.finished = false;
-      this.destroyed = false;
-      assert_default.number(outputLen);
-      if (0 >= this.blockLen || this.blockLen >= 200)
-        throw new Error("Sha3 supports only keccak-f1600 function");
-      this.state = new Uint8Array(200);
-      this.state32 = u32(this.state);
-    }
-    keccak() {
-      keccakP(this.state32, this.rounds);
-      this.posOut = 0;
-      this.pos = 0;
-    }
-    update(data) {
-      assert_default.exists(this);
-      const { blockLen, state } = this;
-      data = toBytes(data);
-      const len = data.length;
-      for (let pos = 0; pos < len; ) {
-        const take = Math.min(blockLen - this.pos, len - pos);
-        for (let i = 0; i < take; i++)
-          state[this.pos++] ^= data[pos++];
-        if (this.pos === blockLen)
-          this.keccak();
-      }
-      return this;
-    }
-    finish() {
-      if (this.finished)
-        return;
-      this.finished = true;
-      const { state, suffix, pos, blockLen } = this;
-      state[pos] ^= suffix;
-      if ((suffix & 128) !== 0 && pos === blockLen - 1)
-        this.keccak();
-      state[blockLen - 1] ^= 128;
-      this.keccak();
-    }
-    writeInto(out) {
-      assert_default.exists(this, false);
-      assert_default.bytes(out);
-      this.finish();
-      const bufferOut = this.state;
-      const { blockLen } = this;
-      for (let pos = 0, len = out.length; pos < len; ) {
-        if (this.posOut >= blockLen)
-          this.keccak();
-        const take = Math.min(blockLen - this.posOut, len - pos);
-        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
-        this.posOut += take;
-        pos += take;
-      }
-      return out;
-    }
-    xofInto(out) {
-      if (!this.enableXOF)
-        throw new Error("XOF is not possible for this instance");
-      return this.writeInto(out);
+  function isBigInt(value) {
+    return typeof value === "bigint";
+  }
+  function toHex(number3) {
+    return addHexPrefix(toBigInt(number3).toString(16));
+  }
+  function hexToDecimalString(hex) {
+    return BigInt(addHexPrefix(hex)).toString(10);
+  }
+  var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
+  function assertInRange(input, lowerBound, upperBound, inputName = "") {
+    const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
+    const inputBigInt = BigInt(input);
+    const lowerBoundBigInt = BigInt(lowerBound);
+    const upperBoundBigInt = BigInt(upperBound);
+    assert(
+      inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
+      `Message not signable, ${messageSuffix}.`
+    );
+  }
+  function bigNumberishArrayToDecimalStringArray(rawCalldata) {
+    return rawCalldata.map((x) => toBigInt(x).toString(10));
+  }
+  function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
+    return rawCalldata.map((x) => toHex(x));
+  }
+  var isStringWholeNumber = (value) => /^\d+$/.test(value);
+  var toHexString = (value) => toHex(value);
+  function getDecimalString(value) {
+    if (isHex(value)) {
+      return hexToDecimalString(value);
     }
-    xof(bytes2) {
-      assert_default.number(bytes2);
-      return this.xofInto(new Uint8Array(bytes2));
+    if (isStringWholeNumber(value)) {
+      return value;
     }
-    digestInto(out) {
-      assert_default.output(out, this);
-      if (this.finished)
-        throw new Error("digest() was already called");
-      this.writeInto(out);
-      this.destroy();
-      return out;
+    throw new Error(`${value} need to be hex-string or whole-number-string`);
+  }
+  function getHexString(value) {
+    if (isHex(value)) {
+      return value;
     }
-    digest() {
-      return this.digestInto(new Uint8Array(this.outputLen));
+    if (isStringWholeNumber(value)) {
+      return toHexString(value);
     }
-    destroy() {
-      this.destroyed = true;
-      this.state.fill(0);
+    throw new Error(`${value} need to be hex-string or whole-number-string`);
+  }
+  function getHexStringArray(value) {
+    return value.map((el) => getHexString(el));
+  }
+  var toCairoBool = (value) => (+value).toString();
+  function hexToBytes2(value) {
+    if (!isHex(value))
+      throw new Error(`${value} need to be a hex-string`);
+    let adaptedValue = removeHexPrefix(value);
+    if (adaptedValue.length % 2 !== 0) {
+      adaptedValue = `0${adaptedValue}`;
     }
-    _cloneInto(to) {
-      const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-      to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
-      to.state32.set(this.state32);
-      to.pos = this.pos;
-      to.posOut = this.posOut;
-      to.finished = this.finished;
-      to.rounds = rounds;
-      to.suffix = suffix;
-      to.outputLen = outputLen;
-      to.enableXOF = enableXOF;
-      to.destroyed = this.destroyed;
-      return to;
+    return hexToBytes(adaptedValue);
+  }
+
+  // node_modules/micro-starknet/lib/esm/index.js
+  var esm_exports = {};
+  __export(esm_exports, {
+    CURVE: () => CURVE,
+    Fp251: () => Fp251,
+    Fp253: () => Fp253,
+    ProjectivePoint: () => ProjectivePoint,
+    Signature: () => Signature,
+    _poseidonMDS: () => _poseidonMDS,
+    _starkCurve: () => _starkCurve,
+    computeHashOnElements: () => computeHashOnElements,
+    ethSigToPrivate: () => ethSigToPrivate,
+    getAccountPath: () => getAccountPath,
+    getPublicKey: () => getPublicKey,
+    getSharedSecret: () => getSharedSecret,
+    getStarkKey: () => getStarkKey,
+    grindKey: () => grindKey,
+    hashChain: () => hashChain,
+    keccak: () => keccak,
+    pedersen: () => pedersen,
+    poseidonBasic: () => poseidonBasic,
+    poseidonCreate: () => poseidonCreate,
+    poseidonHash: () => poseidonHash,
+    poseidonHashFunc: () => poseidonHashFunc,
+    poseidonHashMany: () => poseidonHashMany,
+    poseidonHashSingle: () => poseidonHashSingle,
+    poseidonSmall: () => poseidonSmall,
+    sign: () => sign,
+    utils: () => utils,
+    verify: () => verify
+  });
+
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_assert.js
+  function number(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+      throw new Error(`Wrong positive integer: ${n}`);
+  }
+  function bool(b) {
+    if (typeof b !== "boolean")
+      throw new Error(`Expected boolean, not ${b}`);
+  }
+  function bytes(b, ...lengths) {
+    if (!(b instanceof Uint8Array))
+      throw new TypeError("Expected Uint8Array");
+    if (lengths.length > 0 && !lengths.includes(b.length))
+      throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+  }
+  function hash(hash2) {
+    if (typeof hash2 !== "function" || typeof hash2.create !== "function")
+      throw new Error("Hash should be wrapped by utils.wrapConstructor");
+    number(hash2.outputLen);
+    number(hash2.blockLen);
+  }
+  function exists(instance, checkFinished = true) {
+    if (instance.destroyed)
+      throw new Error("Hash instance has been destroyed");
+    if (checkFinished && instance.finished)
+      throw new Error("Hash#digest() has already been called");
+  }
+  function output(out, instance) {
+    bytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+      throw new Error(`digestInto() expects output buffer of length at least ${min}`);
     }
+  }
+  var assert2 = {
+    number,
+    bool,
+    bytes,
+    hash,
+    exists,
+    output
   };
-  var gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
-  var sha3_224 = gen(6, 144, 224 / 8);
-  var sha3_256 = gen(6, 136, 256 / 8);
-  var sha3_384 = gen(6, 104, 384 / 8);
-  var sha3_512 = gen(6, 72, 512 / 8);
-  var keccak_224 = gen(1, 144, 224 / 8);
-  var keccak_256 = gen(1, 136, 256 / 8);
-  var keccak_384 = gen(1, 104, 384 / 8);
-  var keccak_512 = gen(1, 72, 512 / 8);
-  var genShake = (suffix, blockLen, outputLen) => wrapConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
-  var shake128 = genShake(31, 168, 128 / 8);
-  var shake256 = genShake(31, 136, 256 / 8);
+  var assert_default = assert2;
 
-  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_sha2.js
-  function setBigUint64(view, byteOffset, value, isLE2) {
-    if (typeof view.setBigUint64 === "function")
-      return view.setBigUint64(byteOffset, value, isLE2);
-    const _32n2 = BigInt(32);
-    const _u32_max = BigInt(4294967295);
-    const wh = Number(value >> _32n2 & _u32_max);
-    const wl = Number(value & _u32_max);
-    const h = isLE2 ? 4 : 0;
-    const l = isLE2 ? 0 : 4;
-    view.setUint32(byteOffset + h, wh, isLE2);
-    view.setUint32(byteOffset + l, wl, isLE2);
-  }
-  var SHA2 = class extends Hash {
-    constructor(blockLen, outputLen, padOffset, isLE2) {
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_u64.js
+  var U32_MASK64 = BigInt(2 ** 32 - 1);
+  var _32n = BigInt(32);
+  function fromBig(n, le = false) {
+    if (le)
+      return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+    return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+  }
+  function split(lst, le = false) {
+    let Ah = new Uint32Array(lst.length);
+    let Al = new Uint32Array(lst.length);
+    for (let i = 0; i < lst.length; i++) {
+      const { h, l } = fromBig(lst[i], le);
+      [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+  }
+  var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+  var shrSH = (h, l, s) => h >>> s;
+  var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+  var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+  var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+  var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+  var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+  var rotr32H = (h, l) => l;
+  var rotr32L = (h, l) => h;
+  var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+  var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+  var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+  var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+  function add(Ah, Al, Bh, Bl) {
+    const l = (Al >>> 0) + (Bl >>> 0);
+    return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+  }
+  var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+  var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+  var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+  var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+  var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+  var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+  var u64 = {
+    fromBig,
+    split,
+    toBig,
+    shrSH,
+    shrSL,
+    rotrSH,
+    rotrSL,
+    rotrBH,
+    rotrBL,
+    rotr32H,
+    rotr32L,
+    rotlSH,
+    rotlSL,
+    rotlBH,
+    rotlBL,
+    add,
+    add3L,
+    add3H,
+    add4L,
+    add4H,
+    add5H,
+    add5L
+  };
+  var u64_default = u64;
+
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/crypto.js
+  var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/utils.js
+  var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+  var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+  var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+  if (!isLE)
+    throw new Error("Non little-endian hardware is not supported");
+  var hexes2 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
+  function utf8ToBytes2(str) {
+    if (typeof str !== "string") {
+      throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
+    }
+    return new TextEncoder().encode(str);
+  }
+  function toBytes(data) {
+    if (typeof data === "string")
+      data = utf8ToBytes2(data);
+    if (!(data instanceof Uint8Array))
+      throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
+    return data;
+  }
+  function concatBytes2(...arrays) {
+    if (!arrays.every((a) => a instanceof Uint8Array))
+      throw new Error("Uint8Array list expected");
+    if (arrays.length === 1)
+      return arrays[0];
+    const length = arrays.reduce((a, arr) => a + arr.length, 0);
+    const result = new Uint8Array(length);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+      const arr = arrays[i];
+      result.set(arr, pad);
+      pad += arr.length;
+    }
+    return result;
+  }
+  var Hash = class {
+    clone() {
+      return this._cloneInto();
+    }
+  };
+  function wrapConstructor(hashConstructor) {
+    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
+    const tmp = hashConstructor();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashConstructor();
+    return hashC;
+  }
+  function wrapConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+  }
+  function randomBytes(bytesLength = 32) {
+    if (crypto && typeof crypto.getRandomValues === "function") {
+      return crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    throw new Error("crypto.getRandomValues must be defined");
+  }
+
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/sha3.js
+  var [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
+  var _0n2 = BigInt(0);
+  var _1n2 = BigInt(1);
+  var _2n2 = BigInt(2);
+  var _7n = BigInt(7);
+  var _256n = BigInt(256);
+  var _0x71n = BigInt(113);
+  for (let round = 0, R = _1n2, x = 1, y = 0; round < 24; round++) {
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+    let t = _0n2;
+    for (let j = 0; j < 7; j++) {
+      R = (R << _1n2 ^ (R >> _7n) * _0x71n) % _256n;
+      if (R & _2n2)
+        t ^= _1n2 << (_1n2 << BigInt(j)) - _1n2;
+    }
+    _SHA3_IOTA.push(t);
+  }
+  var [SHA3_IOTA_H, SHA3_IOTA_L] = u64_default.split(_SHA3_IOTA, true);
+  var rotlH = (h, l, s) => s > 32 ? u64_default.rotlBH(h, l, s) : u64_default.rotlSH(h, l, s);
+  var rotlL = (h, l, s) => s > 32 ? u64_default.rotlBL(h, l, s) : u64_default.rotlSL(h, l, s);
+  function keccakP(s, rounds = 24) {
+    const B = new Uint32Array(5 * 2);
+    for (let round = 24 - rounds; round < 24; round++) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+      for (let x = 0; x < 10; x += 2) {
+        const idx1 = (x + 8) % 10;
+        const idx0 = (x + 2) % 10;
+        const B0 = B[idx0];
+        const B1 = B[idx0 + 1];
+        const Th = rotlH(B0, B1, 1) ^ B[idx1];
+        const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+        for (let y = 0; y < 50; y += 10) {
+          s[x + y] ^= Th;
+          s[x + y + 1] ^= Tl;
+        }
+      }
+      let curH = s[2];
+      let curL = s[3];
+      for (let t = 0; t < 24; t++) {
+        const shift = SHA3_ROTL[t];
+        const Th = rotlH(curH, curL, shift);
+        const Tl = rotlL(curH, curL, shift);
+        const PI = SHA3_PI[t];
+        curH = s[PI];
+        curL = s[PI + 1];
+        s[PI] = Th;
+        s[PI + 1] = Tl;
+      }
+      for (let y = 0; y < 50; y += 10) {
+        for (let x = 0; x < 10; x++)
+          B[x] = s[y + x];
+        for (let x = 0; x < 10; x++)
+          s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+      }
+      s[0] ^= SHA3_IOTA_H[round];
+      s[1] ^= SHA3_IOTA_L[round];
+    }
+    B.fill(0);
+  }
+  var Keccak = class extends Hash {
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
       super();
       this.blockLen = blockLen;
+      this.suffix = suffix;
       this.outputLen = outputLen;
-      this.padOffset = padOffset;
-      this.isLE = isLE2;
-      this.finished = false;
-      this.length = 0;
+      this.enableXOF = enableXOF;
+      this.rounds = rounds;
       this.pos = 0;
+      this.posOut = 0;
+      this.finished = false;
       this.destroyed = false;
-      this.buffer = new Uint8Array(blockLen);
-      this.view = createView(this.buffer);
+      assert_default.number(outputLen);
+      if (0 >= this.blockLen || this.blockLen >= 200)
+        throw new Error("Sha3 supports only keccak-f1600 function");
+      this.state = new Uint8Array(200);
+      this.state32 = u32(this.state);
+    }
+    keccak() {
+      keccakP(this.state32, this.rounds);
+      this.posOut = 0;
+      this.pos = 0;
     }
     update(data) {
       assert_default.exists(this);
-      const { view, buffer, blockLen } = this;
+      const { blockLen, state } = this;
       data = toBytes(data);
       const len = data.length;
       for (let pos = 0; pos < len; ) {
         const take = Math.min(blockLen - this.pos, len - pos);
-        if (take === blockLen) {
-          const dataView = createView(data);
-          for (; blockLen <= len - pos; pos += blockLen)
-            this.process(dataView, pos);
-          continue;
-        }
-        buffer.set(data.subarray(pos, pos + take), this.pos);
-        this.pos += take;
-        pos += take;
-        if (this.pos === blockLen) {
-          this.process(view, 0);
-          this.pos = 0;
-        }
+        for (let i = 0; i < take; i++)
+          state[this.pos++] ^= data[pos++];
+        if (this.pos === blockLen)
+          this.keccak();
       }
-      this.length += data.length;
-      this.roundClean();
       return this;
     }
-    digestInto(out) {
-      assert_default.exists(this);
-      assert_default.output(out, this);
+    finish() {
+      if (this.finished)
+        return;
       this.finished = true;
-      const { buffer, view, blockLen, isLE: isLE2 } = this;
-      let { pos } = this;
-      buffer[pos++] = 128;
-      this.buffer.subarray(pos).fill(0);
-      if (this.padOffset > blockLen - pos) {
-        this.process(view, 0);
-        pos = 0;
-      }
-      for (let i = pos; i < blockLen; i++)
-        buffer[i] = 0;
-      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
-      this.process(view, 0);
-      const oview = createView(out);
-      const len = this.outputLen;
-      if (len % 4)
-        throw new Error("_sha2: outputLen should be aligned to 32bit");
-      const outLen = len / 4;
+      const { state, suffix, pos, blockLen } = this;
+      state[pos] ^= suffix;
+      if ((suffix & 128) !== 0 && pos === blockLen - 1)
+        this.keccak();
+      state[blockLen - 1] ^= 128;
+      this.keccak();
+    }
+    writeInto(out) {
+      assert_default.exists(this, false);
+      assert_default.bytes(out);
+      this.finish();
+      const bufferOut = this.state;
+      const { blockLen } = this;
+      for (let pos = 0, len = out.length; pos < len; ) {
+        if (this.posOut >= blockLen)
+          this.keccak();
+        const take = Math.min(blockLen - this.posOut, len - pos);
+        out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+        this.posOut += take;
+        pos += take;
+      }
+      return out;
+    }
+    xofInto(out) {
+      if (!this.enableXOF)
+        throw new Error("XOF is not possible for this instance");
+      return this.writeInto(out);
+    }
+    xof(bytes2) {
+      assert_default.number(bytes2);
+      return this.xofInto(new Uint8Array(bytes2));
+    }
+    digestInto(out) {
+      assert_default.output(out, this);
+      if (this.finished)
+        throw new Error("digest() was already called");
+      this.writeInto(out);
+      this.destroy();
+      return out;
+    }
+    digest() {
+      return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+      this.destroyed = true;
+      this.state.fill(0);
+    }
+    _cloneInto(to) {
+      const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+      to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+      to.state32.set(this.state32);
+      to.pos = this.pos;
+      to.posOut = this.posOut;
+      to.finished = this.finished;
+      to.rounds = rounds;
+      to.suffix = suffix;
+      to.outputLen = outputLen;
+      to.enableXOF = enableXOF;
+      to.destroyed = this.destroyed;
+      return to;
+    }
+  };
+  var gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+  var sha3_224 = gen(6, 144, 224 / 8);
+  var sha3_256 = gen(6, 136, 256 / 8);
+  var sha3_384 = gen(6, 104, 384 / 8);
+  var sha3_512 = gen(6, 72, 512 / 8);
+  var keccak_224 = gen(1, 144, 224 / 8);
+  var keccak_256 = gen(1, 136, 256 / 8);
+  var keccak_384 = gen(1, 104, 384 / 8);
+  var keccak_512 = gen(1, 72, 512 / 8);
+  var genShake = (suffix, blockLen, outputLen) => wrapConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+  var shake128 = genShake(31, 168, 128 / 8);
+  var shake256 = genShake(31, 136, 256 / 8);
+
+  // node_modules/micro-starknet/node_modules/@noble/hashes/esm/_sha2.js
+  function setBigUint64(view, byteOffset, value, isLE2) {
+    if (typeof view.setBigUint64 === "function")
+      return view.setBigUint64(byteOffset, value, isLE2);
+    const _32n2 = BigInt(32);
+    const _u32_max = BigInt(4294967295);
+    const wh = Number(value >> _32n2 & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE2 ? 4 : 0;
+    const l = isLE2 ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE2);
+    view.setUint32(byteOffset + l, wl, isLE2);
+  }
+  var SHA2 = class extends Hash {
+    constructor(blockLen, outputLen, padOffset, isLE2) {
+      super();
+      this.blockLen = blockLen;
+      this.outputLen = outputLen;
+      this.padOffset = padOffset;
+      this.isLE = isLE2;
+      this.finished = false;
+      this.length = 0;
+      this.pos = 0;
+      this.destroyed = false;
+      this.buffer = new Uint8Array(blockLen);
+      this.view = createView(this.buffer);
+    }
+    update(data) {
+      assert_default.exists(this);
+      const { view, buffer, blockLen } = this;
+      data = toBytes(data);
+      const len = data.length;
+      for (let pos = 0; pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        if (take === blockLen) {
+          const dataView = createView(data);
+          for (; blockLen <= len - pos; pos += blockLen)
+            this.process(dataView, pos);
+          continue;
+        }
+        buffer.set(data.subarray(pos, pos + take), this.pos);
+        this.pos += take;
+        pos += take;
+        if (this.pos === blockLen) {
+          this.process(view, 0);
+          this.pos = 0;
+        }
+      }
+      this.length += data.length;
+      this.roundClean();
+      return this;
+    }
+    digestInto(out) {
+      assert_default.exists(this);
+      assert_default.output(out, this);
+      this.finished = true;
+      const { buffer, view, blockLen, isLE: isLE2 } = this;
+      let { pos } = this;
+      buffer[pos++] = 128;
+      this.buffer.subarray(pos).fill(0);
+      if (this.padOffset > blockLen - pos) {
+        this.process(view, 0);
+        pos = 0;
+      }
+      for (let i = pos; i < blockLen; i++)
+        buffer[i] = 0;
+      setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+      this.process(view, 0);
+      const oview = createView(out);
+      const len = this.outputLen;
+      if (len % 4)
+        throw new Error("_sha2: outputLen should be aligned to 32bit");
+      const outLen = len / 4;
       const state = this.get();
       if (outLen > state.length)
         throw new Error("_sha2: outputLen bigger than state");
@@ -1382,52 +1711,52 @@ var starknet = (() => {
   var sha224 = wrapConstructor(() => new SHA224());
 
   // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/utils.js
-  var utils_exports = {};
-  __export(utils_exports, {
-    bitGet: () => bitGet,
-    bitLen: () => bitLen,
-    bitMask: () => bitMask,
-    bitSet: () => bitSet,
-    bytesToHex: () => bytesToHex,
-    bytesToNumberBE: () => bytesToNumberBE,
-    bytesToNumberLE: () => bytesToNumberLE,
-    concatBytes: () => concatBytes2,
-    createHmacDrbg: () => createHmacDrbg,
-    ensureBytes: () => ensureBytes,
-    equalBytes: () => equalBytes,
-    hexToBytes: () => hexToBytes,
-    hexToNumber: () => hexToNumber,
-    numberToBytesBE: () => numberToBytesBE,
-    numberToBytesLE: () => numberToBytesLE,
-    numberToHexUnpadded: () => numberToHexUnpadded,
-    numberToVarBytesBE: () => numberToVarBytesBE,
-    utf8ToBytes: () => utf8ToBytes2,
-    validateObject: () => validateObject
+  var utils_exports2 = {};
+  __export(utils_exports2, {
+    bitGet: () => bitGet2,
+    bitLen: () => bitLen2,
+    bitMask: () => bitMask2,
+    bitSet: () => bitSet2,
+    bytesToHex: () => bytesToHex2,
+    bytesToNumberBE: () => bytesToNumberBE2,
+    bytesToNumberLE: () => bytesToNumberLE2,
+    concatBytes: () => concatBytes3,
+    createHmacDrbg: () => createHmacDrbg2,
+    ensureBytes: () => ensureBytes2,
+    equalBytes: () => equalBytes2,
+    hexToBytes: () => hexToBytes3,
+    hexToNumber: () => hexToNumber2,
+    numberToBytesBE: () => numberToBytesBE2,
+    numberToBytesLE: () => numberToBytesLE2,
+    numberToHexUnpadded: () => numberToHexUnpadded2,
+    numberToVarBytesBE: () => numberToVarBytesBE2,
+    utf8ToBytes: () => utf8ToBytes3,
+    validateObject: () => validateObject2
   });
-  var _0n2 = BigInt(0);
-  var _1n2 = BigInt(1);
-  var _2n2 = BigInt(2);
-  var u8a = (a) => a instanceof Uint8Array;
-  var hexes2 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex(bytes2) {
-    if (!u8a(bytes2))
+  var _0n3 = BigInt(0);
+  var _1n3 = BigInt(1);
+  var _2n3 = BigInt(2);
+  var u8a2 = (a) => a instanceof Uint8Array;
+  var hexes3 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex2(bytes2) {
+    if (!u8a2(bytes2))
       throw new Error("Uint8Array expected");
     let hex = "";
     for (let i = 0; i < bytes2.length; i++) {
-      hex += hexes2[bytes2[i]];
+      hex += hexes3[bytes2[i]];
     }
     return hex;
   }
-  function numberToHexUnpadded(num) {
+  function numberToHexUnpadded2(num) {
     const hex = num.toString(16);
     return hex.length & 1 ? `0${hex}` : hex;
   }
-  function hexToNumber(hex) {
+  function hexToNumber2(hex) {
     if (typeof hex !== "string")
       throw new Error("hex string expected, got " + typeof hex);
     return BigInt(hex === "" ? "0" : `0x${hex}`);
   }
-  function hexToBytes(hex) {
+  function hexToBytes3(hex) {
     if (typeof hex !== "string")
       throw new Error("hex string expected, got " + typeof hex);
     if (hex.length % 2)
@@ -1443,26 +1772,26 @@ var starknet = (() => {
     }
     return array;
   }
-  function bytesToNumberBE(bytes2) {
-    return hexToNumber(bytesToHex(bytes2));
+  function bytesToNumberBE2(bytes2) {
+    return hexToNumber2(bytesToHex2(bytes2));
   }
-  function bytesToNumberLE(bytes2) {
-    if (!u8a(bytes2))
+  function bytesToNumberLE2(bytes2) {
+    if (!u8a2(bytes2))
       throw new Error("Uint8Array expected");
-    return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
+    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
   }
-  var numberToBytesBE = (n, len) => hexToBytes(n.toString(16).padStart(len * 2, "0"));
-  var numberToBytesLE = (n, len) => numberToBytesBE(n, len).reverse();
-  var numberToVarBytesBE = (n) => hexToBytes(numberToHexUnpadded(n));
-  function ensureBytes(title, hex, expectedLength) {
+  var numberToBytesBE2 = (n, len) => hexToBytes3(n.toString(16).padStart(len * 2, "0"));
+  var numberToBytesLE2 = (n, len) => numberToBytesBE2(n, len).reverse();
+  var numberToVarBytesBE2 = (n) => hexToBytes3(numberToHexUnpadded2(n));
+  function ensureBytes2(title, hex, expectedLength) {
     let res;
     if (typeof hex === "string") {
       try {
-        res = hexToBytes(hex);
+        res = hexToBytes3(hex);
       } catch (e) {
         throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
       }
-    } else if (u8a(hex)) {
+    } else if (u8a2(hex)) {
       res = Uint8Array.from(hex);
     } else {
       throw new Error(`${title} must be hex string or Uint8Array`);
@@ -1472,18 +1801,18 @@ var starknet = (() => {
       throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
     return res;
   }
-  function concatBytes2(...arrs) {
+  function concatBytes3(...arrs) {
     const r = new Uint8Array(arrs.reduce((sum, a) => sum + a.length, 0));
     let pad = 0;
     arrs.forEach((a) => {
-      if (!u8a(a))
+      if (!u8a2(a))
         throw new Error("Uint8Array expected");
       r.set(a, pad);
       pad += a.length;
     });
     return r;
   }
-  function equalBytes(b1, b2) {
+  function equalBytes2(b1, b2) {
     if (b1.length !== b2.length)
       return false;
     for (let i = 0; i < b1.length; i++)
@@ -1491,32 +1820,32 @@ var starknet = (() => {
         return false;
     return true;
   }
-  function utf8ToBytes2(str) {
+  function utf8ToBytes3(str) {
     if (typeof str !== "string") {
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
     }
     return new TextEncoder().encode(str);
   }
-  function bitLen(n) {
+  function bitLen2(n) {
     let len;
-    for (len = 0; n > _0n2; n >>= _1n2, len += 1)
+    for (len = 0; n > _0n3; n >>= _1n3, len += 1)
       ;
     return len;
   }
-  var bitGet = (n, pos) => n >> BigInt(pos) & _1n2;
-  var bitSet = (n, pos, value) => n | (value ? _1n2 : _0n2) << BigInt(pos);
-  var bitMask = (n) => (_2n2 << BigInt(n - 1)) - _1n2;
-  var u8n = (data) => new Uint8Array(data);
-  var u8fr = (arr) => Uint8Array.from(arr);
-  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+  var bitGet2 = (n, pos) => n >> BigInt(pos) & _1n3;
+  var bitSet2 = (n, pos, value) => n | (value ? _1n3 : _0n3) << BigInt(pos);
+  var bitMask2 = (n) => (_2n3 << BigInt(n - 1)) - _1n3;
+  var u8n2 = (data) => new Uint8Array(data);
+  var u8fr2 = (arr) => Uint8Array.from(arr);
+  function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
     if (typeof hashLen !== "number" || hashLen < 2)
       throw new Error("hashLen must be a number");
     if (typeof qByteLen !== "number" || qByteLen < 2)
       throw new Error("qByteLen must be a number");
     if (typeof hmacFn !== "function")
       throw new Error("hmacFn must be a function");
-    let v = u8n(hashLen);
-    let k = u8n(hashLen);
+    let v = u8n2(hashLen);
+    let k = u8n2(hashLen);
     let i = 0;
     const reset = () => {
       v.fill(1);
@@ -1524,12 +1853,12 @@ var starknet = (() => {
       i = 0;
     };
     const h = (...b) => hmacFn(k, v, ...b);
-    const reseed = (seed = u8n()) => {
-      k = h(u8fr([0]), seed);
+    const reseed = (seed = u8n2()) => {
+      k = h(u8fr2([0]), seed);
       v = h();
       if (seed.length === 0)
         return;
-      k = h(u8fr([1]), seed);
+      k = h(u8fr2([1]), seed);
       v = h();
     };
     const gen2 = () => {
@@ -1543,7 +1872,7 @@ var starknet = (() => {
         out.push(sl);
         len += v.length;
       }
-      return concatBytes2(...out);
+      return concatBytes3(...out);
     };
     const genUntil = (seed, pred) => {
       reset();
@@ -1556,7 +1885,7 @@ var starknet = (() => {
     };
     return genUntil;
   }
-  var validatorFns = {
+  var validatorFns2 = {
     bigint: (val) => typeof val === "bigint",
     function: (val) => typeof val === "function",
     boolean: (val) => typeof val === "boolean",
@@ -1566,9 +1895,9 @@ var starknet = (() => {
     field: (val, object) => object.Fp.isValid(val),
     hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
   };
-  function validateObject(object, validators, optValidators = {}) {
+  function validateObject2(object, validators, optValidators = {}) {
     const checkField = (fieldName, type, isOptional) => {
-      const checkVal = validatorFns[type];
+      const checkVal = validatorFns2[type];
       if (typeof checkVal !== "function")
         throw new Error(`Invalid validator "${type}", expected function`);
       const val = object[fieldName];
@@ -1586,9 +1915,9 @@ var starknet = (() => {
   }
 
   // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/modular.js
-  var _0n3 = BigInt(0);
-  var _1n3 = BigInt(1);
-  var _2n3 = BigInt(2);
+  var _0n4 = BigInt(0);
+  var _1n4 = BigInt(1);
+  var _2n4 = BigInt(2);
   var _3n = BigInt(3);
   var _4n = BigInt(4);
   var _5n = BigInt(5);
@@ -1597,30 +1926,30 @@ var starknet = (() => {
   var _16n = BigInt(16);
   function mod(a, b) {
     const result = a % b;
-    return result >= _0n3 ? result : b + result;
+    return result >= _0n4 ? result : b + result;
   }
   function pow(num, power, modulo) {
-    if (modulo <= _0n3 || power < _0n3)
+    if (modulo <= _0n4 || power < _0n4)
       throw new Error("Expected power/modulo > 0");
-    if (modulo === _1n3)
-      return _0n3;
-    let res = _1n3;
-    while (power > _0n3) {
-      if (power & _1n3)
+    if (modulo === _1n4)
+      return _0n4;
+    let res = _1n4;
+    while (power > _0n4) {
+      if (power & _1n4)
         res = res * num % modulo;
       num = num * num % modulo;
-      power >>= _1n3;
+      power >>= _1n4;
     }
     return res;
   }
   function invert(number3, modulo) {
-    if (number3 === _0n3 || modulo <= _0n3) {
+    if (number3 === _0n4 || modulo <= _0n4) {
       throw new Error(`invert: expected positive integers, got n=${number3} mod=${modulo}`);
     }
     let a = mod(number3, modulo);
     let b = modulo;
-    let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
-    while (a !== _0n3) {
+    let x = _0n4, y = _1n4, u = _1n4, v = _0n4;
+    while (a !== _0n4) {
       const q = b / a;
       const r = b % a;
       const m = x - u * q;
@@ -1628,19 +1957,19 @@ var starknet = (() => {
       b = a, a = r, x = u, y = v, u = m, v = n;
     }
     const gcd = b;
-    if (gcd !== _1n3)
+    if (gcd !== _1n4)
       throw new Error("invert: does not exist");
     return mod(x, modulo);
   }
   function tonelliShanks(P) {
-    const legendreC = (P - _1n3) / _2n3;
+    const legendreC = (P - _1n4) / _2n4;
     let Q, S, Z;
-    for (Q = P - _1n3, S = 0; Q % _2n3 === _0n3; Q /= _2n3, S++)
+    for (Q = P - _1n4, S = 0; Q % _2n4 === _0n4; Q /= _2n4, S++)
       ;
-    for (Z = _2n3; Z < P && pow(Z, legendreC, P) !== P - _1n3; Z++)
+    for (Z = _2n4; Z < P && pow(Z, legendreC, P) !== P - _1n4; Z++)
       ;
     if (S === 1) {
-      const p1div4 = (P + _1n3) / _4n;
+      const p1div4 = (P + _1n4) / _4n;
       return function tonelliFast(Fp, n) {
         const root = Fp.pow(n, p1div4);
         if (!Fp.eql(Fp.sqr(root), n))
@@ -1648,7 +1977,7 @@ var starknet = (() => {
         return root;
       };
     }
-    const Q1div2 = (Q + _1n3) / _2n3;
+    const Q1div2 = (Q + _1n4) / _2n4;
     return function tonelliSlow(Fp, n) {
       if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
         throw new Error("Cannot find square root");
@@ -1665,7 +1994,7 @@ var starknet = (() => {
             break;
           t2 = Fp.sqr(t2);
         }
-        const ge = Fp.pow(g, _1n3 << BigInt(r - m - 1));
+        const ge = Fp.pow(g, _1n4 << BigInt(r - m - 1));
         g = Fp.sqr(ge);
         x = Fp.mul(x, ge);
         b = Fp.mul(b, g);
@@ -1676,7 +2005,7 @@ var starknet = (() => {
   }
   function FpSqrt(P) {
     if (P % _4n === _3n) {
-      const p1div4 = (P + _1n3) / _4n;
+      const p1div4 = (P + _1n4) / _4n;
       return function sqrt3mod4(Fp, n) {
         const root = Fp.pow(n, p1div4);
         if (!Fp.eql(Fp.sqr(root), n))
@@ -1687,10 +2016,10 @@ var starknet = (() => {
     if (P % _8n === _5n) {
       const c1 = (P - _5n) / _8n;
       return function sqrt5mod8(Fp, n) {
-        const n2 = Fp.mul(n, _2n3);
+        const n2 = Fp.mul(n, _2n4);
         const v = Fp.pow(n2, c1);
         const nv = Fp.mul(n, v);
-        const i = Fp.mul(Fp.mul(nv, _2n3), v);
+        const i = Fp.mul(Fp.mul(nv, _2n4), v);
         const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
         if (!Fp.eql(Fp.sqr(root), n))
           throw new Error("Cannot find square root");
@@ -1731,22 +2060,22 @@ var starknet = (() => {
       map[val] = "function";
       return map;
     }, initial);
-    return validateObject(field, opts);
+    return validateObject2(field, opts);
   }
   function FpPow(f, num, power) {
-    if (power < _0n3)
+    if (power < _0n4)
       throw new Error("Expected power > 0");
-    if (power === _0n3)
+    if (power === _0n4)
       return f.ONE;
-    if (power === _1n3)
+    if (power === _1n4)
       return num;
     let p = f.ONE;
     let d = num;
-    while (power > _0n3) {
-      if (power & _1n3)
+    while (power > _0n4) {
+      if (power & _1n4)
         p = f.mul(p, d);
       d = f.sqr(d);
-      power >>= _1n3;
+      power >>= _1n4;
     }
     return p;
   }
@@ -1773,7 +2102,7 @@ var starknet = (() => {
     return { nBitLength: _nBitLength, nByteLength };
   }
   function Field(ORDER, bitLen3, isLE2 = false, redef = {}) {
-    if (ORDER <= _0n3)
+    if (ORDER <= _0n4)
       throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen3);
     if (BYTES > 2048)
@@ -1783,17 +2112,17 @@ var starknet = (() => {
       ORDER,
       BITS,
       BYTES,
-      MASK: bitMask(BITS),
-      ZERO: _0n3,
-      ONE: _1n3,
+      MASK: bitMask2(BITS),
+      ZERO: _0n4,
+      ONE: _1n4,
       create: (num) => mod(num, ORDER),
       isValid: (num) => {
         if (typeof num !== "bigint")
           throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
-        return _0n3 <= num && num < ORDER;
+        return _0n4 <= num && num < ORDER;
       },
-      is0: (num) => num === _0n3,
-      isOdd: (num) => (num & _1n3) === _1n3,
+      is0: (num) => num === _0n4,
+      isOdd: (num) => (num & _1n4) === _1n4,
       neg: (num) => mod(-num, ORDER),
       eql: (lhs, rhs) => lhs === rhs,
       sqr: (num) => mod(num * num, ORDER),
@@ -1810,23 +2139,23 @@ var starknet = (() => {
       sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
       invertBatch: (lst) => FpInvertBatch(f, lst),
       cmov: (a, b, c) => c ? b : a,
-      toBytes: (num) => isLE2 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
+      toBytes: (num) => isLE2 ? numberToBytesLE2(num, BYTES) : numberToBytesBE2(num, BYTES),
       fromBytes: (bytes2) => {
         if (bytes2.length !== BYTES)
           throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
-        return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
+        return isLE2 ? bytesToNumberLE2(bytes2) : bytesToNumberBE2(bytes2);
       }
     });
     return Object.freeze(f);
   }
   function hashToPrivateScalar(hash2, groupOrder, isLE2 = false) {
-    hash2 = ensureBytes("privateHash", hash2);
+    hash2 = ensureBytes2("privateHash", hash2);
     const hashLen = hash2.length;
     const minLen = nLength(groupOrder).nByteLength + 8;
     if (minLen < 24 || hashLen < minLen || hashLen > 1024)
       throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
-    const num = isLE2 ? bytesToNumberLE(hash2) : bytesToNumberBE(hash2);
-    return mod(num, groupOrder - _1n3) + _1n3;
+    const num = isLE2 ? bytesToNumberLE2(hash2) : bytesToNumberBE2(hash2);
+    return mod(num, groupOrder - _1n4) + _1n4;
   }
 
   // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/poseidon.js
@@ -1914,8 +2243,8 @@ var starknet = (() => {
   }
 
   // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/curve.js
-  var _0n4 = BigInt(0);
-  var _1n4 = BigInt(1);
+  var _0n5 = BigInt(0);
+  var _1n5 = BigInt(1);
   function wNAF(c, bits) {
     const constTimeNegate = (condition, item) => {
       const neg = item.negate();
@@ -1931,11 +2260,11 @@ var starknet = (() => {
       unsafeLadder(elm, n) {
         let p = c.ZERO;
         let d = elm;
-        while (n > _0n4) {
-          if (n & _1n4)
+        while (n > _0n5) {
+          if (n & _1n5)
             p = p.add(d);
           d = d.double();
-          n >>= _1n4;
+          n >>= _1n5;
         }
         return p;
       },
@@ -1968,7 +2297,7 @@ var starknet = (() => {
           n >>= shiftBy;
           if (wbits > windowSize) {
             wbits -= maxNumber;
-            n += _1n4;
+            n += _1n5;
           }
           const offset1 = offset;
           const offset2 = offset + Math.abs(wbits) - 1;
@@ -1997,7 +2326,7 @@ var starknet = (() => {
   }
   function validateBasic(curve2) {
     validateField(curve2.Fp);
-    validateObject(curve2, {
+    validateObject2(curve2, {
       n: "bigint",
       h: "bigint",
       Gx: "field",
@@ -2016,7 +2345,7 @@ var starknet = (() => {
   // node_modules/micro-starknet/node_modules/@noble/curves/esm/abstract/weierstrass.js
   function validatePointOpts(curve2) {
     const opts = validateBasic(curve2);
-    validateObject(opts, {
+    validateObject2(opts, {
       a: "field",
       b: "field"
     }, {
@@ -2039,7 +2368,7 @@ var starknet = (() => {
     }
     return Object.freeze({ ...opts });
   }
-  var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports;
+  var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports2;
   var DER = {
     Err: class DERErr extends Error {
       constructor(m = "") {
@@ -2091,9 +2420,9 @@ var starknet = (() => {
       return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
     }
   };
-  var _0n5 = BigInt(0);
-  var _1n5 = BigInt(1);
-  var _2n4 = BigInt(2);
+  var _0n6 = BigInt(0);
+  var _1n6 = BigInt(1);
+  var _2n5 = BigInt(2);
   var _3n2 = BigInt(3);
   var _4n2 = BigInt(4);
   function weierstrassPoints(opts) {
@@ -2101,7 +2430,7 @@ var starknet = (() => {
     const { Fp } = CURVE2;
     const toBytes2 = CURVE2.toBytes || ((c, point, isCompressed) => {
       const a = point.toAffine();
-      return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+      return concatBytes3(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
     });
     const fromBytes = CURVE2.fromBytes || ((bytes2) => {
       const tail = bytes2.subarray(1);
@@ -2118,7 +2447,7 @@ var starknet = (() => {
     if (!Fp.eql(Fp.sqr(CURVE2.Gy), weierstrassEquation(CURVE2.Gx)))
       throw new Error("bad generator point: equation left != right");
     function isWithinCurveOrder(num) {
-      return typeof num === "bigint" && _0n5 < num && num < CURVE2.n;
+      return typeof num === "bigint" && _0n6 < num && num < CURVE2.n;
     }
     function assertGE(num) {
       if (!isWithinCurveOrder(num))
@@ -2128,14 +2457,14 @@ var starknet = (() => {
       const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE2;
       if (lengths && typeof key !== "bigint") {
         if (key instanceof Uint8Array)
-          key = bytesToHex(key);
+          key = bytesToHex2(key);
         if (typeof key !== "string" || !lengths.includes(key.length))
           throw new Error("Invalid key");
         key = key.padStart(nByteLength * 2, "0");
       }
       let num;
       try {
-        num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
+        num = typeof key === "bigint" ? key : bytesToNumberBE2(ensureBytes2("private key", key, nByteLength));
       } catch (error) {
         throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
       }
@@ -2183,7 +2512,7 @@ var starknet = (() => {
         return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
       }
       static fromHex(hex) {
-        const P = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
+        const P = Point.fromAffine(fromBytes(ensureBytes2("pointHex", hex)));
         P.assertValidity();
         return P;
       }
@@ -2328,10 +2657,10 @@ var starknet = (() => {
       }
       multiplyUnsafe(n) {
         const I = Point.ZERO;
-        if (n === _0n5)
+        if (n === _0n6)
           return I;
         assertGE(n);
-        if (n === _1n5)
+        if (n === _1n6)
           return this;
         const { endo } = CURVE2;
         if (!endo)
@@ -2340,14 +2669,14 @@ var starknet = (() => {
         let k1p = I;
         let k2p = I;
         let d = this;
-        while (k1 > _0n5 || k2 > _0n5) {
-          if (k1 & _1n5)
+        while (k1 > _0n6 || k2 > _0n6) {
+          if (k1 & _1n6)
             k1p = k1p.add(d);
-          if (k2 & _1n5)
+          if (k2 & _1n6)
             k2p = k2p.add(d);
           d = d.double();
-          k1 >>= _1n5;
-          k2 >>= _1n5;
+          k1 >>= _1n6;
+          k2 >>= _1n6;
         }
         if (k1neg)
           k1p = k1p.negate();
@@ -2379,7 +2708,7 @@ var starknet = (() => {
       }
       multiplyAndAddUnsafe(Q, a, b) {
         const G = Point.BASE;
-        const mul = (P, a2) => a2 === _0n5 || a2 === _1n5 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
+        const mul = (P, a2) => a2 === _0n6 || a2 === _1n6 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
         const sum = mul(this, a).add(mul(Q, b));
         return sum.is0() ? void 0 : sum;
       }
@@ -2399,7 +2728,7 @@ var starknet = (() => {
       }
       isTorsionFree() {
         const { h: cofactor, isTorsionFree } = CURVE2;
-        if (cofactor === _1n5)
+        if (cofactor === _1n6)
           return true;
         if (isTorsionFree)
           return isTorsionFree(Point, this);
@@ -2407,7 +2736,7 @@ var starknet = (() => {
       }
       clearCofactor() {
         const { h: cofactor, clearCofactor } = CURVE2;
-        if (cofactor === _1n5)
+        if (cofactor === _1n6)
           return this;
         if (clearCofactor)
           return clearCofactor(Point, this);
@@ -2418,7 +2747,7 @@ var starknet = (() => {
         return toBytes2(Point, this, isCompressed);
       }
       toHex(isCompressed = true) {
-        return bytesToHex(this.toRawBytes(isCompressed));
+        return bytesToHex2(this.toRawBytes(isCompressed));
       }
     }
     Point.BASE = new Point(CURVE2.Gx, CURVE2.Gy, Fp.ONE);
@@ -2435,7 +2764,7 @@ var starknet = (() => {
   }
   function validateOpts2(curve2) {
     const opts = validateBasic(curve2);
-    validateObject(opts, {
+    validateObject2(opts, {
       hash: "hash",
       hmac: "function",
       randomBytes: "function"
@@ -2452,7 +2781,7 @@ var starknet = (() => {
     const compressedLen = Fp.BYTES + 1;
     const uncompressedLen = 2 * Fp.BYTES + 1;
     function isValidFieldElement(num) {
-      return _0n5 < num && num < Fp.ORDER;
+      return _0n6 < num && num < Fp.ORDER;
     }
     function modN(a) {
       return mod(a, CURVE_ORDER2);
@@ -2465,7 +2794,7 @@ var starknet = (() => {
       toBytes(c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp.toBytes(a.x);
-        const cat = concatBytes2;
+        const cat = concatBytes3;
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
@@ -2477,12 +2806,12 @@ var starknet = (() => {
         const head = bytes2[0];
         const tail = bytes2.subarray(1);
         if (len === compressedLen && (head === 2 || head === 3)) {
-          const x = bytesToNumberBE(tail);
+          const x = bytesToNumberBE2(tail);
           if (!isValidFieldElement(x))
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
           let y = Fp.sqrt(y2);
-          const isYOdd = (y & _1n5) === _1n5;
+          const isYOdd = (y & _1n6) === _1n6;
           const isHeadOdd = (head & 1) === 1;
           if (isHeadOdd !== isYOdd)
             y = Fp.neg(y);
@@ -2496,15 +2825,15 @@ var starknet = (() => {
         }
       }
     });
-    const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE2.nByteLength));
+    const numToNByteStr = (num) => bytesToHex2(numberToBytesBE2(num, CURVE2.nByteLength));
     function isBiggerThanHalfOrder(number3) {
-      const HALF = CURVE_ORDER2 >> _1n5;
+      const HALF = CURVE_ORDER2 >> _1n6;
       return number3 > HALF;
     }
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? modN(-s) : s;
     }
-    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
+    const slcNum = (b, from, to) => bytesToNumberBE2(b.slice(from, to));
     class Signature3 {
       constructor(r, s, recovery) {
         this.r = r;
@@ -2514,11 +2843,11 @@ var starknet = (() => {
       }
       static fromCompact(hex) {
         const l = CURVE2.nByteLength;
-        hex = ensureBytes("compactSignature", hex, l * 2);
+        hex = ensureBytes2("compactSignature", hex, l * 2);
         return new Signature3(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
       }
       static fromDER(hex) {
-        const { r, s } = DER.toSig(ensureBytes("DER", hex));
+        const { r, s } = DER.toSig(ensureBytes2("DER", hex));
         return new Signature3(r, s);
       }
       assertValidity() {
@@ -2532,7 +2861,7 @@ var starknet = (() => {
       }
       recoverPublicKey(msgHash) {
         const { r, s, recovery: rec } = this;
-        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
+        const h = bits2int_modN(ensureBytes2("msgHash", msgHash));
         if (rec == null || ![0, 1, 2, 3].includes(rec))
           throw new Error("recovery id invalid");
         const radj = rec === 2 || rec === 3 ? r + CURVE2.n : r;
@@ -2556,13 +2885,13 @@ var starknet = (() => {
         return this.hasHighS() ? new Signature3(this.r, modN(-this.s), this.recovery) : this;
       }
       toDERRawBytes() {
-        return hexToBytes(this.toDERHex());
+        return hexToBytes3(this.toDERHex());
       }
       toDERHex() {
         return DER.hexFromSig({ r: this.r, s: this.s });
       }
       toCompactRawBytes() {
-        return hexToBytes(this.toCompactHex());
+        return hexToBytes3(this.toCompactHex());
       }
       toCompactHex() {
         return numToNByteStr(this.r) + numToNByteStr(this.s);
@@ -2581,7 +2910,7 @@ var starknet = (() => {
       randomPrivateKey: () => {
         const rand = CURVE2.randomBytes(Fp.BYTES + 8);
         const num = hashToPrivateScalar(rand, CURVE_ORDER2);
-        return numberToBytesBE(num, CURVE2.nByteLength);
+        return numberToBytesBE2(num, CURVE2.nByteLength);
       },
       precompute(windowSize = 8, point = Point.BASE) {
         point._setWindowSize(windowSize);
@@ -2613,20 +2942,20 @@ var starknet = (() => {
       return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
     }
     const bits2int2 = CURVE2.bits2int || function(bytes2) {
-      const num = bytesToNumberBE(bytes2);
+      const num = bytesToNumberBE2(bytes2);
       const delta = bytes2.length * 8 - CURVE2.nBitLength;
       return delta > 0 ? num >> BigInt(delta) : num;
     };
     const bits2int_modN = CURVE2.bits2int_modN || function(bytes2) {
       return modN(bits2int2(bytes2));
     };
-    const ORDER_MASK = bitMask(CURVE2.nBitLength);
+    const ORDER_MASK = bitMask2(CURVE2.nBitLength);
     function int2octets(num) {
       if (typeof num !== "bigint")
         throw new Error("bigint expected");
-      if (!(_0n5 <= num && num < ORDER_MASK))
+      if (!(_0n6 <= num && num < ORDER_MASK))
         throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-      return numberToBytesBE(num, CURVE2.nByteLength);
+      return numberToBytesBE2(num, CURVE2.nByteLength);
     }
     function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
       if (["recovered", "canonical"].some((k) => k in opts))
@@ -2635,17 +2964,17 @@ var starknet = (() => {
       let { lowS, prehash, extraEntropy: ent } = opts;
       if (lowS == null)
         lowS = true;
-      msgHash = ensureBytes("msgHash", msgHash);
+      msgHash = ensureBytes2("msgHash", msgHash);
       if (prehash)
-        msgHash = ensureBytes("prehashed msgHash", hash2(msgHash));
+        msgHash = ensureBytes2("prehashed msgHash", hash2(msgHash));
       const h1int = bits2int_modN(msgHash);
       const d = normPrivateKeyToScalar(privateKey);
       const seedArgs = [int2octets(d), int2octets(h1int)];
       if (ent != null) {
         const e = ent === true ? randomBytes2(Fp.BYTES) : ent;
-        seedArgs.push(ensureBytes("extraEntropy", e, Fp.BYTES));
+        seedArgs.push(ensureBytes2("extraEntropy", e, Fp.BYTES));
       }
-      const seed = concatBytes2(...seedArgs);
+      const seed = concatBytes3(...seedArgs);
       const m = h1int;
       function k2sig(kBytes) {
         const k = bits2int2(kBytes);
@@ -2654,12 +2983,12 @@ var starknet = (() => {
         const ik = invN(k);
         const q = Point.BASE.multiply(k).toAffine();
         const r = modN(q.x);
-        if (r === _0n5)
+        if (r === _0n6)
           return;
         const s = modN(ik * modN(m + r * d));
-        if (s === _0n5)
+        if (s === _0n6)
           return;
-        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n6);
         let normS = s;
         if (lowS && isBiggerThanHalfOrder(s)) {
           normS = normalizeS(s);
@@ -2673,15 +3002,15 @@ var starknet = (() => {
     const defaultVerOpts = { lowS: CURVE2.lowS, prehash: false };
     function sign2(msgHash, privKey, opts = defaultSigOpts) {
       const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-      const drbg = createHmacDrbg(CURVE2.hash.outputLen, CURVE2.nByteLength, CURVE2.hmac);
+      const drbg = createHmacDrbg2(CURVE2.hash.outputLen, CURVE2.nByteLength, CURVE2.hmac);
       return drbg(seed, k2sig);
     }
     Point.BASE._setWindowSize(8);
     function verify2(signature, msgHash, publicKey, opts = defaultVerOpts) {
       var _a;
       const sg = signature;
-      msgHash = ensureBytes("msgHash", msgHash);
-      publicKey = ensureBytes("publicKey", publicKey);
+      msgHash = ensureBytes2("msgHash", msgHash);
+      publicKey = ensureBytes2("publicKey", publicKey);
       if ("strict" in opts)
         throw new Error("options.strict was renamed to lowS");
       const { lowS, prehash } = opts;
@@ -2804,7 +3133,7 @@ var starknet = (() => {
   function getHash(hash2) {
     return {
       hash: hash2,
-      hmac: (key, ...msgs) => hmac(hash2, key, concatBytes(...msgs)),
+      hmac: (key, ...msgs) => hmac(hash2, key, concatBytes2(...msgs)),
       randomBytes
     };
   }
@@ -2816,7 +3145,7 @@ var starknet = (() => {
     while (bytes2[0] === 0)
       bytes2 = bytes2.subarray(1);
     const delta = bytes2.length * 8 - nBitLength;
-    const num = bytesToNumberBE(bytes2);
+    const num = bytesToNumberBE2(bytes2);
     return delta > 0 ? num >> BigInt(delta) : num;
   }
   function hex0xToBytes(hex) {
@@ -2825,7 +3154,7 @@ var starknet = (() => {
       if (hex.length & 1)
         hex = "0" + hex;
     }
-    return hexToBytes(hex);
+    return hexToBytes3(hex);
   }
   var curve = weierstrass({
     a: BigInt(1),
@@ -2840,18 +3169,18 @@ var starknet = (() => {
     ...getHash(sha256),
     bits2int,
     bits2int_modN: (bytes2) => {
-      const hex = bytesToNumberBE(bytes2).toString(16);
+      const hex = bytesToNumberBE2(bytes2).toString(16);
       if (hex.length === 63)
         bytes2 = hex0xToBytes(hex + "0");
       return mod(bits2int(bytes2), CURVE_ORDER);
     }
   });
   var _starkCurve = curve;
-  function ensureBytes2(hex) {
-    return ensureBytes("", typeof hex === "string" ? hex0xToBytes(hex) : hex);
+  function ensureBytes3(hex) {
+    return ensureBytes2("", typeof hex === "string" ? hex0xToBytes(hex) : hex);
   }
   function normPrivKey(privKey) {
-    return bytesToHex(ensureBytes2(privKey)).padStart(64, "0");
+    return bytesToHex2(ensureBytes3(privKey)).padStart(64, "0");
   }
   function getPublicKey(privKey, isCompressed = false) {
     return curve.getPublicKey(normPrivKey(privKey), isCompressed);
@@ -2860,15 +3189,15 @@ var starknet = (() => {
     return curve.getSharedSecret(normPrivKey(privKeyA), pubKeyB);
   }
   function sign(msgHash, privKey, opts) {
-    return curve.sign(ensureBytes2(msgHash), normPrivKey(privKey), opts);
+    return curve.sign(ensureBytes3(msgHash), normPrivKey(privKey), opts);
   }
   function verify(signature, msgHash, pubKey) {
-    const sig = signature instanceof Signature ? signature : ensureBytes2(signature);
-    return curve.verify(sig, ensureBytes2(msgHash), ensureBytes2(pubKey));
+    const sig = signature instanceof Signature ? signature : ensureBytes3(signature);
+    return curve.verify(sig, ensureBytes3(msgHash), ensureBytes3(pubKey));
   }
   var { CURVE, ProjectivePoint, Signature, utils } = curve;
   function extractX(bytes2) {
-    const hex = bytesToHex(bytes2.subarray(1));
+    const hex = bytesToHex2(bytes2.subarray(1));
     const stripped = hex.replace(/^0+/gm, "");
     return `0x${stripped}`;
   }
@@ -2879,11 +3208,11 @@ var starknet = (() => {
     return `0x${num.toString(16)}`;
   }
   function grindKey(seed) {
-    const _seed = ensureBytes2(seed);
+    const _seed = ensureBytes3(seed);
     const sha256mask = 2n ** 256n;
     const limit = sha256mask - mod(sha256mask, CURVE_ORDER);
     for (let i = 0; ; i++) {
-      const key = sha256Num(concatBytes2(_seed, numberToVarBytesBE(BigInt(i))));
+      const key = sha256Num(concatBytes3(_seed, numberToVarBytesBE2(BigInt(i))));
       if (key < limit)
         return mod(key, CURVE_ORDER).toString(16);
       if (i === 1e5)
@@ -2904,7 +3233,7 @@ var starknet = (() => {
   function getAccountPath(layer, application, ethereumAddress, index) {
     const layerNum = int31(sha256Num(layer));
     const applicationNum = int31(sha256Num(application));
-    const eth = hexToNumber(strip0x(ethereumAddress));
+    const eth = hexToNumber2(strip0x(ethereumAddress));
     return `m/2645'/${layerNum}'/${applicationNum}'/${int31(eth)}'/${int31(eth >> 31n)}'/${index}`;
   }
   var PEDERSEN_POINTS = [
@@ -2939,7 +3268,7 @@ var starknet = (() => {
         throw new Error(`Invalid pedersenArg: ${arg}`);
       value = BigInt(arg);
     } else {
-      value = bytesToNumberBE(ensureBytes2(arg));
+      value = bytesToNumberBE2(ensureBytes3(arg));
     }
     if (!(0n <= value && value < curve.CURVE.Fp.ORDER))
       throw new Error(`PedersenArg should be 0 <= value < CURVE.P: ${value}`);
@@ -2971,13 +3300,13 @@ var starknet = (() => {
     return Array.from(data).reverse().reduce((acc, i) => fn(i, acc));
   }
   var computeHashOnElements = (data, fn = pedersen) => [0, ...data, data.length].reduce((x, y) => fn(x, y));
-  var MASK_250 = bitMask(250);
-  var keccak = (data) => bytesToNumberBE(keccak_256(data)) & MASK_250;
-  var sha256Num = (data) => bytesToNumberBE(sha256(data));
+  var MASK_250 = bitMask2(250);
+  var keccak = (data) => bytesToNumberBE2(keccak_256(data)) & MASK_250;
+  var sha256Num = (data) => bytesToNumberBE2(sha256(data));
   var Fp253 = Field(BigInt("14474011154664525231415395255581126252639794253786371766033694892385558855681"));
   var Fp251 = Field(BigInt("3618502788666131213697322783095070105623107215331596699973092056135872020481"));
   function poseidonRoundConstant(Fp, name, idx) {
-    const val = Fp.fromBytes(sha256(utf8ToBytes(`${name}${idx}`)));
+    const val = Fp.fromBytes(sha256(utf8ToBytes2(`${name}${idx}`)));
     return Fp.create(val);
   }
   function _poseidonMDS(Fp, name, m, attempt = 0) {
@@ -3033,7 +3362,7 @@ var starknet = (() => {
     return fn([x, y, 2n])[0];
   }
   function poseidonHashFunc(x, y, fn = poseidonSmall) {
-    return numberToVarBytesBE(poseidonHash(bytesToNumberBE(x), bytesToNumberBE(y), fn));
+    return numberToVarBytesBE2(poseidonHash(bytesToNumberBE2(x), bytesToNumberBE2(y), fn));
   }
   function poseidonHashSingle(x, fn = poseidonSmall) {
     return fn([x, 0n, 1n])[0];
@@ -3077,71 +3406,6 @@ var starknet = (() => {
     UDC: () => UDC,
     ZERO: () => ZERO
   });
-
-  // src/utils/encode.ts
-  var encode_exports = {};
-  __export(encode_exports, {
-    IS_BROWSER: () => IS_BROWSER,
-    addHexPrefix: () => addHexPrefix,
-    arrayBufferToString: () => arrayBufferToString,
-    btoaUniversal: () => btoaUniversal,
-    buf2hex: () => buf2hex,
-    calcByteLength: () => calcByteLength,
-    padLeft: () => padLeft,
-    removeHexPrefix: () => removeHexPrefix,
-    sanitizeBytes: () => sanitizeBytes,
-    sanitizeHex: () => sanitizeHex,
-    utf8ToArray: () => utf8ToArray
-  });
-  var IS_BROWSER = typeof window !== "undefined";
-  var STRING_ZERO = "0";
-  function arrayBufferToString(array) {
-    return new Uint8Array(array).reduce((data, byte) => data + String.fromCharCode(byte), "");
-  }
-  function btoaUniversal(b) {
-    return IS_BROWSER ? btoa(arrayBufferToString(b)) : Buffer.from(b).toString("base64");
-  }
-  function buf2hex(buffer) {
-    return [...buffer].map((x) => x.toString(16).padStart(2, "0")).join("");
-  }
-  function removeHexPrefix(hex) {
-    return hex.replace(/^0x/i, "");
-  }
-  function addHexPrefix(hex) {
-    return `0x${removeHexPrefix(hex)}`;
-  }
-  function padString(str, length, left, padding = STRING_ZERO) {
-    const diff = length - str.length;
-    let result = str;
-    if (diff > 0) {
-      const pad = padding.repeat(diff);
-      result = left ? pad + str : str + pad;
-    }
-    return result;
-  }
-  function padLeft(str, length, padding = STRING_ZERO) {
-    return padString(str, length, true, padding);
-  }
-  function calcByteLength(length, byteSize = 8) {
-    const remainder = length % byteSize;
-    return remainder ? (length - remainder) / byteSize * byteSize + byteSize : length;
-  }
-  function sanitizeBytes(str, byteSize = 8, padding = STRING_ZERO) {
-    return padLeft(str, calcByteLength(str.length, byteSize), padding);
-  }
-  function sanitizeHex(hex) {
-    hex = removeHexPrefix(hex);
-    hex = sanitizeBytes(hex, 2);
-    if (hex) {
-      hex = addHexPrefix(hex);
-    }
-    return hex;
-  }
-  function utf8ToArray(str) {
-    return new TextEncoder().encode(str);
-  }
-
-  // src/constants.ts
   var ZERO = 0n;
   var MASK_2502 = 2n ** 250n - 1n;
   var MASK_251 = 2n ** 251n;
@@ -5210,6 +5474,83 @@ var starknet = (() => {
     ]
   ];
 
+  // src/utils/selector.ts
+  function keccakBn(value) {
+    const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
+    const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
+    return addHexPrefix(keccak(hexToBytes2(addHexPrefix(evenHex))).toString(16));
+  }
+  function keccakHex(value) {
+    return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
+  }
+  function starknetKeccak(value) {
+    const hash2 = BigInt(keccakHex(value));
+    return hash2 & MASK_2502;
+  }
+  function getSelectorFromName(funcName) {
+    return toHex(starknetKeccak(funcName));
+  }
+  function getSelector(value) {
+    if (isHex(value)) {
+      return value;
+    }
+    if (isStringWholeNumber(value)) {
+      return toHexString(value);
+    }
+    return getSelectorFromName(value);
+  }
+
+  // src/utils/shortString.ts
+  var shortString_exports = {};
+  __export(shortString_exports, {
+    decodeShortString: () => decodeShortString,
+    encodeShortString: () => encodeShortString,
+    isASCII: () => isASCII,
+    isDecimalString: () => isDecimalString,
+    isLongText: () => isLongText,
+    isShortString: () => isShortString,
+    isShortText: () => isShortText,
+    isText: () => isText,
+    splitLongString: () => splitLongString
+  });
+  var TEXT_TO_FELT_MAX_LEN = 31;
+  function isASCII(str) {
+    return /^[\x00-\x7F]*$/.test(str);
+  }
+  function isShortString(str) {
+    return str.length <= TEXT_TO_FELT_MAX_LEN;
+  }
+  function isDecimalString(decim) {
+    return /^[0-9]*$/i.test(decim);
+  }
+  function isText(val) {
+    return typeof val === "string" && !isHex(val) && !isStringWholeNumber(val);
+  }
+  var isShortText = (val) => isText(val) && isShortString(val);
+  var isLongText = (val) => isText(val) && !isShortString(val);
+  function splitLongString(longStr) {
+    const regex = RegExp(`[^]{1,${TEXT_TO_FELT_MAX_LEN}}`, "g");
+    return longStr.match(regex) || [];
+  }
+  function encodeShortString(str) {
+    if (!isASCII(str))
+      throw new Error(`${str} is not an ASCII string`);
+    if (!isShortString(str))
+      throw new Error(`${str} is too long`);
+    return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
+  }
+  function decodeShortString(str) {
+    if (!isASCII(str))
+      throw new Error(`${str} is not an ASCII string`);
+    if (isHex(str)) {
+      return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+    if (isDecimalString(str)) {
+      return decodeShortString("0X".concat(BigInt(str).toString(16)));
+    }
+    throw new Error(`${str} is not Hex or decimal`);
+  }
+
   // src/utils/calldata/cairo.ts
   var cairo_exports = {};
   __export(cairo_exports, {
@@ -5231,441 +5572,666 @@ var starknet = (() => {
     uint256: () => uint256
   });
 
-  // src/utils/num.ts
-  var num_exports = {};
-  __export(num_exports, {
-    assertInRange: () => assertInRange,
-    bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
-    bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
-    cleanHex: () => cleanHex,
-    getDecimalString: () => getDecimalString,
-    getHexString: () => getHexString,
-    getHexStringArray: () => getHexStringArray,
-    hexToBytes: () => hexToBytes3,
-    hexToDecimalString: () => hexToDecimalString,
-    isBigInt: () => isBigInt,
-    isHex: () => isHex,
-    isStringWholeNumber: () => isStringWholeNumber,
-    toBigInt: () => toBigInt,
-    toCairoBool: () => toCairoBool,
-    toHex: () => toHex,
-    toHexString: () => toHexString
+  // src/utils/uint256.ts
+  var uint256_exports = {};
+  __export(uint256_exports, {
+    UINT_128_MAX: () => UINT_128_MAX,
+    UINT_256_MAX: () => UINT_256_MAX,
+    bnToUint256: () => bnToUint256,
+    isUint256: () => isUint256,
+    uint256ToBN: () => uint256ToBN
   });
+  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;
+  function isUint256(bn) {
+    return toBigInt(bn) <= UINT_256_MAX;
+  }
+  function bnToUint256(bignumber) {
+    const bn = toBigInt(bignumber);
+    if (!isUint256(bn))
+      throw new Error("Number is too large");
+    return {
+      low: addHexPrefix((bn & UINT_128_MAX).toString(16)),
+      high: addHexPrefix((bn >> 128n).toString(16))
+    };
+  }
 
-  // node_modules/@noble/curves/esm/abstract/utils.js
-  var utils_exports2 = {};
-  __export(utils_exports2, {
-    bitGet: () => bitGet2,
-    bitLen: () => bitLen2,
-    bitMask: () => bitMask2,
-    bitSet: () => bitSet2,
-    bytesToHex: () => bytesToHex2,
-    bytesToNumberBE: () => bytesToNumberBE2,
-    bytesToNumberLE: () => bytesToNumberLE2,
-    concatBytes: () => concatBytes3,
-    createHmacDrbg: () => createHmacDrbg2,
-    ensureBytes: () => ensureBytes3,
-    equalBytes: () => equalBytes2,
-    hexToBytes: () => hexToBytes2,
-    hexToNumber: () => hexToNumber2,
-    numberToBytesBE: () => numberToBytesBE2,
-    numberToBytesLE: () => numberToBytesLE2,
-    numberToHexUnpadded: () => numberToHexUnpadded2,
-    numberToVarBytesBE: () => numberToVarBytesBE2,
-    utf8ToBytes: () => utf8ToBytes3,
-    validateObject: () => validateObject2
-  });
-  var _0n6 = BigInt(0);
-  var _1n6 = BigInt(1);
-  var _2n5 = BigInt(2);
-  var u8a2 = (a) => a instanceof Uint8Array;
-  var hexes3 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex2(bytes2) {
-    if (!u8a2(bytes2))
-      throw new Error("Uint8Array expected");
-    let hex = "";
-    for (let i = 0; i < bytes2.length; i++) {
-      hex += hexes3[bytes2[i]];
+  // 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" || type === "core::felt252";
+  var isTypeArray = (type) => /\*/.test(type) || type.startsWith("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 isTypeUint256 = (type) => type === "core::integer::u256";
+  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.lastIndexOf(">"));
     }
-    return hex;
-  }
-  function numberToHexUnpadded2(num) {
-    const hex = num.toString(16);
-    return hex.length & 1 ? `0${hex}` : hex;
-  }
-  function hexToNumber2(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    return BigInt(hex === "" ? "0" : `0x${hex}`);
-  }
-  function hexToBytes2(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    if (hex.length % 2)
-      throw new Error("hex string is invalid: unpadded " + hex.length);
-    const array = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < array.length; i++) {
-      const j = i * 2;
-      const hexByte = hex.slice(j, j + 2);
-      const byte = Number.parseInt(hexByte, 16);
-      if (Number.isNaN(byte) || byte < 0)
-        throw new Error("invalid byte sequence");
-      array[i] = byte;
+    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();
     }
-    return array;
+    if (isText(it)) {
+      if (!isShortString(it))
+        throw new Error(
+          `${it} is a long string > 31 chars, felt can store short strings, split it to array of short strings`
+        );
+      const encoded = encodeShortString(it);
+      return BigInt(encoded).toString();
+    }
+    if (typeof it === "string" && isHex(it)) {
+      return BigInt(it).toString();
+    }
+    if (typeof it === "string" && isStringWholeNumber(it)) {
+      return it;
+    }
+    if (typeof it === "boolean") {
+      return `${+it}`;
+    }
+    throw new Error(`${it} can't be computed by felt()`);
   }
-  function bytesToNumberBE2(bytes2) {
-    return hexToNumber2(bytesToHex2(bytes2));
+
+  // src/utils/calldata/formatter.ts
+  var guard = {
+    isBN: (data, type, key) => {
+      if (!isBigInt(data[key]))
+        throw new Error(
+          `Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`
+        );
+    },
+    unknown: (data, type, key) => {
+      throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
+    }
+  };
+  function formatter(data, type, sameType) {
+    return Object.entries(data).reduce((acc, [key, value]) => {
+      const elType = sameType ?? type[key];
+      if (!(key in type) && !sameType) {
+        acc[key] = value;
+        return acc;
+      }
+      if (elType === "string") {
+        if (Array.isArray(data[key])) {
+          const arrayStr = formatter(
+            data[key],
+            data[key].map((_) => elType)
+          );
+          acc[key] = Object.values(arrayStr).join("");
+          return acc;
+        }
+        guard.isBN(data, type, key);
+        acc[key] = decodeShortString(value);
+        return acc;
+      }
+      if (elType === "number") {
+        guard.isBN(data, type, key);
+        acc[key] = Number(value);
+        return acc;
+      }
+      if (typeof elType === "function") {
+        acc[key] = elType(value);
+        return acc;
+      }
+      if (Array.isArray(elType)) {
+        const arrayObj = formatter(data[key], elType, elType[0]);
+        acc[key] = Object.values(arrayObj);
+        return acc;
+      }
+      if (typeof elType === "object") {
+        acc[key] = formatter(data[key], elType);
+        return acc;
+      }
+      guard.unknown(data, type, key);
+      return acc;
+    }, {});
   }
-  function bytesToNumberLE2(bytes2) {
-    if (!u8a2(bytes2))
-      throw new Error("Uint8Array expected");
-    return hexToNumber2(bytesToHex2(Uint8Array.from(bytes2).reverse()));
+
+  // src/utils/calldata/tuple.ts
+  function parseNamedTuple(namedTuple) {
+    const name = namedTuple.substring(0, namedTuple.indexOf(":"));
+    const type = namedTuple.substring(name.length + ":".length);
+    return { name, type };
   }
-  var numberToBytesBE2 = (n, len) => hexToBytes2(n.toString(16).padStart(len * 2, "0"));
-  var numberToBytesLE2 = (n, len) => numberToBytesBE2(n, len).reverse();
-  var numberToVarBytesBE2 = (n) => hexToBytes2(numberToHexUnpadded2(n));
-  function ensureBytes3(title, hex, expectedLength) {
-    let res;
-    if (typeof hex === "string") {
-      try {
-        res = hexToBytes2(hex);
-      } catch (e) {
-        throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+  function parseSubTuple(s) {
+    if (!s.includes("("))
+      return { subTuple: [], result: s };
+    const subTuple = [];
+    let result = "";
+    let i = 0;
+    while (i < s.length) {
+      if (s[i] === "(") {
+        let counter = 1;
+        const lBracket = i;
+        i++;
+        while (counter) {
+          if (s[i] === ")")
+            counter--;
+          if (s[i] === "(")
+            counter++;
+          i++;
+        }
+        subTuple.push(s.substring(lBracket, i));
+        result += " ";
+        i--;
+      } else {
+        result += s[i];
       }
-    } else if (u8a2(hex)) {
-      res = Uint8Array.from(hex);
-    } else {
-      throw new Error(`${title} must be hex string or Uint8Array`);
+      i++;
     }
-    const len = res.length;
-    if (typeof expectedLength === "number" && len !== expectedLength)
-      throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
-    return res;
+    return {
+      subTuple,
+      result
+    };
   }
-  function concatBytes3(...arrs) {
-    const r = new Uint8Array(arrs.reduce((sum, a) => sum + a.length, 0));
-    let pad = 0;
-    arrs.forEach((a) => {
-      if (!u8a2(a))
-        throw new Error("Uint8Array expected");
-      r.set(a, pad);
-      pad += a.length;
+  function extractCairo0Tuple(type) {
+    const cleanType = type.replace(/\s/g, "").slice(1, -1);
+    const { subTuple, result } = parseSubTuple(cleanType);
+    let recomposed = result.split(",").map((it) => {
+      return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
     });
-    return r;
+    if (isTypeNamedTuple(type)) {
+      recomposed = recomposed.reduce((acc, it) => {
+        return acc.concat(parseNamedTuple(it));
+      }, []);
+    }
+    return recomposed;
   }
-  function equalBytes2(b1, b2) {
-    if (b1.length !== b2.length)
-      return false;
-    for (let i = 0; i < b1.length; i++)
-      if (b1[i] !== b2[i])
-        return false;
-    return true;
+  function extractCairo1Tuple(type) {
+    const cleanType = type.replace(/\s/g, "").slice(1, -1);
+    return cleanType.split(",");
   }
-  function utf8ToBytes3(str) {
-    if (typeof str !== "string") {
-      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  function extractTupleMemberTypes(type) {
+    if (isCairo1Type(type)) {
+      return extractCairo1Tuple(type);
     }
-    return new TextEncoder().encode(str);
-  }
-  function bitLen2(n) {
-    let len;
-    for (len = 0; n > 0n; n >>= _1n6, len += 1)
-      ;
-    return len;
-  }
-  var bitGet2 = (n, pos) => n >> BigInt(pos) & 1n;
-  var bitSet2 = (n, pos, value) => n | (value ? _1n6 : _0n6) << BigInt(pos);
-  var bitMask2 = (n) => (_2n5 << BigInt(n - 1)) - _1n6;
-  var u8n2 = (data) => new Uint8Array(data);
-  var u8fr2 = (arr) => Uint8Array.from(arr);
-  function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
-    if (typeof hashLen !== "number" || hashLen < 2)
-      throw new Error("hashLen must be a number");
-    if (typeof qByteLen !== "number" || qByteLen < 2)
-      throw new Error("qByteLen must be a number");
-    if (typeof hmacFn !== "function")
-      throw new Error("hmacFn must be a function");
-    let v = u8n2(hashLen);
-    let k = u8n2(hashLen);
-    let i = 0;
-    const reset = () => {
-      v.fill(1);
-      k.fill(0);
-      i = 0;
-    };
-    const h = (...b) => hmacFn(k, v, ...b);
-    const reseed = (seed = u8n2()) => {
-      k = h(u8fr2([0]), seed);
-      v = h();
-      if (seed.length === 0)
-        return;
-      k = h(u8fr2([1]), seed);
-      v = h();
-    };
-    const gen2 = () => {
-      if (i++ >= 1e3)
-        throw new Error("drbg: tried 1000 values");
-      let len = 0;
-      const out = [];
-      while (len < qByteLen) {
-        v = h();
-        const sl = v.slice();
-        out.push(sl);
-        len += v.length;
-      }
-      return concatBytes3(...out);
-    };
-    const genUntil = (seed, pred) => {
-      reset();
-      reseed(seed);
-      let res = void 0;
-      while (!(res = pred(gen2())))
-        reseed();
-      reset();
-      return res;
-    };
-    return genUntil;
-  }
-  var validatorFns2 = {
-    bigint: (val) => typeof val === "bigint",
-    function: (val) => typeof val === "function",
-    boolean: (val) => typeof val === "boolean",
-    string: (val) => typeof val === "string",
-    isSafeInteger: (val) => Number.isSafeInteger(val),
-    array: (val) => Array.isArray(val),
-    field: (val, object) => object.Fp.isValid(val),
-    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
-  };
-  function validateObject2(object, validators, optValidators = {}) {
-    const checkField = (fieldName, type, isOptional) => {
-      const checkVal = validatorFns2[type];
-      if (typeof checkVal !== "function")
-        throw new Error(`Invalid validator "${type}", expected function`);
-      const val = object[fieldName];
-      if (isOptional && val === void 0)
-        return;
-      if (!checkVal(val, object)) {
-        throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
-      }
-    };
-    for (const [fieldName, type] of Object.entries(validators))
-      checkField(fieldName, type, false);
-    for (const [fieldName, type] of Object.entries(optValidators))
-      checkField(fieldName, type, true);
-    return object;
+    return extractCairo0Tuple(type);
   }
 
-  // src/utils/num.ts
-  function isHex(hex) {
-    return /^0x[0-9a-f]*$/i.test(hex);
-  }
-  function toBigInt(value) {
-    return BigInt(value);
-  }
-  function isBigInt(value) {
-    return typeof value === "bigint";
-  }
-  function toHex(number3) {
-    return addHexPrefix(toBigInt(number3).toString(16));
-  }
-  function hexToDecimalString(hex) {
-    return BigInt(addHexPrefix(hex)).toString(10);
-  }
-  var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
-  function assertInRange(input, lowerBound, upperBound, inputName = "") {
-    const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
-    const inputBigInt = BigInt(input);
-    const lowerBoundBigInt = BigInt(lowerBound);
-    const upperBoundBigInt = BigInt(upperBound);
-    assert(
-      inputBigInt >= lowerBoundBigInt && inputBigInt <= upperBoundBigInt,
-      `Message not signable, ${messageSuffix}.`
-    );
-  }
-  function bigNumberishArrayToDecimalStringArray(rawCalldata) {
-    return rawCalldata.map((x) => toBigInt(x).toString(10));
+  // src/utils/calldata/requestParser.ts
+  function parseBaseTypes(type, val) {
+    switch (true) {
+      case isTypeUint256(type):
+        const el_uint256 = uint256(val);
+        return [felt(el_uint256.low), felt(el_uint256.high)];
+      default:
+        return felt(val);
+    }
   }
-  function bigNumberishArrayToHexadecimalStringArray(rawCalldata) {
-    return rawCalldata.map((x) => toHex(x));
+  function parseTuple(element, typeStr) {
+    const memberTypes = extractTupleMemberTypes(typeStr);
+    const elements = Object.values(element);
+    if (elements.length !== memberTypes.length) {
+      throw Error(
+        `ParseTuple: provided and expected abi tuple size do not match.
+      provided: ${elements} 
+      expected: ${memberTypes}`
+      );
+    }
+    return memberTypes.map((it, dx) => {
+      return {
+        element: elements[dx],
+        type: it.type ?? it
+      };
+    });
   }
-  var isStringWholeNumber = (value) => /^\d+$/.test(value);
-  var toHexString = (value) => toHex(value);
-  function getDecimalString(value) {
-    if (isHex(value)) {
-      return hexToDecimalString(value);
+  function parseCalldataValue(element, type, structs) {
+    if (element === void 0) {
+      throw Error(`Missing parameter for type ${type}`);
     }
-    if (isStringWholeNumber(value)) {
-      return value;
+    if (Array.isArray(element)) {
+      const result = [];
+      result.push(felt(element.length));
+      const arrayType = getArrayType(type);
+      return element.reduce((acc, it) => {
+        return acc.concat(parseCalldataValue(it, arrayType, structs));
+      }, result);
     }
-    throw new Error(`${value} need to be hex-string or whole-number-string`);
-  }
-  function getHexString(value) {
-    if (isHex(value)) {
-      return value;
+    if (structs[type] && structs[type].members.length) {
+      const { members } = structs[type];
+      const subElement = element;
+      return members.reduce((acc, it) => {
+        return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs));
+      }, []);
     }
-    if (isStringWholeNumber(value)) {
-      return toHexString(value);
+    if (isTypeTuple(type)) {
+      const tupled = parseTuple(element, type);
+      return tupled.reduce((acc, it) => {
+        const parsedData = parseCalldataValue(it.element, it.type, structs);
+        return acc.concat(parsedData);
+      }, []);
     }
-    throw new Error(`${value} need to be hex-string or whole-number-string`);
-  }
-  function getHexStringArray(value) {
-    return value.map((el) => getHexString(el));
+    if (typeof element === "object") {
+      throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
+    }
+    return parseBaseTypes(type, element);
   }
-  var toCairoBool = (value) => (+value).toString();
-  function hexToBytes3(value) {
-    if (!isHex(value))
-      throw new Error(`${value} need to be a hex-string`);
-    let adaptedValue = removeHexPrefix(value);
-    if (adaptedValue.length % 2 !== 0) {
-      adaptedValue = `0${adaptedValue}`;
+  function parseCalldataField(argsIterator, input, structs) {
+    const { name, type } = input;
+    let { value } = argsIterator.next();
+    switch (true) {
+      case isTypeArray(type):
+        if (!Array.isArray(value) && !isText(value)) {
+          throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
+        }
+        if (typeof value === "string") {
+          value = splitLongString(value);
+        }
+        return parseCalldataValue(value, input.type, structs);
+      case (isTypeStruct(type, structs) || isTypeTuple(type)):
+        return parseCalldataValue(value, type, structs);
+      case isTypeUint256(type):
+        if (typeof value === "object") {
+          return [felt(value.low), felt(value.high)];
+        }
+        const el_uint256 = uint256(value);
+        return [felt(el_uint256.low), felt(el_uint256.high)];
+      default:
+        return parseBaseTypes(type, value);
     }
-    return hexToBytes2(adaptedValue);
   }
 
-  // src/utils/shortString.ts
-  var shortString_exports = {};
-  __export(shortString_exports, {
-    decodeShortString: () => decodeShortString,
-    encodeShortString: () => encodeShortString,
-    isASCII: () => isASCII,
-    isDecimalString: () => isDecimalString,
-    isLongText: () => isLongText,
-    isShortString: () => isShortString,
-    isShortText: () => isShortText,
-    isText: () => isText,
-    splitLongString: () => splitLongString
-  });
-  var TEXT_TO_FELT_MAX_LEN = 31;
-  function isASCII(str) {
-    return /^[\x00-\x7F]*$/.test(str);
-  }
-  function isShortString(str) {
-    return str.length <= TEXT_TO_FELT_MAX_LEN;
-  }
-  function isDecimalString(decim) {
-    return /^[0-9]*$/i.test(decim);
-  }
-  function isText(val) {
-    return typeof val === "string" && !isHex(val) && !isStringWholeNumber(val);
-  }
-  var isShortText = (val) => isText(val) && isShortString(val);
-  var isLongText = (val) => isText(val) && !isShortString(val);
-  function splitLongString(longStr) {
-    const regex = RegExp(`[^]{1,${TEXT_TO_FELT_MAX_LEN}}`, "g");
-    return longStr.match(regex) || [];
-  }
-  function encodeShortString(str) {
-    if (!isASCII(str))
-      throw new Error(`${str} is not an ASCII string`);
-    if (!isShortString(str))
-      throw new Error(`${str} is too long`);
-    return addHexPrefix(str.replace(/./g, (char) => char.charCodeAt(0).toString(16)));
-  }
-  function decodeShortString(str) {
-    if (!isASCII(str))
-      throw new Error(`${str} is not an ASCII string`);
-    if (isHex(str)) {
-      return removeHexPrefix(str).replace(/.{2}/g, (hex) => String.fromCharCode(parseInt(hex, 16)));
-    }
-    if (isDecimalString(str)) {
-      return decodeShortString("0X".concat(BigInt(str).toString(16)));
+  // src/utils/calldata/responseParser.ts
+  function parseBaseTypes2(type, it) {
+    let temp;
+    switch (true) {
+      case isTypeBool(type):
+        temp = it.next().value;
+        return Boolean(BigInt(temp));
+      case isTypeUint256(type):
+        const low = it.next().value;
+        const high = it.next().value;
+        return uint256ToBN({ low, high });
+      default:
+        temp = it.next().value;
+        return BigInt(temp);
     }
-    throw new Error(`${str} is not Hex or decimal`);
   }
-
-  // src/utils/uint256.ts
-  var uint256_exports = {};
-  __export(uint256_exports, {
-    UINT_128_MAX: () => UINT_128_MAX,
-    UINT_256_MAX: () => UINT_256_MAX,
-    bnToUint256: () => bnToUint256,
-    isUint256: () => isUint256,
-    uint256ToBN: () => uint256ToBN
-  });
-  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;
-  function isUint256(bn) {
-    return toBigInt(bn) <= UINT_256_MAX;
+  function parseResponseValue(responseIterator, element, structs) {
+    if (element.type in structs && structs[element.type]) {
+      return structs[element.type].members.reduce((acc, el) => {
+        acc[el.name] = parseResponseValue(responseIterator, el, structs);
+        return acc;
+      }, {});
+    }
+    if (isTypeTuple(element.type)) {
+      const memberTypes = extractTupleMemberTypes(element.type);
+      return memberTypes.reduce((acc, it, idx) => {
+        const name = (it == null ? void 0 : it.name) ? it.name : idx;
+        const type = (it == null ? void 0 : it.type) ? it.type : it;
+        const el = { name, type };
+        acc[name] = parseResponseValue(responseIterator, el, structs);
+        return acc;
+      }, {});
+    }
+    if (isTypeArray(element.type)) {
+      const parsedDataArr = [];
+      const el = { name: "", type: getArrayType(element.type) };
+      const len = BigInt(responseIterator.next().value);
+      while (parsedDataArr.length < len) {
+        parsedDataArr.push(parseResponseValue(responseIterator, el, structs));
+      }
+      return parsedDataArr;
+    }
+    return parseBaseTypes2(element.type, responseIterator);
   }
-  function bnToUint256(bignumber) {
-    const bn = toBigInt(bignumber);
-    if (!isUint256(bn))
-      throw new Error("Number is too large");
-    return {
-      low: addHexPrefix((bn & UINT_128_MAX).toString(16)),
-      high: addHexPrefix((bn >> 128n).toString(16))
-    };
+  function responseParser(responseIterator, output2, structs, parsedResult) {
+    const { name, type } = output2;
+    let temp;
+    switch (true) {
+      case isLen(name):
+        temp = responseIterator.next().value;
+        return BigInt(temp);
+      case (type in structs || isTypeTuple(type)):
+        return parseResponseValue(responseIterator, output2, structs);
+      case isTypeArray(type):
+        if (isCairo1Type(type)) {
+          return parseResponseValue(responseIterator, output2, structs);
+        }
+        const parsedDataArr = [];
+        if (parsedResult && parsedResult[`${name}_len`]) {
+          const arrLen = parsedResult[`${name}_len`];
+          while (parsedDataArr.length < arrLen) {
+            parsedDataArr.push(
+              parseResponseValue(
+                responseIterator,
+                { name, type: output2.type.replace("*", "") },
+                structs
+              )
+            );
+          }
+        }
+        return parsedDataArr;
+      default:
+        return parseBaseTypes2(type, responseIterator);
+    }
   }
 
-  // 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" || 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 isTypeUint256 = (type) => type === "core::integer::u256";
-  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(">"));
+  // src/utils/calldata/validate.ts
+  var validateFelt = (parameter, input) => {
+    assert(
+      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
+      `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
+    );
+  };
+  var validateUint = (parameter, input) => {
+    if (typeof parameter === "number") {
+      assert(
+        parameter <= Number.MAX_SAFE_INTEGER,
+        `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
+      );
+    }
+    assert(
+      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint" || typeof parameter === "object" && "low" in parameter && "high" in parameter,
+      `Validate: arg ${input.name} of cairo ZORG type ${input.type} should be type (String, Number or BigInt)`
+    );
+    const param = typeof parameter === "object" ? uint256ToBN(parameter) : toBigInt(parameter);
+    switch (input.type) {
+      case "core::integer::u8" /* u8 */:
+        assert(
+          param >= 0n && param <= 255n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
+        );
+        break;
+      case "core::integer::u16" /* u16 */:
+        assert(
+          param >= 0n && param <= 65535n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
+        );
+        break;
+      case "core::integer::u32" /* u32 */:
+        assert(
+          param >= 0n && param <= 4294967295n,
+          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
+        );
+        break;
+      case "core::integer::u64" /* u64 */:
+        assert(
+          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 */:
+        assert(
+          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 */:
+        assert(
+          param >= 0n && param <= 2n ** 256n - 1n,
+          `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
+        );
+        break;
+      default:
+        break;
     }
-    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 validateBool = (parameter, input) => {
+    assert(
+      typeof parameter === "boolean",
+      `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
+    );
   };
-  var tuple = (...args) => ({ ...args });
-  function felt(it) {
-    if (isBigInt(it) || typeof it === "number" && Number.isInteger(it)) {
-      return it.toString();
-    }
-    if (isText(it)) {
-      if (!isShortString(it))
+  var validateStruct = (parameter, input, structs) => {
+    assert(
+      typeof parameter === "object" && !Array.isArray(parameter),
+      `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`
+    );
+    structs[input.type].members.forEach(({ name }) => {
+      assert(
+        Object.keys(parameter).includes(name),
+        `Validate: arg ${input.name} should have a property ${name}`
+      );
+    });
+  };
+  var validateTuple = (parameter, input) => {
+    assert(
+      typeof parameter === "object" && !Array.isArray(parameter),
+      `Validate: arg ${input.name} should be a tuple (defined as object)`
+    );
+  };
+  var validateArray = (parameter, input, structs) => {
+    const baseType = getArrayType(input.type);
+    if (isTypeFelt(baseType) && isLongText(parameter))
+      return;
+    assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
+    switch (true) {
+      case isTypeFelt(baseType):
+        parameter.forEach((param) => validateFelt(param, input));
+        break;
+      case isTypeTuple(baseType):
+        parameter.forEach((it) => validateTuple(it, { name: input.name, type: baseType }));
+        break;
+      case isTypeStruct(baseType, structs):
+        parameter.forEach(
+          (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;
+      case isTypeArray(baseType):
+        parameter.forEach(
+          (param) => validateArray(param, { name: "", type: baseType }, structs)
+        );
+        break;
+      default:
         throw new Error(
-          `${it} is a long string > 31 chars, felt can store short strings, split it to array of short strings`
+          `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
         );
-      const encoded = encodeShortString(it);
-      return BigInt(encoded).toString();
     }
-    if (typeof it === "string" && isHex(it)) {
-      return BigInt(it).toString();
-    }
-    if (typeof it === "string" && isStringWholeNumber(it)) {
-      return it;
-    }
-    if (typeof it === "boolean") {
-      return `${+it}`;
-    }
-    throw new Error(`${it} can't be computed by felt()`);
+  };
+  function validateFields(abiMethod, args, structs) {
+    abiMethod.inputs.reduce((acc, input) => {
+      const parameter = args[acc];
+      switch (true) {
+        case isLen(input.name):
+          return acc;
+        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;
+        case isTypeTuple(input.type):
+          validateTuple(parameter, input);
+          break;
+        case isTypeArray(input.type):
+          validateArray(parameter, input, structs);
+          break;
+        default:
+          throw new Error(
+            `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
+          );
+      }
+      return acc + 1;
+    }, 0);
   }
 
-  // src/utils/ec.ts
-  var ec_exports = {};
-  __export(ec_exports, {
-    starkCurve: () => esm_exports,
+  // src/utils/calldata/index.ts
+  var CallData = class {
+    constructor(abi) {
+      this.abi = abi;
+      this.structs = CallData.getAbiStruct(abi);
+    }
+    validate(type, method, args = []) {
+      if (type !== "DEPLOY") {
+        const invocableFunctionNames = this.abi.filter((abi) => {
+          if (abi.type !== "function")
+            return false;
+          const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
+          return type === "INVOKE" ? !isView : isView;
+        }).map((abi) => abi.name);
+        assert(
+          invocableFunctionNames.includes(method),
+          `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
+        );
+      }
+      const abiMethod = this.abi.find(
+        (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
+      );
+      const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
+      if (args.length !== inputsLength) {
+        throw Error(
+          `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
+        );
+      }
+      validateFields(abiMethod, args, this.structs);
+    }
+    compile(method, args) {
+      const argsIterator = args[Symbol.iterator]();
+      const { inputs } = this.abi.find((abi) => abi.name === method);
+      return inputs.reduce(
+        (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
+        []
+      );
+    }
+    static compile(rawArgs) {
+      const createTree = (obj) => {
+        const getEntries = (o, prefix = "") => {
+          const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
+          return Object.entries(oe).flatMap(([k, v]) => {
+            let value = v;
+            if (isLongText(value))
+              value = splitLongString(value);
+            if (k === "entrypoint")
+              value = getSelectorFromName(value);
+            const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
+            if (isBigInt(value))
+              return [[`${prefix}${kk}`, felt(value)]];
+            return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
+          });
+        };
+        return Object.fromEntries(getEntries(obj));
+      };
+      let callTreeArray;
+      if (!Array.isArray(rawArgs)) {
+        const callTree = createTree(rawArgs);
+        callTreeArray = Object.values(callTree);
+      } else {
+        const callObj = { ...rawArgs };
+        const callTree = createTree(callObj);
+        callTreeArray = Object.values(callTree);
+      }
+      Object.defineProperty(callTreeArray, "__compiled__", {
+        enumerable: false,
+        writable: false,
+        value: true
+      });
+      return callTreeArray;
+    }
+    parse(method, response) {
+      const { outputs } = this.abi.find((abi) => abi.name === method);
+      const responseIterator = response.flat()[Symbol.iterator]();
+      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);
+      return formatter(parsed, format);
+    }
+    static abiInputsLength(inputs) {
+      return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+    }
+    static getAbiStruct(abi) {
+      return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
+        (acc, abiEntry) => ({
+          ...acc,
+          [abiEntry.name]: abiEntry
+        }),
+        {}
+      );
+    }
+    static toCalldata(rawCalldata = []) {
+      return CallData.compile(rawCalldata);
+    }
+    static toHex(raw = []) {
+      const calldata = CallData.compile(raw);
+      return calldata.map((it) => toHex(it));
+    }
+  };
+
+  // src/utils/fetchPonyfill.ts
+  var import_isomorphic_fetch = __toESM(require_fetch_npm_browserify());
+  var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || import_isomorphic_fetch.default;
+
+  // src/utils/hash.ts
+  var hash_exports = {};
+  __export(hash_exports, {
+    calculateContractAddressFromHash: () => calculateContractAddressFromHash,
+    calculateDeclareTransactionHash: () => calculateDeclareTransactionHash,
+    calculateDeployAccountTransactionHash: () => calculateDeployAccountTransactionHash,
+    calculateDeployTransactionHash: () => calculateDeployTransactionHash,
+    calculateTransactionHash: () => calculateTransactionHash,
+    calculateTransactionHashCommon: () => calculateTransactionHashCommon,
+    computeCompiledClassHash: () => computeCompiledClassHash,
+    computeContractClassHash: () => computeContractClassHash,
+    computeHashOnElements: () => computeHashOnElements2,
+    computeLegacyContractClassHash: () => computeLegacyContractClassHash,
+    computeSierraContractClassHash: () => computeSierraContractClassHash,
+    default: () => computeHintedClassHash,
+    feeTransactionVersion: () => feeTransactionVersion,
+    formatSpaces: () => formatSpaces,
+    getSelector: () => getSelector,
+    getSelectorFromName: () => getSelectorFromName,
+    keccakBn: () => keccakBn,
+    poseidon: () => poseidon_exports,
+    starknetKeccak: () => starknetKeccak,
+    transactionVersion: () => transactionVersion,
+    transactionVersion_2: () => transactionVersion_2
+  });
+
+  // src/utils/ec.ts
+  var ec_exports = {};
+  __export(ec_exports, {
+    starkCurve: () => esm_exports,
     weierstrass: () => weierstrass_exports
   });
 
@@ -5741,7 +6307,7 @@ var starknet = (() => {
       map[val] = "function";
       return map;
     }, initial);
-    return validateObject2(field, opts);
+    return validateObject(field, opts);
   }
   function FpPow2(f, num, power) {
     if (power < _0n7)
@@ -5766,12 +6332,12 @@ var starknet = (() => {
     return { nBitLength: _nBitLength, nByteLength };
   }
   function hashToPrivateScalar2(hash2, groupOrder, isLE2 = false) {
-    hash2 = ensureBytes3("privateHash", hash2);
+    hash2 = ensureBytes("privateHash", hash2);
     const hashLen = hash2.length;
     const minLen = nLength2(groupOrder).nByteLength + 8;
     if (minLen < 24 || hashLen < minLen || hashLen > 1024)
       throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
-    const num = isLE2 ? bytesToNumberLE2(hash2) : bytesToNumberBE2(hash2);
+    const num = isLE2 ? bytesToNumberLE(hash2) : bytesToNumberBE(hash2);
     return mod2(num, groupOrder - _1n7) + _1n7;
   }
 
@@ -5859,7 +6425,7 @@ var starknet = (() => {
   }
   function validateBasic2(curve2) {
     validateField2(curve2.Fp);
-    validateObject2(curve2, {
+    validateObject(curve2, {
       n: "bigint",
       h: "bigint",
       Gx: "field",
@@ -5874,7 +6440,7 @@ var starknet = (() => {
   // node_modules/@noble/curves/esm/abstract/weierstrass.js
   function validatePointOpts2(curve2) {
     const opts = validateBasic2(curve2);
-    validateObject2(opts, {
+    validateObject(opts, {
       a: "field",
       b: "field",
       fromBytes: "function",
@@ -5897,7 +6463,7 @@ var starknet = (() => {
     }
     return Object.freeze({ ...opts });
   }
-  var { bytesToNumberBE: b2n2, hexToBytes: h2b2 } = utils_exports2;
+  var { bytesToNumberBE: b2n2, hexToBytes: h2b2 } = utils_exports;
   var DER2 = {
     Err: class DERErr2 extends Error {
       constructor(m = "") {
@@ -5969,14 +6535,14 @@ var starknet = (() => {
       const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE2;
       if (lengths && typeof key !== "bigint") {
         if (key instanceof Uint8Array)
-          key = bytesToHex2(key);
+          key = bytesToHex(key);
         if (typeof key !== "string" || !lengths.includes(key.length))
           throw new Error("Invalid key");
         key = key.padStart(nByteLength * 2, "0");
       }
       let num;
       try {
-        num = typeof key === "bigint" ? key : bytesToNumberBE2(ensureBytes3("private key", key, nByteLength));
+        num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
       } catch (error) {
         throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
       }
@@ -6024,7 +6590,7 @@ var starknet = (() => {
         return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
       }
       static fromHex(hex) {
-        const P = Point.fromAffine(CURVE2.fromBytes(ensureBytes3("pointHex", hex)));
+        const P = Point.fromAffine(CURVE2.fromBytes(ensureBytes("pointHex", hex)));
         P.assertValidity();
         return P;
       }
@@ -6259,7 +6825,7 @@ var starknet = (() => {
         return CURVE2.toBytes(Point, this, isCompressed);
       }
       toHex(isCompressed = true) {
-        return bytesToHex2(this.toRawBytes(isCompressed));
+        return bytesToHex(this.toRawBytes(isCompressed));
       }
     }
     Point.BASE = new Point(CURVE2.Gx, CURVE2.Gy, Fp.ONE);
@@ -6275,7 +6841,7 @@ var starknet = (() => {
   }
   function validateOpts3(curve2) {
     const opts = validateBasic2(curve2);
-    validateObject2(opts, {
+    validateObject(opts, {
       hash: "hash",
       hmac: "function",
       randomBytes: "function"
@@ -6306,7 +6872,7 @@ var starknet = (() => {
       toBytes(c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp.toBytes(a.x);
-        const cat = concatBytes3;
+        const cat = concatBytes;
         if (isCompressed) {
           return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
         } else {
@@ -6318,7 +6884,7 @@ var starknet = (() => {
         const head = bytes2[0];
         const tail = bytes2.subarray(1);
         if (len === compressedLen && (head === 2 || head === 3)) {
-          const x = bytesToNumberBE2(tail);
+          const x = bytesToNumberBE(tail);
           if (!isValidFieldElement(x))
             throw new Error("Point is not on curve");
           const y2 = weierstrassEquation(x);
@@ -6337,7 +6903,7 @@ var starknet = (() => {
         }
       }
     });
-    const numToNByteStr = (num) => bytesToHex2(numberToBytesBE2(num, CURVE2.nByteLength));
+    const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE2.nByteLength));
     function isBiggerThanHalfOrder(number3) {
       const HALF = CURVE_ORDER2 >> _1n9;
       return number3 > HALF;
@@ -6345,7 +6911,7 @@ var starknet = (() => {
     function normalizeS(s) {
       return isBiggerThanHalfOrder(s) ? modN(-s) : s;
     }
-    const slcNum = (b, from, to) => bytesToNumberBE2(b.slice(from, to));
+    const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
     class Signature3 {
       constructor(r, s, recovery) {
         this.r = r;
@@ -6355,11 +6921,11 @@ var starknet = (() => {
       }
       static fromCompact(hex) {
         const l = CURVE2.nByteLength;
-        hex = ensureBytes3("compactSignature", hex, l * 2);
+        hex = ensureBytes("compactSignature", hex, l * 2);
         return new Signature3(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
       }
       static fromDER(hex) {
-        const { r, s } = DER2.toSig(ensureBytes3("DER", hex));
+        const { r, s } = DER2.toSig(ensureBytes("DER", hex));
         return new Signature3(r, s);
       }
       assertValidity() {
@@ -6373,7 +6939,7 @@ var starknet = (() => {
       }
       recoverPublicKey(msgHash) {
         const { r, s, recovery: rec } = this;
-        const h = bits2int_modN(ensureBytes3("msgHash", msgHash));
+        const h = bits2int_modN(ensureBytes("msgHash", msgHash));
         if (rec == null || ![0, 1, 2, 3].includes(rec))
           throw new Error("recovery id invalid");
         const radj = rec === 2 || rec === 3 ? r + CURVE2.n : r;
@@ -6397,13 +6963,13 @@ var starknet = (() => {
         return this.hasHighS() ? new Signature3(this.r, modN(-this.s), this.recovery) : this;
       }
       toDERRawBytes() {
-        return hexToBytes2(this.toDERHex());
+        return hexToBytes(this.toDERHex());
       }
       toDERHex() {
         return DER2.hexFromSig({ r: this.r, s: this.s });
       }
       toCompactRawBytes() {
-        return hexToBytes2(this.toCompactHex());
+        return hexToBytes(this.toCompactHex());
       }
       toCompactHex() {
         return numToNByteStr(this.r) + numToNByteStr(this.s);
@@ -6422,7 +6988,7 @@ var starknet = (() => {
       randomPrivateKey: () => {
         const rand = CURVE2.randomBytes(Fp.BYTES + 8);
         const num = hashToPrivateScalar2(rand, CURVE_ORDER2);
-        return numberToBytesBE2(num, CURVE2.nByteLength);
+        return numberToBytesBE(num, CURVE2.nByteLength);
       },
       precompute(windowSize = 8, point = Point.BASE) {
         point._setWindowSize(windowSize);
@@ -6454,20 +7020,20 @@ var starknet = (() => {
       return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
     }
     const bits2int2 = CURVE2.bits2int || function(bytes2) {
-      const num = bytesToNumberBE2(bytes2);
+      const num = bytesToNumberBE(bytes2);
       const delta = bytes2.length * 8 - CURVE2.nBitLength;
       return delta > 0 ? num >> BigInt(delta) : num;
     };
     const bits2int_modN = CURVE2.bits2int_modN || function(bytes2) {
       return modN(bits2int2(bytes2));
     };
-    const ORDER_MASK = bitMask2(CURVE2.nBitLength);
+    const ORDER_MASK = bitMask(CURVE2.nBitLength);
     function int2octets(num) {
       if (typeof num !== "bigint")
         throw new Error("bigint expected");
       if (!(_0n9 <= num && num < ORDER_MASK))
         throw new Error(`bigint expected < 2^${CURVE2.nBitLength}`);
-      return numberToBytesBE2(num, CURVE2.nByteLength);
+      return numberToBytesBE(num, CURVE2.nByteLength);
     }
     function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
       if (["recovered", "canonical"].some((k) => k in opts))
@@ -6476,17 +7042,17 @@ var starknet = (() => {
       let { lowS, prehash, extraEntropy: ent } = opts;
       if (lowS == null)
         lowS = true;
-      msgHash = ensureBytes3("msgHash", msgHash);
+      msgHash = ensureBytes("msgHash", msgHash);
       if (prehash)
-        msgHash = ensureBytes3("prehashed msgHash", hash2(msgHash));
+        msgHash = ensureBytes("prehashed msgHash", hash2(msgHash));
       const h1int = bits2int_modN(msgHash);
       const d = normPrivateKeyToScalar(privateKey);
       const seedArgs = [int2octets(d), int2octets(h1int)];
       if (ent != null) {
         const e = ent === true ? randomBytes2(Fp.BYTES) : ent;
-        seedArgs.push(ensureBytes3("extraEntropy", e, Fp.BYTES));
+        seedArgs.push(ensureBytes("extraEntropy", e, Fp.BYTES));
       }
-      const seed = concatBytes3(...seedArgs);
+      const seed = concatBytes(...seedArgs);
       const m = h1int;
       function k2sig(kBytes) {
         const k = bits2int2(kBytes);
@@ -6514,15 +7080,15 @@ var starknet = (() => {
     const defaultVerOpts = { lowS: CURVE2.lowS, prehash: false };
     function sign2(msgHash, privKey, opts = defaultSigOpts) {
       const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-      const drbg = createHmacDrbg2(CURVE2.hash.outputLen, CURVE2.nByteLength, CURVE2.hmac);
+      const drbg = createHmacDrbg(CURVE2.hash.outputLen, CURVE2.nByteLength, CURVE2.hmac);
       return drbg(seed, k2sig);
     }
     Point.BASE._setWindowSize(8);
     function verify2(signature, msgHash, publicKey, opts = defaultVerOpts) {
       var _a;
       const sg = signature;
-      msgHash = ensureBytes3("msgHash", msgHash);
-      publicKey = ensureBytes3("publicKey", publicKey);
+      msgHash = ensureBytes("msgHash", msgHash);
+      publicKey = ensureBytes("publicKey", publicKey);
       if ("strict" in opts)
         throw new Error("options.strict was renamed to lowS");
       const { lowS, prehash } = opts;
@@ -7449,30 +8015,6 @@ var starknet = (() => {
   var transactionVersion = 1n;
   var transactionVersion_2 = 2n;
   var feeTransactionVersion = 2n ** 128n + transactionVersion;
-  function keccakBn(value) {
-    const hexWithoutPrefix = removeHexPrefix(toHex(BigInt(value)));
-    const evenHex = hexWithoutPrefix.length % 2 === 0 ? hexWithoutPrefix : `0${hexWithoutPrefix}`;
-    return addHexPrefix(keccak(hexToBytes3(addHexPrefix(evenHex))).toString(16));
-  }
-  function keccakHex(value) {
-    return addHexPrefix(keccak(utf8ToArray(value)).toString(16));
-  }
-  function starknetKeccak(value) {
-    const hash2 = BigInt(keccakHex(value));
-    return hash2 & MASK_2502;
-  }
-  function getSelectorFromName(funcName) {
-    return toHex(starknetKeccak(funcName));
-  }
-  function getSelector(value) {
-    if (isHex(value)) {
-      return value;
-    }
-    if (isStringWholeNumber(value)) {
-      return toHexString(value);
-    }
-    return getSelectorFromName(value);
-  }
   function computeHashOnElements2(data) {
     return [...data, data.length].reduce((x, y) => esm_exports.pedersen(toBigInt(x), toBigInt(y)), 0).toString();
   }
@@ -7533,678 +8075,146 @@ var starknet = (() => {
       contractAddress,
       0,
       calldata,
-      maxFee,
-      chainId,
-      [nonce]
-    );
-  }
-  function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
-    const constructorCalldataHash = computeHashOnElements2(constructorCalldata);
-    const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
-    return computeHashOnElements2([
-      CONTRACT_ADDRESS_PREFIX,
-      deployerAddress,
-      salt,
-      classHash,
-      constructorCalldataHash
-    ]);
-  }
-  function nullSkipReplacer(key, value) {
-    if (key === "attributes" || key === "accessible_scopes") {
-      return Array.isArray(value) && value.length === 0 ? void 0 : value;
-    }
-    if (key === "debug_info") {
-      return null;
-    }
-    return value === null ? void 0 : value;
-  }
-  function formatSpaces(json) {
-    let insideQuotes = false;
-    let newString = "";
-    for (const char of json) {
-      if (char === '"' && newString.endsWith("\\") === false) {
-        insideQuotes = !insideQuotes;
-      }
-      if (insideQuotes) {
-        newString += char;
-      } else {
-        newString += char === ":" ? ": " : char === "," ? ", " : char;
-      }
-    }
-    return newString;
-  }
-  function computeHintedClassHash(compiledContract) {
-    const { abi, program } = compiledContract;
-    const contractClass = { abi, program };
-    const serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
-    return addHexPrefix(esm_exports.keccak(utf8ToArray(serializedJson)).toString(16));
-  }
-  function computeLegacyContractClassHash(contract) {
-    const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
-    const apiVersion = toHex(API_VERSION);
-    const externalEntryPointsHash = computeHashOnElements2(
-      compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
-    );
-    const l1HandlerEntryPointsHash = computeHashOnElements2(
-      compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
-    );
-    const constructorEntryPointHash = computeHashOnElements2(
-      compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
-    );
-    const builtinsHash = computeHashOnElements2(
-      compiledContract.program.builtins.map((s) => encodeShortString(s))
-    );
-    const hintedClassHash = computeHintedClassHash(compiledContract);
-    const dataHash = computeHashOnElements2(compiledContract.program.data);
-    return computeHashOnElements2([
-      apiVersion,
-      externalEntryPointsHash,
-      l1HandlerEntryPointsHash,
-      constructorEntryPointHash,
-      builtinsHash,
-      hintedClassHash,
-      dataHash
-    ]);
-  }
-  function hashBuiltins(builtins) {
-    return poseidonHashMany(
-      builtins.flatMap((it) => {
-        return BigInt(encodeShortString(it));
-      })
-    );
-  }
-  function hashEntryPoint(data) {
-    const base = data.flatMap((it) => {
-      return [BigInt(it.selector), BigInt(it.offset), hashBuiltins(it.builtins)];
-    });
-    return poseidonHashMany(base);
-  }
-  function computeCompiledClassHash(casm) {
-    const COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
-    const compiledClassVersion = BigInt(encodeShortString(COMPILED_CLASS_VERSION));
-    const externalEntryPointsHash = hashEntryPoint(casm.entry_points_by_type.EXTERNAL);
-    const l1Handlers = hashEntryPoint(casm.entry_points_by_type.L1_HANDLER);
-    const constructor = hashEntryPoint(casm.entry_points_by_type.CONSTRUCTOR);
-    const bytecode = poseidonHashMany(casm.bytecode.map((it) => BigInt(it)));
-    return toHex(
-      poseidonHashMany([
-        compiledClassVersion,
-        externalEntryPointsHash,
-        l1Handlers,
-        constructor,
-        bytecode
-      ])
-    );
-  }
-  function hashEntryPointSierra(data) {
-    const base = data.flatMap((it) => {
-      return [BigInt(it.selector), BigInt(it.function_idx)];
-    });
-    return poseidonHashMany(base);
-  }
-  function hashAbi(sierra) {
-    const indentString = formatSpaces(stringify2(sierra.abi, null));
-    return BigInt(addHexPrefix(esm_exports.keccak(utf8ToArray(indentString)).toString(16)));
-  }
-  function computeSierraContractClassHash(sierra) {
-    const CONTRACT_CLASS_VERSION = "CONTRACT_CLASS_V0.1.0";
-    const compiledClassVersion = BigInt(encodeShortString(CONTRACT_CLASS_VERSION));
-    const externalEntryPointsHash = hashEntryPointSierra(sierra.entry_points_by_type.EXTERNAL);
-    const l1Handlers = hashEntryPointSierra(sierra.entry_points_by_type.L1_HANDLER);
-    const constructor = hashEntryPointSierra(sierra.entry_points_by_type.CONSTRUCTOR);
-    const abiHash = hashAbi(sierra);
-    const sierraProgram = poseidonHashMany(sierra.sierra_program.map((it) => BigInt(it)));
-    return toHex(
-      poseidonHashMany([
-        compiledClassVersion,
-        externalEntryPointsHash,
-        l1Handlers,
-        constructor,
-        abiHash,
-        sierraProgram
-      ])
-    );
-  }
-  function computeContractClassHash(contract) {
-    const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
-    if ("sierra_program" in compiledContract) {
-      return computeSierraContractClassHash(compiledContract);
-    }
-    return computeLegacyContractClassHash(compiledContract);
-  }
-
-  // src/utils/calldata/formatter.ts
-  var guard = {
-    isBN: (data, type, key) => {
-      if (!isBigInt(data[key]))
-        throw new Error(
-          `Data and formatter mismatch on ${key}:${type[key]}, expected response data ${key}:${data[key]} to be BN instead it is ${typeof data[key]}`
-        );
-    },
-    unknown: (data, type, key) => {
-      throw new Error(`Unhandled formatter type on ${key}:${type[key]} for data ${key}:${data[key]}`);
-    }
-  };
-  function formatter(data, type, sameType) {
-    return Object.entries(data).reduce((acc, [key, value]) => {
-      const elType = sameType ?? type[key];
-      if (!(key in type) && !sameType) {
-        acc[key] = value;
-        return acc;
-      }
-      if (elType === "string") {
-        if (Array.isArray(data[key])) {
-          const arrayStr = formatter(
-            data[key],
-            data[key].map((_) => elType)
-          );
-          acc[key] = Object.values(arrayStr).join("");
-          return acc;
-        }
-        guard.isBN(data, type, key);
-        acc[key] = decodeShortString(value);
-        return acc;
-      }
-      if (elType === "number") {
-        guard.isBN(data, type, key);
-        acc[key] = Number(value);
-        return acc;
-      }
-      if (typeof elType === "function") {
-        acc[key] = elType(value);
-        return acc;
-      }
-      if (Array.isArray(elType)) {
-        const arrayObj = formatter(data[key], elType, elType[0]);
-        acc[key] = Object.values(arrayObj);
-        return acc;
-      }
-      if (typeof elType === "object") {
-        acc[key] = formatter(data[key], elType);
-        return acc;
-      }
-      guard.unknown(data, type, key);
-      return acc;
-    }, {});
-  }
-
-  // src/utils/calldata/tuple.ts
-  function parseNamedTuple(namedTuple) {
-    const name = namedTuple.substring(0, namedTuple.indexOf(":"));
-    const type = namedTuple.substring(name.length + ":".length);
-    return { name, type };
-  }
-  function parseSubTuple(s) {
-    if (!s.includes("("))
-      return { subTuple: [], result: s };
-    const subTuple = [];
-    let result = "";
-    let i = 0;
-    while (i < s.length) {
-      if (s[i] === "(") {
-        let counter = 1;
-        const lBracket = i;
-        i++;
-        while (counter) {
-          if (s[i] === ")")
-            counter--;
-          if (s[i] === "(")
-            counter++;
-          i++;
-        }
-        subTuple.push(s.substring(lBracket, i));
-        result += " ";
-        i--;
-      } else {
-        result += s[i];
-      }
-      i++;
-    }
-    return {
-      subTuple,
-      result
-    };
-  }
-  function extractCairo0Tuple(type) {
-    const cleanType = type.replace(/\s/g, "").slice(1, -1);
-    const { subTuple, result } = parseSubTuple(cleanType);
-    let recomposed = result.split(",").map((it) => {
-      return subTuple.length ? it.replace(" ", subTuple.shift()) : it;
-    });
-    if (isTypeNamedTuple(type)) {
-      recomposed = recomposed.reduce((acc, it) => {
-        return acc.concat(parseNamedTuple(it));
-      }, []);
-    }
-    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 parseBaseTypes(type, val) {
-    switch (true) {
-      case isTypeUint256(type):
-        const el_uint256 = uint256(val);
-        return [felt(el_uint256.low), felt(el_uint256.high)];
-      default:
-        return felt(val);
-    }
-  }
-  function parseTuple(element, typeStr) {
-    const memberTypes = extractTupleMemberTypes(typeStr);
-    const elements = Object.values(element);
-    if (elements.length !== memberTypes.length) {
-      throw Error(
-        `ParseTuple: provided and expected abi tuple size do not match.
-      provided: ${elements} 
-      expected: ${memberTypes}`
-      );
-    }
-    return memberTypes.map((it, dx) => {
-      return {
-        element: elements[dx],
-        type: it.type ?? it
-      };
-    });
-  }
-  function parseCalldataValue(element, type, structs) {
-    if (element === void 0) {
-      throw Error(`Missing parameter for type ${type}`);
-    }
-    if (Array.isArray(element)) {
-      throw Error(`Array inside array (nD) are not supported by cairo. Element: ${element} ${type}`);
-    }
-    if (structs[type] && structs[type].members.length) {
-      const { members } = structs[type];
-      const subElement = element;
-      return members.reduce((acc, it) => {
-        return acc.concat(parseCalldataValue(subElement[it.name], it.type, structs));
-      }, []);
-    }
-    if (isTypeTuple(type)) {
-      const tupled = parseTuple(element, type);
-      return tupled.reduce((acc, it) => {
-        const parsedData = parseCalldataValue(it.element, it.type, structs);
-        return acc.concat(parsedData);
-      }, []);
-    }
-    if (typeof element === "object") {
-      throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
-    }
-    return parseBaseTypes(type, element);
-  }
-  function parseCalldataField(argsIterator, input, structs) {
-    const { name, type } = input;
-    let { value } = argsIterator.next();
-    switch (true) {
-      case isTypeArray(type):
-        if (!Array.isArray(value) && !isText(value)) {
-          throw Error(`ABI expected parameter ${name} to be array or long string, got ${value}`);
-        }
-        if (typeof value === "string") {
-          value = splitLongString(value);
-        }
-        const result = [];
-        result.push(felt(value.length));
-        const arrayType = getArrayType(input.type);
-        return value.reduce((acc, el) => {
-          if (isTypeStruct(arrayType, structs) || isTypeTuple(arrayType) || isTypeArray(arrayType)) {
-            acc.push(...parseCalldataValue(el, arrayType, structs));
-          } else {
-            return acc.concat(parseBaseTypes(arrayType, el));
-          }
-          return acc;
-        }, result);
-      case (isTypeStruct(type, structs) || isTypeTuple(type)):
-        return parseCalldataValue(value, type, structs);
-      case isTypeUint256(type):
-        if (typeof value === "object") {
-          return [felt(value.low), felt(value.high)];
-        }
-        const el_uint256 = uint256(value);
-        return [felt(el_uint256.low), felt(el_uint256.high)];
-      default:
-        return parseBaseTypes(type, value);
-    }
-  }
-
-  // src/utils/calldata/responseParser.ts
-  function parseBaseTypes2(type, it) {
-    let temp;
-    switch (true) {
-      case isTypeBool(type):
-        temp = it.next().value;
-        return Boolean(BigInt(temp));
-      case isTypeUint256(type):
-        const low = it.next().value;
-        const high = it.next().value;
-        return uint256ToBN({ low, high });
-      default:
-        temp = it.next().value;
-        return BigInt(temp);
-    }
-  }
-  function parseResponseStruct(responseIterator, type, structs) {
-    if (type in structs && structs[type]) {
-      return structs[type].members.reduce((acc, el) => {
-        acc[el.name] = parseResponseStruct(responseIterator, el.type, structs);
-        return acc;
-      }, {});
-    }
-    if (isTypeTuple(type)) {
-      const memberTypes = extractTupleMemberTypes(type);
-      return memberTypes.reduce((acc, it, idx) => {
-        const tName = (it == null ? void 0 : it.name) ? it.name : idx;
-        const tType = (it == null ? void 0 : it.type) ? it.type : it;
-        acc[tName] = parseResponseStruct(responseIterator, tType, structs);
-        return acc;
-      }, {});
-    }
-    return parseBaseTypes2(type, responseIterator);
-  }
-  function responseParser(responseIterator, output2, structs, parsedResult) {
-    const { name, type } = output2;
-    let temp;
-    switch (true) {
-      case isLen(name):
-        temp = responseIterator.next().value;
-        return BigInt(temp);
-      case isTypeArray(type):
-        const parsedDataArr = [];
-        if (isCairo1Type(type)) {
-          const arrayType = getArrayType(type);
-          const len = BigInt(responseIterator.next().value);
-          while (parsedDataArr.length < len) {
-            parsedDataArr.push(parseResponseStruct(responseIterator, arrayType, structs));
-          }
-          return parsedDataArr;
-        }
-        if (parsedResult && parsedResult[`${name}_len`]) {
-          const arrLen = parsedResult[`${name}_len`];
-          while (parsedDataArr.length < arrLen) {
-            parsedDataArr.push(
-              parseResponseStruct(responseIterator, output2.type.replace("*", ""), structs)
-            );
-          }
-        }
-        return parsedDataArr;
-      case (type in structs || isTypeTuple(type)):
-        return parseResponseStruct(responseIterator, type, structs);
-      default:
-        return parseBaseTypes2(type, responseIterator);
-    }
-  }
-
-  // src/utils/calldata/validate.ts
-  var validateFelt = (parameter, input) => {
-    assert(
-      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint",
-      `Validate: arg ${input.name} should be a felt typed as (String, Number or BigInt)`
-    );
-  };
-  var validateUint = (parameter, input) => {
-    if (typeof parameter === "number") {
-      assert(
-        parameter <= Number.MAX_SAFE_INTEGER,
-        `Validation: Parameter is to large to be typed as Number use (BigInt or String)`
-      );
-    }
-    assert(
-      typeof parameter === "string" || typeof parameter === "number" || typeof parameter === "bigint" || typeof parameter === "object" && "low" in parameter && "high" in parameter,
-      `Validate: arg ${input.name} of cairo ZORG type ${input.type} should be type (String, Number or BigInt)`
-    );
-    const param = typeof parameter === "object" ? uint256ToBN(parameter) : toBigInt(parameter);
-    switch (input.type) {
-      case "core::integer::u8" /* u8 */:
-        assert(
-          param >= 0n && param <= 255n,
-          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0 - 255]`
-        );
-        break;
-      case "core::integer::u16" /* u16 */:
-        assert(
-          param >= 0n && param <= 65535n,
-          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 65535]`
-        );
-        break;
-      case "core::integer::u32" /* u32 */:
-        assert(
-          param >= 0n && param <= 4294967295n,
-          `Validate: arg ${input.name} cairo typed ${input.type} should be in range [0, 4294967295]`
-        );
-        break;
-      case "core::integer::u64" /* u64 */:
-        assert(
-          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 */:
-        assert(
-          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 */:
-        assert(
-          param >= 0n && param <= 2n ** 256n - 1n,
-          `Validate: arg ${input.name} is ${input.type} 0 - 2^256-1`
-        );
-        break;
-      default:
-        break;
-    }
-  };
-  var validateBool = (parameter, input) => {
-    assert(
-      typeof parameter === "boolean",
-      `Validate: arg ${input.name} of cairo type ${input.type} should be type (Boolean)`
-    );
-  };
-  var validateStruct = (parameter, input, structs) => {
-    assert(
-      typeof parameter === "object" && !Array.isArray(parameter),
-      `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`
-    );
-    structs[input.type].members.forEach(({ name }) => {
-      assert(
-        Object.keys(parameter).includes(name),
-        `Validate: arg ${input.name} should have a property ${name}`
-      );
-    });
-  };
-  var validateTuple = (parameter, input) => {
-    assert(
-      typeof parameter === "object" && !Array.isArray(parameter),
-      `Validate: arg ${input.name} should be a tuple (defined as object)`
-    );
-  };
-  var validateArray = (parameter, input, structs) => {
-    const baseType = getArrayType(input.type);
-    if (isTypeFelt(baseType) && isLongText(parameter))
-      return;
-    assert(Array.isArray(parameter), `Validate: arg ${input.name} should be an Array`);
-    switch (true) {
-      case isTypeFelt(baseType):
-        parameter.forEach((param) => validateFelt(param, input));
-        break;
-      case isTypeTuple(baseType):
-        parameter.forEach((it) => validateTuple(it, { name: input.name, type: baseType }));
-        break;
-      case isTypeStruct(baseType, structs):
-        parameter.forEach(
-          (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}`
-        );
-    }
-  };
-  function validateFields(abiMethod, args, structs) {
-    abiMethod.inputs.reduce((acc, input) => {
-      const parameter = args[acc];
-      switch (true) {
-        case isLen(input.name):
-          return acc;
-        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;
-        case isTypeTuple(input.type):
-          validateTuple(parameter, input);
-          break;
-        case isTypeArray(input.type):
-          validateArray(parameter, input, structs);
-          break;
-        default:
-          throw new Error(
-            `Validate Unhandled: argument ${input.name}, type ${input.type}, value ${parameter}`
-          );
-      }
-      return acc + 1;
-    }, 0);
+      maxFee,
+      chainId,
+      [nonce]
+    );
   }
-
-  // src/utils/calldata/index.ts
-  var CallData = class {
-    constructor(abi) {
-      this.abi = abi;
-      this.structs = CallData.getAbiStruct(abi);
-    }
-    validate(type, method, args = []) {
-      if (type !== "DEPLOY") {
-        const invocableFunctionNames = this.abi.filter((abi) => {
-          if (abi.type !== "function")
-            return false;
-          const isView = abi.stateMutability === "view" || abi.state_mutability === "view";
-          return type === "INVOKE" ? !isView : isView;
-        }).map((abi) => abi.name);
-        assert(
-          invocableFunctionNames.includes(method),
-          `${type === "INVOKE" ? "invocable" : "viewable"} method not found in abi`
-        );
-      }
-      const abiMethod = this.abi.find(
-        (abi) => type === "DEPLOY" ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
-      );
-      const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
-      if (args.length !== inputsLength) {
-        throw Error(
-          `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
-        );
-      }
-      validateFields(abiMethod, args, this.structs);
+  function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const constructorCalldataHash = computeHashOnElements2(compiledCalldata);
+    const CONTRACT_ADDRESS_PREFIX = felt("0x535441524b4e45545f434f4e54524143545f41444452455353");
+    return computeHashOnElements2([
+      CONTRACT_ADDRESS_PREFIX,
+      deployerAddress,
+      salt,
+      classHash,
+      constructorCalldataHash
+    ]);
+  }
+  function nullSkipReplacer(key, value) {
+    if (key === "attributes" || key === "accessible_scopes") {
+      return Array.isArray(value) && value.length === 0 ? void 0 : value;
     }
-    compile(method, args) {
-      const argsIterator = args[Symbol.iterator]();
-      const { inputs } = this.abi.find((abi) => abi.name === method);
-      return inputs.reduce(
-        (acc, input) => isLen(input.name) ? acc : acc.concat(parseCalldataField(argsIterator, input, this.structs)),
-        []
-      );
+    if (key === "debug_info") {
+      return null;
     }
-    static compile(rawArgs) {
-      const createTree = (obj) => {
-        const getEntries = (o, prefix = "") => {
-          const oe = Array.isArray(o) ? [o.length.toString(), ...o] : o;
-          return Object.entries(oe).flatMap(([k, v]) => {
-            let value = v;
-            if (isLongText(value))
-              value = splitLongString(value);
-            if (k === "entrypoint")
-              value = getSelectorFromName(value);
-            const kk = Array.isArray(oe) && k === "0" ? "$$len" : k;
-            if (isBigInt(value))
-              return [[`${prefix}${kk}`, felt(value)]];
-            return Object(value) === value ? getEntries(value, `${prefix}${kk}.`) : [[`${prefix}${kk}`, felt(value)]];
-          });
-        };
-        return Object.fromEntries(getEntries(obj));
-      };
-      let callTreeArray;
-      if (!Array.isArray(rawArgs)) {
-        const callTree = createTree(rawArgs);
-        callTreeArray = Object.values(callTree);
+    return value === null ? void 0 : value;
+  }
+  function formatSpaces(json) {
+    let insideQuotes = false;
+    let newString = "";
+    for (const char of json) {
+      if (char === '"' && newString.endsWith("\\") === false) {
+        insideQuotes = !insideQuotes;
+      }
+      if (insideQuotes) {
+        newString += char;
       } else {
-        const callObj = { ...rawArgs };
-        const callTree = createTree(callObj);
-        callTreeArray = Object.values(callTree);
+        newString += char === ":" ? ": " : char === "," ? ", " : char;
       }
-      Object.defineProperty(callTreeArray, "__compiled__", {
-        enumerable: false,
-        writable: false,
-        value: true
-      });
-      return callTreeArray;
-    }
-    parse(method, response) {
-      const { outputs } = this.abi.find((abi) => abi.name === method);
-      const responseIterator = response.flat()[Symbol.iterator]();
-      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);
-      return formatter(parsed, format);
-    }
-    static abiInputsLength(inputs) {
-      return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
-    }
-    static getAbiStruct(abi) {
-      return abi.filter((abiEntry) => abiEntry.type === "struct").reduce(
-        (acc, abiEntry) => ({
-          ...acc,
-          [abiEntry.name]: abiEntry
-        }),
-        {}
-      );
     }
-    static toCalldata(rawCalldata = []) {
-      return CallData.compile(rawCalldata);
-    }
-    static toHex(rawCalldata = []) {
-      const calldata = CallData.compile(rawCalldata);
-      return calldata.map((it) => toHex(it));
+    return newString;
+  }
+  function computeHintedClassHash(compiledContract) {
+    const { abi, program } = compiledContract;
+    const contractClass = { abi, program };
+    const serializedJson = formatSpaces(stringify2(contractClass, nullSkipReplacer));
+    return addHexPrefix(esm_exports.keccak(utf8ToArray(serializedJson)).toString(16));
+  }
+  function computeLegacyContractClassHash(contract) {
+    const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+    const apiVersion = toHex(API_VERSION);
+    const externalEntryPointsHash = computeHashOnElements2(
+      compiledContract.entry_points_by_type.EXTERNAL.flatMap((e) => [e.selector, e.offset])
+    );
+    const l1HandlerEntryPointsHash = computeHashOnElements2(
+      compiledContract.entry_points_by_type.L1_HANDLER.flatMap((e) => [e.selector, e.offset])
+    );
+    const constructorEntryPointHash = computeHashOnElements2(
+      compiledContract.entry_points_by_type.CONSTRUCTOR.flatMap((e) => [e.selector, e.offset])
+    );
+    const builtinsHash = computeHashOnElements2(
+      compiledContract.program.builtins.map((s) => encodeShortString(s))
+    );
+    const hintedClassHash = computeHintedClassHash(compiledContract);
+    const dataHash = computeHashOnElements2(compiledContract.program.data);
+    return computeHashOnElements2([
+      apiVersion,
+      externalEntryPointsHash,
+      l1HandlerEntryPointsHash,
+      constructorEntryPointHash,
+      builtinsHash,
+      hintedClassHash,
+      dataHash
+    ]);
+  }
+  function hashBuiltins(builtins) {
+    return poseidonHashMany(
+      builtins.flatMap((it) => {
+        return BigInt(encodeShortString(it));
+      })
+    );
+  }
+  function hashEntryPoint(data) {
+    const base = data.flatMap((it) => {
+      return [BigInt(it.selector), BigInt(it.offset), hashBuiltins(it.builtins)];
+    });
+    return poseidonHashMany(base);
+  }
+  function computeCompiledClassHash(casm) {
+    const COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
+    const compiledClassVersion = BigInt(encodeShortString(COMPILED_CLASS_VERSION));
+    const externalEntryPointsHash = hashEntryPoint(casm.entry_points_by_type.EXTERNAL);
+    const l1Handlers = hashEntryPoint(casm.entry_points_by_type.L1_HANDLER);
+    const constructor = hashEntryPoint(casm.entry_points_by_type.CONSTRUCTOR);
+    const bytecode = poseidonHashMany(casm.bytecode.map((it) => BigInt(it)));
+    return toHex(
+      poseidonHashMany([
+        compiledClassVersion,
+        externalEntryPointsHash,
+        l1Handlers,
+        constructor,
+        bytecode
+      ])
+    );
+  }
+  function hashEntryPointSierra(data) {
+    const base = data.flatMap((it) => {
+      return [BigInt(it.selector), BigInt(it.function_idx)];
+    });
+    return poseidonHashMany(base);
+  }
+  function hashAbi(sierra) {
+    const indentString = formatSpaces(stringify2(sierra.abi, null));
+    return BigInt(addHexPrefix(esm_exports.keccak(utf8ToArray(indentString)).toString(16)));
+  }
+  function computeSierraContractClassHash(sierra) {
+    const CONTRACT_CLASS_VERSION = "CONTRACT_CLASS_V0.1.0";
+    const compiledClassVersion = BigInt(encodeShortString(CONTRACT_CLASS_VERSION));
+    const externalEntryPointsHash = hashEntryPointSierra(sierra.entry_points_by_type.EXTERNAL);
+    const l1Handlers = hashEntryPointSierra(sierra.entry_points_by_type.L1_HANDLER);
+    const constructor = hashEntryPointSierra(sierra.entry_points_by_type.CONSTRUCTOR);
+    const abiHash = hashAbi(sierra);
+    const sierraProgram = poseidonHashMany(sierra.sierra_program.map((it) => BigInt(it)));
+    return toHex(
+      poseidonHashMany([
+        compiledClassVersion,
+        externalEntryPointsHash,
+        l1Handlers,
+        constructor,
+        abiHash,
+        sierraProgram
+      ])
+    );
+  }
+  function computeContractClassHash(contract) {
+    const compiledContract = typeof contract === "string" ? parse2(contract) : contract;
+    if ("sierra_program" in compiledContract) {
+      return computeSierraContractClassHash(compiledContract);
     }
-  };
-
-  // src/utils/fetchPonyfill.ts
-  var import_isomorphic_fetch = __toESM(require_fetch_npm_browserify());
-  var fetchPonyfill_default = typeof window !== "undefined" && window.fetch || typeof global !== "undefined" && global.fetch || import_isomorphic_fetch.default;
+    return computeLegacyContractClassHash(compiledContract);
+  }
 
   // src/utils/contract.ts
   function isSierra(contract) {
@@ -12817,7 +12827,7 @@ var starknet = (() => {
       return this.fetchEndpoint("starknet_estimateFee", {
         request: {
           type: RPC.TransactionType.DEPLOY_ACCOUNT,
-          constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
+          constructor_calldata: CallData.toHex(constructorCalldata || []),
           class_hash: toHex(classHash),
           contract_address_salt: toHex(addressSalt || 0),
           signature: signatureToHexArray(signature),
@@ -12854,7 +12864,7 @@ var starknet = (() => {
     async deployAccountContract({ classHash, constructorCalldata, addressSalt, signature }, details) {
       return this.fetchEndpoint("starknet_addDeployAccountTransaction", {
         deploy_account_transaction: {
-          constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
+          constructor_calldata: CallData.toHex(constructorCalldata || []),
           class_hash: toHex(classHash),
           contract_address_salt: toHex(addressSalt || 0),
           type: RPC.TransactionType.DEPLOY_ACCOUNT,
@@ -13292,7 +13302,7 @@ var starknet = (() => {
         {
           contract_address: contractAddress,
           entry_point_selector: getSelectorFromName(entryPointSelector),
-          calldata
+          calldata: CallData.compile(calldata)
         }
       ).then(this.responseParser.parseCallContractResponse);
     }
@@ -13406,7 +13416,7 @@ var starknet = (() => {
         {
           type: "INVOKE_FUNCTION" /* INVOKE */,
           sender_address: invocation.contractAddress,
-          calldata: invocation.calldata ?? [],
+          calldata: CallData.compile(invocation.calldata ?? []),
           signature: signatureToDecimalArray(invocation.signature),
           version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
           nonce: toHex(invocationDetails.nonce)
@@ -13464,7 +13474,7 @@ var starknet = (() => {
           res = {
             type: invocation.type,
             sender_address: invocation.contractAddress,
-            calldata: invocation.calldata ?? []
+            calldata: CallData.compile(invocation.calldata ?? [])
           };
         } else if (invocation.type === "DECLARE") {
           res = {
@@ -13547,7 +13557,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         {
           type: "INVOKE_FUNCTION",
           sender_address: invocation.contractAddress,
-          calldata: invocation.calldata ?? [],
+          calldata: CallData.compile(invocation.calldata ?? []),
           signature: signatureToDecimalArray(invocation.signature),
           version: toHex((invocationDetails == null ? void 0 : invocationDetails.version) || 1),
           nonce: toHex(invocationDetails.nonce),
@@ -13960,7 +13970,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     const callArray = [];
     const calldata = [];
     calls.forEach((call) => {
-      const data = call.calldata || [];
+      const data = CallData.compile(call.calldata || []);
       callArray.push({
         to: toBigInt(call.contractAddress).toString(10),
         selector: toBigInt(getSelectorFromName(call.entrypoint)).toString(10),
@@ -13991,11 +14001,16 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     return callArray;
   };
   var fromCallsToExecuteCalldata_cairo1 = (calls) => {
-    return CallData.compile({ calls });
+    const orderCalls = calls.map((call) => ({
+      contractAddress: call.contractAddress,
+      entrypoint: call.entrypoint,
+      calldata: call.calldata
+    }));
+    return CallData.compile({ orderCalls });
   };
   var getExecuteCalldata = (calls, cairoVersion = "0") => {
     if (cairoVersion === "1") {
-      return CallData.compile({ calls });
+      return fromCallsToExecuteCalldata_cairo1(calls);
     }
     return fromCallsToExecuteCalldata(calls);
   };
@@ -14249,7 +14264,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       const msgHash = calculateDeployAccountTransactionHash(
         contractAddress,
         classHash,
-        constructorCalldata,
+        CallData.compile(constructorCalldata),
         addressSalt,
         version,
         maxFee,
@@ -14305,10 +14320,12 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
 
   // src/account/default.ts
   var Account = class extends Provider {
-    constructor(providerOrOptions, address, pkOrSigner) {
+    constructor(providerOrOptions, address, pkOrSigner, cairoVersion = "0") {
       super(providerOrOptions);
+      this.deploySelf = this.deployAccount;
       this.address = address.toLowerCase();
       this.signer = typeof pkOrSigner === "string" || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
+      this.cairoVersion = cairoVersion;
     }
     async getNonce(blockIdentifier) {
       return super.getNonceForAddress(this.address, blockIdentifier);
@@ -14316,7 +14333,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     async estimateFee(calls, estimateFeeDetails) {
       return this.estimateInvokeFee(calls, estimateFeeDetails);
     }
-    async estimateInvokeFee(calls, { nonce: providedNonce, blockIdentifier, skipValidate, cairoVersion } = {}) {
+    async estimateInvokeFee(calls, { nonce: providedNonce, blockIdentifier, skipValidate } = {}) {
       const transactions = Array.isArray(calls) ? calls : [calls];
       const nonce = toBigInt(providedNonce ?? await this.getNonce());
       const version = toBigInt(feeTransactionVersion);
@@ -14327,7 +14344,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         maxFee: ZERO,
         version,
         chainId,
-        cairoVersion: cairoVersion ?? "0"
+        cairoVersion: this.cairoVersion
       };
       const invocation = await this.buildInvocation(transactions, signerDetails);
       const response = await super.getInvokeEstimateFee(
@@ -14342,7 +14359,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         suggestedMaxFee
       };
     }
-    async estimateDeclareFee({ contract, classHash: providedClassHash, casm, compiledClassHash }, { blockIdentifier, nonce: providedNonce, skipValidate, cairoVersion } = {}) {
+    async estimateDeclareFee({ contract, classHash: providedClassHash, casm, compiledClassHash }, { blockIdentifier, nonce: providedNonce, skipValidate } = {}) {
       const nonce = toBigInt(providedNonce ?? await this.getNonce());
       const version = !isSierra(contract) ? toBigInt(feeTransactionVersion) : transactionVersion_2;
       const chainId = await this.getChainId();
@@ -14354,7 +14371,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
           version,
           walletAddress: this.address,
           maxFee: ZERO,
-          cairoVersion: cairoVersion ?? "0"
+          cairoVersion: this.cairoVersion
         }
       );
       const response = await super.getDeclareEstimateFee(
@@ -14374,7 +14391,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       addressSalt = 0,
       constructorCalldata = [],
       contractAddress: providedContractAddress
-    }, { blockIdentifier, skipValidate, cairoVersion } = {}) {
+    }, { blockIdentifier, skipValidate } = {}) {
       const version = toBigInt(feeTransactionVersion);
       const nonce = ZERO;
       const chainId = await this.getChainId();
@@ -14386,7 +14403,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
           version,
           walletAddress: this.address,
           maxFee: ZERO,
-          cairoVersion: cairoVersion ?? "0"
+          cairoVersion: this.cairoVersion
         }
       );
       const response = await super.getDeployAccountEstimateFee(
@@ -14405,7 +14422,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       const calls = this.buildUDCContractPayload(payload);
       return this.estimateInvokeFee(calls, transactionsDetail);
     }
-    async estimateFeeBulk(transactions, { nonce: providedNonce, blockIdentifier, cairoVersion } = {}) {
+    async estimateFeeBulk(transactions, { nonce: providedNonce, blockIdentifier } = {}) {
       const nonce = toBigInt(providedNonce ?? await this.getNonce());
       const version = toBigInt(feeTransactionVersion);
       const chainId = await this.getChainId();
@@ -14417,7 +14434,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
             maxFee: ZERO,
             version,
             chainId,
-            cairoVersion: cairoVersion ?? "0"
+            cairoVersion: this.cairoVersion
           };
           const txPayload = transaction.payload;
           let res;
@@ -14475,7 +14492,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       });
     }
     async buildInvocation(call, signerDetails) {
-      const calldata = getExecuteCalldata(call, signerDetails.cairoVersion);
+      const calldata = getExecuteCalldata(call, this.cairoVersion);
       const signature = await this.signer.signTransaction(call, signerDetails);
       return {
         contractAddress: this.address,
@@ -14492,17 +14509,16 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       );
       const version = toBigInt(transactionVersion);
       const chainId = await this.getChainId();
-      const cairoVersion = transactionsDetail.cairoVersion ?? "0";
       const signerDetails = {
         walletAddress: this.address,
         nonce,
         maxFee,
         version,
         chainId,
-        cairoVersion
+        cairoVersion: this.cairoVersion
       };
       const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
-      const calldata = getExecuteCalldata(transactions, cairoVersion);
+      const calldata = getExecuteCalldata(transactions, this.cairoVersion);
       return this.invokeFunction(
         { contractAddress: this.address, calldata, signature },
         {
@@ -14512,6 +14528,18 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         }
       );
     }
+    async declareIfNot(payload, transactionsDetail = {}) {
+      const declareContractPayload = extractContractHashes(payload);
+      try {
+        await this.getClassByHash(declareContractPayload.classHash);
+      } catch (error) {
+        return this.declare(payload, transactionsDetail);
+      }
+      return {
+        transaction_hash: "",
+        class_hash: declareContractPayload.classHash
+      };
+    }
     async declare(payload, transactionsDetail = {}) {
       const declareContractPayload = extractContractHashes(payload);
       const details = {};
@@ -14528,7 +14556,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       const declareContractTransaction = await this.buildDeclarePayload(declareContractPayload, {
         ...details,
         walletAddress: this.address,
-        cairoVersion: transactionsDetail.cairoVersion ?? "0"
+        cairoVersion: this.cairoVersion
       });
       return this.declareContract(declareContractTransaction, details);
     }
@@ -14564,10 +14592,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       });
       const calls = params.map((it) => it.call);
       const addresses = params.map((it) => it.address);
-      const invokeResponse = await this.execute(calls, void 0, {
-        ...details,
-        cairoVersion: "0"
-      });
+      const invokeResponse = await this.execute(calls, void 0, details);
       return {
         ...invokeResponse,
         contract_address: addresses
@@ -14582,15 +14607,18 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
     }
     async declareAndDeploy(payload, 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 */]
-      });
+      let declare = await this.declareIfNot(payload, details);
+      if (declare.transaction_hash !== "") {
+        const tx = await this.waitForTransaction(declare.transaction_hash, {
+          successStates: ["ACCEPTED_ON_L2" /* ACCEPTED_ON_L2 */]
+        });
+        declare = { ...declare, ...tx };
+      }
       const deploy = await this.deployContract(
-        { classHash: class_hash, salt, unique, constructorCalldata },
+        { classHash: declare.class_hash, salt, unique, constructorCalldata },
         details
       );
-      return { declare: { ...declare, class_hash }, deploy };
+      return { declare: { ...declare }, deploy };
     }
     async deployAccount({
       classHash,
@@ -14606,13 +14634,18 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       const maxFee = transactionsDetail.maxFee ?? await this.getSuggestedMaxFee(
         {
           type: "DEPLOY_ACCOUNT" /* DEPLOY_ACCOUNT */,
-          payload: { classHash, constructorCalldata, addressSalt, contractAddress }
+          payload: {
+            classHash,
+            constructorCalldata: compiledCalldata,
+            addressSalt,
+            contractAddress
+          }
         },
         transactionsDetail
       );
       const signature = await this.signer.signDeployAccountTransaction({
         classHash,
-        constructorCalldata,
+        constructorCalldata: compiledCalldata,
         contractAddress,
         addressSalt,
         chainId,
@@ -14710,12 +14743,12 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         version,
         nonce,
         addressSalt,
-        constructorCalldata
+        constructorCalldata: compiledCalldata
       });
       return {
         classHash,
         addressSalt,
-        constructorCalldata,
+        constructorCalldata: compiledCalldata,
         signature
       };
     }
@@ -14742,7 +14775,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       });
       return calls;
     }
-    async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier, skipValidate, cairoVersion } = {}) {
+    async simulateTransaction(calls, { nonce: providedNonce, blockIdentifier, skipValidate } = {}) {
       const transactions = Array.isArray(calls) ? calls : [calls];
       const nonce = toBigInt(providedNonce ?? await this.getNonce());
       const version = toBigInt(feeTransactionVersion);
@@ -14753,7 +14786,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         maxFee: ZERO,
         version,
         chainId,
-        cairoVersion: cairoVersion ?? "0"
+        cairoVersion: this.cairoVersion
       };
       const invocation = await this.buildInvocation(transactions, signerDetails);
       const response = await super.getSimulateTransaction(
@@ -14795,7 +14828,7 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
   function getChecksumAddress(address) {
     const chars = removeHexPrefix(validateAndParseAddress(address)).toLowerCase().split("");
     const hex = removeHexPrefix(keccakBn(address));
-    const hashed = hexToBytes2(hex.padStart(64, "0"));
+    const hashed = hexToBytes(hex.padStart(64, "0"));
     for (let i = 0; i < chars.length; i += 2) {
       if (hashed[i >> 1] >> 4 >= 8) {
         chars[i] = chars[i].toUpperCase();