starknet 5.19.3 → 5.19.4

package/dist/index.global.js

@@ -778,7 +778,7 @@ var starknet = (() => {
   function utf8ToArray(str) {
     return new TextEncoder().encode(str);
   }
-  var pascalToSnake = (text) => text.split(/(?=[A-Z])/).join("_").toUpperCase();
+  var pascalToSnake = (text) => !/[a-z]/.test(text) ? text.split(/(?=[A-Z])/).join("_").toUpperCase() : text;
 
   // src/constants.ts
   var HEX_STR_TRANSACTION_VERSION_1 = "0x1";
@@ -3048,7 +3048,7 @@ var starknet = (() => {
   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"));
+  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
   function bytesToHex(bytes2) {
     if (!u8a(bytes2))
       throw new Error("Uint8Array expected");
@@ -3070,15 +3070,16 @@ var starknet = (() => {
   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);
+    const len = hex.length;
+    if (len % 2)
+      throw new Error("padded hex string expected, got unpadded hex of length " + len);
+    const array = new Uint8Array(len / 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");
+        throw new Error("Invalid byte sequence");
       array[i] = byte;
     }
     return array;
@@ -3091,9 +3092,15 @@ var starknet = (() => {
       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 numberToBytesBE(n, len) {
+    return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+  }
+  function numberToBytesLE(n, len) {
+    return numberToBytesBE(n, len).reverse();
+  }
+  function numberToVarBytesBE(n) {
+    return hexToBytes(numberToHexUnpadded(n));
+  }
   function ensureBytes(title, hex, expectedLength) {
     let res;
     if (typeof hex === "string") {
@@ -3112,10 +3119,10 @@ var starknet = (() => {
       throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
     return res;
   }
-  function concatBytes(...arrs) {
-    const r = new Uint8Array(arrs.reduce((sum, a) => sum + a.length, 0));
+  function concatBytes(...arrays) {
+    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
     let pad = 0;
-    arrs.forEach((a) => {
+    arrays.forEach((a) => {
       if (!u8a(a))
         throw new Error("Uint8Array expected");
       r.set(a, pad);
@@ -3132,10 +3139,9 @@ var starknet = (() => {
     return true;
   }
   function utf8ToBytes(str) {
-    if (typeof str !== "string") {
+    if (typeof str !== "string")
       throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-    }
-    return new TextEncoder().encode(str);
+    return new Uint8Array(new TextEncoder().encode(str));
   }
   function bitLen(n) {
     let len;
@@ -3143,8 +3149,12 @@ var starknet = (() => {
       ;
     return len;
   }
-  var bitGet = (n, pos) => n >> BigInt(pos) & _1n;
-  var bitSet = (n, pos, value) => n | (value ? _1n : _0n) << BigInt(pos);
+  function bitGet(n, pos) {
+    return n >> BigInt(pos) & _1n;
+  }
+  var bitSet = (n, pos, value) => {
+    return 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);
@@ -3201,6 +3211,7 @@ var starknet = (() => {
     function: (val) => typeof val === "function",
     boolean: (val) => typeof val === "boolean",
     string: (val) => typeof val === "string",
+    stringOrUint8Array: (val) => typeof val === "string" || val instanceof Uint8Array,
     isSafeInteger: (val) => Number.isSafeInteger(val),
     array: (val) => Array.isArray(val),
     field: (val, object) => object.Fp.isValid(val),
@@ -3305,12 +3316,12 @@ var starknet = (() => {
     starknetKeccak: () => starknetKeccak
   });
 
-  // node_modules/micro-starknet/lib/esm/index.js
+  // node_modules/@scure/starknet/lib/esm/index.js
   var esm_exports = {};
   __export(esm_exports, {
     CURVE: () => CURVE,
     Fp251: () => Fp251,
-    Fp253: () => Fp253,
+    MAX_VALUE: () => MAX_VALUE,
     ProjectivePoint: () => ProjectivePoint,
     Signature: () => Signature,
     _poseidonMDS: () => _poseidonMDS,
@@ -3322,7 +3333,6 @@ var starknet = (() => {
     getSharedSecret: () => getSharedSecret,
     getStarkKey: () => getStarkKey,
     grindKey: () => grindKey,
-    hashChain: () => hashChain,
     keccak: () => keccak,
     pedersen: () => pedersen,
     poseidonBasic: () => poseidonBasic,
@@ -3342,15 +3352,11 @@ var starknet = (() => {
     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");
+      throw new Error("Expected Uint8Array");
     if (lengths.length > 0 && !lengths.includes(b.length))
-      throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+      throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
   }
   function hash(hash2) {
     if (typeof hash2 !== "function" || typeof hash2.create !== "function")
@@ -3371,19 +3377,10 @@ var starknet = (() => {
       throw new Error(`digestInto() expects output buffer of length at least ${min}`);
     }
   }
-  var assert2 = {
-    number,
-    bool,
-    bytes,
-    hash,
-    exists,
-    output
-  };
-  var assert_default = assert2;
 
   // node_modules/@noble/hashes/esm/_u64.js
-  var U32_MASK64 = BigInt(2 ** 32 - 1);
-  var _32n = BigInt(32);
+  var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+  var _32n = /* @__PURE__ */ BigInt(32);
   function fromBig(n, le = false) {
     if (le)
       return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
@@ -3398,92 +3395,44 @@ var starknet = (() => {
     }
     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/@noble/hashes/esm/crypto.js
   var crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
 
   // node_modules/@noble/hashes/esm/utils.js
+  var u8a2 = (a) => a instanceof Uint8Array;
   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);
+    if (typeof str !== "string")
+      throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    return new Uint8Array(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})`);
+    if (!u8a2(data))
+      throw new Error(`expected 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;
+    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
+    let pad = 0;
+    arrays.forEach((a) => {
+      if (!u8a2(a))
+        throw new Error("Uint8Array expected");
+      r.set(a, pad);
+      pad += a.length;
+    });
+    return r;
   }
   var Hash = class {
     // Safe version that clones internal state
@@ -3491,15 +3440,16 @@ var starknet = (() => {
       return this._cloneInto();
     }
   };
-  function wrapConstructor(hashConstructor) {
-    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
-    const tmp = hashConstructor();
+  var toStr = {}.toString;
+  function wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
     hashC.outputLen = tmp.outputLen;
     hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashConstructor();
+    hashC.create = () => hashCons();
     return hashC;
   }
-  function wrapConstructorWithOpts(hashCons) {
+  function wrapXOFConstructorWithOpts(hashCons) {
     const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
     const tmp = hashCons({});
     hashC.outputLen = tmp.outputLen;
@@ -3516,12 +3466,12 @@ var 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);
+  var _0n2 = /* @__PURE__ */ BigInt(0);
+  var _1n2 = /* @__PURE__ */ BigInt(1);
+  var _2n2 = /* @__PURE__ */ BigInt(2);
+  var _7n = /* @__PURE__ */ BigInt(7);
+  var _256n = /* @__PURE__ */ BigInt(256);
+  var _0x71n = /* @__PURE__ */ 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));
@@ -3530,13 +3480,13 @@ var starknet = (() => {
     for (let j = 0; j < 7; j++) {
       R = (R << _1n2 ^ (R >> _7n) * _0x71n) % _256n;
       if (R & _2n2)
-        t ^= _1n2 << (_1n2 << BigInt(j)) - _1n2;
+        t ^= _1n2 << (_1n2 << /* @__PURE__ */ 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);
+  var [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
+  var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+  var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
   function keccakP(s, rounds = 24) {
     const B = new Uint32Array(5 * 2);
     for (let round = 24 - rounds; round < 24; round++) {
@@ -3590,7 +3540,7 @@ var starknet = (() => {
       this.posOut = 0;
       this.finished = false;
       this.destroyed = false;
-      assert_default.number(outputLen);
+      number(outputLen);
       if (0 >= this.blockLen || this.blockLen >= 200)
         throw new Error("Sha3 supports only keccak-f1600 function");
       this.state = new Uint8Array(200);
@@ -3602,7 +3552,7 @@ var starknet = (() => {
       this.pos = 0;
     }
     update(data) {
-      assert_default.exists(this);
+      exists(this);
       const { blockLen, state } = this;
       data = toBytes(data);
       const len = data.length;
@@ -3627,8 +3577,8 @@ var starknet = (() => {
       this.keccak();
     }
     writeInto(out) {
-      assert_default.exists(this, false);
-      assert_default.bytes(out);
+      exists(this, false);
+      bytes(out);
       this.finish();
       const bufferOut = this.state;
       const { blockLen } = this;
@@ -3648,11 +3598,11 @@ var starknet = (() => {
       return this.writeInto(out);
     }
     xof(bytes2) {
-      assert_default.number(bytes2);
+      number(bytes2);
       return this.xofInto(new Uint8Array(bytes2));
     }
     digestInto(out) {
-      assert_default.output(out, this);
+      output(out, this);
       if (this.finished)
         throw new Error("digest() was already called");
       this.writeInto(out);
@@ -3682,17 +3632,17 @@ var starknet = (() => {
     }
   };
   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 sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
+  var sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
+  var sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
+  var sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
+  var keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
+  var keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
+  var keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
+  var keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
+  var genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+  var shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
+  var shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
 
   // node_modules/@noble/hashes/esm/_sha2.js
   function setBigUint64(view, byteOffset, value, isLE2) {
@@ -3722,7 +3672,7 @@ var starknet = (() => {
       this.view = createView(this.buffer);
     }
     update(data) {
-      assert_default.exists(this);
+      exists(this);
       const { view, buffer, blockLen } = this;
       data = toBytes(data);
       const len = data.length;
@@ -3747,8 +3697,8 @@ var starknet = (() => {
       return this;
     }
     digestInto(out) {
-      assert_default.exists(this);
-      assert_default.output(out, this);
+      exists(this);
+      output(out, this);
       this.finished = true;
       const { buffer, view, blockLen, isLE: isLE2 } = this;
       let { pos } = this;
@@ -3797,7 +3747,7 @@ var starknet = (() => {
   // node_modules/@noble/hashes/esm/sha256.js
   var Chi = (a, b, c) => a & b ^ ~a & c;
   var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
-  var SHA256_K = new Uint32Array([
+  var SHA256_K = /* @__PURE__ */ new Uint32Array([
     1116352408,
     1899447441,
     3049323471,
@@ -3863,7 +3813,7 @@ var starknet = (() => {
     3204031479,
     3329325298
   ]);
-  var IV = new Uint32Array([
+  var IV = /* @__PURE__ */ new Uint32Array([
     1779033703,
     3144134277,
     1013904242,
@@ -3873,7 +3823,7 @@ var starknet = (() => {
     528734635,
     1541459225
   ]);
-  var SHA256_W = new Uint32Array(64);
+  var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
   var SHA256 = class extends SHA2 {
     constructor() {
       super(64, 32, 8, false);
@@ -3944,22 +3894,7 @@ var starknet = (() => {
       this.buffer.fill(0);
     }
   };
-  var SHA224 = class extends SHA256 {
-    constructor() {
-      super();
-      this.A = 3238371032 | 0;
-      this.B = 914150663 | 0;
-      this.C = 812702999 | 0;
-      this.D = 4144912697 | 0;
-      this.E = 4290775857 | 0;
-      this.F = 1750603025 | 0;
-      this.G = 1694076839 | 0;
-      this.H = 3204075428 | 0;
-      this.outputLen = 28;
-    }
-  };
-  var sha256 = wrapConstructor(() => new SHA256());
-  var sha224 = wrapConstructor(() => new SHA224());
+  var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
   // node_modules/@noble/curves/esm/abstract/modular.js
   var _0n3 = BigInt(0);
@@ -4150,7 +4085,7 @@ var starknet = (() => {
   }
   function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
     if (ORDER <= _0n3)
-      throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
+      throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
     const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
     if (BYTES > 2048)
       throw new Error("Field lengths over 2048 bytes are not supported");
@@ -4198,14 +4133,25 @@ var starknet = (() => {
     });
     return Object.freeze(f);
   }
-  function hashToPrivateScalar(hash2, groupOrder, isLE2 = false) {
-    hash2 = ensureBytes("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;
+  function getFieldBytesLength(fieldOrder) {
+    if (typeof fieldOrder !== "bigint")
+      throw new Error("field order must be bigint");
+    const bitLength = fieldOrder.toString(2).length;
+    return Math.ceil(bitLength / 8);
+  }
+  function getMinHashLength(fieldOrder) {
+    const length = getFieldBytesLength(fieldOrder);
+    return length + Math.ceil(length / 2);
+  }
+  function mapHashToField(key, fieldOrder, isLE2 = false) {
+    const len = key.length;
+    const fieldLen = getFieldBytesLength(fieldOrder);
+    const minLen = getMinHashLength(fieldOrder);
+    if (len < 16 || len < minLen || len > 1024)
+      throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
+    const num = isLE2 ? bytesToNumberBE(key) : bytesToNumberLE(key);
+    const reduced = mod(num, fieldOrder - _1n3) + _1n3;
+    return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
   }
 
   // node_modules/@noble/curves/esm/abstract/poseidon.js
@@ -4216,43 +4162,17 @@ var starknet = (() => {
     validateOpts: () => validateOpts
   });
   function validateOpts(opts) {
-    const { Fp } = opts;
+    const { Fp, mds, reversePartialPowIdx: rev, roundConstants: rc } = opts;
+    const { roundsFull, roundsPartial, sboxPower, t } = opts;
     validateField(Fp);
     for (const i of ["t", "roundsFull", "roundsPartial"]) {
       if (typeof opts[i] !== "number" || !Number.isSafeInteger(opts[i]))
         throw new Error(`Poseidon: invalid param ${i}=${opts[i]} (${typeof opts[i]})`);
     }
-    if (opts.reversePartialPowIdx !== void 0 && typeof opts.reversePartialPowIdx !== "boolean")
-      throw new Error(`Poseidon: invalid param reversePartialPowIdx=${opts.reversePartialPowIdx}`);
-    let sboxPower = opts.sboxPower;
-    if (sboxPower === void 0)
-      sboxPower = 5;
-    if (typeof sboxPower !== "number" || !Number.isSafeInteger(sboxPower))
-      throw new Error(`Poseidon wrong sboxPower=${sboxPower}`);
-    const _sboxPower = BigInt(sboxPower);
-    let sboxFn = (n) => FpPow(Fp, n, _sboxPower);
-    if (sboxPower === 3)
-      sboxFn = (n) => Fp.mul(Fp.sqrN(n), n);
-    else if (sboxPower === 5)
-      sboxFn = (n) => Fp.mul(Fp.sqrN(Fp.sqrN(n)), n);
-    if (opts.roundsFull % 2 !== 0)
-      throw new Error(`Poseidon roundsFull is not even: ${opts.roundsFull}`);
-    const rounds = opts.roundsFull + opts.roundsPartial;
-    if (!Array.isArray(opts.roundConstants) || opts.roundConstants.length !== rounds)
-      throw new Error("Poseidon: wrong round constants");
-    const roundConstants = opts.roundConstants.map((rc) => {
-      if (!Array.isArray(rc) || rc.length !== opts.t)
-        throw new Error(`Poseidon wrong round constants: ${rc}`);
-      return rc.map((i) => {
-        if (typeof i !== "bigint" || !Fp.isValid(i))
-          throw new Error(`Poseidon wrong round constant=${i}`);
-        return Fp.create(i);
-      });
-    });
-    if (!Array.isArray(opts.mds) || opts.mds.length !== opts.t)
+    if (!Array.isArray(mds) || mds.length !== t)
       throw new Error("Poseidon: wrong MDS matrix");
-    const mds = opts.mds.map((mdsRow) => {
-      if (!Array.isArray(mdsRow) || mdsRow.length !== opts.t)
+    const _mds = mds.map((mdsRow) => {
+      if (!Array.isArray(mdsRow) || mdsRow.length !== t)
         throw new Error(`Poseidon MDS matrix row: ${mdsRow}`);
       return mdsRow.map((i) => {
         if (typeof i !== "bigint")
@@ -4260,7 +4180,31 @@ var starknet = (() => {
         return Fp.create(i);
       });
     });
-    return Object.freeze({ ...opts, rounds, sboxFn, roundConstants, mds });
+    if (rev !== void 0 && typeof rev !== "boolean")
+      throw new Error(`Poseidon: invalid param reversePartialPowIdx=${rev}`);
+    if (roundsFull % 2 !== 0)
+      throw new Error(`Poseidon roundsFull is not even: ${roundsFull}`);
+    const rounds = roundsFull + roundsPartial;
+    if (!Array.isArray(rc) || rc.length !== rounds)
+      throw new Error("Poseidon: wrong round constants");
+    const roundConstants = rc.map((rc2) => {
+      if (!Array.isArray(rc2) || rc2.length !== t)
+        throw new Error(`Poseidon wrong round constants: ${rc2}`);
+      return rc2.map((i) => {
+        if (typeof i !== "bigint" || !Fp.isValid(i))
+          throw new Error(`Poseidon wrong round constant=${i}`);
+        return Fp.create(i);
+      });
+    });
+    if (!sboxPower || ![3, 5, 7].includes(sboxPower))
+      throw new Error(`Poseidon wrong sboxPower=${sboxPower}`);
+    const _sboxPower = BigInt(sboxPower);
+    let sboxFn = (n) => FpPow(Fp, n, _sboxPower);
+    if (sboxPower === 3)
+      sboxFn = (n) => Fp.mul(Fp.sqrN(n), n);
+    else if (sboxPower === 5)
+      sboxFn = (n) => Fp.mul(Fp.sqrN(Fp.sqrN(n)), n);
+    return Object.freeze({ ...opts, rounds, sboxFn, roundConstants, mds: _mds });
   }
   function splitConstants(rc, t) {
     if (typeof t !== "number")
@@ -4279,16 +4223,17 @@ var starknet = (() => {
     return res;
   }
   function poseidon(opts) {
-    const { t, Fp, rounds, sboxFn, reversePartialPowIdx } = validateOpts(opts);
-    const halfRoundsFull = Math.floor(opts.roundsFull / 2);
-    const partialIdx = reversePartialPowIdx ? t - 1 : 0;
+    const _opts = validateOpts(opts);
+    const { Fp, mds, roundConstants, rounds, roundsPartial, sboxFn, t } = _opts;
+    const halfRoundsFull = _opts.roundsFull / 2;
+    const partialIdx = _opts.reversePartialPowIdx ? t - 1 : 0;
     const poseidonRound = (values, isFull, idx) => {
-      values = values.map((i, j) => Fp.add(i, opts.roundConstants[idx][j]));
+      values = values.map((i, j) => Fp.add(i, roundConstants[idx][j]));
       if (isFull)
         values = values.map((i) => sboxFn(i));
       else
         values[partialIdx] = sboxFn(values[partialIdx]);
-      values = opts.mds.map((i) => i.reduce((acc, i2, j) => Fp.add(acc, Fp.mulN(i2, values[j])), Fp.ZERO));
+      values = mds.map((i) => i.reduce((acc, i2, j) => Fp.add(acc, Fp.mulN(i2, values[j])), Fp.ZERO));
       return values;
     };
     const poseidonHash2 = function poseidonHash3(values) {
@@ -4302,7 +4247,7 @@ var starknet = (() => {
       let round = 0;
       for (let i = 0; i < halfRoundsFull; i++)
         values = poseidonRound(values, true, round++);
-      for (let i = 0; i < opts.roundsPartial; i++)
+      for (let i = 0; i < roundsPartial; i++)
         values = poseidonRound(values, false, round++);
       for (let i = 0; i < halfRoundsFull; i++)
         values = poseidonRound(values, true, round++);
@@ -4310,7 +4255,7 @@ var starknet = (() => {
         throw new Error(`Poseidon: wrong number of rounds: last round=${round}, total=${rounds}`);
       return values;
     };
-    poseidonHash2.roundConstants = opts.roundConstants;
+    poseidonHash2.roundConstants = roundConstants;
     return poseidonHash2;
   }
 
@@ -4529,7 +4474,7 @@ var starknet = (() => {
   function weierstrassPoints(opts) {
     const CURVE2 = validatePointOpts(opts);
     const { Fp } = CURVE2;
-    const toBytes2 = CURVE2.toBytes || ((c, point, isCompressed) => {
+    const toBytes2 = CURVE2.toBytes || ((_c, point, _isCompressed) => {
       const a = point.toAffine();
       return concatBytes(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
     });
@@ -4641,7 +4586,7 @@ var starknet = (() => {
       // A point on curve is valid if it conforms to equation.
       assertValidity() {
         if (this.is0()) {
-          if (CURVE2.allowInfinityPoint)
+          if (CURVE2.allowInfinityPoint && !Fp.is0(this.py))
             return;
           throw new Error("bad point: ZERO");
         }
@@ -4944,7 +4889,7 @@ var starknet = (() => {
     }
     const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
       ...CURVE2,
-      toBytes(c, point, isCompressed) {
+      toBytes(_c, point, isCompressed) {
         const a = point.toAffine();
         const x = Fp.toBytes(a.x);
         const cat = concatBytes;
@@ -5067,13 +5012,12 @@ var starknet = (() => {
       },
       normPrivateKeyToScalar,
       /**
-       * Produces cryptographically secure private key from random of size (nBitLength+64)
-       * as per FIPS 186 B.4.1 with modulo bias being neglible.
+       * Produces cryptographically secure private key from random of size
+       * (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
        */
       randomPrivateKey: () => {
-        const rand = CURVE2.randomBytes(Fp.BYTES + 8);
-        const num = hashToPrivateScalar(rand, CURVE_ORDER2);
-        return numberToBytesBE(num, CURVE2.nByteLength);
+        const length = getMinHashLength(CURVE2.n);
+        return mapHashToField(CURVE2.randomBytes(length), CURVE2.n);
       },
       /**
        * Creates precompute table for an arbitrary EC point. Makes point "cached".
@@ -5143,7 +5087,7 @@ var starknet = (() => {
       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(ensureBytes("extraEntropy", e));
       }
       const seed = concatBytes(...seedArgs);
       const m = h1int;
@@ -5173,7 +5117,8 @@ 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 C = CURVE2;
+      const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
       return drbg(seed, k2sig);
     }
     Point.BASE._setWindowSize(8);
@@ -5239,10 +5184,12 @@ var starknet = (() => {
     for (let o = q - _1n5; o % _2n4 === _0n5; o /= _2n4)
       l += _1n5;
     const c1 = l;
-    const c2 = (q - _1n5) / _2n4 ** c1;
+    const _2n_pow_c1_1 = _2n4 << c1 - _1n5 - _1n5;
+    const _2n_pow_c1 = _2n_pow_c1_1 * _2n4;
+    const c2 = (q - _1n5) / _2n_pow_c1;
     const c3 = (c2 - _1n5) / _2n4;
-    const c4 = _2n4 ** c1 - _1n5;
-    const c5 = _2n4 ** (c1 - _1n5);
+    const c4 = _2n_pow_c1 - _1n5;
+    const c5 = _2n_pow_c1_1;
     const c6 = Fp.pow(Z, c2);
     const c7 = Fp.pow(Z, (c2 + _1n5) / _2n4);
     let sqrtRatio = (u, v) => {
@@ -5263,7 +5210,8 @@ var starknet = (() => {
       tv3 = Fp.cmov(tv2, tv3, isQR);
       tv4 = Fp.cmov(tv5, tv4, isQR);
       for (let i = c1; i > _1n5; i--) {
-        let tv52 = _2n4 ** (i - _2n4);
+        let tv52 = i - _2n4;
+        tv52 = _2n4 << tv52 - _1n5;
         let tvv5 = Fp.pow(tv4, tv52);
         const e1 = Fp.eql(tvv5, Fp.ONE);
         tv2 = Fp.mul(tv3, tv1);
@@ -5336,11 +5284,11 @@ var starknet = (() => {
       super();
       this.finished = false;
       this.destroyed = false;
-      assert_default.hash(hash2);
+      hash(hash2);
       const key = toBytes(_key);
       this.iHash = hash2.create();
       if (typeof this.iHash.update !== "function")
-        throw new TypeError("Expected instance of class which extends utils.Hash");
+        throw new Error("Expected instance of class which extends utils.Hash");
       this.blockLen = this.iHash.blockLen;
       this.outputLen = this.iHash.outputLen;
       const blockLen = this.blockLen;
@@ -5356,13 +5304,13 @@ var starknet = (() => {
       pad.fill(0);
     }
     update(buf) {
-      assert_default.exists(this);
+      exists(this);
       this.iHash.update(buf);
       return this;
     }
     digestInto(out) {
-      assert_default.exists(this);
-      assert_default.bytes(out, this.outputLen);
+      exists(this);
+      bytes(out, this.outputLen);
       this.finished = true;
       this.iHash.digestInto(out);
       this.oHash.update(out);
@@ -5404,8 +5352,9 @@ var starknet = (() => {
     };
   }
 
-  // node_modules/micro-starknet/lib/esm/index.js
+  // node_modules/@scure/starknet/lib/esm/index.js
   var CURVE_ORDER = BigInt("3618502788666131213697322783095070105526743751716087489154079457884512865583");
+  var MAX_VALUE = BigInt("0x800000000000000000000000000000000000000000000000000000000000000");
   var nBitLength = 252;
   function bits2int(bytes2) {
     while (bytes2[0] === 0)
@@ -5454,12 +5403,39 @@ var starknet = (() => {
   function getSharedSecret(privKeyA, pubKeyB) {
     return curve.getSharedSecret(normPrivKey(privKeyA), pubKeyB);
   }
+  function checkSignature(signature) {
+    const { r, s } = signature;
+    if (r < 0n || r >= MAX_VALUE)
+      throw new Error(`Signature.r should be [1, ${MAX_VALUE})`);
+    const w = invert(s, CURVE_ORDER);
+    if (w < 0n || w >= MAX_VALUE)
+      throw new Error(`inv(Signature.s) should be [1, ${MAX_VALUE})`);
+  }
+  function checkMessage(msgHash) {
+    const bytes2 = ensureBytes2(msgHash);
+    const num = bytesToNumberBE(bytes2);
+    if (num >= MAX_VALUE)
+      throw new Error(`msgHash should be [0, ${MAX_VALUE})`);
+    return bytes2;
+  }
   function sign(msgHash, privKey, opts) {
-    return curve.sign(ensureBytes2(msgHash), normPrivKey(privKey), opts);
+    const sig = curve.sign(checkMessage(msgHash), normPrivKey(privKey), opts);
+    checkSignature(sig);
+    return sig;
   }
   function verify(signature, msgHash, pubKey) {
-    const sig = signature instanceof Signature ? signature : ensureBytes2(signature);
-    return curve.verify(sig, ensureBytes2(msgHash), ensureBytes2(pubKey));
+    if (!(signature instanceof Signature)) {
+      const bytes2 = ensureBytes2(signature);
+      try {
+        signature = Signature.fromDER(bytes2);
+      } catch (derError) {
+        if (!(derError instanceof DER.Err))
+          throw derError;
+        signature = Signature.fromCompact(bytes2);
+      }
+    }
+    checkSignature(signature);
+    return curve.verify(signature, checkMessage(msgHash), ensureBytes2(pubKey));
   }
   var { CURVE, ProjectivePoint, Signature, utils } = curve;
   function extractX(bytes2) {
@@ -5470,9 +5446,6 @@ var starknet = (() => {
   function strip0x(hex) {
     return hex.replace(/^0x/i, "");
   }
-  function numberTo0x16(num) {
-    return `0x${num.toString(16)}`;
-  }
   function grindKey(seed) {
     const _seed = ensureBytes2(seed);
     const sha256mask = 2n ** 256n;
@@ -5558,18 +5531,10 @@ var starknet = (() => {
     point = pedersenSingle(point, y, PEDERSEN_POINTS2);
     return extractX(point.toRawBytes(true));
   }
-  function hashChain(data, fn = pedersen) {
-    if (!Array.isArray(data) || data.length < 1)
-      throw new Error("data should be array of at least 1 element");
-    if (data.length === 1)
-      return numberTo0x16(pedersenArg(data[0]));
-    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_2502 = bitMask(250);
   var keccak = (data) => bytesToNumberBE(keccak_256(data)) & MASK_2502;
   var sha256Num = (data) => bytesToNumberBE(sha256(data));
-  var Fp253 = Field(BigInt("14474011154664525231415395255581126252639794253786371766033694892385558855681"));
   var Fp251 = Field(BigInt("3618502788666131213697322783095070105623107215331596699973092056135872020481"));
   function poseidonRoundConstant(Fp, name, idx) {
     const val = Fp.fromBytes(sha256(utf8ToBytes2(`${name}${idx}`)));
@@ -6228,10 +6193,6 @@ var starknet = (() => {
       if (isTypeEthAddress(abiType)) {
         return unorderedItem;
       }
-      if (isTypeStruct(abiType, structs)) {
-        const abiOfStruct = structs[abiType].members;
-        return orderStruct(unorderedItem, abiOfStruct);
-      }
       if (isTypeUint256(abiType)) {
         const u256 = unorderedItem;
         if (typeof u256 !== "object") {
@@ -6242,6 +6203,10 @@ var starknet = (() => {
         }
         return { low: u256.low, high: u256.high };
       }
+      if (isTypeStruct(abiType, structs)) {
+        const abiOfStruct = structs[abiType].members;
+        return orderStruct(unorderedItem, abiOfStruct);
+      }
       return unorderedItem;
     };
     const orderStruct = (unorderedObject2, abiObject) => {