@settlemint/sdk-cli 2.4.0-pr88ac0d7d → 2.4.0-pra6821f69

package/dist/cli.js

@@ -5149,7 +5149,7 @@ var require_sha2 = __commonJS((exports) => {
   exports.sha512_224 = (0, utils_ts_1.createHasher)(() => new SHA512_224);
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/utils.js
+// ../../node_modules/@noble/curves/abstract/utils.js
 var require_utils5 = __commonJS((exports) => {
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -5423,7 +5423,7 @@ var require_utils5 = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/modular.js
+// ../../node_modules/@noble/curves/abstract/modular.js
 var require_modular = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.isNegativeLE = undefined;
@@ -5753,7 +5753,7 @@ var require_modular = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/curve.js
+// ../../node_modules/@noble/curves/abstract/curve.js
 var require_curve = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.wNAF = wNAF;
@@ -6002,7 +6002,7 @@ var require_curve = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/edwards.js
+// ../../node_modules/@noble/curves/abstract/edwards.js
 var require_edwards = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.twistedEdwards = twistedEdwards;
@@ -6361,7 +6361,7 @@ var require_edwards = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/hash-to-curve.js
+// ../../node_modules/@noble/curves/abstract/hash-to-curve.js
 var require_hash_to_curve = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.expand_message_xmd = expand_message_xmd;
@@ -6514,7 +6514,7 @@ var require_hash_to_curve = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/montgomery.js
+// ../../node_modules/@noble/curves/abstract/montgomery.js
 var require_montgomery = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.montgomery = montgomery;
@@ -6621,7 +6621,7 @@ var require_montgomery = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/ed25519.js
+// ../../node_modules/@noble/curves/ed25519.js
 var require_ed25519 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.hash_to_ristretto255 = exports.hashToRistretto255 = exports.RistrettoPoint = exports.encodeToCurve = exports.hashToCurve = exports.ed25519_hasher = exports.edwardsToMontgomery = exports.x25519 = exports.ed25519ph = exports.ed25519ctx = exports.ed25519 = exports.ED25519_TORSION_SUBGROUP = undefined;
@@ -7061,7 +7061,7 @@ var require_hmac = __commonJS((exports) => {
   exports.hmac.create = (hash, key) => new HMAC(hash, key);
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/abstract/weierstrass.js
+// ../../node_modules/@noble/curves/abstract/weierstrass.js
 var require_weierstrass = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.DER = exports.DERErr = undefined;
@@ -7980,7 +7980,7 @@ var require_weierstrass = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/_shortw_utils.js
+// ../../node_modules/@noble/curves/_shortw_utils.js
 var require__shortw_utils = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.getHash = getHash;
@@ -8002,7 +8002,7 @@ var require__shortw_utils = __commonJS((exports) => {
   }
 });
 
-// ../../node_modules/eciesjs/node_modules/@noble/curves/secp256k1.js
+// ../../node_modules/@noble/curves/secp256k1.js
 var require_secp256k1 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.encodeToCurve = exports.hashToCurve = exports.secp256k1_hasher = exports.schnorr = exports.secp256k1 = undefined;
@@ -231623,7 +231623,7 @@ function size(value4) {
 var init_size = () => {};
 
 // ../../node_modules/viem/_esm/errors/version.js
-var version5 = "2.31.6";
+var version5 = "2.31.1";
 
 // ../../node_modules/viem/_esm/errors/base.js
 function walk(err, fn) {
@@ -232421,46 +232421,6 @@ function byteSwap32(arr) {
   }
   return arr;
 }
-function bytesToHex2(bytes) {
-  abytes(bytes);
-  if (hasHexBuiltin)
-    return bytes.toHex();
-  let hex = "";
-  for (let i6 = 0;i6 < bytes.length; i6++) {
-    hex += hexes2[bytes[i6]];
-  }
-  return hex;
-}
-function asciiToBase16(ch) {
-  if (ch >= asciis._0 && ch <= asciis._9)
-    return ch - asciis._0;
-  if (ch >= asciis.A && ch <= asciis.F)
-    return ch - (asciis.A - 10);
-  if (ch >= asciis.a && ch <= asciis.f)
-    return ch - (asciis.a - 10);
-  return;
-}
-function hexToBytes2(hex) {
-  if (typeof hex !== "string")
-    throw new Error("hex string expected, got " + typeof hex);
-  if (hasHexBuiltin)
-    return Uint8Array.fromHex(hex);
-  const hl = hex.length;
-  const al = hl / 2;
-  if (hl % 2)
-    throw new Error("hex string expected, got unpadded hex of length " + hl);
-  const array4 = new Uint8Array(al);
-  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
-    const n1 = asciiToBase16(hex.charCodeAt(hi));
-    const n22 = asciiToBase16(hex.charCodeAt(hi + 1));
-    if (n1 === undefined || n22 === undefined) {
-      const char = hex[hi] + hex[hi + 1];
-      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-    }
-    array4[ai] = n1 * 16 + n22;
-  }
-  return array4;
-}
 function utf8ToBytes(str) {
   if (typeof str !== "string")
     throw new Error("string expected");
@@ -232507,15 +232467,12 @@ function randomBytes(bytesLength = 32) {
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
-var isLE, swap32IfBE, hasHexBuiltin, hexes2, asciis;
+var isLE, swap32IfBE;
 var init_utils2 = __esm(() => {
   init_cryptoNode();
   /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
   swap32IfBE = isLE ? (u6) => u6 : byteSwap32;
-  hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
-  hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_5, i6) => i6.toString(16).padStart(2, "0"));
-  asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
 });
 
 // ../../node_modules/@noble/hashes/esm/sha3.js
@@ -235181,7 +235138,14 @@ var init_hmac = __esm(() => {
   hmac.create = (hash2, key2) => new HMAC(hash2, key2);
 });
 
-// ../../node_modules/@noble/curves/esm/utils.js
+// ../../node_modules/@noble/curves/esm/abstract/utils.js
+function isBytes2(a7) {
+  return a7 instanceof Uint8Array || ArrayBuffer.isView(a7) && a7.constructor.name === "Uint8Array";
+}
+function abytes2(item) {
+  if (!isBytes2(item))
+    throw new Error("Uint8Array expected");
+}
 function abool(title, value4) {
   if (typeof value4 !== "boolean")
     throw new Error(title + " boolean expected, got " + value4);
@@ -235195,11 +235159,51 @@ function hexToNumber2(hex) {
     throw new Error("hex string expected, got " + typeof hex);
   return hex === "" ? _0n2 : BigInt("0x" + hex);
 }
+function bytesToHex2(bytes) {
+  abytes2(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i6 = 0;i6 < bytes.length; i6++) {
+    hex += hexes2[bytes[i6]];
+  }
+  return hex;
+}
+function asciiToBase16(ch) {
+  if (ch >= asciis._0 && ch <= asciis._9)
+    return ch - asciis._0;
+  if (ch >= asciis.A && ch <= asciis.F)
+    return ch - (asciis.A - 10);
+  if (ch >= asciis.a && ch <= asciis.f)
+    return ch - (asciis.a - 10);
+  return;
+}
+function hexToBytes2(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  if (hasHexBuiltin)
+    return Uint8Array.fromHex(hex);
+  const hl = hex.length;
+  const al = hl / 2;
+  if (hl % 2)
+    throw new Error("hex string expected, got unpadded hex of length " + hl);
+  const array4 = new Uint8Array(al);
+  for (let ai = 0, hi = 0;ai < al; ai++, hi += 2) {
+    const n1 = asciiToBase16(hex.charCodeAt(hi));
+    const n22 = asciiToBase16(hex.charCodeAt(hi + 1));
+    if (n1 === undefined || n22 === undefined) {
+      const char = hex[hi] + hex[hi + 1];
+      throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+    }
+    array4[ai] = n1 * 16 + n22;
+  }
+  return array4;
+}
 function bytesToNumberBE(bytes) {
   return hexToNumber2(bytesToHex2(bytes));
 }
 function bytesToNumberLE(bytes) {
-  abytes(bytes);
+  abytes2(bytes);
   return hexToNumber2(bytesToHex2(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n6, len) {
@@ -235216,7 +235220,7 @@ function ensureBytes(title, hex, expectedLength) {
     } catch (e10) {
       throw new Error(title + " must be hex string or Uint8Array, cause: " + e10);
     }
-  } else if (isBytes(hex)) {
+  } else if (isBytes2(hex)) {
     res = Uint8Array.from(hex);
   } else {
     throw new Error(title + " must be hex string or Uint8Array");
@@ -235226,6 +235230,26 @@ function ensureBytes(title, hex, expectedLength) {
     throw new Error(title + " of length " + expectedLength + " expected, got " + len);
   return res;
 }
+function concatBytes3(...arrays) {
+  let sum = 0;
+  for (let i6 = 0;i6 < arrays.length; i6++) {
+    const a7 = arrays[i6];
+    abytes2(a7);
+    sum += a7.length;
+  }
+  const res = new Uint8Array(sum);
+  for (let i6 = 0, pad2 = 0;i6 < arrays.length; i6++) {
+    const a7 = arrays[i6];
+    res.set(a7, pad2);
+    pad2 += a7.length;
+  }
+  return res;
+}
+function utf8ToBytes2(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
 function inRange(n6, min, max) {
   return isPosBig(n6) && isPosBig(min) && isPosBig(max) && min <= n6 && n6 < max;
 }
@@ -235246,8 +235270,6 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
     throw new Error("qByteLen must be a number");
   if (typeof hmacFn !== "function")
     throw new Error("hmacFn must be a function");
-  const u8n = (len) => new Uint8Array(len);
-  const u8of = (byte) => Uint8Array.of(byte);
   let v6 = u8n(hashLen);
   let k5 = u8n(hashLen);
   let i6 = 0;
@@ -235258,11 +235280,11 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   const h8 = (...b4) => hmacFn(k5, v6, ...b4);
   const reseed = (seed = u8n(0)) => {
-    k5 = h8(u8of(0), seed);
+    k5 = h8(u8fr([0]), seed);
     v6 = h8();
     if (seed.length === 0)
       return;
-    k5 = h8(u8of(1), seed);
+    k5 = h8(u8fr([1]), seed);
     v6 = h8();
   };
   const gen2 = () => {
@@ -235276,7 +235298,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
       out.push(sl);
       len += v6.length;
     }
-    return concatBytes(...out);
+    return concatBytes3(...out);
   };
   const genUntil = (seed, pred) => {
     reset2();
@@ -235289,22 +235311,23 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   };
   return genUntil;
 }
-function isHash(val) {
-  return typeof val === "function" && Number.isSafeInteger(val.outputLen);
-}
-function _validateObject(object4, fields, optFields = {}) {
-  if (!object4 || typeof object4 !== "object")
-    throw new Error("expected valid options object");
-  function checkField(fieldName, expectedType, isOpt) {
+function validateObject(object4, validators, optValidators = {}) {
+  const checkField = (fieldName, type4, isOptional) => {
+    const checkVal = validatorFns[type4];
+    if (typeof checkVal !== "function")
+      throw new Error("invalid validator function");
     const val = object4[fieldName];
-    if (isOpt && val === undefined)
+    if (isOptional && val === undefined)
       return;
-    const current = typeof val;
-    if (current !== expectedType || val === null)
-      throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
-  }
-  Object.entries(fields).forEach(([k5, v6]) => checkField(k5, v6, false));
-  Object.entries(optFields).forEach(([k5, v6]) => checkField(k5, v6, true));
+    if (!checkVal(val, object4)) {
+      throw new Error("param " + String(fieldName) + " is invalid. Expected " + type4 + ", got " + val);
+    }
+  };
+  for (const [fieldName, type4] of Object.entries(validators))
+    checkField(fieldName, type4, false);
+  for (const [fieldName, type4] of Object.entries(optValidators))
+    checkField(fieldName, type4, true);
+  return object4;
 }
 function memoized(fn) {
   const map6 = new WeakMap;
@@ -235317,13 +235340,25 @@ function memoized(fn) {
     return computed;
   };
 }
-var _0n2, _1n2, isPosBig = (n6) => typeof n6 === "bigint" && _0n2 <= n6, bitMask = (n6) => (_1n2 << BigInt(n6)) - _1n2;
+var _0n2, _1n2, hasHexBuiltin, hexes2, asciis, isPosBig = (n6) => typeof n6 === "bigint" && _0n2 <= n6, bitMask = (n6) => (_1n2 << BigInt(n6)) - _1n2, u8n = (len) => new Uint8Array(len), u8fr = (arr) => Uint8Array.from(arr), validatorFns;
 var init_utils3 = __esm(() => {
-  init_utils2();
-  init_utils2();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n2 = /* @__PURE__ */ BigInt(0);
   _1n2 = /* @__PURE__ */ BigInt(1);
+  hasHexBuiltin = typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
+  hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_5, i6) => i6.toString(16).padStart(2, "0"));
+  asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+  validatorFns = {
+    bigint: (val) => typeof val === "bigint",
+    function: (val) => typeof val === "function",
+    boolean: (val) => typeof val === "boolean",
+    string: (val) => typeof val === "string",
+    stringOrUint8Array: (val) => typeof val === "string" || isBytes2(val),
+    isSafeInteger: (val) => Number.isSafeInteger(val),
+    array: (val) => Array.isArray(val),
+    field: (val, object4) => object4.Fp.isValid(val),
+    hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
+  };
 });
 
 // ../../node_modules/@noble/curves/esm/abstract/modular.js
@@ -235437,15 +235472,14 @@ function validateField(field2) {
   const initial = {
     ORDER: "bigint",
     MASK: "bigint",
-    BYTES: "number",
-    BITS: "number"
+    BYTES: "isSafeInteger",
+    BITS: "isSafeInteger"
   };
   const opts = FIELD_FIELDS.reduce((map6, val) => {
     map6[val] = "function";
     return map6;
   }, initial);
-  _validateObject(field2, opts);
-  return field2;
+  return validateObject(field2, opts);
 }
 function FpPow(Fp, num, power) {
   if (power < _0n3)
@@ -235498,28 +235532,10 @@ function nLength(n6, nBitLength) {
   const nByteLength = Math.ceil(_nBitLength / 8);
   return { nBitLength: _nBitLength, nByteLength };
 }
-function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
+function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
   if (ORDER <= _0n3)
     throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
-  let _nbitLength = undefined;
-  let _sqrt = undefined;
-  if (typeof bitLenOrOpts === "object" && bitLenOrOpts != null) {
-    if (opts.sqrt || isLE2)
-      throw new Error("cannot specify opts in two arguments");
-    const _opts = bitLenOrOpts;
-    if (_opts.BITS)
-      _nbitLength = _opts.BITS;
-    if (_opts.sqrt)
-      _sqrt = _opts.sqrt;
-    if (typeof _opts.isLE === "boolean")
-      isLE2 = _opts.isLE;
-  } else {
-    if (typeof bitLenOrOpts === "number")
-      _nbitLength = bitLenOrOpts;
-    if (opts.sqrt)
-      _sqrt = opts.sqrt;
-  }
-  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, _nbitLength);
+  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
   if (BYTES > 2048)
     throw new Error("invalid field: expected ORDER of <= 2048 bytes");
   let sqrtP;
@@ -235538,7 +235554,6 @@ function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
       return _0n3 <= num && num < ORDER;
     },
     is0: (num) => num === _0n3,
-    isValidNot0: (num) => !f5.is0(num) && f5.isValid(num),
     isOdd: (num) => (num & _1n3) === _1n3,
     neg: (num) => mod(-num, ORDER),
     eql: (lhs, rhs) => lhs === rhs,
@@ -235553,7 +235568,7 @@ function Field(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
     subN: (lhs, rhs) => lhs - rhs,
     mulN: (lhs, rhs) => lhs * rhs,
     inv: (num) => invert(num, ORDER),
-    sqrt: _sqrt || ((n6) => {
+    sqrt: redef.sqrt || ((n6) => {
       if (!sqrtP)
         sqrtP = FpSqrt(ORDER);
       return sqrtP(f5, n6);
@@ -235591,6 +235606,7 @@ function mapHashToField(key2, fieldOrder, isLE2 = false) {
 }
 var _0n3, _1n3, _2n2, _3n, _4n, _5n, _8n, FIELD_FIELDS;
 var init_modular = __esm(() => {
+  init_utils2();
   init_utils3();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n3 = BigInt(0);
@@ -235622,16 +235638,10 @@ var init_modular = __esm(() => {
 });
 
 // ../../node_modules/@noble/curves/esm/abstract/curve.js
-function negateCt(condition, item) {
+function constTimeNegate(condition, item) {
   const neg = item.negate();
   return condition ? neg : item;
 }
-function normalizeZ(c3, property, points) {
-  const getz = property === "pz" ? (p5) => p5.pz : (p5) => p5.ez;
-  const toInv = FpInvertBatch(c3.Fp, points.map(getz));
-  const affined = points.map((p5, i6) => p5.toAffine(toInv[i6]));
-  return affined.map(c3.fromAffine);
-}
 function validateW(W5, bits) {
   if (!Number.isSafeInteger(W5) || W5 <= 0 || W5 > bits)
     throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W5);
@@ -235680,13 +235690,9 @@ function validateMSMScalars(scalars, field2) {
 function getW(P5) {
   return pointWindowSizes.get(P5) || 1;
 }
-function assert0(n6) {
-  if (n6 !== _0n4)
-    throw new Error("invalid wNAF");
-}
 function wNAF(c3, bits) {
   return {
-    constTimeNegate: negateCt,
+    constTimeNegate,
     hasPrecomputes(elm) {
       return getW(elm) !== 1;
     },
@@ -235724,12 +235730,11 @@ function wNAF(c3, bits) {
         const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n6, window2, wo);
         n6 = nextN;
         if (isZero) {
-          f5 = f5.add(negateCt(isNegF, precomputes[offsetF]));
+          f5 = f5.add(constTimeNegate(isNegF, precomputes[offsetF]));
         } else {
-          p5 = p5.add(negateCt(isNeg, precomputes[offset]));
+          p5 = p5.add(constTimeNegate(isNeg, precomputes[offset]));
         }
       }
-      assert0(n6);
       return { p: p5, f: f5 };
     },
     wNAFUnsafe(W5, precomputes, n6, acc = c3.ZERO) {
@@ -235746,18 +235751,14 @@ function wNAF(c3, bits) {
           acc = acc.add(isNeg ? item.negate() : item);
         }
       }
-      assert0(n6);
       return acc;
     },
     getPrecomputes(W5, P5, transform5) {
       let comp = pointPrecomputes.get(P5);
       if (!comp) {
         comp = this.precomputeWindow(P5, W5);
-        if (W5 !== 1) {
-          if (typeof transform5 === "function")
-            comp = transform5(comp);
-          pointPrecomputes.set(P5, comp);
-        }
+        if (W5 !== 1)
+          pointPrecomputes.set(P5, transform5(comp));
       }
       return comp;
     },
@@ -235778,21 +235779,6 @@ function wNAF(c3, bits) {
     }
   };
 }
-function mulEndoUnsafe(c3, point, k1, k22) {
-  let acc = point;
-  let p1 = c3.ZERO;
-  let p22 = c3.ZERO;
-  while (k1 > _0n4 || k22 > _0n4) {
-    if (k1 & _1n4)
-      p1 = p1.add(acc);
-    if (k22 & _1n4)
-      p22 = p22.add(acc);
-    acc = acc.double();
-    k1 >>= _1n4;
-    k22 >>= _1n4;
-  }
-  return { p1, p2: p22 };
-}
 function pippenger(c3, fieldN, points, scalars) {
   validateMSMPoints(points, c3);
   validateMSMScalars(scalars, fieldN);
@@ -235832,38 +235818,27 @@ function pippenger(c3, fieldN, points, scalars) {
   }
   return sum;
 }
-function createField(order, field2) {
-  if (field2) {
-    if (field2.ORDER !== order)
-      throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
-    validateField(field2);
-    return field2;
-  } else {
-    return Field(order);
-  }
-}
-function _createCurveFields(type4, CURVE, curveOpts = {}) {
-  if (!CURVE || typeof CURVE !== "object")
-    throw new Error(`expected valid ${type4} CURVE object`);
-  for (const p5 of ["p", "n", "h"]) {
-    const val = CURVE[p5];
-    if (!(typeof val === "bigint" && val > _0n4))
-      throw new Error(`CURVE.${p5} must be positive bigint`);
-  }
-  const Fp = createField(CURVE.p, curveOpts.Fp);
-  const Fn = createField(CURVE.n, curveOpts.Fn);
-  const _b = type4 === "weierstrass" ? "b" : "d";
-  const params = ["Gx", "Gy", "a", _b];
-  for (const p5 of params) {
-    if (!Fp.isValid(CURVE[p5]))
-      throw new Error(`CURVE.${p5} must be valid field element of CURVE.Fp`);
-  }
-  return { Fp, Fn };
+function validateBasic(curve) {
+  validateField(curve.Fp);
+  validateObject(curve, {
+    n: "bigint",
+    h: "bigint",
+    Gx: "field",
+    Gy: "field"
+  }, {
+    nBitLength: "isSafeInteger",
+    nByteLength: "isSafeInteger"
+  });
+  return Object.freeze({
+    ...nLength(curve.n, curve.nBitLength),
+    ...curve,
+    ...{ p: curve.Fp.ORDER }
+  });
 }
 var _0n4, _1n4, pointPrecomputes, pointWindowSizes;
 var init_curve = __esm(() => {
-  init_utils3();
   init_modular();
+  init_utils3();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   _0n4 = BigInt(0);
   _1n4 = BigInt(1);
@@ -235878,116 +235853,54 @@ function validateSigVerOpts(opts) {
   if (opts.prehash !== undefined)
     abool("prehash", opts.prehash);
 }
-function _legacyHelperEquat(Fp, a7, b4) {
-  function weierstrassEquation(x6) {
-    const x22 = Fp.sqr(x6);
-    const x32 = Fp.mul(x22, x6);
-    return Fp.add(Fp.add(x32, Fp.mul(x6, a7)), b4);
-  }
-  return weierstrassEquation;
-}
-function _legacyHelperNormPriv(Fn, allowedPrivateKeyLengths, wrapPrivateKey) {
-  const { BYTES: expected } = Fn;
-  function normPrivateKeyToScalar(key2) {
-    let num;
-    if (typeof key2 === "bigint") {
-      num = key2;
-    } else {
-      let bytes = ensureBytes("private key", key2);
-      if (allowedPrivateKeyLengths) {
-        if (!allowedPrivateKeyLengths.includes(bytes.length * 2))
-          throw new Error("invalid private key");
-        const padded = new Uint8Array(expected);
-        padded.set(bytes, padded.length - bytes.length);
-        bytes = padded;
-      }
-      try {
-        num = Fn.fromBytes(bytes);
-      } catch (error44) {
-        throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key2}`);
-      }
-    }
-    if (wrapPrivateKey)
-      num = Fn.create(num);
-    if (!Fn.isValidNot0(num))
-      throw new Error("invalid private key: out of range [1..N-1]");
-    return num;
-  }
-  return normPrivateKeyToScalar;
-}
-function weierstrassN(CURVE, curveOpts = {}) {
-  const { Fp, Fn } = _createCurveFields("weierstrass", CURVE, curveOpts);
-  const { h: cofactor, n: CURVE_ORDER } = CURVE;
-  _validateObject(curveOpts, {}, {
+function validatePointOpts(curve) {
+  const opts = validateBasic(curve);
+  validateObject(opts, {
+    a: "field",
+    b: "field"
+  }, {
     allowInfinityPoint: "boolean",
+    allowedPrivateKeyLengths: "array",
     clearCofactor: "function",
-    isTorsionFree: "function",
     fromBytes: "function",
+    isTorsionFree: "function",
     toBytes: "function",
-    endo: "object",
     wrapPrivateKey: "boolean"
   });
-  const { endo } = curveOpts;
+  const { endo, Fp, a: a7 } = opts;
   if (endo) {
-    if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
-      throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
+    if (!Fp.eql(a7, Fp.ZERO)) {
+      throw new Error("invalid endo: CURVE.a must be 0");
     }
-  }
-  function assertCompressionIsSupported() {
-    if (!Fp.isOdd)
-      throw new Error("compression is not supported: Field does not have .isOdd()");
-  }
-  function pointToBytes(_c, point, isCompressed) {
-    const { x: x6, y: y4 } = point.toAffine();
-    const bx = Fp.toBytes(x6);
-    abool("isCompressed", isCompressed);
-    if (isCompressed) {
-      assertCompressionIsSupported();
-      const hasEvenY = !Fp.isOdd(y4);
-      return concatBytes(pprefix(hasEvenY), bx);
-    } else {
-      return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y4));
+    if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
+      throw new Error('invalid endo: expected "beta": bigint and "splitScalar": function');
     }
   }
-  function pointFromBytes(bytes) {
-    abytes(bytes);
-    const L5 = Fp.BYTES;
-    const LC = L5 + 1;
-    const LU = 2 * L5 + 1;
-    const length = bytes.length;
-    const head = bytes[0];
+  return Object.freeze({ ...opts });
+}
+function numToSizedHex(num, size2) {
+  return bytesToHex2(numberToBytesBE(num, size2));
+}
+function weierstrassPoints(opts) {
+  const CURVE = validatePointOpts(opts);
+  const { Fp } = CURVE;
+  const Fn = Field(CURVE.n, CURVE.nBitLength);
+  const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
+    const a7 = point.toAffine();
+    return concatBytes3(Uint8Array.from([4]), Fp.toBytes(a7.x), Fp.toBytes(a7.y));
+  });
+  const fromBytes = CURVE.fromBytes || ((bytes) => {
     const tail = bytes.subarray(1);
-    if (length === LC && (head === 2 || head === 3)) {
-      const x6 = Fp.fromBytes(tail);
-      if (!Fp.isValid(x6))
-        throw new Error("bad point: is not on curve, wrong x");
-      const y22 = weierstrassEquation(x6);
-      let y4;
-      try {
-        y4 = Fp.sqrt(y22);
-      } catch (sqrtError) {
-        const err = sqrtError instanceof Error ? ": " + sqrtError.message : "";
-        throw new Error("bad point: is not on curve, sqrt error" + err);
-      }
-      assertCompressionIsSupported();
-      const isYOdd = Fp.isOdd(y4);
-      const isHeadOdd = (head & 1) === 1;
-      if (isHeadOdd !== isYOdd)
-        y4 = Fp.neg(y4);
-      return { x: x6, y: y4 };
-    } else if (length === LU && head === 4) {
-      const x6 = Fp.fromBytes(tail.subarray(L5 * 0, L5 * 1));
-      const y4 = Fp.fromBytes(tail.subarray(L5 * 1, L5 * 2));
-      if (!isValidXY(x6, y4))
-        throw new Error("bad point: is not on curve");
-      return { x: x6, y: y4 };
-    } else {
-      throw new Error(`bad point: got length ${length}, expected compressed=${LC} or uncompressed=${LU}`);
-    }
+    const x6 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+    const y4 = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+    return { x: x6, y: y4 };
+  });
+  function weierstrassEquation(x6) {
+    const { a: a7, b: b4 } = CURVE;
+    const x22 = Fp.sqr(x6);
+    const x32 = Fp.mul(x22, x6);
+    return Fp.add(Fp.add(x32, Fp.mul(x6, a7)), b4);
   }
-  const toBytes3 = curveOpts.toBytes || pointToBytes;
-  const fromBytes = curveOpts.fromBytes || pointFromBytes;
-  const weierstrassEquation = _legacyHelperEquat(Fp, CURVE.a, CURVE.b);
   function isValidXY(x6, y4) {
     const left = Fp.sqr(y4);
     const right = weierstrassEquation(x6);
@@ -235999,10 +235912,28 @@ function weierstrassN(CURVE, curveOpts = {}) {
   const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
   if (Fp.is0(Fp.add(_4a3, _27b2)))
     throw new Error("bad curve params: a or b");
-  function acoord(title, n6, banZero = false) {
-    if (!Fp.isValid(n6) || banZero && Fp.is0(n6))
-      throw new Error(`bad point coordinate ${title}`);
-    return n6;
+  function isWithinCurveOrder(num) {
+    return inRange(num, _1n5, CURVE.n);
+  }
+  function normPrivateKeyToScalar(key2) {
+    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N6 } = CURVE;
+    if (lengths && typeof key2 !== "bigint") {
+      if (isBytes2(key2))
+        key2 = bytesToHex2(key2);
+      if (typeof key2 !== "string" || !lengths.includes(key2.length))
+        throw new Error("invalid private key");
+      key2 = key2.padStart(nByteLength * 2, "0");
+    }
+    let num;
+    try {
+      num = typeof key2 === "bigint" ? key2 : bytesToNumberBE(ensureBytes("private key", key2, nByteLength));
+    } catch (error44) {
+      throw new Error("invalid private key, expected hex or " + nByteLength + " bytes, got " + typeof key2);
+    }
+    if (wrapPrivateKey)
+      num = mod(num, N6);
+    aInRange("private key", num, _1n5, N6);
+    return num;
   }
   function aprjpoint(other) {
     if (!(other instanceof Point))
@@ -236026,31 +235957,31 @@ function weierstrassN(CURVE, curveOpts = {}) {
   });
   const assertValidMemo = memoized((p5) => {
     if (p5.is0()) {
-      if (curveOpts.allowInfinityPoint && !Fp.is0(p5.py))
+      if (CURVE.allowInfinityPoint && !Fp.is0(p5.py))
         return;
       throw new Error("bad point: ZERO");
     }
     const { x: x6, y: y4 } = p5.toAffine();
     if (!Fp.isValid(x6) || !Fp.isValid(y4))
-      throw new Error("bad point: x or y not field elements");
+      throw new Error("bad point: x or y not FE");
     if (!isValidXY(x6, y4))
       throw new Error("bad point: equation left != right");
     if (!p5.isTorsionFree())
       throw new Error("bad point: not in prime-order subgroup");
     return true;
   });
-  function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
-    k2p = new Point(Fp.mul(k2p.px, endoBeta), k2p.py, k2p.pz);
-    k1p = negateCt(k1neg, k1p);
-    k2p = negateCt(k2neg, k2p);
-    return k1p.add(k2p);
-  }
 
   class Point {
     constructor(px, py, pz) {
-      this.px = acoord("x", px);
-      this.py = acoord("y", py, true);
-      this.pz = acoord("z", pz);
+      if (px == null || !Fp.isValid(px))
+        throw new Error("x required");
+      if (py == null || !Fp.isValid(py) || Fp.is0(py))
+        throw new Error("y required");
+      if (pz == null || !Fp.isValid(pz))
+        throw new Error("z required");
+      this.px = px;
+      this.py = py;
+      this.pz = pz;
       Object.freeze(this);
     }
     static fromAffine(p5) {
@@ -236059,7 +235990,8 @@ function weierstrassN(CURVE, curveOpts = {}) {
         throw new Error("invalid affine point");
       if (p5 instanceof Point)
         throw new Error("projective point not allowed");
-      if (Fp.is0(x6) && Fp.is0(y4))
+      const is0 = (i6) => Fp.eql(i6, Fp.ZERO);
+      if (is0(x6) && is0(y4))
         return Point.ZERO;
       return new Point(x6, y4, Fp.ONE);
     }
@@ -236070,11 +236002,8 @@ function weierstrassN(CURVE, curveOpts = {}) {
       return this.toAffine().y;
     }
     static normalizeZ(points) {
-      return normalizeZ(Point, "pz", points);
-    }
-    static fromBytes(bytes) {
-      abytes(bytes);
-      return Point.fromHex(bytes);
+      const toInv = FpInvertBatch(Fp, points.map((p5) => p5.pz));
+      return points.map((p5, i6) => p5.toAffine(toInv[i6])).map(Point.fromAffine);
     }
     static fromHex(hex) {
       const P5 = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
@@ -236082,29 +236011,22 @@ function weierstrassN(CURVE, curveOpts = {}) {
       return P5;
     }
     static fromPrivateKey(privateKey) {
-      const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
       return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
     }
     static msm(points, scalars) {
       return pippenger(Point, Fn, points, scalars);
     }
-    precompute(windowSize = 8, isLazy = true) {
-      wnaf.setWindowSize(this, windowSize);
-      if (!isLazy)
-        this.multiply(_3n2);
-      return this;
-    }
     _setWindowSize(windowSize) {
-      this.precompute(windowSize);
+      wnaf.setWindowSize(this, windowSize);
     }
     assertValidity() {
       assertValidMemo(this);
     }
     hasEvenY() {
       const { y: y4 } = this.toAffine();
-      if (!Fp.isOdd)
-        throw new Error("Field doesn't support isOdd");
-      return !Fp.isOdd(y4);
+      if (Fp.isOdd)
+        return !Fp.isOdd(y4);
+      throw new Error("Field doesn't support isOdd");
     }
     equals(other) {
       aprjpoint(other);
@@ -236210,121 +236132,188 @@ function weierstrassN(CURVE, curveOpts = {}) {
     is0() {
       return this.equals(Point.ZERO);
     }
+    wNAF(n6) {
+      return wnaf.wNAFCached(this, n6, Point.normalizeZ);
+    }
+    multiplyUnsafe(sc) {
+      const { endo: endo2, n: N6 } = CURVE;
+      aInRange("scalar", sc, _0n5, N6);
+      const I6 = Point.ZERO;
+      if (sc === _0n5)
+        return I6;
+      if (this.is0() || sc === _1n5)
+        return this;
+      if (!endo2 || wnaf.hasPrecomputes(this))
+        return wnaf.wNAFCachedUnsafe(this, sc, Point.normalizeZ);
+      let { k1neg, k1, k2neg, k2: k22 } = endo2.splitScalar(sc);
+      let k1p = I6;
+      let k2p = I6;
+      let d6 = this;
+      while (k1 > _0n5 || k22 > _0n5) {
+        if (k1 & _1n5)
+          k1p = k1p.add(d6);
+        if (k22 & _1n5)
+          k2p = k2p.add(d6);
+        d6 = d6.double();
+        k1 >>= _1n5;
+        k22 >>= _1n5;
+      }
+      if (k1neg)
+        k1p = k1p.negate();
+      if (k2neg)
+        k2p = k2p.negate();
+      k2p = new Point(Fp.mul(k2p.px, endo2.beta), k2p.py, k2p.pz);
+      return k1p.add(k2p);
+    }
     multiply(scalar) {
-      const { endo: endo2 } = curveOpts;
-      if (!Fn.isValidNot0(scalar))
-        throw new Error("invalid scalar: out of range");
+      const { endo: endo2, n: N6 } = CURVE;
+      aInRange("scalar", scalar, _1n5, N6);
       let point, fake;
-      const mul = (n6) => wnaf.wNAFCached(this, n6, Point.normalizeZ);
       if (endo2) {
         const { k1neg, k1, k2neg, k2: k22 } = endo2.splitScalar(scalar);
-        const { p: k1p, f: k1f } = mul(k1);
-        const { p: k2p, f: k2f } = mul(k22);
-        fake = k1f.add(k2f);
-        point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg);
+        let { p: k1p, f: f1p } = this.wNAF(k1);
+        let { p: k2p, f: f2p } = this.wNAF(k22);
+        k1p = wnaf.constTimeNegate(k1neg, k1p);
+        k2p = wnaf.constTimeNegate(k2neg, k2p);
+        k2p = new Point(Fp.mul(k2p.px, endo2.beta), k2p.py, k2p.pz);
+        point = k1p.add(k2p);
+        fake = f1p.add(f2p);
       } else {
-        const { p: p5, f: f5 } = mul(scalar);
+        const { p: p5, f: f5 } = this.wNAF(scalar);
         point = p5;
         fake = f5;
       }
       return Point.normalizeZ([point, fake])[0];
     }
-    multiplyUnsafe(sc) {
-      const { endo: endo2 } = curveOpts;
-      const p5 = this;
-      if (!Fn.isValid(sc))
-        throw new Error("invalid scalar: out of range");
-      if (sc === _0n5 || p5.is0())
-        return Point.ZERO;
-      if (sc === _1n5)
-        return p5;
-      if (wnaf.hasPrecomputes(this))
-        return this.multiply(sc);
-      if (endo2) {
-        const { k1neg, k1, k2neg, k2: k22 } = endo2.splitScalar(sc);
-        const { p1, p2: p22 } = mulEndoUnsafe(Point, p5, k1, k22);
-        return finishEndo(endo2.beta, p1, p22, k1neg, k2neg);
-      } else {
-        return wnaf.wNAFCachedUnsafe(p5, sc);
-      }
-    }
     multiplyAndAddUnsafe(Q4, a7, b4) {
-      const sum = this.multiplyUnsafe(a7).add(Q4.multiplyUnsafe(b4));
+      const G4 = Point.BASE;
+      const mul = (P5, a8) => a8 === _0n5 || a8 === _1n5 || !P5.equals(G4) ? P5.multiplyUnsafe(a8) : P5.multiply(a8);
+      const sum = mul(this, a7).add(mul(Q4, b4));
       return sum.is0() ? undefined : sum;
     }
-    toAffine(invertedZ) {
-      return toAffineMemo(this, invertedZ);
+    toAffine(iz) {
+      return toAffineMemo(this, iz);
     }
     isTorsionFree() {
-      const { isTorsionFree } = curveOpts;
+      const { h: cofactor, isTorsionFree } = CURVE;
       if (cofactor === _1n5)
         return true;
       if (isTorsionFree)
         return isTorsionFree(Point, this);
-      return wnaf.wNAFCachedUnsafe(this, CURVE_ORDER).is0();
+      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
     }
     clearCofactor() {
-      const { clearCofactor } = curveOpts;
+      const { h: cofactor, clearCofactor } = CURVE;
       if (cofactor === _1n5)
         return this;
       if (clearCofactor)
         return clearCofactor(Point, this);
-      return this.multiplyUnsafe(cofactor);
+      return this.multiplyUnsafe(CURVE.h);
     }
-    toBytes(isCompressed = true) {
+    toRawBytes(isCompressed = true) {
       abool("isCompressed", isCompressed);
       this.assertValidity();
       return toBytes3(Point, this, isCompressed);
     }
-    toRawBytes(isCompressed = true) {
-      return this.toBytes(isCompressed);
-    }
     toHex(isCompressed = true) {
-      return bytesToHex2(this.toBytes(isCompressed));
-    }
-    toString() {
-      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+      abool("isCompressed", isCompressed);
+      return bytesToHex2(this.toRawBytes(isCompressed));
     }
   }
   Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
   Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
-  Point.Fp = Fp;
-  Point.Fn = Fn;
-  const bits = Fn.BITS;
-  const wnaf = wNAF(Point, curveOpts.endo ? Math.ceil(bits / 2) : bits);
-  return Point;
-}
-function pprefix(hasEvenY) {
-  return Uint8Array.of(hasEvenY ? 2 : 3);
+  const { endo, nBitLength } = CURVE;
+  const wnaf = wNAF(Point, endo ? Math.ceil(nBitLength / 2) : nBitLength);
+  return {
+    CURVE,
+    ProjectivePoint: Point,
+    normPrivateKeyToScalar,
+    weierstrassEquation,
+    isWithinCurveOrder
+  };
 }
-function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
-  _validateObject(ecdsaOpts, { hash: "function" }, {
+function validateOpts(curve) {
+  const opts = validateBasic(curve);
+  validateObject(opts, {
+    hash: "hash",
     hmac: "function",
-    lowS: "boolean",
-    randomBytes: "function",
+    randomBytes: "function"
+  }, {
     bits2int: "function",
-    bits2int_modN: "function"
+    bits2int_modN: "function",
+    lowS: "boolean"
+  });
+  return Object.freeze({ lowS: true, ...opts });
+}
+function weierstrass(curveDef) {
+  const CURVE = validateOpts(curveDef);
+  const { Fp, n: CURVE_ORDER, nByteLength, nBitLength } = CURVE;
+  const compressedLen = Fp.BYTES + 1;
+  const uncompressedLen = 2 * Fp.BYTES + 1;
+  function modN(a7) {
+    return mod(a7, CURVE_ORDER);
+  }
+  function invN(a7) {
+    return invert(a7, CURVE_ORDER);
+  }
+  const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
+    ...CURVE,
+    toBytes(_c, point, isCompressed) {
+      const a7 = point.toAffine();
+      const x6 = Fp.toBytes(a7.x);
+      const cat = concatBytes3;
+      abool("isCompressed", isCompressed);
+      if (isCompressed) {
+        return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x6);
+      } else {
+        return cat(Uint8Array.from([4]), x6, Fp.toBytes(a7.y));
+      }
+    },
+    fromBytes(bytes) {
+      const len = bytes.length;
+      const head = bytes[0];
+      const tail = bytes.subarray(1);
+      if (len === compressedLen && (head === 2 || head === 3)) {
+        const x6 = bytesToNumberBE(tail);
+        if (!inRange(x6, _1n5, Fp.ORDER))
+          throw new Error("Point is not on curve");
+        const y22 = weierstrassEquation(x6);
+        let y4;
+        try {
+          y4 = Fp.sqrt(y22);
+        } catch (sqrtError) {
+          const suffix = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+          throw new Error("Point is not on curve" + suffix);
+        }
+        const isYOdd = (y4 & _1n5) === _1n5;
+        const isHeadOdd = (head & 1) === 1;
+        if (isHeadOdd !== isYOdd)
+          y4 = Fp.neg(y4);
+        return { x: x6, y: y4 };
+      } else if (len === uncompressedLen && head === 4) {
+        const x6 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+        const y4 = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+        return { x: x6, y: y4 };
+      } else {
+        const cl = compressedLen;
+        const ul = uncompressedLen;
+        throw new Error("invalid Point, expected length of " + cl + ", or uncompressed " + ul + ", got " + len);
+      }
+    }
   });
-  const randomBytes_ = ecdsaOpts.randomBytes || randomBytes;
-  const hmac_ = ecdsaOpts.hmac || ((key2, ...msgs) => hmac(ecdsaOpts.hash, key2, concatBytes(...msgs)));
-  const { Fp, Fn } = Point;
-  const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
   function isBiggerThanHalfOrder(number6) {
     const HALF = CURVE_ORDER >> _1n5;
     return number6 > HALF;
   }
   function normalizeS(s7) {
-    return isBiggerThanHalfOrder(s7) ? Fn.neg(s7) : s7;
-  }
-  function aValidRS(title, num) {
-    if (!Fn.isValidNot0(num))
-      throw new Error(`invalid signature ${title}: out of range 1..CURVE.n`);
+    return isBiggerThanHalfOrder(s7) ? modN(-s7) : s7;
   }
+  const slcNum = (b4, from, to) => bytesToNumberBE(b4.slice(from, to));
 
   class Signature {
     constructor(r6, s7, recovery) {
-      aValidRS("r", r6);
-      aValidRS("s", s7);
+      aInRange("r", r6, _1n5, CURVE_ORDER);
+      aInRange("s", s7, _1n5, CURVE_ORDER);
       this.r = r6;
       this.s = s7;
       if (recovery != null)
@@ -236332,9 +236321,9 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
       Object.freeze(this);
     }
     static fromCompact(hex) {
-      const L5 = Fn.BYTES;
-      const b4 = ensureBytes("compactSignature", hex, L5 * 2);
-      return new Signature(Fn.fromBytes(b4.subarray(0, L5)), Fn.fromBytes(b4.subarray(L5, L5 * 2)));
+      const l3 = nByteLength;
+      hex = ensureBytes("compactSignature", hex, l3 * 2);
+      return new Signature(slcNum(hex, 0, l3), slcNum(hex, l3, 2 * l3));
     }
     static fromDER(hex) {
       const { r: r6, s: s7 } = DER.toSig(ensureBytes("DER", hex));
@@ -236345,24 +236334,20 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
       return new Signature(this.r, this.s, recovery);
     }
     recoverPublicKey(msgHash) {
-      const FIELD_ORDER = Fp.ORDER;
       const { r: r6, s: s7, recovery: rec } = this;
+      const h8 = bits2int_modN(ensureBytes("msgHash", msgHash));
       if (rec == null || ![0, 1, 2, 3].includes(rec))
         throw new Error("recovery id invalid");
-      const hasCofactor = CURVE_ORDER * _2n3 < FIELD_ORDER;
-      if (hasCofactor && rec > 1)
-        throw new Error("recovery id is ambiguous for h>1 curve");
-      const radj = rec === 2 || rec === 3 ? r6 + CURVE_ORDER : r6;
-      if (!Fp.isValid(radj))
+      const radj = rec === 2 || rec === 3 ? r6 + CURVE.n : r6;
+      if (radj >= Fp.ORDER)
         throw new Error("recovery id 2 or 3 invalid");
-      const x6 = Fp.toBytes(radj);
-      const R7 = Point.fromHex(concatBytes(pprefix((rec & 1) === 0), x6));
-      const ir2 = Fn.inv(radj);
-      const h8 = bits2int_modN(ensureBytes("msgHash", msgHash));
-      const u1 = Fn.create(-h8 * ir2);
-      const u22 = Fn.create(s7 * ir2);
-      const Q4 = Point.BASE.multiplyUnsafe(u1).add(R7.multiplyUnsafe(u22));
-      if (Q4.is0())
+      const prefix = (rec & 1) === 0 ? "02" : "03";
+      const R7 = Point.fromHex(prefix + numToSizedHex(radj, Fp.BYTES));
+      const ir2 = invN(radj);
+      const u1 = modN(-h8 * ir2);
+      const u22 = modN(s7 * ir2);
+      const Q4 = Point.BASE.multiplyAndAddUnsafe(R7, u1, u22);
+      if (!Q4)
         throw new Error("point at infinify");
       Q4.assertValidity();
       return Q4;
@@ -236371,29 +236356,22 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
       return isBiggerThanHalfOrder(this.s);
     }
     normalizeS() {
-      return this.hasHighS() ? new Signature(this.r, Fn.neg(this.s), this.recovery) : this;
-    }
-    toBytes(format2) {
-      if (format2 === "compact")
-        return concatBytes(Fn.toBytes(this.r), Fn.toBytes(this.s));
-      if (format2 === "der")
-        return hexToBytes2(DER.hexFromSig(this));
-      throw new Error("invalid format");
+      return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
     }
     toDERRawBytes() {
-      return this.toBytes("der");
+      return hexToBytes2(this.toDERHex());
     }
     toDERHex() {
-      return bytesToHex2(this.toBytes("der"));
+      return DER.hexFromSig(this);
     }
     toCompactRawBytes() {
-      return this.toBytes("compact");
+      return hexToBytes2(this.toCompactHex());
     }
     toCompactHex() {
-      return bytesToHex2(this.toBytes("compact"));
+      const l3 = nByteLength;
+      return numToSizedHex(this.r, l3) + numToSizedHex(this.s, l3);
     }
   }
-  const normPrivateKeyToScalar = _legacyHelperNormPriv(Fn, curveOpts.allowedPrivateKeyLengths, curveOpts.wrapPrivateKey);
   const utils = {
     isValidPrivateKey(privateKey) {
       try {
@@ -236405,15 +236383,17 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     },
     normPrivateKeyToScalar,
     randomPrivateKey: () => {
-      const n6 = CURVE_ORDER;
-      return mapHashToField(randomBytes_(getMinHashLength(n6)), n6);
+      const length = getMinHashLength(CURVE.n);
+      return mapHashToField(CURVE.randomBytes(length), CURVE.n);
     },
     precompute(windowSize = 8, point = Point.BASE) {
-      return point.precompute(windowSize, false);
+      point._setWindowSize(windowSize);
+      point.multiply(BigInt(3));
+      return point;
     }
   };
   function getPublicKey(privateKey, isCompressed = true) {
-    return Point.fromPrivateKey(privateKey).toBytes(isCompressed);
+    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
   }
   function isProbPub(item) {
     if (typeof item === "bigint")
@@ -236421,14 +236401,14 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     if (item instanceof Point)
       return true;
     const arr = ensureBytes("key", item);
-    const length = arr.length;
-    const L5 = Fp.BYTES;
-    const LC = L5 + 1;
-    const LU = 2 * L5 + 1;
-    if (curveOpts.allowedPrivateKeyLengths || Fn.BYTES === LC) {
+    const len = arr.length;
+    const fpl = Fp.BYTES;
+    const compLen = fpl + 1;
+    const uncompLen = 2 * fpl + 1;
+    if (CURVE.allowedPrivateKeyLengths || nByteLength === compLen) {
       return;
     } else {
-      return length === LC || length === LU;
+      return len === compLen || len === uncompLen;
     }
   }
   function getSharedSecret(privateA, publicB, isCompressed = true) {
@@ -236437,27 +236417,27 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     if (isProbPub(publicB) === false)
       throw new Error("second arg must be public key");
     const b4 = Point.fromHex(publicB);
-    return b4.multiply(normPrivateKeyToScalar(privateA)).toBytes(isCompressed);
+    return b4.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
   }
-  const bits2int = ecdsaOpts.bits2int || function(bytes) {
+  const bits2int = CURVE.bits2int || function(bytes) {
     if (bytes.length > 8192)
       throw new Error("input is too large");
     const num = bytesToNumberBE(bytes);
-    const delta = bytes.length * 8 - fnBits;
+    const delta = bytes.length * 8 - nBitLength;
     return delta > 0 ? num >> BigInt(delta) : num;
   };
-  const bits2int_modN = ecdsaOpts.bits2int_modN || function(bytes) {
-    return Fn.create(bits2int(bytes));
+  const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
+    return modN(bits2int(bytes));
   };
-  const ORDER_MASK = bitMask(fnBits);
+  const ORDER_MASK = bitMask(nBitLength);
   function int2octets(num) {
-    aInRange("num < 2^" + fnBits, num, _0n5, ORDER_MASK);
-    return Fn.toBytes(num);
+    aInRange("num < 2^" + nBitLength, num, _0n5, ORDER_MASK);
+    return numberToBytesBE(num, nByteLength);
   }
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k5) => (k5 in opts)))
       throw new Error("sign() legacy options not supported");
-    const { hash: hash2 } = ecdsaOpts;
+    const { hash: hash2, randomBytes: randomBytes2 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -236469,21 +236449,21 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     const d6 = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d6), int2octets(h1int)];
     if (ent != null && ent !== false) {
-      const e10 = ent === true ? randomBytes_(Fp.BYTES) : ent;
+      const e10 = ent === true ? randomBytes2(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e10));
     }
-    const seed = concatBytes(...seedArgs);
+    const seed = concatBytes3(...seedArgs);
     const m7 = h1int;
     function k2sig(kBytes) {
       const k5 = bits2int(kBytes);
-      if (!Fn.isValidNot0(k5))
+      if (!isWithinCurveOrder(k5))
         return;
-      const ik = Fn.inv(k5);
+      const ik = invN(k5);
       const q6 = Point.BASE.multiply(k5).toAffine();
-      const r6 = Fn.create(q6.x);
+      const r6 = modN(q6.x);
       if (r6 === _0n5)
         return;
-      const s7 = Fn.create(ik * Fn.create(m7 + r6 * d6));
+      const s7 = modN(ik * modN(m7 + r6 * d6));
       if (s7 === _0n5)
         return;
       let recovery = (q6.x === r6 ? 0 : 2) | Number(q6.y & _1n5);
@@ -236496,38 +236476,34 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     }
     return { seed, k2sig };
   }
-  const defaultSigOpts = { lowS: ecdsaOpts.lowS, prehash: false };
-  const defaultVerOpts = { lowS: ecdsaOpts.lowS, prehash: false };
+  const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
+  const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
   function sign(msgHash, privKey, opts = defaultSigOpts) {
     const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-    const drbg = createHmacDrbg(ecdsaOpts.hash.outputLen, Fn.BYTES, hmac_);
+    const C4 = CURVE;
+    const drbg = createHmacDrbg(C4.hash.outputLen, C4.nByteLength, C4.hmac);
     return drbg(seed, k2sig);
   }
-  Point.BASE.precompute(8);
+  Point.BASE._setWindowSize(8);
   function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
     const sg = signature;
     msgHash = ensureBytes("msgHash", msgHash);
     publicKey = ensureBytes("publicKey", publicKey);
-    validateSigVerOpts(opts);
     const { lowS, prehash, format: format2 } = opts;
+    validateSigVerOpts(opts);
     if ("strict" in opts)
       throw new Error("options.strict was renamed to lowS");
-    if (format2 !== undefined && !["compact", "der", "js"].includes(format2))
-      throw new Error('format must be "compact", "der" or "js"');
-    const isHex2 = typeof sg === "string" || isBytes(sg);
+    if (format2 !== undefined && format2 !== "compact" && format2 !== "der")
+      throw new Error("format must be compact or der");
+    const isHex2 = typeof sg === "string" || isBytes2(sg);
     const isObj = !isHex2 && !format2 && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
     if (!isHex2 && !isObj)
       throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
     let _sig = undefined;
     let P5;
     try {
-      if (isObj) {
-        if (format2 === undefined || format2 === "js") {
-          _sig = new Signature(sg.r, sg.s);
-        } else {
-          throw new Error("invalid format");
-        }
-      }
+      if (isObj)
+        _sig = new Signature(sg.r, sg.s);
       if (isHex2) {
         try {
           if (format2 !== "compact")
@@ -236548,77 +236524,28 @@ function ecdsa(Point, ecdsaOpts, curveOpts = {}) {
     if (lowS && _sig.hasHighS())
       return false;
     if (prehash)
-      msgHash = ecdsaOpts.hash(msgHash);
+      msgHash = CURVE.hash(msgHash);
     const { r: r6, s: s7 } = _sig;
     const h8 = bits2int_modN(msgHash);
-    const is = Fn.inv(s7);
-    const u1 = Fn.create(h8 * is);
-    const u22 = Fn.create(r6 * is);
-    const R7 = Point.BASE.multiplyUnsafe(u1).add(P5.multiplyUnsafe(u22));
-    if (R7.is0())
+    const is = invN(s7);
+    const u1 = modN(h8 * is);
+    const u22 = modN(r6 * is);
+    const R7 = Point.BASE.multiplyAndAddUnsafe(P5, u1, u22)?.toAffine();
+    if (!R7)
       return false;
-    const v6 = Fn.create(R7.x);
+    const v6 = modN(R7.x);
     return v6 === r6;
   }
-  return Object.freeze({
+  return {
+    CURVE,
     getPublicKey,
     getSharedSecret,
     sign,
     verify,
-    utils,
-    Point,
-    Signature
-  });
-}
-function _weierstrass_legacy_opts_to_new(c3) {
-  const CURVE = {
-    a: c3.a,
-    b: c3.b,
-    p: c3.Fp.ORDER,
-    n: c3.n,
-    h: c3.h,
-    Gx: c3.Gx,
-    Gy: c3.Gy
-  };
-  const Fp = c3.Fp;
-  const Fn = Field(CURVE.n, c3.nBitLength);
-  const curveOpts = {
-    Fp,
-    Fn,
-    allowedPrivateKeyLengths: c3.allowedPrivateKeyLengths,
-    allowInfinityPoint: c3.allowInfinityPoint,
-    endo: c3.endo,
-    wrapPrivateKey: c3.wrapPrivateKey,
-    isTorsionFree: c3.isTorsionFree,
-    clearCofactor: c3.clearCofactor,
-    fromBytes: c3.fromBytes,
-    toBytes: c3.toBytes
-  };
-  return { CURVE, curveOpts };
-}
-function _ecdsa_legacy_opts_to_new(c3) {
-  const { CURVE, curveOpts } = _weierstrass_legacy_opts_to_new(c3);
-  const ecdsaOpts = {
-    hash: c3.hash,
-    hmac: c3.hmac,
-    randomBytes: c3.randomBytes,
-    lowS: c3.lowS,
-    bits2int: c3.bits2int,
-    bits2int_modN: c3.bits2int_modN
-  };
-  return { CURVE, curveOpts, ecdsaOpts };
-}
-function _ecdsa_new_output_to_legacy(c3, ecdsa2) {
-  return Object.assign({}, ecdsa2, {
-    ProjectivePoint: ecdsa2.Point,
-    CURVE: c3
-  });
-}
-function weierstrass(c3) {
-  const { CURVE, curveOpts, ecdsaOpts } = _ecdsa_legacy_opts_to_new(c3);
-  const Point = weierstrassN(CURVE, curveOpts);
-  const signs = ecdsa(Point, ecdsaOpts, curveOpts);
-  return _ecdsa_new_output_to_legacy(c3, signs);
+    ProjectivePoint: Point,
+    Signature,
+    utils
+  };
 }
 function SWUFpSqrtRatio(Fp, Z4) {
   const q6 = Fp.ORDER;
@@ -236684,29 +236611,28 @@ function SWUFpSqrtRatio(Fp, Z4) {
 }
 function mapToCurveSimpleSWU(Fp, opts) {
   validateField(Fp);
-  const { A: A5, B: B4, Z: Z4 } = opts;
-  if (!Fp.isValid(A5) || !Fp.isValid(B4) || !Fp.isValid(Z4))
+  if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))
     throw new Error("mapToCurveSimpleSWU: invalid opts");
-  const sqrtRatio = SWUFpSqrtRatio(Fp, Z4);
+  const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);
   if (!Fp.isOdd)
-    throw new Error("Field does not have .isOdd()");
+    throw new Error("Fp.isOdd is not implemented!");
   return (u6) => {
     let tv1, tv2, tv3, tv4, tv5, tv6, x6, y4;
     tv1 = Fp.sqr(u6);
-    tv1 = Fp.mul(tv1, Z4);
+    tv1 = Fp.mul(tv1, opts.Z);
     tv2 = Fp.sqr(tv1);
     tv2 = Fp.add(tv2, tv1);
     tv3 = Fp.add(tv2, Fp.ONE);
-    tv3 = Fp.mul(tv3, B4);
-    tv4 = Fp.cmov(Z4, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
-    tv4 = Fp.mul(tv4, A5);
+    tv3 = Fp.mul(tv3, opts.B);
+    tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO));
+    tv4 = Fp.mul(tv4, opts.A);
     tv2 = Fp.sqr(tv3);
     tv6 = Fp.sqr(tv4);
-    tv5 = Fp.mul(tv6, A5);
+    tv5 = Fp.mul(tv6, opts.A);
     tv2 = Fp.add(tv2, tv5);
     tv2 = Fp.mul(tv2, tv3);
     tv6 = Fp.mul(tv6, tv4);
-    tv5 = Fp.mul(tv6, B4);
+    tv5 = Fp.mul(tv6, opts.B);
     tv2 = Fp.add(tv2, tv5);
     x6 = Fp.mul(tv1, tv3);
     const { isValid, value: value4 } = sqrtRatio(tv2, tv6);
@@ -236723,10 +236649,9 @@ function mapToCurveSimpleSWU(Fp, opts) {
 }
 var DERErr, DER, _0n5, _1n5, _2n3, _3n2, _4n2;
 var init_weierstrass = __esm(() => {
-  init_hmac();
-  init_utils3();
   init_curve();
   init_modular();
+  init_utils3();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
   DERErr = class DERErr extends Error {
     constructor(m7 = "") {
@@ -236834,11 +236759,20 @@ var init_weierstrass = __esm(() => {
 });
 
 // ../../node_modules/@noble/curves/esm/_shortw_utils.js
+function getHash(hash2) {
+  return {
+    hash: hash2,
+    hmac: (key2, ...msgs) => hmac(hash2, key2, concatBytes(...msgs)),
+    randomBytes
+  };
+}
 function createCurve(curveDef, defHash) {
-  const create2 = (hash2) => weierstrass({ ...curveDef, hash: hash2 });
+  const create2 = (hash2) => weierstrass({ ...curveDef, ...getHash(hash2) });
   return { ...create2(defHash), create: create2 };
 }
 var init__shortw_utils = __esm(() => {
+  init_hmac();
+  init_utils2();
   init_weierstrass();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 });
@@ -236868,55 +236802,52 @@ function anum(item) {
     throw new Error("number expected");
 }
 function expand_message_xmd(msg, DST, lenInBytes, H4) {
-  abytes(msg);
-  abytes(DST);
+  abytes2(msg);
+  abytes2(DST);
   anum(lenInBytes);
   if (DST.length > 255)
-    DST = H4(concatBytes(utf8ToBytes("H2C-OVERSIZE-DST-"), DST));
+    DST = H4(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
   const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H4;
   const ell = Math.ceil(lenInBytes / b_in_bytes);
   if (lenInBytes > 65535 || ell > 255)
     throw new Error("expand_message_xmd: invalid lenInBytes");
-  const DST_prime = concatBytes(DST, i2osp(DST.length, 1));
+  const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
   const Z_pad = i2osp(0, r_in_bytes);
   const l_i_b_str = i2osp(lenInBytes, 2);
   const b4 = new Array(ell);
-  const b_0 = H4(concatBytes(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-  b4[0] = H4(concatBytes(b_0, i2osp(1, 1), DST_prime));
+  const b_0 = H4(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+  b4[0] = H4(concatBytes3(b_0, i2osp(1, 1), DST_prime));
   for (let i6 = 1;i6 <= ell; i6++) {
     const args = [strxor(b_0, b4[i6 - 1]), i2osp(i6 + 1, 1), DST_prime];
-    b4[i6] = H4(concatBytes(...args));
+    b4[i6] = H4(concatBytes3(...args));
   }
-  const pseudo_random_bytes = concatBytes(...b4);
+  const pseudo_random_bytes = concatBytes3(...b4);
   return pseudo_random_bytes.slice(0, lenInBytes);
 }
 function expand_message_xof(msg, DST, lenInBytes, k5, H4) {
-  abytes(msg);
-  abytes(DST);
+  abytes2(msg);
+  abytes2(DST);
   anum(lenInBytes);
   if (DST.length > 255) {
     const dkLen = Math.ceil(2 * k5 / 8);
-    DST = H4.create({ dkLen }).update(utf8ToBytes("H2C-OVERSIZE-DST-")).update(DST).digest();
+    DST = H4.create({ dkLen }).update(utf8ToBytes2("H2C-OVERSIZE-DST-")).update(DST).digest();
   }
   if (lenInBytes > 65535 || DST.length > 255)
     throw new Error("expand_message_xof: invalid lenInBytes");
   return H4.create({ dkLen: lenInBytes }).update(msg).update(i2osp(lenInBytes, 2)).update(DST).update(i2osp(DST.length, 1)).digest();
 }
 function hash_to_field(msg, count, options) {
-  _validateObject(options, {
+  validateObject(options, {
+    DST: "stringOrUint8Array",
     p: "bigint",
-    m: "number",
-    k: "number",
-    hash: "function"
+    m: "isSafeInteger",
+    k: "isSafeInteger",
+    hash: "hash"
   });
   const { p: p5, k: k5, m: m7, hash: hash2, expand, DST: _DST } = options;
-  if (!isBytes(_DST) && typeof _DST !== "string")
-    throw new Error("DST must be string or uint8array");
-  if (!isHash(options.hash))
-    throw new Error("expected valid hash");
-  abytes(msg);
+  abytes2(msg);
   anum(count);
-  const DST = typeof _DST === "string" ? utf8ToBytes(_DST) : _DST;
+  const DST = typeof _DST === "string" ? utf8ToBytes2(_DST) : _DST;
   const log2p = p5.toString(2).length;
   const L5 = Math.ceil((log2p + k5) / 8);
   const len_in_bytes = count * m7 * L5;
@@ -236968,17 +236899,13 @@ function createHasher2(Point, mapToCurve, defaults4) {
   return {
     defaults: defaults4,
     hashToCurve(msg, options) {
-      const dst = defaults4.DST ? defaults4.DST : {};
-      const opts = Object.assign({}, defaults4, dst, options);
-      const u6 = hash_to_field(msg, 2, opts);
+      const u6 = hash_to_field(msg, 2, { ...defaults4, DST: defaults4.DST, ...options });
       const u0 = map6(u6[0]);
       const u1 = map6(u6[1]);
       return clear(u0.add(u1));
     },
     encodeToCurve(msg, options) {
-      const dst = defaults4.encodeDST ? defaults4.encodeDST : {};
-      const opts = Object.assign({}, defaults4, dst, options);
-      const u6 = hash_to_field(msg, 1, opts);
+      const u6 = hash_to_field(msg, 1, { ...defaults4, DST: defaults4.encodeDST, ...options });
       return clear(map6(u6[0]));
     },
     mapToCurve(scalars) {
@@ -236993,8 +236920,8 @@ function createHasher2(Point, mapToCurve, defaults4) {
 }
 var os2ip;
 var init_hash_to_curve = __esm(() => {
-  init_utils3();
   init_modular();
+  init_utils3();
   os2ip = bytesToNumberBE;
 });
 
@@ -237008,7 +236935,7 @@ __export(exports_secp256k1, {
   encodeToCurve: () => encodeToCurve
 });
 function sqrtMod(y4) {
-  const P5 = secp256k1_CURVE.p;
+  const P5 = secp256k1P;
   const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
   const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
   const b22 = y4 * y4 * y4 % P5;
@@ -237033,25 +236960,25 @@ function taggedHash(tag, ...messages) {
   let tagP = TAGGED_HASH_PREFIXES[tag];
   if (tagP === undefined) {
     const tagH = sha256(Uint8Array.from(tag, (c3) => c3.charCodeAt(0)));
-    tagP = concatBytes(tagH, tagH);
+    tagP = concatBytes3(tagH, tagH);
     TAGGED_HASH_PREFIXES[tag] = tagP;
   }
-  return sha256(concatBytes(tagP, ...messages));
+  return sha256(concatBytes3(tagP, ...messages));
 }
 function schnorrGetExtPubKey(priv) {
   let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
   let p5 = Point.fromPrivateKey(d_);
-  const scalar = hasEven(p5.y) ? d_ : modN(-d_);
+  const scalar = p5.hasEvenY() ? d_ : modN(-d_);
   return { scalar, bytes: pointToBytes(p5) };
 }
 function lift_x(x6) {
-  aInRange("x", x6, _1n6, secp256k1_CURVE.p);
+  aInRange("x", x6, _1n6, secp256k1P);
   const xx = modP(x6 * x6);
   const c3 = modP(xx * x6 + BigInt(7));
   let y4 = sqrtMod(c3);
-  if (!hasEven(y4))
+  if (y4 % _2n4 !== _0n6)
     y4 = modP(-y4);
-  const p5 = Point.fromAffine({ x: x6, y: y4 });
+  const p5 = new Point(x6, y4, _1n6);
   p5.assertValidity();
   return p5;
 }
@@ -237086,52 +237013,49 @@ function schnorrVerify(signature, message, publicKey) {
   try {
     const P5 = lift_x(num(pub));
     const r6 = num(sig.subarray(0, 32));
-    if (!inRange(r6, _1n6, secp256k1_CURVE.p))
+    if (!inRange(r6, _1n6, secp256k1P))
       return false;
     const s7 = num(sig.subarray(32, 64));
-    if (!inRange(s7, _1n6, secp256k1_CURVE.n))
+    if (!inRange(s7, _1n6, secp256k1N))
       return false;
     const e10 = challenge(numTo32b(r6), pointToBytes(P5), m7);
-    const R7 = Point.BASE.multiplyUnsafe(s7).add(P5.multiplyUnsafe(modN(-e10)));
-    const { x: x6, y: y4 } = R7.toAffine();
-    if (R7.is0() || !hasEven(y4) || x6 !== r6)
+    const R7 = GmulAdd(P5, s7, modN(-e10));
+    if (!R7 || !R7.hasEvenY() || R7.toAffine().x !== r6)
       return false;
     return true;
   } catch (error44) {
     return false;
   }
 }
-var secp256k1_CURVE, _0n6, _1n6, _2n4, divNearest = (a7, b4) => (a7 + b4 / _2n4) / b4, Fpk1, secp256k1, TAGGED_HASH_PREFIXES, pointToBytes = (point) => point.toBytes(true).slice(1), numTo32b = (n6) => numberToBytesBE(n6, 32), modP = (x6) => mod(x6, secp256k1_CURVE.p), modN = (x6) => mod(x6, secp256k1_CURVE.n), Point, hasEven = (y4) => y4 % _2n4 === _0n6, num, schnorr, isoMap, mapSWU, secp256k1_hasher, hashToCurve, encodeToCurve;
+var secp256k1P, secp256k1N, _0n6, _1n6, _2n4, divNearest = (a7, b4) => (a7 + b4 / _2n4) / b4, Fpk1, secp256k1, TAGGED_HASH_PREFIXES, pointToBytes = (point) => point.toRawBytes(true).slice(1), numTo32b = (n6) => numberToBytesBE(n6, 32), modP = (x6) => mod(x6, secp256k1P), modN = (x6) => mod(x6, secp256k1N), Point, GmulAdd = (Q4, a7, b4) => Point.BASE.multiplyAndAddUnsafe(Q4, a7, b4), num, schnorr, isoMap, mapSWU, secp256k1_hasher, hashToCurve, encodeToCurve;
 var init_secp256k1 = __esm(() => {
   init_sha2();
   init_utils2();
   init__shortw_utils();
   init_hash_to_curve();
   init_modular();
-  init_weierstrass();
   init_utils3();
+  init_weierstrass();
   /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-  secp256k1_CURVE = {
-    p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
-    n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
-    h: BigInt(1),
-    a: BigInt(0),
-    b: BigInt(7),
-    Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
-    Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
-  };
+  secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
+  secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
   _0n6 = BigInt(0);
   _1n6 = BigInt(1);
   _2n4 = BigInt(2);
-  Fpk1 = Field(secp256k1_CURVE.p, undefined, undefined, { sqrt: sqrtMod });
+  Fpk1 = Field(secp256k1P, undefined, undefined, { sqrt: sqrtMod });
   secp256k1 = createCurve({
-    ...secp256k1_CURVE,
+    a: _0n6,
+    b: BigInt(7),
     Fp: Fpk1,
+    n: secp256k1N,
+    Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
+    Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
+    h: BigInt(1),
     lowS: true,
     endo: {
       beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
       splitScalar: (k5) => {
-        const n6 = secp256k1_CURVE.n;
+        const n6 = secp256k1N;
         const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
         const b1 = -_1n6 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
         const a22 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
@@ -237155,7 +237079,7 @@ var init_secp256k1 = __esm(() => {
     }
   }, sha256);
   TAGGED_HASH_PREFIXES = {};
-  Point = /* @__PURE__ */ (() => secp256k1.Point)();
+  Point = /* @__PURE__ */ (() => secp256k1.ProjectivePoint)();
   num = bytesToNumberBE;
   schnorr = /* @__PURE__ */ (() => ({
     getPublicKey: schnorrGetPublicKey,
@@ -237201,7 +237125,7 @@ var init_secp256k1 = __esm(() => {
     B: BigInt("1771"),
     Z: Fpk1.create(BigInt("-11"))
   }))();
-  secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.Point, (scalars) => {
+  secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.ProjectivePoint, (scalars) => {
     const { x: x6, y: y4 } = mapSWU(Fpk1.create(scalars[0]));
     return isoMap(x6, y4);
   }, {
@@ -238855,7 +238779,7 @@ async function localBatchGatewayRequest(parameters) {
   const responses = [];
   await Promise.all(queries.map(async (query, i6) => {
     try {
-      responses[i6] = query.urls.includes(localBatchGatewayUrl) ? await localBatchGatewayRequest({ data: query.data, ccipRequest }) : await ccipRequest(query);
+      responses[i6] = await ccipRequest(query);
       failures[i6] = false;
     } catch (err) {
       failures[i6] = true;
@@ -258129,9 +258053,9 @@ ${formattedErrors}`);
     throw error$37;
   }
 }
-var ApplicationAccessTokenSchema = string$1().regex(/^sm_aat_.+$/);
-var PersonalAccessTokenSchema = string$1().regex(/^sm_pat_.+$/);
-var AccessTokenSchema = string$1().regex(/^(sm_pat_.+|sm_aat_.+)$/);
+var ApplicationAccessTokenSchema = string$1().regex(/^sm_aat_.*$/);
+var PersonalAccessTokenSchema = string$1().regex(/^sm_pat_.*$/);
+var AccessTokenSchema = string$1().regex(/^sm_pat_.*|sm_aat_.*$/);
 function tryParseJson(value, defaultValue = null) {
   try {
     const parsed = JSON.parse(value);
@@ -258139,7 +258063,7 @@ function tryParseJson(value, defaultValue = null) {
       return defaultValue;
     }
     return parsed;
-  } catch (_err) {
+  } catch (err) {
     return defaultValue;
   }
 }
@@ -263769,7 +263693,7 @@ async function findMonoRepoPackages(projectDir) {
     }));
     const allPaths = packagePaths.flat();
     return allPaths.length === 0 ? [projectDir] : [monoRepoRoot, ...allPaths];
-  } catch (_error) {
+  } catch (error$37) {
     return [projectDir];
   }
 }
@@ -263840,7 +263764,7 @@ function pruneCurrentEnv(currentEnv, env2) {
 var package_default = {
   name: "@settlemint/sdk-cli",
   description: "Command-line interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.4.0-pr88ac0d7d",
+  version: "2.4.0-pra6821f69",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -263859,9 +263783,7 @@ var package_default = {
     url: "https://github.com/settlemint/sdk/issues",
     email: "support@settlemint.com"
   },
-  files: [
-    "dist"
-  ],
+  files: ["dist"],
   exports: {
     "./*": {
       types: "./dist/*.d.ts",
@@ -263891,10 +263813,10 @@ var package_default = {
     "@inquirer/input": "4.1.12",
     "@inquirer/password": "4.0.15",
     "@inquirer/select": "4.2.3",
-    "@settlemint/sdk-js": "2.4.0-pr88ac0d7d",
-    "@settlemint/sdk-utils": "2.4.0-pr88ac0d7d",
-    "@settlemint/sdk-viem": "2.4.0-pr88ac0d7d",
-    "@types/node": "24.0.10",
+    "@settlemint/sdk-js": "2.4.0-pra6821f69",
+    "@settlemint/sdk-utils": "2.4.0-pra6821f69",
+    "@settlemint/sdk-viem": "2.4.0-pra6821f69",
+    "@types/node": "24.0.1",
     "@types/semver": "7.7.0",
     "@types/which": "3.0.4",
     "get-tsconfig": "4.10.1",
@@ -263902,13 +263824,13 @@ var package_default = {
     "is-in-ci": "1.0.0",
     semver: "7.7.2",
     slugify: "1.6.6",
-    viem: "2.31.6",
+    viem: "2.31.1",
     which: "5.0.0",
     yaml: "2.8.0",
     yoctocolors: "2.1.1"
   },
   peerDependencies: {
-    hardhat: "2.25.0"
+    hardhat: "2.24.3"
   },
   peerDependenciesMeta: {
     hardhat: {
@@ -263963,7 +263885,7 @@ async function telemetry(data) {
       signal: controller.signal
     });
     clearTimeout(timeout);
-  } catch (_error) {}
+  } catch (error2) {}
 }
 
 // ../../node_modules/@commander-js/extra-typings/esm.mjs
@@ -276515,9 +276437,9 @@ ${formattedErrors}`);
     throw error$372;
   }
 }
-var ApplicationAccessTokenSchema2 = string$12().regex(/^sm_aat_.+$/);
-var PersonalAccessTokenSchema2 = string$12().regex(/^sm_pat_.+$/);
-var AccessTokenSchema2 = string$12().regex(/^(sm_pat_.+|sm_aat_.+)$/);
+var ApplicationAccessTokenSchema2 = string$12().regex(/^sm_aat_.*$/);
+var PersonalAccessTokenSchema2 = string$12().regex(/^sm_pat_.*$/);
+var AccessTokenSchema2 = string$12().regex(/^sm_pat_.*|sm_aat_.*$/);
 function tryParseJson2(value, defaultValue = null) {
   try {
     const parsed = JSON.parse(value);
@@ -276525,7 +276447,7 @@ function tryParseJson2(value, defaultValue = null) {
       return defaultValue;
     }
     return parsed;
-  } catch (_err) {
+  } catch (err) {
     return defaultValue;
   }
 }
@@ -288291,20 +288213,6 @@ var restartBlockchainNetwork = graphql(`
     }
   }
   `, [BlockchainNetworkFragment]);
-var pauseBlockchainNetwork = graphql(`
-  mutation PauseBlockchainNetwork($uniqueName: String!) {
-    pauseBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
-var resumeBlockchainNetwork = graphql(`
-  mutation ResumeBlockchainNetwork($uniqueName: String!) {
-    resumeBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
 var blockchainNetworkList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { blockchainNetworksByUniqueName: { items } } = await gqlClient.request(getBlockchainNetworks, { applicationUniqueName });
@@ -288339,14 +288247,6 @@ var blockchainNetworkRestart = (gqlClient) => async (blockchainNetworkUniqueName
   const { restartBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(restartBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
   return blockchainNetwork;
 };
-var blockchainNetworkPause = (gqlClient) => async (blockchainNetworkUniqueName) => {
-  const { pauseBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(pauseBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-  return blockchainNetwork;
-};
-var blockchainNetworkResume = (gqlClient) => async (blockchainNetworkUniqueName) => {
-  const { resumeBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(resumeBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-  return blockchainNetwork;
-};
 var BlockchainNodeFragment = graphql(`
   fragment BlockchainNode on BlockchainNode {
     __typename
@@ -288480,20 +288380,6 @@ var restartBlockchainNode = graphql(`
       }
     }
   `, [BlockchainNodeFragment]);
-var pauseBlockchainNode = graphql(`
-    mutation PauseBlockchainNode($uniqueName: String!) {
-      pauseBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
-var resumeBlockchainNode = graphql(`
-    mutation ResumeBlockchainNode($uniqueName: String!) {
-      resumeBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
 var blockchainNodeList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { blockchainNodesByUniqueName: { items } } = await gqlClient.request(getBlockchainNodes, { applicationUniqueName });
@@ -288522,14 +288408,6 @@ var blockchainNodeRestart = (gqlClient) => async (blockchainNodeUniqueName) => {
   const { restartBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(restartBlockchainNode, { uniqueName: blockchainNodeUniqueName });
   return blockchainNode;
 };
-var blockchainNodePause = (gqlClient) => async (blockchainNodeUniqueName) => {
-  const { pauseBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(pauseBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-  return blockchainNode;
-};
-var blockchainNodeResume = (gqlClient) => async (blockchainNodeUniqueName) => {
-  const { resumeBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(resumeBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-  return blockchainNode;
-};
 var CustomDeploymentFragment = graphql(`
   fragment CustomDeployment on CustomDeployment {
     id
@@ -288612,20 +288490,6 @@ var restartCustomDeployment = graphql(`
       }
     }
   `, [CustomDeploymentFragment]);
-var pauseCustomDeployment = graphql(`
-    mutation PauseCustomDeployment($uniqueName: String!) {
-      pauseCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
-var resumeCustomDeployment = graphql(`
-    mutation ResumeCustomDeployment($uniqueName: String!) {
-      resumeCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
 var customdeploymentList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { customDeploymentsByUniqueName: { items } } = await gqlClient.request(getCustomDeployments, { applicationUniqueName });
@@ -288662,14 +288526,6 @@ var customDeploymentRestart = (gqlClient) => async (customDeploymentUniqueName)
   const { restartCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(restartCustomDeployment, { uniqueName: customDeploymentUniqueName });
   return customDeployment;
 };
-var customDeploymentPause = (gqlClient) => async (customDeploymentUniqueName) => {
-  const { pauseCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(pauseCustomDeployment, { uniqueName: customDeploymentUniqueName });
-  return customDeployment;
-};
-var customDeploymentResume = (gqlClient) => async (customDeploymentUniqueName) => {
-  const { resumeCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(resumeCustomDeployment, { uniqueName: customDeploymentUniqueName });
-  return customDeployment;
-};
 var getFoundryEnvConfig = graphql(`
     query GetFoundryEnvConfig($blockchainNodeUniqueName: String!) {
       foundryEnvConfigByUniqueName(blockchainNodeUniqueName: $blockchainNodeUniqueName)
@@ -288746,20 +288602,6 @@ var restartLoadBalancer = graphql(`
       }
     }
   `, [LoadBalancerFragment]);
-var pauseLoadBalancer = graphql(`
-    mutation PauseLoadBalancer($uniqueName: String!) {
-      pauseLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
-var resumeLoadBalancer = graphql(`
-    mutation ResumeLoadBalancer($uniqueName: String!) {
-      resumeLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
 var loadBalancerRead = (gqlClient) => {
   return async (loadBalancerUniqueName) => {
     const { loadBalancerByUniqueName: loadBalancer } = await gqlClient.request(getLoadBalancer, { uniqueName: loadBalancerUniqueName });
@@ -288793,14 +288635,6 @@ var loadBalancerRestart = (gqlClient) => async (loadBalancerUniqueName) => {
   const { restartLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(restartLoadBalancer, { uniqueName: loadBalancerUniqueName });
   return loadBalancer;
 };
-var loadBalancerPause = (gqlClient) => async (loadBalancerUniqueName) => {
-  const { pauseLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(pauseLoadBalancer, { uniqueName: loadBalancerUniqueName });
-  return loadBalancer;
-};
-var loadBalancerResume = (gqlClient) => async (loadBalancerUniqueName) => {
-  const { resumeLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(resumeLoadBalancer, { uniqueName: loadBalancerUniqueName });
-  return loadBalancer;
-};
 var InsightsFragment = graphql(`
   fragment Insights on Insights {
     __typename
@@ -288874,20 +288708,6 @@ var restartInsights = graphql(`
       }
     }
   `, [InsightsFragment]);
-var pauseInsights = graphql(`
-    mutation PauseInsights($uniqueName: String!) {
-      pauseInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
-var resumeInsights = graphql(`
-    mutation ResumeInsights($uniqueName: String!) {
-      resumeInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
 var insightsList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { insightsListByUniqueName: { items } } = await gqlClient.request(getInsights, { applicationUniqueName });
@@ -288921,14 +288741,6 @@ var insightsRestart = (gqlClient) => async (insightsUniqueName) => {
   const { restartInsightsByUniqueName: insights } = await gqlClient.request(restartInsights, { uniqueName: insightsUniqueName });
   return insights;
 };
-var insightsPause = (gqlClient) => async (insightsUniqueName) => {
-  const { pauseInsightsByUniqueName: insights } = await gqlClient.request(pauseInsights, { uniqueName: insightsUniqueName });
-  return insights;
-};
-var insightsResume = (gqlClient) => async (insightsUniqueName) => {
-  const { resumeInsightsByUniqueName: insights } = await gqlClient.request(resumeInsights, { uniqueName: insightsUniqueName });
-  return insights;
-};
 var IntegrationFragment = graphql(`
   fragment Integration on Integration {
     __typename
@@ -288998,20 +288810,6 @@ var restartIntegrationTool = graphql(`
       }
     }
   `, [IntegrationFragment]);
-var pauseIntegrationTool = graphql(`
-    mutation PauseIntegrationTool($uniqueName: String!) {
-      pauseIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
-var resumeIntegrationTool = graphql(`
-    mutation ResumeIntegrationTool($uniqueName: String!) {
-      resumeIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
 var integrationToolList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { integrationsByUniqueName: { items } } = await gqlClient.request(getIntegrations, { applicationUniqueName });
@@ -289039,14 +288837,6 @@ var integrationToolRestart = (gqlClient) => async (integrationUniqueName) => {
   const { restartIntegrationByUniqueName: integration } = await gqlClient.request(restartIntegrationTool, { uniqueName: integrationUniqueName });
   return integration;
 };
-var integrationToolPause = (gqlClient) => async (integrationUniqueName) => {
-  const { pauseIntegrationByUniqueName: integration } = await gqlClient.request(pauseIntegrationTool, { uniqueName: integrationUniqueName });
-  return integration;
-};
-var integrationToolResume = (gqlClient) => async (integrationUniqueName) => {
-  const { resumeIntegrationByUniqueName: integration } = await gqlClient.request(resumeIntegrationTool, { uniqueName: integrationUniqueName });
-  return integration;
-};
 var StorageFragment = graphql(`
   fragment Storage on Storage {
     __typename
@@ -289116,20 +288906,6 @@ var restartStorage = graphql(`
       }
     }
   `, [StorageFragment]);
-var pauseStorage = graphql(`
-    mutation PauseStorage($uniqueName: String!) {
-      pauseStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
-var resumeStorage = graphql(`
-    mutation ResumeStorage($uniqueName: String!) {
-      resumeStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
 var storageList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { storagesByUniqueName: { items } } = await gqlClient.request(getStorages, { applicationUniqueName });
@@ -289157,14 +288933,6 @@ var storageRestart = (gqlClient) => async (storageUniqueName) => {
   const { restartStorageByUniqueName: storage } = await gqlClient.request(restartStorage, { uniqueName: storageUniqueName });
   return storage;
 };
-var storagePause = (gqlClient) => async (storageUniqueName) => {
-  const { pauseStorageByUniqueName: storage } = await gqlClient.request(pauseStorage, { uniqueName: storageUniqueName });
-  return storage;
-};
-var storageResume = (gqlClient) => async (storageUniqueName) => {
-  const { resumeStorageByUniqueName: storage } = await gqlClient.request(resumeStorage, { uniqueName: storageUniqueName });
-  return storage;
-};
 var MiddlewareFragment = graphql(`
   fragment Middleware on Middleware {
     __typename
@@ -289265,20 +289033,6 @@ var restartMiddleware = graphql(`
       }
     }
   `, [MiddlewareFragment]);
-var pauseMiddleware = graphql(`
-    mutation PauseMiddleware($uniqueName: String!) {
-      pauseMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
-var resumeMiddleware = graphql(`
-    mutation ResumeMiddleware($uniqueName: String!) {
-      resumeMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
 var middlewareList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { middlewaresByUniqueName: { items } } = await gqlClient.request(getMiddlewares, { applicationUniqueName });
@@ -289323,14 +289077,6 @@ var middlewareRestart = (gqlClient) => async (middlewareUniqueName) => {
   const { restartMiddlewareByUniqueName: middleware } = await gqlClient.request(restartMiddleware, { uniqueName: middlewareUniqueName });
   return middleware;
 };
-var middlewarePause = (gqlClient) => async (middlewareUniqueName) => {
-  const { pauseMiddlewareByUniqueName: middleware } = await gqlClient.request(pauseMiddleware, { uniqueName: middlewareUniqueName });
-  return middleware;
-};
-var middlewareResume = (gqlClient) => async (middlewareUniqueName) => {
-  const { resumeMiddlewareByUniqueName: middleware } = await gqlClient.request(resumeMiddleware, { uniqueName: middlewareUniqueName });
-  return middleware;
-};
 var getPlatformConfigQuery = graphql(`
     query platformConfig {
       config {
@@ -289463,20 +289209,6 @@ var restartPrivateKey = graphql(`
       }
     }
   `, [PrivateKeyFragment]);
-var pausePrivateKey = graphql(`
-    mutation PausePrivateKey($uniqueName: String!) {
-      pausePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
-var resumePrivateKey = graphql(`
-    mutation ResumePrivateKey($uniqueName: String!) {
-      resumePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
 var privateKeyList = (gqlClient) => {
   return async (applicationUniqueName) => {
     const { privateKeysByUniqueName: { items } } = await gqlClient.request(getPrivateKeys, { applicationUniqueName });
@@ -289515,14 +289247,6 @@ var privateKeyRestart = (gqlClient) => async (privateKeyUniqueName) => {
   const { restartPrivateKeyByUniqueName: privateKey } = await gqlClient.request(restartPrivateKey, { uniqueName: privateKeyUniqueName });
   return privateKey;
 };
-var privateKeyPause = (gqlClient) => async (privateKeyUniqueName) => {
-  const { pausePrivateKeyByUniqueName: privateKey } = await gqlClient.request(pausePrivateKey, { uniqueName: privateKeyUniqueName });
-  return privateKey;
-};
-var privateKeyResume = (gqlClient) => async (privateKeyUniqueName) => {
-  const { resumePrivateKeyByUniqueName: privateKey } = await gqlClient.request(resumePrivateKey, { uniqueName: privateKeyUniqueName });
-  return privateKey;
-};
 var ClientOptionsSchema = exports_external.object({
   accessToken: AccessTokenSchema2,
   instance: UrlSchema2
@@ -289602,75 +289326,57 @@ function createSettleMintClient(options) {
       read: blockchainNetworkRead(gqlClient),
       create: blockchainNetworkCreate(gqlClient),
       delete: blockchainNetworkDelete(gqlClient),
-      restart: blockchainNetworkRestart(gqlClient),
-      pause: blockchainNetworkPause(gqlClient),
-      resume: blockchainNetworkResume(gqlClient)
+      restart: blockchainNetworkRestart(gqlClient)
     },
     blockchainNode: {
       list: blockchainNodeList(gqlClient),
       read: blockchainNodeRead(gqlClient),
       create: blockchainNodeCreate(gqlClient),
-      restart: blockchainNodeRestart(gqlClient),
-      pause: blockchainNodePause(gqlClient),
-      resume: blockchainNodeResume(gqlClient)
+      restart: blockchainNodeRestart(gqlClient)
     },
     loadBalancer: {
       list: loadBalancerList(gqlClient),
       read: loadBalancerRead(gqlClient),
       create: loadBalancerCreate(gqlClient),
-      restart: loadBalancerRestart(gqlClient),
-      pause: loadBalancerPause(gqlClient),
-      resume: loadBalancerResume(gqlClient)
+      restart: loadBalancerRestart(gqlClient)
     },
     middleware: {
       list: middlewareList(gqlClient),
       read: middlewareRead(gqlClient),
       graphSubgraphs: graphMiddlewareSubgraphs(gqlClient),
       create: middlewareCreate(gqlClient),
-      restart: middlewareRestart(gqlClient),
-      pause: middlewarePause(gqlClient),
-      resume: middlewareResume(gqlClient)
+      restart: middlewareRestart(gqlClient)
     },
     integrationTool: {
       list: integrationToolList(gqlClient),
       read: integrationToolRead(gqlClient),
       create: integrationToolCreate(gqlClient),
-      restart: integrationToolRestart(gqlClient),
-      pause: integrationToolPause(gqlClient),
-      resume: integrationToolResume(gqlClient)
+      restart: integrationToolRestart(gqlClient)
     },
     storage: {
       list: storageList(gqlClient),
       read: storageRead(gqlClient),
       create: storageCreate(gqlClient),
-      restart: storageRestart(gqlClient),
-      pause: storagePause(gqlClient),
-      resume: storageResume(gqlClient)
+      restart: storageRestart(gqlClient)
     },
     privateKey: {
       list: privateKeyList(gqlClient),
       read: privatekeyRead(gqlClient),
       create: privateKeyCreate(gqlClient),
-      restart: privateKeyRestart(gqlClient),
-      pause: privateKeyPause(gqlClient),
-      resume: privateKeyResume(gqlClient)
+      restart: privateKeyRestart(gqlClient)
     },
     insights: {
       list: insightsList(gqlClient),
       read: insightsRead(gqlClient),
       create: insightsCreate(gqlClient),
-      restart: insightsRestart(gqlClient),
-      pause: insightsPause(gqlClient),
-      resume: insightsResume(gqlClient)
+      restart: insightsRestart(gqlClient)
     },
     customDeployment: {
       list: customdeploymentList(gqlClient),
       read: customdeploymentRead(gqlClient),
       create: customdeploymentCreate(gqlClient),
       update: customdeploymentUpdate(gqlClient),
-      restart: customDeploymentRestart(gqlClient),
-      pause: customDeploymentPause(gqlClient),
-      resume: customDeploymentResume(gqlClient)
+      restart: customDeploymentRestart(gqlClient)
     },
     foundry: { env: getEnv(gqlClient) },
     applicationAccessToken: { create: applicationAccessTokenCreate(gqlClient) },
@@ -296087,6 +295793,17 @@ async function exists3(path$1) {
     return false;
   }
 }
+function tryParseJson3(value2, defaultValue = null) {
+  try {
+    const parsed = JSON.parse(value2);
+    if (parsed === undefined || parsed === null) {
+      return defaultValue;
+    }
+    return parsed;
+  } catch (err) {
+    return defaultValue;
+  }
+}
 var require_balanced_match4 = __commonJS4({ "../../node_modules/balanced-match/index.js"(exports, module) {
   module.exports = balanced$1;
   function balanced$1(a3, b, str) {
@@ -301565,17 +301282,6 @@ var glob3 = Object.assign(glob_3, {
   unescape: unescape4
 });
 glob3.glob = glob3;
-function tryParseJson3(value2, defaultValue = null) {
-  try {
-    const parsed = JSON.parse(value2);
-    if (parsed === undefined || parsed === null) {
-      return defaultValue;
-    }
-    return parsed;
-  } catch (_err) {
-    return defaultValue;
-  }
-}
 async function findMonoRepoRoot2(startDir) {
   const lockFilePath = await findUp([
     "package-lock.json",
@@ -301621,7 +301327,7 @@ function tryParseJson4(value2, defaultValue = null) {
       return defaultValue;
     }
     return parsed;
-  } catch (_err) {
+  } catch (err) {
     return defaultValue;
   }
 }
@@ -301649,7 +301355,7 @@ async function readConfig() {
   try {
     const content = await readFile4(CONFIG_FILE, "utf-8");
     return tryParseJson4(content, { instances: {} });
-  } catch (_error) {
+  } catch (error41) {
     return { instances: {} };
   }
 }
@@ -305229,11 +304935,8 @@ function observe(observerId, callbacks, fn) {
     if (!listeners2.some((cb) => cb.id === callbackId))
       return;
     const cleanup2 = cleanupCache.get(observerId);
-    if (listeners2.length === 1 && cleanup2) {
-      const p5 = cleanup2();
-      if (p5 instanceof Promise)
-        p5.catch(() => {});
-    }
+    if (listeners2.length === 1 && cleanup2)
+      cleanup2();
     unsubscribe();
   };
   const listeners = getListeners();
@@ -305372,9 +305075,9 @@ function watchContractEvent(client, parameters) {
       return poll_;
     if (typeof fromBlock === "bigint")
       return true;
-    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
+    if (client.transport.type === "webSocket")
       return false;
-    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
+    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
       return false;
     return true;
   })();
@@ -305475,7 +305178,7 @@ function watchContractEvent(client, parameters) {
         try {
           const transport = (() => {
             if (client.transport.type === "fallback") {
-              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
+              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
               if (!transport2)
                 return client.transport;
               return transport2.value;
@@ -307363,10 +307066,9 @@ async function simulateBlocks(client, parameters) {
       const calls = block2.calls.map((call_) => {
         const call2 = call_;
         const account = call2.account ? parseAccount(call2.account) : undefined;
-        const data = call2.abi ? encodeFunctionData(call2) : call2.data;
         const request2 = {
           ...call2,
-          data: call2.dataSuffix ? concat2([data || "0x", call2.dataSuffix]) : data,
+          data: call2.abi ? encodeFunctionData(call2) : call2.data,
           from: call2.from ?? account?.address
         };
         assertRequest(request2);
@@ -307413,7 +307115,7 @@ async function simulateBlocks(client, parameters) {
             return;
           return getContractError(error45, {
             abi: abi2 ?? [],
-            address: to ?? "0x",
+            address: to,
             args,
             functionName: functionName ?? "<unknown>"
           });
@@ -308355,6 +308057,14 @@ async function simulateCalls(client, parameters) {
     });
     return accessList.map(({ address, storageKeys }) => storageKeys.length > 0 ? address : null);
   })).then((x6) => x6.flat().filter(Boolean)) : [];
+  const resultsStateOverrides = stateOverrides?.map((override) => {
+    if (override.address === account?.address)
+      return {
+        ...override,
+        nonce: 0
+      };
+    return override;
+  });
   const blocks = await simulateBlocks(client, {
     blockNumber,
     blockTag,
@@ -308384,11 +308094,12 @@ async function simulateCalls(client, parameters) {
         }
       ] : [],
       {
-        calls: [...calls, {}].map((call2) => ({
+        calls: [...calls, {}].map((call2, index2) => ({
           ...call2,
-          from: account?.address
+          from: account?.address,
+          nonce: index2
         })),
-        stateOverrides
+        stateOverrides: resultsStateOverrides
       },
       ...traceAssetChanges ? [
         {
@@ -308636,9 +308347,9 @@ function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onB
   const enablePolling = (() => {
     if (typeof poll_ !== "undefined")
       return poll_;
-    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
+    if (client.transport.type === "webSocket")
       return false;
-    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
+    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
       return false;
     return true;
   })();
@@ -308690,7 +308401,7 @@ function watchBlockNumber(client, { emitOnBegin = false, emitMissed = false, onB
         try {
           const transport = (() => {
             if (client.transport.type === "fallback") {
-              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
+              const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
               if (!transport2)
                 return client.transport;
               return transport2.value;
@@ -308843,9 +308554,9 @@ function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBe
   const enablePolling = (() => {
     if (typeof poll_ !== "undefined")
       return poll_;
-    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
+    if (client.transport.type === "webSocket")
       return false;
-    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
+    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
       return false;
     return true;
   })();
@@ -308914,7 +308625,7 @@ function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBe
         }
         const transport = (() => {
           if (client.transport.type === "fallback") {
-            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
+            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
             if (!transport2)
               return client.transport;
             return transport2.value;
@@ -308927,7 +308638,7 @@ function watchBlocks(client, { blockTag = "latest", emitMissed = false, emitOnBe
             if (!active)
               return;
             const block = await getAction(client, getBlock, "getBlock")({
-              blockNumber: data.result?.number,
+              blockNumber: data.blockNumber,
               includeTransactions
             }).catch(() => {});
             if (!active)
@@ -308961,9 +308672,9 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
       return poll_;
     if (typeof fromBlock === "bigint")
       return true;
-    if (client.transport.type === "webSocket" || client.transport.type === "ipc")
+    if (client.transport.type === "webSocket")
       return false;
-    if (client.transport.type === "fallback" && (client.transport.transports[0].config.type === "webSocket" || client.transport.transports[0].config.type === "ipc"))
+    if (client.transport.type === "fallback" && client.transport.transports[0].config.type === "webSocket")
       return false;
     return true;
   })();
@@ -309050,7 +308761,7 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
       try {
         const transport = (() => {
           if (client.transport.type === "fallback") {
-            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket" || transport3.config.type === "ipc");
+            const transport2 = client.transport.transports.find((transport3) => transport3.config.type === "webSocket");
             if (!transport2)
               return client.transport;
             return transport2.value;
@@ -309117,7 +308828,7 @@ function watchEvent(client, { address, args, batch = true, event, events, fromBl
 }
 // ../../node_modules/viem/_esm/actions/public/watchPendingTransactions.js
 function watchPendingTransactions(client, { batch = true, onError, onTransactions, poll: poll_, pollingInterval = client.pollingInterval }) {
-  const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket" && client.transport.type !== "ipc";
+  const enablePolling = typeof poll_ !== "undefined" ? poll_ : client.transport.type !== "webSocket";
   const pollPendingTransactions = () => {
     const observerId = stringify3([
       "watchPendingTransactions",
@@ -320775,7 +320486,7 @@ async function applicationAccessTokenPrompt(env2, application, settlemint, accep
         try {
           validate2(exports_external.string(), value4);
           return true;
-        } catch (_error) {
+        } catch (error45) {
           return "Invalid token name";
         }
       }
@@ -320828,7 +320539,7 @@ async function applicationAccessTokenPrompt(env2, application, settlemint, accep
     try {
       validate2(ApplicationAccessTokenSchema2, aat);
       return aat;
-    } catch (_error) {}
+    } catch (error45) {}
   }
   return esm_default5({
     message: "What is the application access token for your application in SettleMint? (format: sm_aat_...)",
@@ -320836,7 +320547,7 @@ async function applicationAccessTokenPrompt(env2, application, settlemint, accep
       try {
         validate2(ApplicationAccessTokenSchema2, value4);
         return true;
-      } catch (_error) {
+      } catch (error45) {
         return "Invalid application access token, it should start with sm_aat_...";
       }
     }
@@ -321241,7 +320952,7 @@ async function instancePrompt({
         try {
           validate2(UrlSchema2, value4);
           return true;
-        } catch (_error) {
+        } catch (error45) {
           return "Invalid URL";
         }
       },
@@ -321325,7 +321036,7 @@ async function serviceUrlPrompt({
       try {
         validate2(UrlSchema2, value4);
         return true;
-      } catch (_error) {
+      } catch (error45) {
         return "Invalid URL";
       }
     },
@@ -322269,7 +321980,7 @@ async function projectNamePrompt(env2, argument) {
       try {
         validate2(exports_external.string(), value4);
         return true;
-      } catch (_error) {
+      } catch (error45) {
         return "Invalid projectname";
       }
     }
@@ -326257,7 +325968,7 @@ async function personalAccessTokenPrompt(env2, instance, accept) {
       try {
         validate2(PersonalAccessTokenSchema2, value4);
         return true;
-      } catch (_error) {
+      } catch (error45) {
         return "Invalid personal access token, it should start with sm_pat_...";
       }
     }
@@ -326338,7 +326049,7 @@ function loginCommand() {
     });
     try {
       await loginSpinner(client);
-    } catch (_error) {
+    } catch (error45) {
       cancel2(`Invalid personal access token for instance ${selectedInstance}`);
     }
     await storeCredentials(personalAccessToken, selectedInstance);
@@ -326488,17 +326199,13 @@ function addClusterServiceArgs(cmd2) {
 // src/commands/platform/utils/wait-for-completion.ts
 class TimeoutError2 extends Error {
 }
-
-class DeploymentFailedError extends Error {
-}
 async function waitForCompletion({
   settlemint,
   type: type4,
   uniqueName,
   action,
   maxTimeout = 10 * 60 * 1000,
-  restartIfTimeout = false,
-  restartOnError = false
+  restartIfTimeout = false
 }) {
   const serviceType = SETTLEMINT_CLIENT_MAP[type4];
   if (serviceType === "workspace" || serviceType === "application" || serviceType === "foundry" || serviceType === "applicationAccessToken" || serviceType === "platform" || serviceType === "wallet") {
@@ -326508,7 +326215,6 @@ async function waitForCompletion({
   if (!service || !("read" in service)) {
     throw new Error(`Service ${serviceType} does not support status checking`);
   }
-  let hasRestarted = false;
   function showSpinner() {
     return spinner({
       startMessage: `Waiting for ${type4} to be ${getActionLabel(action)}`,
@@ -326518,20 +326224,33 @@ async function waitForCompletion({
         while (true) {
           try {
             const resource = await service.read(uniqueName);
+            if (resource.status === "COMPLETED") {
+              if (spinner2) {
+                spinner2.text = `${capitalizeFirstLetter2(type4)} is ${getActionLabel(action)}`;
+              } else {
+                note(`${capitalizeFirstLetter2(type4)} is ${getActionLabel(action)}`);
+              }
+              return true;
+            }
             if (resource.status === "FAILED") {
-              updateStatus(spinner2, `${capitalizeFirstLetter2(type4)} failed to ${getActionLabel(action)}`);
-              if (restartOnError) {
-                throw new DeploymentFailedError;
+              if (spinner2) {
+                spinner2.text = `${capitalizeFirstLetter2(type4)} failed to ${getActionLabel(action)}`;
+              } else {
+                note(`${capitalizeFirstLetter2(type4)} failed to ${getActionLabel(action)}`);
               }
               return false;
             }
-            if (isActionComplete(action, resource.status)) {
-              updateStatus(spinner2, `${capitalizeFirstLetter2(type4)} is ${getActionLabel(action)}`);
-              return true;
+            if (spinner2) {
+              spinner2.text = `${capitalizeFirstLetter2(type4)} is not ready yet (status: ${resource.status})`;
+            } else {
+              note(`${capitalizeFirstLetter2(type4)} is not ready yet (status: ${resource.status})`);
+            }
+          } catch (error45) {
+            if (spinner2) {
+              spinner2.text = `${capitalizeFirstLetter2(type4)} is not ready yet (status: UNKNOWN)`;
+            } else {
+              note(`${capitalizeFirstLetter2(type4)} is not ready yet (status: UNKNOWN)`);
             }
-            updateStatus(spinner2, `${capitalizeFirstLetter2(type4)} is not ready yet (status: ${resource.status})`);
-          } catch (_error) {
-            updateStatus(spinner2, `${capitalizeFirstLetter2(type4)} is not ready yet (status: UNKNOWN)`);
           }
           if (Date.now() - startTime > maxTimeout) {
             throw new TimeoutError2(`Operation timed out after ${maxTimeout / 60000} minutes for ${type4} with unique name ${uniqueName}`);
@@ -326544,59 +326263,23 @@ async function waitForCompletion({
   try {
     return await showSpinner();
   } catch (error45) {
-    if (!hasRestarted && shouldRestart(error45, restartIfTimeout)) {
+    const isTimeoutError = error45 instanceof SpinnerError && error45.originalError instanceof TimeoutError2;
+    if (restartIfTimeout && isTimeoutError) {
       note(`Restarting ${capitalizeFirstLetter2(type4)}`);
-      hasRestarted = true;
       await service.restart(uniqueName);
       return showSpinner();
     }
     throw error45;
   }
 }
-function shouldRestart(error45, restartIfTimeout) {
-  const isSpinnerError = error45 instanceof SpinnerError;
-  const isDeploymentFailedError = error45 instanceof DeploymentFailedError || isSpinnerError && error45.originalError instanceof DeploymentFailedError;
-  if (isDeploymentFailedError) {
-    return true;
-  }
-  const isTimeoutError = error45 instanceof TimeoutError2 || isSpinnerError && error45.originalError instanceof TimeoutError2;
-  return restartIfTimeout && isTimeoutError;
-}
-function updateStatus(spinner2, message) {
-  if (spinner2) {
-    spinner2.text = message;
-  } else {
-    note(message);
-  }
-}
-function isActionComplete(action, status) {
-  switch (action) {
-    case "pause":
-      return status === "PAUSED" || status === "AUTO_PAUSED";
-    case "resume":
-    case "deploy":
-    case "destroy":
-    case "restart":
-      return status === "COMPLETED";
-    default:
-      return false;
-  }
-}
 function getActionLabel(action) {
-  switch (action) {
-    case "restart":
-      return "restarted";
-    case "destroy":
-      return "destroyed";
-    case "pause":
-      return "paused";
-    case "resume":
-      return "resumed";
-    case "deploy":
-      return "deployed";
-    default:
-      return "deployed";
+  if (action === "restart") {
+    return "restarted";
+  }
+  if (action === "destroy") {
+    return "destroyed";
   }
+  return "deployed";
 }
 
 // src/prompts/provider.prompt.ts
@@ -326677,9 +326360,9 @@ function getCreateCommand({
     cmd2.alias(alias);
   }
   if (requiresDeployment) {
-    cmd2.option("-w, --wait", "Wait until deployed").option("--restart-if-timeout", "Restart if wait time is exceeded").option("--restart-on-error", "Restart if deployment fails");
+    cmd2.option("-w, --wait", "Wait until deployed").option("-r, --restart-if-timeout", "Restart if wait time is exceeded");
   }
-  execute2(cmd2, async ({ acceptDefaults, prod, default: isDefault, wait: wait2, restartIfTimeout, restartOnError, provider, region }, createFunction) => {
+  execute2(cmd2, async ({ acceptDefaults, prod, default: isDefault, wait: wait2, restartIfTimeout, provider, region }, createFunction) => {
     intro(`Creating ${type4} in the SettleMint platform`);
     const env2 = await loadEnv(false, !!prod);
     const instance = await instancePrompt({ env: env2, accept: acceptDefaults });
@@ -326693,8 +326376,8 @@ function getCreateCommand({
       instance
     });
     const platformConfig = await settlemint.platform.config();
-    let selectedProvider;
-    let selectedRegion;
+    let selectedProvider = undefined;
+    let selectedRegion = undefined;
     if (cmd2.options.some((option) => option.long === "--provider")) {
       selectedProvider = await providerPrompt(platformConfig, provider);
       if (!selectedProvider) {
@@ -326723,8 +326406,7 @@ function getCreateCommand({
         type: waitFor?.resourceType ?? type4,
         uniqueName: waitFor?.uniqueName ?? result.uniqueName,
         action: "deploy",
-        restartIfTimeout,
-        restartOnError
+        restartIfTimeout
       });
       if (!isDeployed) {
         throw new Error(`Failed to deploy ${waitFor?.resourceType ?? type4} ${waitFor?.uniqueName ?? result.uniqueName}`);
@@ -327906,7 +327588,7 @@ function privateKeyHsmCreateCommand() {
         return baseAction({
           ...defaultArgs,
           acceptDefaults
-        }, async ({ settlemint, env: env2, showSpinner, provider: _provider, region: _region }) => {
+        }, async ({ settlemint, env: env2, showSpinner, provider, region }) => {
           const applicationUniqueName = application ?? env2.SETTLEMINT_APPLICATION;
           if (!applicationUniqueName) {
             return missingApplication();
@@ -328195,256 +327877,25 @@ function deleteCommand() {
   return new Command("delete").alias("d").description("Delete a resource in the SettleMint platform").addCommand(applicationDeleteCommand()).addCommand(workspaceDeleteCommand());
 }
 
-// src/commands/platform/common/pause-command.ts
-function getPauseCommand({
-  name: name3,
-  type: type4,
-  alias,
-  envKey,
-  pauseFunction,
-  usePersonalAccessToken = true
-}) {
-  const commandName = sanitizeCommandName(name3);
-  const typeCommandName = sanitizeCommandName(type4);
-  const exampleCommandPrefix = `platform pause ${typeCommandName !== commandName ? `${typeCommandName} ` : ""}${commandName}`;
-  return new Command(commandName).alias(alias).description(`Pause a ${type4} in the SettleMint platform. Provide the ${type4} unique name or use 'default' to pause the default ${type4} from your .env file.`).usage(createExamples([
-    {
-      description: `Pauses the specified ${type4} by unique name`,
-      command: `${exampleCommandPrefix} <unique-name>`
-    },
-    {
-      description: `Pauses the default ${type4} in the production environment`,
-      command: `${exampleCommandPrefix} default --prod`
-    }
-  ])).argument("<unique-name>", `The unique name of the ${type4}, use 'default' to pause the default one from your .env file`).option("-a, --accept-defaults", "Accept the default and previously set values").option("--prod", "Connect to your production environment").option("-w, --wait", "Wait until paused").action(async (uniqueName, { acceptDefaults, prod, wait: wait2 }) => {
-    intro(`Pausing ${type4} in the SettleMint platform`);
-    const env2 = await loadEnv(false, !!prod);
-    const instance = await instancePrompt({ env: env2, accept: acceptDefaults });
-    const accessToken = await getApplicationOrPersonalAccessToken({
-      env: env2,
-      instance,
-      prefer: usePersonalAccessToken ? "personal" : "application"
-    });
-    const settlemint = createSettleMintClient({
-      accessToken,
-      instance
-    });
-    const isDefaultUniqueName = uniqueName === "default";
-    const serviceUniqueName = isDefaultUniqueName ? typeof env2[envKey] === "string" ? env2[envKey] : null : uniqueName;
-    if (!serviceUniqueName) {
-      cancel2(`No default ${type4} found in your .env file. Please provide a valid ${type4} unique name or set a default ${type4} first.`);
-    }
-    const result = await spinner({
-      startMessage: `Pausing ${type4}`,
-      task: async () => {
-        return pauseFunction(settlemint, serviceUniqueName);
-      },
-      stopMessage: `${capitalizeFirstLetter2(type4)} pause initiated`
-    });
-    if (wait2) {
-      const isPaused = await waitForCompletion({
-        settlemint,
-        type: type4,
-        uniqueName: serviceUniqueName,
-        action: "pause"
-      });
-      if (!isPaused) {
-        throw new Error(`Failed to pause ${type4} ${serviceUniqueName}`);
-      }
-    }
-    outro(`${capitalizeFirstLetter2(type4)} ${result.name} pause initiated successfully`);
-  });
-}
-
-// src/commands/platform/blockchain-network/pause.ts
-function blockchainNetworkPauseCommand() {
-  return getPauseCommand({
-    name: "blockchain-network",
-    type: "blockchain network",
-    alias: "bnw",
-    envKey: "SETTLEMINT_BLOCKCHAIN_NETWORK",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.blockchainNetwork.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/blockchain-node/pause.ts
-function blockchainNodePauseCommand() {
-  return getPauseCommand({
-    name: "blockchain-node",
-    type: "blockchain node",
-    alias: "bn",
-    envKey: "SETTLEMINT_BLOCKCHAIN_NODE",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.blockchainNode.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/custom-deployments/pause.ts
-function customDeploymentPauseCommand() {
-  return getPauseCommand({
-    name: "custom-deployment",
-    type: "custom deployment",
-    alias: "cd",
-    envKey: "SETTLEMINT_CUSTOM_DEPLOYMENT",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.customDeployment.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/insights/blockscout/pause.ts
-function blockscoutPauseCommand() {
-  return getPauseCommand({
-    name: "blockscout",
-    type: "insights",
-    alias: "bs",
-    envKey: "SETTLEMINT_BLOCKSCOUT",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.insights.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/insights/pause.ts
-function insightsPauseCommand() {
-  return new Command("insights").alias("in").description("Pause an insights service in the SettleMint platform").addCommand(blockscoutPauseCommand());
-}
-
-// src/commands/platform/integration-tools/hasura/pause.ts
-function hasuraPauseCommand() {
-  return getPauseCommand({
-    name: "hasura",
-    type: "integration tool",
-    alias: "ha",
-    envKey: "SETTLEMINT_HASURA",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.integrationTool.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/integration-tools/pause.ts
-function integrationToolPauseCommand() {
-  return new Command("integration-tool").alias("it").description("Pause an integration tool service in the SettleMint platform").addCommand(hasuraPauseCommand());
-}
-
-// src/commands/platform/load-balancer/pause.ts
-function loadBalancerPauseCommand() {
-  return getPauseCommand({
-    name: "evm",
-    type: "load balancer",
-    alias: "lb",
-    envKey: "SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.loadBalancer.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/middleware/graph/pause.ts
-function graphMiddlewarePauseCommand() {
-  return getPauseCommand({
-    name: "graph",
-    type: "middleware",
-    alias: "gr",
-    envKey: "SETTLEMINT_THEGRAPH",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.middleware.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/middleware/smart-contract-portal/pause.ts
-function smartContractPortalMiddlewarePauseCommand() {
-  return getPauseCommand({
-    name: "smart-contract-portal",
-    type: "middleware",
-    alias: "scp",
-    envKey: "SETTLEMINT_PORTAL",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.middleware.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/middleware/pause.ts
-function middlewarePauseCommand() {
-  return new Command("middleware").alias("mw").description("Pause a middleware service in the SettleMint platform").addCommand(graphMiddlewarePauseCommand()).addCommand(smartContractPortalMiddlewarePauseCommand());
-}
-
-// src/commands/platform/private-key/pause.ts
-function privateKeyPauseCommand() {
-  return getPauseCommand({
-    name: "private-key",
-    type: "private key",
-    alias: "pk",
-    envKey: "SETTLEMINT_ACCESSIBLE_PRIVATE_KEY",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.privateKey.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/storage/ipfs/pause.ts
-function ipfsStoragePauseCommand() {
-  return getPauseCommand({
-    name: "ipfs",
-    type: "storage",
-    alias: "ip",
-    envKey: "SETTLEMINT_IPFS",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.storage.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/storage/minio/pause.ts
-function minioStoragePauseCommand() {
-  return getPauseCommand({
-    name: "minio",
-    type: "storage",
-    alias: "m",
-    envKey: "SETTLEMINT_MINIO",
-    pauseFunction: async (settlemint, id) => {
-      return settlemint.storage.pause(id);
-    }
-  });
-}
-
-// src/commands/platform/storage/pause.ts
-function storagePauseCommand() {
-  return new Command("storage").alias("st").description("Pause a storage service in the SettleMint platform").addCommand(ipfsStoragePauseCommand()).addCommand(minioStoragePauseCommand());
-}
-
-// src/commands/platform/pause.ts
-function pauseCommand() {
-  const cmd2 = new Command("pause").description("Pause a resource in the SettleMint platform").addCommand(blockchainNodePauseCommand()).addCommand(blockchainNetworkPauseCommand()).addCommand(customDeploymentPauseCommand()).addCommand(insightsPauseCommand()).addCommand(integrationToolPauseCommand()).addCommand(loadBalancerPauseCommand()).addCommand(middlewarePauseCommand()).addCommand(privateKeyPauseCommand()).addCommand(storagePauseCommand());
-  return cmd2;
-}
-
 // src/commands/platform/common/restart-command.ts
 function getRestartCommand({
   name: name3,
   type: type4,
+  subType,
   alias,
   envKey,
   restartFunction,
   usePersonalAccessToken = true
 }) {
   const commandName = sanitizeCommandName(name3);
-  const typeCommandName = sanitizeCommandName(type4);
-  const exampleCommandPrefix = `platform restart ${typeCommandName !== commandName ? `${typeCommandName} ` : ""}${commandName}`;
   return new Command(commandName).alias(alias).description(`Restart a ${type4} in the SettleMint platform. Provide the ${type4} unique name or use 'default' to restart the default ${type4} from your .env file.`).usage(createExamples([
     {
-      description: `Restarts the specified ${type4} by unique name`,
-      command: `${exampleCommandPrefix} <unique-name>`
+      description: `Restarts the specified ${type4} by id`,
+      command: `platform restart ${commandName}${subType ? ` ${subType}` : ""} <${type4}-id>`
     },
     {
       description: `Restarts the default ${type4} in the production environment`,
-      command: `${exampleCommandPrefix} default --prod`
+      command: `platform restart ${commandName}${subType ? ` ${subType}` : ""} default --prod`
     }
   ])).argument("<unique-name>", `The unique name of the ${type4}, use 'default' to restart the default one from your .env file`).option("-a, --accept-defaults", "Accept the default and previously set values").option("--prod", "Connect to your production environment").option("-w, --wait", "Wait until restarted").action(async (uniqueName, { acceptDefaults, prod, wait: wait2 }) => {
     intro(`Restarting ${type4} in the SettleMint platform`);
@@ -328531,6 +327982,7 @@ function blockscoutRestartCommand() {
   return getRestartCommand({
     name: "blockscout",
     type: "insights",
+    subType: "blockscout",
     alias: "bs",
     envKey: "SETTLEMINT_BLOCKSCOUT",
     restartFunction: async (settlemint, uniqueName) => {
@@ -328549,6 +328001,7 @@ function hasuraRestartCommand() {
   return getRestartCommand({
     name: "hasura",
     type: "integration tool",
+    subType: "hasura",
     alias: "ha",
     envKey: "SETTLEMINT_HASURA",
     restartFunction: async (settlemint, uniqueName) => {
@@ -328580,6 +328033,7 @@ function graphRestartCommand() {
   return getRestartCommand({
     name: "graph",
     type: "middleware",
+    subType: "graph",
     alias: "gr",
     envKey: "SETTLEMINT_THEGRAPH",
     restartFunction: async (settlemint, id) => {
@@ -328593,6 +328047,7 @@ function smartContractPortalRestartCommand() {
   return getRestartCommand({
     name: "smart-contract-portal",
     type: "middleware",
+    subType: "smart-contract-portal",
     alias: "scp",
     envKey: "SETTLEMINT_PORTAL",
     restartFunction: async (settlemint, uniqueName) => {
@@ -328643,236 +328098,6 @@ function restartCommand() {
   return cmd2;
 }
 
-// src/commands/platform/common/resume-command.ts
-function getResumeCommand({
-  name: name3,
-  type: type4,
-  alias,
-  envKey,
-  resumeFunction,
-  usePersonalAccessToken = true
-}) {
-  const commandName = sanitizeCommandName(name3);
-  const typeCommandName = sanitizeCommandName(type4);
-  const exampleCommandPrefix = `platform resume ${typeCommandName !== commandName ? `${typeCommandName} ` : ""}${commandName}`;
-  return new Command(commandName).alias(alias).description(`Resume a ${type4} in the SettleMint platform. Provide the ${type4} unique name or use 'default' to resume the default ${type4} from your .env file.`).usage(createExamples([
-    {
-      description: `Resumes the specified ${type4} by unique name`,
-      command: `${exampleCommandPrefix} <unique-name>`
-    },
-    {
-      description: `Resumes the default ${type4} in the production environment`,
-      command: `${exampleCommandPrefix} default --prod`
-    }
-  ])).argument("<unique-name>", `The unique name of the ${type4}, use 'default' to resume the default one from your .env file`).option("-a, --accept-defaults", "Accept the default and previously set values").option("--prod", "Connect to your production environment").option("-w, --wait", "Wait until resumed").action(async (uniqueName, { acceptDefaults, prod, wait: wait2 }) => {
-    intro(`Resuming ${type4} in the SettleMint platform`);
-    const env2 = await loadEnv(false, !!prod);
-    const instance = await instancePrompt({ env: env2, accept: acceptDefaults });
-    const accessToken = await getApplicationOrPersonalAccessToken({
-      env: env2,
-      instance,
-      prefer: usePersonalAccessToken ? "personal" : "application"
-    });
-    const settlemint = createSettleMintClient({
-      accessToken,
-      instance
-    });
-    const isDefaultUniqueName = uniqueName === "default";
-    const serviceUniqueName = isDefaultUniqueName ? typeof env2[envKey] === "string" ? env2[envKey] : null : uniqueName;
-    if (!serviceUniqueName) {
-      cancel2(`No default ${type4} found in your .env file. Please provide a valid ${type4} unique name or set a default ${type4} first.`);
-    }
-    const result = await spinner({
-      startMessage: `Resuming ${type4}`,
-      task: async () => {
-        return resumeFunction(settlemint, serviceUniqueName);
-      },
-      stopMessage: `${capitalizeFirstLetter2(type4)} resume initiated`
-    });
-    if (wait2) {
-      const isResumed = await waitForCompletion({
-        settlemint,
-        type: type4,
-        uniqueName: serviceUniqueName,
-        action: "resume"
-      });
-      if (!isResumed) {
-        throw new Error(`Failed to resume ${type4} ${serviceUniqueName}`);
-      }
-    }
-    outro(`${capitalizeFirstLetter2(type4)} ${result.name} resume initiated successfully`);
-  });
-}
-
-// src/commands/platform/blockchain-network/resume.ts
-function blockchainNetworkResumeCommand() {
-  return getResumeCommand({
-    name: "blockchain-network",
-    type: "blockchain network",
-    alias: "bnw",
-    envKey: "SETTLEMINT_BLOCKCHAIN_NETWORK",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.blockchainNetwork.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/blockchain-node/resume.ts
-function blockchainNodeResumeCommand() {
-  return getResumeCommand({
-    name: "blockchain-node",
-    type: "blockchain node",
-    alias: "bn",
-    envKey: "SETTLEMINT_BLOCKCHAIN_NODE",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.blockchainNode.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/custom-deployments/resume.ts
-function customDeploymentResumeCommand() {
-  return getResumeCommand({
-    name: "custom-deployment",
-    type: "custom deployment",
-    alias: "cd",
-    envKey: "SETTLEMINT_CUSTOM_DEPLOYMENT",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.customDeployment.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/insights/blockscout/resume.ts
-function blockscoutResumeCommand() {
-  return getResumeCommand({
-    name: "blockscout",
-    type: "insights",
-    alias: "bs",
-    envKey: "SETTLEMINT_BLOCKSCOUT",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.insights.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/insights/resume.ts
-function insightsResumeCommand() {
-  return new Command("insights").alias("in").description("Resume an insights service in the SettleMint platform").addCommand(blockscoutResumeCommand());
-}
-
-// src/commands/platform/integration-tools/hasura/resume.ts
-function hasuraResumeCommand() {
-  return getResumeCommand({
-    name: "hasura",
-    type: "integration tool",
-    alias: "ha",
-    envKey: "SETTLEMINT_HASURA",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.integrationTool.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/integration-tools/resume.ts
-function integrationToolResumeCommand() {
-  return new Command("integration-tool").alias("it").description("Resume an integration tool service in the SettleMint platform").addCommand(hasuraResumeCommand());
-}
-
-// src/commands/platform/load-balancer/resume.ts
-function loadBalancerResumeCommand() {
-  return getResumeCommand({
-    name: "load-balancer",
-    type: "load balancer",
-    alias: "lb",
-    envKey: "SETTLEMINT_BLOCKCHAIN_NODE_OR_LOAD_BALANCER",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.loadBalancer.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/middleware/graph/resume.ts
-function graphMiddlewareResumeCommand() {
-  return getResumeCommand({
-    name: "graph",
-    type: "middleware",
-    alias: "gr",
-    envKey: "SETTLEMINT_THEGRAPH",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.middleware.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/middleware/smart-contract-portal/resume.ts
-function smartContractPortalMiddlewareResumeCommand() {
-  return getResumeCommand({
-    name: "smart-contract-portal",
-    type: "middleware",
-    alias: "scp",
-    envKey: "SETTLEMINT_PORTAL",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.middleware.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/middleware/resume.ts
-function middlewareResumeCommand() {
-  return new Command("middleware").alias("mw").description("Resume a middleware service in the SettleMint platform").addCommand(graphMiddlewareResumeCommand()).addCommand(smartContractPortalMiddlewareResumeCommand());
-}
-
-// src/commands/platform/private-key/resume.ts
-function privateKeyResumeCommand() {
-  return getResumeCommand({
-    name: "private-key",
-    type: "private key",
-    alias: "pk",
-    envKey: "SETTLEMINT_ACCESSIBLE_PRIVATE_KEY",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.privateKey.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/storage/ipfs/resume.ts
-function ipfsStorageResumeCommand() {
-  return getResumeCommand({
-    name: "ipfs",
-    type: "storage",
-    alias: "ip",
-    envKey: "SETTLEMINT_IPFS",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.storage.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/storage/minio/resume.ts
-function minioStorageResumeCommand() {
-  return getResumeCommand({
-    name: "minio",
-    type: "storage",
-    alias: "m",
-    envKey: "SETTLEMINT_MINIO",
-    resumeFunction: async (settlemint, id) => {
-      return settlemint.storage.resume(id);
-    }
-  });
-}
-
-// src/commands/platform/storage/resume.ts
-function storageResumeCommand() {
-  return new Command("storage").alias("st").description("Resume a storage service in the SettleMint platform").addCommand(ipfsStorageResumeCommand()).addCommand(minioStorageResumeCommand());
-}
-
-// src/commands/platform/resume.ts
-function resumeCommand() {
-  const cmd2 = new Command("resume").description("Resume a resource in the SettleMint platform").addCommand(blockchainNodeResumeCommand()).addCommand(blockchainNetworkResumeCommand()).addCommand(customDeploymentResumeCommand()).addCommand(insightsResumeCommand()).addCommand(integrationToolResumeCommand()).addCommand(loadBalancerResumeCommand()).addCommand(middlewareResumeCommand()).addCommand(privateKeyResumeCommand()).addCommand(storageResumeCommand());
-  return cmd2;
-}
-
 // src/commands/platform/custom-deployments/update.ts
 function customDeploymentsUpdateCommand() {
   return new Command("custom-deployment").alias("cd").argument("<tag>", "The tag to update the custom deployment to").option("--unique-name <uniqueName>", "The unique name of the custom deployment to update. If not provided, will use SETTLEMINT_CUSTOM_DEPLOYMENT from env").option("--prod", "Connect to your production environment").option("--wait", "Wait for the custom deployment to be redeployed").description("Update a custom deployment in the SettleMint platform").usage(createExamples([
@@ -329263,7 +328488,7 @@ function servicesCommand() {
     if (!applicationUniqueName) {
       return nothingSelectedError("application");
     }
-    let effectiveTypes;
+    let effectiveTypes = undefined;
     if (options.type && options.type.length > 0) {
       effectiveTypes = options.type;
     } else if (typeOperands && typeOperands.length > 0) {
@@ -329321,7 +328546,7 @@ async function getServicesAndMapResults({
   const application = await settlemint.application.read(applicationUniqueName);
   const services = await servicesSpinner(settlemint, applicationUniqueName, types4);
   const results = (types4 ?? SERVICE_TYPES).filter((serviceType) => !types4 || types4.includes(serviceType)).map((serviceType) => {
-    const [_6, labels] = Object.entries(LABELS_MAP).find(([_key, value4]) => value4.command === serviceType) ?? [
+    const [_6, labels] = Object.entries(LABELS_MAP).find(([key2, value4]) => value4.command === serviceType) ?? [
       null,
       { plural: serviceType }
     ];
@@ -329448,7 +328673,7 @@ function listCommand() {
 
 // src/commands/platform.ts
 function platformCommand() {
-  return new Command("platform").description("Manage SettleMint platform resources").addCommand(configCommand()).addCommand(createCommand3()).addCommand(deleteCommand()).addCommand(listCommand()).addCommand(pauseCommand()).addCommand(resumeCommand()).addCommand(restartCommand()).addCommand(updateCommand());
+  return new Command("platform").description("Manage SettleMint platform resources").addCommand(configCommand()).addCommand(createCommand3()).addCommand(deleteCommand()).addCommand(listCommand()).addCommand(restartCommand()).addCommand(updateCommand());
 }
 
 // src/commands/smart-contract-set/create.ts
@@ -329498,7 +328723,7 @@ var import_which = __toESM(require_lib5(), 1);
 async function executeFoundryCommand(command, args) {
   try {
     await import_which.default(command);
-  } catch (_error) {
+  } catch (error45) {
     cancel2("Foundry is not installed. Instructions to install Foundry can be found here: https://book.getfoundry.sh/getting-started/installation");
   }
   return executeCommand(command, args);
@@ -329586,7 +328811,7 @@ function foundryBuildCommand() {
       description: "Build the smart contracts with additional Forge options",
       command: "scs foundry build --optimize --force"
     }
-  ])).helpOption(false).option("-h, --help", "Get list of possible forge options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, _cmd) => {
+  ])).helpOption(false).option("-h, --help", "Get list of possible forge options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, cmd2) => {
     intro("Building smart contracts using Foundry");
     const forgeOptions = mapPassthroughOptions(options, { args: operands });
     await executeFoundryCommand("forge", ["build", ...forgeOptions]);
@@ -329609,7 +328834,7 @@ function foundryFormatCommand() {
       description: "Format the smart contracts with additional Forge options",
       command: "scs foundry format --check"
     }
-  ])).helpOption(false).option("-h, --help", "Get list of possible forge options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, _cmd) => {
+  ])).helpOption(false).option("-h, --help", "Get list of possible forge options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, cmd2) => {
     intro("Formatting smart contracts using Foundry");
     const forgeOptions = mapPassthroughOptions(options, { args: operands });
     await executeFoundryCommand("forge", ["fmt", ...forgeOptions]);
@@ -329632,7 +328857,7 @@ function foundryNetworkCommand() {
       description: "Start a development network using Foundry with a specific port",
       command: "scs foundry network --port 3000"
     }
-  ])).helpOption(false).option("-h, --help", "Get list of possible anvil options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, _cmd) => {
+  ])).helpOption(false).option("-h, --help", "Get list of possible anvil options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, cmd2) => {
     const anvilOptions = mapPassthroughOptions(options, { args: operands });
     await executeFoundryCommand("anvil", anvilOptions);
   });
@@ -329653,7 +328878,7 @@ function foundryTestCommand() {
       description: "Run a specific test function",
       command: "scs foundry test --match-test testToken"
     }
-  ])).helpOption(false).option("-h, --help", "Get list of possible forge options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, _cmd) => {
+  ])).helpOption(false).option("-h, --help", "Get list of possible forge options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, cmd2) => {
     intro("Running smart contract tests using Foundry");
     const forgeOptions = mapPassthroughOptions(options, { args: operands });
     await executeFoundryCommand("forge", ["test", ...forgeOptions]);
@@ -329667,7 +328892,7 @@ var validateIfRequiredPackagesAreInstalled = async (packages, cwd2) => {
     try {
       const isInstalled = await isPackageInstalled(pkg, cwd2);
       return { packageName: pkg, isInstalled };
-    } catch (_err) {
+    } catch (err) {
       return { packageName: pkg, isInstalled: false };
     }
   }));
@@ -329692,7 +328917,7 @@ function hardhatBuildCommand() {
       description: "Build the smart contracts using additional options to the Hardhat compile command",
       command: "scs hardhat build --concurrency 2"
     }
-  ])).helpOption(false).option("-h, --help", "Get list of possible hardhat compile options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, _cmd) => {
+  ])).helpOption(false).option("-h, --help", "Get list of possible hardhat compile options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, cmd2) => {
     intro("Building smart contracts using Hardhat");
     await validateIfRequiredPackagesAreInstalled(["hardhat"]);
     const hardhatOptions = mapPassthroughOptions(options, { args: operands });
@@ -329763,7 +328988,7 @@ async function selectTargetNode({
   settlemint
 }) {
   const nodeUniqueName = blockchainNodeUniqueName ?? (autoAccept ? env2.SETTLEMINT_BLOCKCHAIN_NODE : undefined);
-  let node;
+  let node = undefined;
   if (!nodeUniqueName) {
     if (!env2.SETTLEMINT_APPLICATION) {
       return missingApplication();
@@ -329987,7 +329212,7 @@ function hardhatDeployRemoteCommand() {
       } else {
         note("Smart contract deployment was cancelled");
       }
-    } catch (_error) {
+    } catch (error45) {
       cancel2("The smart contract deployment was unsuccessful. Please check the error details above and try again. You may need to review your contract code or deployment configuration.");
     }
   });
@@ -330017,7 +329242,7 @@ function hardhatNetworkCommand() {
       description: "Start a development network using Hardhat with a specific port",
       command: "scs hardhat network --port 3000"
     }
-  ])).helpOption(false).option("-h, --help", "Get list of possible hardhat node options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, _cmd) => {
+  ])).helpOption(false).option("-h, --help", "Get list of possible hardhat node options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, cmd2) => {
     intro("Starting development network using Hardhat");
     await validateIfRequiredPackagesAreInstalled(["hardhat"]);
     const hardhatOptions = mapPassthroughOptions(options, { args: operands });
@@ -330126,7 +329351,7 @@ function hardhatTestCommand() {
       description: "Run a specific test file",
       command: "scs hardhat test test/token.test.ts"
     }
-  ])).helpOption(false).option("-h, --help", "Get list of possible hardhat test options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, _cmd) => {
+  ])).helpOption(false).option("-h, --help", "Get list of possible hardhat test options").passThroughOptions().allowUnknownOption(true).arguments("[operands...]").action(async (operands, options, cmd2) => {
     intro("Running smart contract tests using Hardhat");
     await validateIfRequiredPackagesAreInstalled(["hardhat"]);
     const hardhatOptions = mapPassthroughOptions(options, { args: operands });
@@ -330384,12 +329609,12 @@ async function getNodeName({
 
 // src/commands/smart-contract-set/subgraph/build.ts
 function subgraphBuildCommand() {
-  return new Command("build").description("Build the subgraph").option("--ipfs <ipfs-url>", "The IPFS URL to use for the subgraph deployment").usage(createExamples([
+  return new Command("build").description("Build the subgraph").usage(createExamples([
     {
       description: "Build the subgraph",
       command: "scs subgraph build"
     }
-  ])).action(async ({ ipfs }) => {
+  ])).action(async () => {
     intro("Building subgraph");
     await validateIfRequiredPackagesAreInstalled(["@graphprotocol/graph-cli"]);
     await subgraphSetup({
@@ -330398,7 +329623,7 @@ function subgraphBuildCommand() {
     const { command, args } = await getPackageManagerExecutable();
     const subgraphYamlFile = await getSubgraphYamlFile();
     await executeCommand(command, [...args, "graph", "codegen", subgraphYamlFile]);
-    await executeCommand(command, [...args, "graph", "build", ...ipfs ? ["--ipfs", ipfs] : [], subgraphYamlFile]);
+    await executeCommand(command, [...args, "graph", "build", subgraphYamlFile]);
     outro("Subgraph built successfully");
   });
 }
@@ -330794,4 +330019,4 @@ async function sdkCliCommand(argv = process.argv) {
 // src/cli.ts
 sdkCliCommand();
 
-//# debugId=93BE7E1BD62375F564756E2164756E21
+//# debugId=752E0471C745FE3A64756E2164756E21