@vultisig/cli 4.5.0 → 4.6.0

package/dist/index.js

@@ -1234,11 +1234,70 @@ var init_base = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/errors/abi.js
+var AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, BytesSizeMismatchError, InvalidAbiEncodingTypeError, InvalidArrayError;
+var init_abi = __esm({
+  "../../node_modules/viem/_esm/errors/abi.js"() {
+    init_size();
+    init_base();
+    AbiEncodingArrayLengthMismatchError = class extends BaseError {
+      constructor({ expectedLength, givenLength, type }) {
+        super([
+          `ABI encoding array length mismatch for type ${type}.`,
+          `Expected length: ${expectedLength}`,
+          `Given length: ${givenLength}`
+        ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
+      }
+    };
+    AbiEncodingBytesSizeMismatchError = class extends BaseError {
+      constructor({ expectedSize, value }) {
+        super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
+      }
+    };
+    AbiEncodingLengthMismatchError = class extends BaseError {
+      constructor({ expectedLength, givenLength }) {
+        super([
+          "ABI encoding params/values length mismatch.",
+          `Expected length (params): ${expectedLength}`,
+          `Given length (values): ${givenLength}`
+        ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
+      }
+    };
+    BytesSizeMismatchError = class extends BaseError {
+      constructor({ expectedSize, givenSize }) {
+        super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
+          name: "BytesSizeMismatchError"
+        });
+      }
+    };
+    InvalidAbiEncodingTypeError = class extends BaseError {
+      constructor(type, { docsPath }) {
+        super([
+          `Type "${type}" is not a valid encoding type.`,
+          "Please provide a valid ABI type."
+        ].join("\n"), { docsPath, name: "InvalidAbiEncodingType" });
+      }
+    };
+    InvalidArrayError = class extends BaseError {
+      constructor(value) {
+        super([`Value "${value}" is not a valid array.`].join("\n"), {
+          name: "InvalidArrayError"
+        });
+      }
+    };
+  }
+});
+
 // ../../node_modules/viem/_esm/errors/data.js
-var SizeExceedsPaddingSizeError;
+var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
 var init_data = __esm({
   "../../node_modules/viem/_esm/errors/data.js"() {
     init_base();
+    SliceOffsetOutOfBoundsError = class extends BaseError {
+      constructor({ offset, position, size: size2 }) {
+        super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
+      }
+    };
     SizeExceedsPaddingSizeError = class extends BaseError {
       constructor({ size: size2, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
@@ -1853,6 +1912,25 @@ var init_keccak256 = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/errors/address.js
+var InvalidAddressError2;
+var init_address = __esm({
+  "../../node_modules/viem/_esm/errors/address.js"() {
+    init_base();
+    InvalidAddressError2 = class extends BaseError {
+      constructor({ address }) {
+        super(`Address "${address}" is invalid.`, {
+          metaMessages: [
+            "- Address must be a hex value of 20 bytes (40 hex characters).",
+            "- Address must match its checksum counterpart."
+          ],
+          name: "InvalidAddressError"
+        });
+      }
+    };
+  }
+});
+
 // ../../node_modules/viem/_esm/utils/lru.js
 var LruMap;
 var init_lru = __esm({
@@ -1920,6 +1998,374 @@ var init_getAddress = __esm({
   }
 });
 
+// ../../node_modules/viem/_esm/utils/address/isAddress.js
+function isAddress(address, options) {
+  const { strict = true } = options ?? {};
+  const cacheKey = `${address}.${strict}`;
+  if (isAddressCache.has(cacheKey))
+    return isAddressCache.get(cacheKey);
+  const result = (() => {
+    if (!addressRegex.test(address))
+      return false;
+    if (address.toLowerCase() === address)
+      return true;
+    if (strict)
+      return checksumAddress(address) === address;
+    return true;
+  })();
+  isAddressCache.set(cacheKey, result);
+  return result;
+}
+var addressRegex, isAddressCache;
+var init_isAddress = __esm({
+  "../../node_modules/viem/_esm/utils/address/isAddress.js"() {
+    init_lru();
+    init_getAddress();
+    addressRegex = /^0x[a-fA-F0-9]{40}$/;
+    isAddressCache = /* @__PURE__ */ new LruMap(8192);
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/data/concat.js
+function concat(values) {
+  if (typeof values[0] === "string")
+    return concatHex(values);
+  return concatBytes2(values);
+}
+function concatBytes2(values) {
+  let length = 0;
+  for (const arr of values) {
+    length += arr.length;
+  }
+  const result = new Uint8Array(length);
+  let offset = 0;
+  for (const arr of values) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+function concatHex(values) {
+  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
+}
+var init_concat = __esm({
+  "../../node_modules/viem/_esm/utils/data/concat.js"() {
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/data/slice.js
+function slice(value, start, end, { strict } = {}) {
+  if (isHex(value, { strict: false }))
+    return sliceHex(value, start, end, {
+      strict
+    });
+  return sliceBytes(value, start, end, {
+    strict
+  });
+}
+function assertStartOffset(value, start) {
+  if (typeof start === "number" && start > 0 && start > size(value) - 1)
+    throw new SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: "start",
+      size: size(value)
+    });
+}
+function assertEndOffset(value, start, end) {
+  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
+    throw new SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: "end",
+      size: size(value)
+    });
+  }
+}
+function sliceBytes(value_, start, end, { strict } = {}) {
+  assertStartOffset(value_, start);
+  const value = value_.slice(start, end);
+  if (strict)
+    assertEndOffset(value, start, end);
+  return value;
+}
+function sliceHex(value_, start, end, { strict } = {}) {
+  assertStartOffset(value_, start);
+  const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
+  if (strict)
+    assertEndOffset(value, start, end);
+  return value;
+}
+var init_slice = __esm({
+  "../../node_modules/viem/_esm/utils/data/slice.js"() {
+    init_data();
+    init_isHex();
+    init_size();
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/regex.js
+var bytesRegex, integerRegex;
+var init_regex = __esm({
+  "../../node_modules/viem/_esm/utils/regex.js"() {
+    bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+    integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
+function encodeAbiParameters(params, values) {
+  if (params.length !== values.length)
+    throw new AbiEncodingLengthMismatchError({
+      expectedLength: params.length,
+      givenLength: values.length
+    });
+  const preparedParams = prepareParams({
+    params,
+    values
+  });
+  return encodeParams(preparedParams);
+}
+function prepareParams({ params, values }) {
+  const preparedParams = [];
+  for (let i = 0; i < params.length; i++) {
+    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
+  }
+  return preparedParams;
+}
+function prepareParam({ param, value }) {
+  const arrayComponents = getArrayComponents(param.type);
+  if (arrayComponents) {
+    const [length, type] = arrayComponents;
+    return encodeArray(value, { length, param: { ...param, type } });
+  }
+  if (param.type === "tuple") {
+    return encodeTuple(value, {
+      param
+    });
+  }
+  if (param.type === "address") {
+    return encodeAddress(value);
+  }
+  if (param.type === "bool") {
+    return encodeBool(value);
+  }
+  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
+    const signed = param.type.startsWith("int");
+    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
+    return encodeNumber(value, {
+      signed,
+      size: Number(size2)
+    });
+  }
+  if (param.type.startsWith("bytes")) {
+    return encodeBytes(value, { param });
+  }
+  if (param.type === "string") {
+    return encodeString(value);
+  }
+  throw new InvalidAbiEncodingTypeError(param.type, {
+    docsPath: "/docs/contract/encodeAbiParameters"
+  });
+}
+function encodeParams(preparedParams) {
+  let staticSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic)
+      staticSize += 32;
+    else
+      staticSize += size(encoded);
+  }
+  const staticParams = [];
+  const dynamicParams = [];
+  let dynamicSize = 0;
+  for (let i = 0; i < preparedParams.length; i++) {
+    const { dynamic, encoded } = preparedParams[i];
+    if (dynamic) {
+      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+      dynamicParams.push(encoded);
+      dynamicSize += size(encoded);
+    } else {
+      staticParams.push(encoded);
+    }
+  }
+  return concatHex([...staticParams, ...dynamicParams]);
+}
+function encodeAddress(value) {
+  if (!isAddress(value))
+    throw new InvalidAddressError2({ address: value });
+  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
+function encodeArray(value, { length, param }) {
+  const dynamic = length === null;
+  if (!Array.isArray(value))
+    throw new InvalidArrayError(value);
+  if (!dynamic && value.length !== length)
+    throw new AbiEncodingArrayLengthMismatchError({
+      expectedLength: length,
+      givenLength: value.length,
+      type: `${param.type}[${length}]`
+    });
+  let dynamicChild = value.length === 0 && isDynamicType(param);
+  const preparedParams = [];
+  for (let i = 0; i < value.length; i++) {
+    const preparedParam = prepareParam({ param, value: value[i] });
+    if (preparedParam.dynamic)
+      dynamicChild = true;
+    preparedParams.push(preparedParam);
+  }
+  if (dynamic || dynamicChild) {
+    const data = encodeParams(preparedParams);
+    if (dynamic) {
+      const length2 = numberToHex(preparedParams.length, { size: 32 });
+      return {
+        dynamic: true,
+        encoded: concatHex([length2, data])
+      };
+    }
+    if (dynamicChild)
+      return { dynamic: true, encoded: data };
+  }
+  return {
+    dynamic: false,
+    encoded: concatHex(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function encodeBytes(value, { param }) {
+  const [, paramSize] = param.type.split("bytes");
+  const bytesSize = size(value);
+  if (!paramSize) {
+    let value_ = value;
+    if (bytesSize % 32 !== 0)
+      value_ = padHex(value_, {
+        dir: "right",
+        size: Math.ceil((value.length - 2) / 2 / 32) * 32
+      });
+    return {
+      dynamic: true,
+      encoded: concatHex([
+        padHex(numberToHex(bytesSize, { size: 32 })),
+        value_
+      ])
+    };
+  }
+  if (bytesSize !== Number.parseInt(paramSize, 10))
+    throw new AbiEncodingBytesSizeMismatchError({
+      expectedSize: Number.parseInt(paramSize, 10),
+      value
+    });
+  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
+}
+function encodeBool(value) {
+  if (typeof value !== "boolean")
+    throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+  return { dynamic: false, encoded: padHex(boolToHex(value)) };
+}
+function encodeNumber(value, { signed, size: size2 = 256 }) {
+  if (typeof size2 === "number") {
+    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
+    const min = signed ? -max - 1n : 0n;
+    if (value > max || value < min)
+      throw new IntegerOutOfRangeError({
+        max: max.toString(),
+        min: min.toString(),
+        signed,
+        size: size2 / 8,
+        value: value.toString()
+      });
+  }
+  return {
+    dynamic: false,
+    encoded: numberToHex(value, {
+      size: 32,
+      signed
+    })
+  };
+}
+function encodeString(value) {
+  const hexValue = stringToHex(value);
+  const partsLength = Math.ceil(size(hexValue) / 32);
+  const parts = [];
+  for (let i = 0; i < partsLength; i++) {
+    parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
+      dir: "right"
+    }));
+  }
+  return {
+    dynamic: true,
+    encoded: concatHex([
+      padHex(numberToHex(size(hexValue), { size: 32 })),
+      ...parts
+    ])
+  };
+}
+function encodeTuple(value, { param }) {
+  let dynamic = false;
+  const preparedParams = [];
+  for (let i = 0; i < param.components.length; i++) {
+    const param_ = param.components[i];
+    const index = Array.isArray(value) ? i : param_.name;
+    const preparedParam = prepareParam({
+      param: param_,
+      value: value[index]
+    });
+    preparedParams.push(preparedParam);
+    if (preparedParam.dynamic)
+      dynamic = true;
+  }
+  return {
+    dynamic,
+    encoded: dynamic ? encodeParams(preparedParams) : concatHex(preparedParams.map(({ encoded }) => encoded))
+  };
+}
+function getArrayComponents(type) {
+  const matches = type.match(/^(.*)\[(\d+)?\]$/);
+  return matches ? (
+    // Return `null` if the array is dynamic.
+    [matches[2] ? Number(matches[2]) : null, matches[1]]
+  ) : void 0;
+}
+function isDynamicType(param) {
+  const { type } = param;
+  if (type === "string")
+    return true;
+  if (type === "bytes")
+    return true;
+  if (type.endsWith("[]"))
+    return true;
+  if (type === "tuple")
+    return param.components.some(isDynamicType);
+  const arrayComponents = getArrayComponents(type);
+  if (arrayComponents)
+    return isDynamicType({ ...param, type: arrayComponents[1] });
+  return false;
+}
+var init_encodeAbiParameters = __esm({
+  "../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
+    init_abi();
+    init_address();
+    init_base();
+    init_encoding();
+    init_isAddress();
+    init_concat();
+    init_pad();
+    init_size();
+    init_slice();
+    init_toHex();
+    init_regex();
+  }
+});
+
+// ../../node_modules/viem/_esm/utils/stringify.js
+var stringify;
+var init_stringify = __esm({
+  "../../node_modules/viem/_esm/utils/stringify.js"() {
+    stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
+      const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
+      return typeof replacer === "function" ? replacer(key, value2) : value2;
+    }, space);
+  }
+});
+
 // ../../node_modules/viem/_esm/utils/unit/Value.js
 function format(value, decimals = 0) {
   if (!Number.isInteger(decimals) || decimals < 0)
@@ -2392,7 +2838,7 @@ function ensureBytes(title, hex, expectedLength) {
     throw new Error(title + " of length " + expectedLength + " expected, got " + len);
   return res;
 }
-function concatBytes2(...arrays) {
+function concatBytes3(...arrays) {
   let sum = 0;
   for (let i = 0; i < arrays.length; i++) {
     const a = arrays[i];
@@ -2460,7 +2906,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
       out.push(sl);
       len += v.length;
     }
-    return concatBytes2(...out);
+    return concatBytes3(...out);
   };
   const genUntil = (seed, pred) => {
     reset();
@@ -3092,7 +3538,7 @@ function weierstrassPoints(opts) {
   const Fn = Field(CURVE.n, CURVE.nBitLength);
   const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
     const a = point.toAffine();
-    return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+    return concatBytes3(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
   });
   const fromBytes = CURVE.fromBytes || ((bytes) => {
     const tail = bytes.subarray(1);
@@ -3518,7 +3964,7 @@ function weierstrass(curveDef) {
     toBytes(_c, point, isCompressed) {
       const a = point.toAffine();
       const x = Fp.toBytes(a.x);
-      const cat = concatBytes2;
+      const cat = concatBytes3;
       abool("isCompressed", isCompressed);
       if (isCompressed) {
         return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
@@ -3731,7 +4177,7 @@ function weierstrass(curveDef) {
       const e = ent === true ? randomBytes4(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e));
     }
-    const seed = concatBytes2(...seedArgs);
+    const seed = concatBytes3(...seedArgs);
     const m = h1int;
     function k2sig(kBytes) {
       const k = bits2int(kBytes);
@@ -4094,22 +4540,22 @@ function expand_message_xmd(msg, DST, lenInBytes, H) {
   abytes2(DST);
   anum(lenInBytes);
   if (DST.length > 255)
-    DST = H(concatBytes2(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
+    DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
   const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
   const ell = Math.ceil(lenInBytes / b_in_bytes);
   if (lenInBytes > 65535 || ell > 255)
     throw new Error("expand_message_xmd: invalid lenInBytes");
-  const DST_prime = concatBytes2(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 b = new Array(ell);
-  const b_0 = H(concatBytes2(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-  b[0] = H(concatBytes2(b_0, i2osp(1, 1), DST_prime));
+  const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+  b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
   for (let i = 1; i <= ell; i++) {
     const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
-    b[i] = H(concatBytes2(...args));
+    b[i] = H(concatBytes3(...args));
   }
-  const pseudo_random_bytes = concatBytes2(...b);
+  const pseudo_random_bytes = concatBytes3(...b);
   return pseudo_random_bytes.slice(0, lenInBytes);
 }
 function expand_message_xof(msg, DST, lenInBytes, k, H) {
@@ -4255,10 +4701,10 @@ function taggedHash(tag, ...messages) {
   let tagP = TAGGED_HASH_PREFIXES[tag];
   if (tagP === void 0) {
     const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
-    tagP = concatBytes2(tagH, tagH);
+    tagP = concatBytes3(tagH, tagH);
     TAGGED_HASH_PREFIXES[tag] = tagP;
   }
-  return sha256(concatBytes2(tagP, ...messages));
+  return sha256(concatBytes3(tagP, ...messages));
 }
 function schnorrGetExtPubKey(priv) {
   let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
@@ -4372,82 +4818,1791 @@ var init_secp256k1 = __esm({
           if (k1 > POW_2_128 || k2 > POW_2_128) {
             throw new Error("splitScalar: Endomorphism failed, k=" + k);
           }
-          return { k1neg, k1, k2neg, k2 };
+          return { k1neg, k1, k2neg, k2 };
+        }
+      }
+    }, sha256);
+    TAGGED_HASH_PREFIXES = {};
+    pointToBytes = (point) => point.toRawBytes(true).slice(1);
+    numTo32b = (n) => numberToBytesBE(n, 32);
+    modP = (x) => mod(x, secp256k1P);
+    modN = (x) => mod(x, secp256k1N);
+    Point = /* @__PURE__ */ (() => secp256k1.ProjectivePoint)();
+    GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
+    num = bytesToNumberBE;
+    schnorr = /* @__PURE__ */ (() => ({
+      getPublicKey: schnorrGetPublicKey,
+      sign: schnorrSign,
+      verify: schnorrVerify,
+      utils: {
+        randomPrivateKey: secp256k1.utils.randomPrivateKey,
+        lift_x,
+        pointToBytes,
+        numberToBytesBE,
+        bytesToNumberBE,
+        taggedHash,
+        mod
+      }
+    }))();
+    isoMap = /* @__PURE__ */ (() => isogenyMap(Fpk1, [
+      // xNum
+      [
+        "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
+        "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
+        "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
+        "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
+      ],
+      // xDen
+      [
+        "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
+        "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
+        "0x0000000000000000000000000000000000000000000000000000000000000001"
+        // LAST 1
+      ],
+      // yNum
+      [
+        "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
+        "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
+        "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
+        "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
+      ],
+      // yDen
+      [
+        "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
+        "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
+        "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
+        "0x0000000000000000000000000000000000000000000000000000000000000001"
+        // LAST 1
+      ]
+    ].map((i) => i.map((j) => BigInt(j)))))();
+    mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fpk1, {
+      A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
+      B: BigInt("1771"),
+      Z: Fpk1.create(BigInt("-11"))
+    }))();
+    secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.ProjectivePoint, (scalars) => {
+      const { x, y } = mapSWU(Fpk1.create(scalars[0]));
+      return isoMap(x, y);
+    }, {
+      DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
+      encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
+      p: Fpk1.ORDER,
+      m: 1,
+      k: 128,
+      expand: "xmd",
+      hash: sha256
+    }))();
+    hashToCurve = /* @__PURE__ */ (() => secp256k1_hasher.hashToCurve)();
+    encodeToCurve = /* @__PURE__ */ (() => secp256k1_hasher.encodeToCurve)();
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/utils/utf8.cjs
+var require_utf8 = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/utils/utf8.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.utf8Count = utf8Count;
+    exports.utf8EncodeJs = utf8EncodeJs;
+    exports.utf8EncodeTE = utf8EncodeTE;
+    exports.utf8Encode = utf8Encode;
+    exports.utf8DecodeJs = utf8DecodeJs;
+    exports.utf8DecodeTD = utf8DecodeTD;
+    exports.utf8Decode = utf8Decode;
+    function utf8Count(str2) {
+      const strLength = str2.length;
+      let byteLength = 0;
+      let pos = 0;
+      while (pos < strLength) {
+        let value = str2.charCodeAt(pos++);
+        if ((value & 4294967168) === 0) {
+          byteLength++;
+          continue;
+        } else if ((value & 4294965248) === 0) {
+          byteLength += 2;
+        } else {
+          if (value >= 55296 && value <= 56319) {
+            if (pos < strLength) {
+              const extra = str2.charCodeAt(pos);
+              if ((extra & 64512) === 56320) {
+                ++pos;
+                value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+              }
+            }
+          }
+          if ((value & 4294901760) === 0) {
+            byteLength += 3;
+          } else {
+            byteLength += 4;
+          }
+        }
+      }
+      return byteLength;
+    }
+    function utf8EncodeJs(str2, output, outputOffset) {
+      const strLength = str2.length;
+      let offset = outputOffset;
+      let pos = 0;
+      while (pos < strLength) {
+        let value = str2.charCodeAt(pos++);
+        if ((value & 4294967168) === 0) {
+          output[offset++] = value;
+          continue;
+        } else if ((value & 4294965248) === 0) {
+          output[offset++] = value >> 6 & 31 | 192;
+        } else {
+          if (value >= 55296 && value <= 56319) {
+            if (pos < strLength) {
+              const extra = str2.charCodeAt(pos);
+              if ((extra & 64512) === 56320) {
+                ++pos;
+                value = ((value & 1023) << 10) + (extra & 1023) + 65536;
+              }
+            }
+          }
+          if ((value & 4294901760) === 0) {
+            output[offset++] = value >> 12 & 15 | 224;
+            output[offset++] = value >> 6 & 63 | 128;
+          } else {
+            output[offset++] = value >> 18 & 7 | 240;
+            output[offset++] = value >> 12 & 63 | 128;
+            output[offset++] = value >> 6 & 63 | 128;
+          }
+        }
+        output[offset++] = value & 63 | 128;
+      }
+    }
+    var sharedTextEncoder = new TextEncoder();
+    var TEXT_ENCODER_THRESHOLD = 50;
+    function utf8EncodeTE(str2, output, outputOffset) {
+      sharedTextEncoder.encodeInto(str2, output.subarray(outputOffset));
+    }
+    function utf8Encode(str2, output, outputOffset) {
+      if (str2.length > TEXT_ENCODER_THRESHOLD) {
+        utf8EncodeTE(str2, output, outputOffset);
+      } else {
+        utf8EncodeJs(str2, output, outputOffset);
+      }
+    }
+    var CHUNK_SIZE = 4096;
+    function utf8DecodeJs(bytes, inputOffset, byteLength) {
+      let offset = inputOffset;
+      const end = offset + byteLength;
+      const units = [];
+      let result = "";
+      while (offset < end) {
+        const byte1 = bytes[offset++];
+        if ((byte1 & 128) === 0) {
+          units.push(byte1);
+        } else if ((byte1 & 224) === 192) {
+          const byte2 = bytes[offset++] & 63;
+          units.push((byte1 & 31) << 6 | byte2);
+        } else if ((byte1 & 240) === 224) {
+          const byte2 = bytes[offset++] & 63;
+          const byte3 = bytes[offset++] & 63;
+          units.push((byte1 & 31) << 12 | byte2 << 6 | byte3);
+        } else if ((byte1 & 248) === 240) {
+          const byte2 = bytes[offset++] & 63;
+          const byte3 = bytes[offset++] & 63;
+          const byte4 = bytes[offset++] & 63;
+          let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+          if (unit > 65535) {
+            unit -= 65536;
+            units.push(unit >>> 10 & 1023 | 55296);
+            unit = 56320 | unit & 1023;
+          }
+          units.push(unit);
+        } else {
+          units.push(byte1);
+        }
+        if (units.length >= CHUNK_SIZE) {
+          result += String.fromCharCode(...units);
+          units.length = 0;
+        }
+      }
+      if (units.length > 0) {
+        result += String.fromCharCode(...units);
+      }
+      return result;
+    }
+    var sharedTextDecoder = new TextDecoder();
+    var TEXT_DECODER_THRESHOLD = 200;
+    function utf8DecodeTD(bytes, inputOffset, byteLength) {
+      const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength);
+      return sharedTextDecoder.decode(stringBytes);
+    }
+    function utf8Decode(bytes, inputOffset, byteLength) {
+      if (byteLength > TEXT_DECODER_THRESHOLD) {
+        return utf8DecodeTD(bytes, inputOffset, byteLength);
+      } else {
+        return utf8DecodeJs(bytes, inputOffset, byteLength);
+      }
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/ExtData.cjs
+var require_ExtData = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/ExtData.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExtData = void 0;
+    var ExtData = class {
+      type;
+      data;
+      constructor(type, data) {
+        this.type = type;
+        this.data = data;
+      }
+    };
+    exports.ExtData = ExtData;
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/DecodeError.cjs
+var require_DecodeError = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/DecodeError.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DecodeError = void 0;
+    var DecodeError = class _DecodeError extends Error {
+      constructor(message) {
+        super(message);
+        const proto = Object.create(_DecodeError.prototype);
+        Object.setPrototypeOf(this, proto);
+        Object.defineProperty(this, "name", {
+          configurable: true,
+          enumerable: false,
+          value: _DecodeError.name
+        });
+      }
+    };
+    exports.DecodeError = DecodeError;
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/utils/int.cjs
+var require_int = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/utils/int.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.UINT32_MAX = void 0;
+    exports.setUint64 = setUint64;
+    exports.setInt64 = setInt64;
+    exports.getInt64 = getInt64;
+    exports.getUint64 = getUint64;
+    exports.UINT32_MAX = 4294967295;
+    function setUint64(view, offset, value) {
+      const high = value / 4294967296;
+      const low = value;
+      view.setUint32(offset, high);
+      view.setUint32(offset + 4, low);
+    }
+    function setInt64(view, offset, value) {
+      const high = Math.floor(value / 4294967296);
+      const low = value;
+      view.setUint32(offset, high);
+      view.setUint32(offset + 4, low);
+    }
+    function getInt64(view, offset) {
+      const high = view.getInt32(offset);
+      const low = view.getUint32(offset + 4);
+      return high * 4294967296 + low;
+    }
+    function getUint64(view, offset) {
+      const high = view.getUint32(offset);
+      const low = view.getUint32(offset + 4);
+      return high * 4294967296 + low;
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/timestamp.cjs
+var require_timestamp = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/timestamp.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.timestampExtension = exports.EXT_TIMESTAMP = void 0;
+    exports.encodeTimeSpecToTimestamp = encodeTimeSpecToTimestamp;
+    exports.encodeDateToTimeSpec = encodeDateToTimeSpec;
+    exports.encodeTimestampExtension = encodeTimestampExtension;
+    exports.decodeTimestampToTimeSpec = decodeTimestampToTimeSpec;
+    exports.decodeTimestampExtension = decodeTimestampExtension;
+    var DecodeError_ts_1 = require_DecodeError();
+    var int_ts_1 = require_int();
+    exports.EXT_TIMESTAMP = -1;
+    var TIMESTAMP32_MAX_SEC = 4294967296 - 1;
+    var TIMESTAMP64_MAX_SEC = 17179869184 - 1;
+    function encodeTimeSpecToTimestamp({ sec, nsec }) {
+      if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) {
+        if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) {
+          const rv = new Uint8Array(4);
+          const view = new DataView(rv.buffer);
+          view.setUint32(0, sec);
+          return rv;
+        } else {
+          const secHigh = sec / 4294967296;
+          const secLow = sec & 4294967295;
+          const rv = new Uint8Array(8);
+          const view = new DataView(rv.buffer);
+          view.setUint32(0, nsec << 2 | secHigh & 3);
+          view.setUint32(4, secLow);
+          return rv;
+        }
+      } else {
+        const rv = new Uint8Array(12);
+        const view = new DataView(rv.buffer);
+        view.setUint32(0, nsec);
+        (0, int_ts_1.setInt64)(view, 4, sec);
+        return rv;
+      }
+    }
+    function encodeDateToTimeSpec(date) {
+      const msec = date.getTime();
+      const sec = Math.floor(msec / 1e3);
+      const nsec = (msec - sec * 1e3) * 1e6;
+      const nsecInSec = Math.floor(nsec / 1e9);
+      return {
+        sec: sec + nsecInSec,
+        nsec: nsec - nsecInSec * 1e9
+      };
+    }
+    function encodeTimestampExtension(object) {
+      if (object instanceof Date) {
+        const timeSpec = encodeDateToTimeSpec(object);
+        return encodeTimeSpecToTimestamp(timeSpec);
+      } else {
+        return null;
+      }
+    }
+    function decodeTimestampToTimeSpec(data) {
+      const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      switch (data.byteLength) {
+        case 4: {
+          const sec = view.getUint32(0);
+          const nsec = 0;
+          return { sec, nsec };
+        }
+        case 8: {
+          const nsec30AndSecHigh2 = view.getUint32(0);
+          const secLow32 = view.getUint32(4);
+          const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32;
+          const nsec = nsec30AndSecHigh2 >>> 2;
+          return { sec, nsec };
+        }
+        case 12: {
+          const sec = (0, int_ts_1.getInt64)(view, 4);
+          const nsec = view.getUint32(0);
+          return { sec, nsec };
+        }
+        default:
+          throw new DecodeError_ts_1.DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`);
+      }
+    }
+    function decodeTimestampExtension(data) {
+      const timeSpec = decodeTimestampToTimeSpec(data);
+      return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6);
+    }
+    exports.timestampExtension = {
+      type: exports.EXT_TIMESTAMP,
+      encode: encodeTimestampExtension,
+      decode: decodeTimestampExtension
+    };
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/ExtensionCodec.cjs
+var require_ExtensionCodec = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/ExtensionCodec.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExtensionCodec = void 0;
+    var ExtData_ts_1 = require_ExtData();
+    var timestamp_ts_1 = require_timestamp();
+    var ExtensionCodec = class _ExtensionCodec {
+      static defaultCodec = new _ExtensionCodec();
+      // ensures ExtensionCodecType<X> matches ExtensionCodec<X>
+      // this will make type errors a lot more clear
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      __brand;
+      // built-in extensions
+      builtInEncoders = [];
+      builtInDecoders = [];
+      // custom extensions
+      encoders = [];
+      decoders = [];
+      constructor() {
+        this.register(timestamp_ts_1.timestampExtension);
+      }
+      register({ type, encode, decode }) {
+        if (type >= 0) {
+          this.encoders[type] = encode;
+          this.decoders[type] = decode;
+        } else {
+          const index = -1 - type;
+          this.builtInEncoders[index] = encode;
+          this.builtInDecoders[index] = decode;
+        }
+      }
+      tryToEncode(object, context) {
+        for (let i = 0; i < this.builtInEncoders.length; i++) {
+          const encodeExt = this.builtInEncoders[i];
+          if (encodeExt != null) {
+            const data = encodeExt(object, context);
+            if (data != null) {
+              const type = -1 - i;
+              return new ExtData_ts_1.ExtData(type, data);
+            }
+          }
+        }
+        for (let i = 0; i < this.encoders.length; i++) {
+          const encodeExt = this.encoders[i];
+          if (encodeExt != null) {
+            const data = encodeExt(object, context);
+            if (data != null) {
+              const type = i;
+              return new ExtData_ts_1.ExtData(type, data);
+            }
+          }
+        }
+        if (object instanceof ExtData_ts_1.ExtData) {
+          return object;
+        }
+        return null;
+      }
+      decode(data, type, context) {
+        const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+        if (decodeExt) {
+          return decodeExt(data, type, context);
+        } else {
+          return new ExtData_ts_1.ExtData(type, data);
+        }
+      }
+    };
+    exports.ExtensionCodec = ExtensionCodec;
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/utils/typedArrays.cjs
+var require_typedArrays = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/utils/typedArrays.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ensureUint8Array = ensureUint8Array;
+    function isArrayBufferLike(buffer) {
+      return buffer instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && buffer instanceof SharedArrayBuffer;
+    }
+    function ensureUint8Array(buffer) {
+      if (buffer instanceof Uint8Array) {
+        return buffer;
+      } else if (ArrayBuffer.isView(buffer)) {
+        return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      } else if (isArrayBufferLike(buffer)) {
+        return new Uint8Array(buffer);
+      } else {
+        return Uint8Array.from(buffer);
+      }
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/Encoder.cjs
+var require_Encoder = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/Encoder.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Encoder = exports.DEFAULT_INITIAL_BUFFER_SIZE = exports.DEFAULT_MAX_DEPTH = void 0;
+    var utf8_ts_1 = require_utf8();
+    var ExtensionCodec_ts_1 = require_ExtensionCodec();
+    var int_ts_1 = require_int();
+    var typedArrays_ts_1 = require_typedArrays();
+    exports.DEFAULT_MAX_DEPTH = 100;
+    exports.DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+    var Encoder = class _Encoder {
+      extensionCodec;
+      context;
+      useBigInt64;
+      maxDepth;
+      initialBufferSize;
+      sortKeys;
+      forceFloat32;
+      ignoreUndefined;
+      forceIntegerToFloat;
+      pos;
+      view;
+      bytes;
+      entered = false;
+      constructor(options) {
+        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec_ts_1.ExtensionCodec.defaultCodec;
+        this.context = options?.context;
+        this.useBigInt64 = options?.useBigInt64 ?? false;
+        this.maxDepth = options?.maxDepth ?? exports.DEFAULT_MAX_DEPTH;
+        this.initialBufferSize = options?.initialBufferSize ?? exports.DEFAULT_INITIAL_BUFFER_SIZE;
+        this.sortKeys = options?.sortKeys ?? false;
+        this.forceFloat32 = options?.forceFloat32 ?? false;
+        this.ignoreUndefined = options?.ignoreUndefined ?? false;
+        this.forceIntegerToFloat = options?.forceIntegerToFloat ?? false;
+        this.pos = 0;
+        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+        this.bytes = new Uint8Array(this.view.buffer);
+      }
+      clone() {
+        return new _Encoder({
+          extensionCodec: this.extensionCodec,
+          context: this.context,
+          useBigInt64: this.useBigInt64,
+          maxDepth: this.maxDepth,
+          initialBufferSize: this.initialBufferSize,
+          sortKeys: this.sortKeys,
+          forceFloat32: this.forceFloat32,
+          ignoreUndefined: this.ignoreUndefined,
+          forceIntegerToFloat: this.forceIntegerToFloat
+        });
+      }
+      reinitializeState() {
+        this.pos = 0;
+      }
+      /**
+       * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+       *
+       * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+       */
+      encodeSharedRef(object) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encodeSharedRef(object);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.subarray(0, this.pos);
+        } finally {
+          this.entered = false;
+        }
+      }
+      /**
+       * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+       */
+      encode(object) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.encode(object);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.doEncode(object, 1);
+          return this.bytes.slice(0, this.pos);
+        } finally {
+          this.entered = false;
+        }
+      }
+      doEncode(object, depth) {
+        if (depth > this.maxDepth) {
+          throw new Error(`Too deep objects in depth ${depth}`);
+        }
+        if (object == null) {
+          this.encodeNil();
+        } else if (typeof object === "boolean") {
+          this.encodeBoolean(object);
+        } else if (typeof object === "number") {
+          if (!this.forceIntegerToFloat) {
+            this.encodeNumber(object);
+          } else {
+            this.encodeNumberAsFloat(object);
+          }
+        } else if (typeof object === "string") {
+          this.encodeString(object);
+        } else if (this.useBigInt64 && typeof object === "bigint") {
+          this.encodeBigInt64(object);
+        } else {
+          this.encodeObject(object, depth);
+        }
+      }
+      ensureBufferSizeToWrite(sizeToWrite) {
+        const requiredSize = this.pos + sizeToWrite;
+        if (this.view.byteLength < requiredSize) {
+          this.resizeBuffer(requiredSize * 2);
+        }
+      }
+      resizeBuffer(newSize) {
+        const newBuffer = new ArrayBuffer(newSize);
+        const newBytes = new Uint8Array(newBuffer);
+        const newView = new DataView(newBuffer);
+        newBytes.set(this.bytes);
+        this.view = newView;
+        this.bytes = newBytes;
+      }
+      encodeNil() {
+        this.writeU8(192);
+      }
+      encodeBoolean(object) {
+        if (object === false) {
+          this.writeU8(194);
+        } else {
+          this.writeU8(195);
+        }
+      }
+      encodeNumber(object) {
+        if (!this.forceIntegerToFloat && Number.isSafeInteger(object)) {
+          if (object >= 0) {
+            if (object < 128) {
+              this.writeU8(object);
+            } else if (object < 256) {
+              this.writeU8(204);
+              this.writeU8(object);
+            } else if (object < 65536) {
+              this.writeU8(205);
+              this.writeU16(object);
+            } else if (object < 4294967296) {
+              this.writeU8(206);
+              this.writeU32(object);
+            } else if (!this.useBigInt64) {
+              this.writeU8(207);
+              this.writeU64(object);
+            } else {
+              this.encodeNumberAsFloat(object);
+            }
+          } else {
+            if (object >= -32) {
+              this.writeU8(224 | object + 32);
+            } else if (object >= -128) {
+              this.writeU8(208);
+              this.writeI8(object);
+            } else if (object >= -32768) {
+              this.writeU8(209);
+              this.writeI16(object);
+            } else if (object >= -2147483648) {
+              this.writeU8(210);
+              this.writeI32(object);
+            } else if (!this.useBigInt64) {
+              this.writeU8(211);
+              this.writeI64(object);
+            } else {
+              this.encodeNumberAsFloat(object);
+            }
+          }
+        } else {
+          this.encodeNumberAsFloat(object);
+        }
+      }
+      encodeNumberAsFloat(object) {
+        if (this.forceFloat32) {
+          this.writeU8(202);
+          this.writeF32(object);
+        } else {
+          this.writeU8(203);
+          this.writeF64(object);
+        }
+      }
+      encodeBigInt64(object) {
+        if (object >= BigInt(0)) {
+          this.writeU8(207);
+          this.writeBigUint64(object);
+        } else {
+          this.writeU8(211);
+          this.writeBigInt64(object);
+        }
+      }
+      writeStringHeader(byteLength) {
+        if (byteLength < 32) {
+          this.writeU8(160 + byteLength);
+        } else if (byteLength < 256) {
+          this.writeU8(217);
+          this.writeU8(byteLength);
+        } else if (byteLength < 65536) {
+          this.writeU8(218);
+          this.writeU16(byteLength);
+        } else if (byteLength < 4294967296) {
+          this.writeU8(219);
+          this.writeU32(byteLength);
+        } else {
+          throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);
+        }
+      }
+      encodeString(object) {
+        const maxHeaderSize = 1 + 4;
+        const byteLength = (0, utf8_ts_1.utf8Count)(object);
+        this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+        this.writeStringHeader(byteLength);
+        (0, utf8_ts_1.utf8Encode)(object, this.bytes, this.pos);
+        this.pos += byteLength;
+      }
+      encodeObject(object, depth) {
+        const ext = this.extensionCodec.tryToEncode(object, this.context);
+        if (ext != null) {
+          this.encodeExtension(ext);
+        } else if (Array.isArray(object)) {
+          this.encodeArray(object, depth);
+        } else if (ArrayBuffer.isView(object)) {
+          this.encodeBinary(object);
+        } else if (typeof object === "object") {
+          this.encodeMap(object, depth);
+        } else {
+          throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+        }
+      }
+      encodeBinary(object) {
+        const size2 = object.byteLength;
+        if (size2 < 256) {
+          this.writeU8(196);
+          this.writeU8(size2);
+        } else if (size2 < 65536) {
+          this.writeU8(197);
+          this.writeU16(size2);
+        } else if (size2 < 4294967296) {
+          this.writeU8(198);
+          this.writeU32(size2);
+        } else {
+          throw new Error(`Too large binary: ${size2}`);
+        }
+        const bytes = (0, typedArrays_ts_1.ensureUint8Array)(object);
+        this.writeU8a(bytes);
+      }
+      encodeArray(object, depth) {
+        const size2 = object.length;
+        if (size2 < 16) {
+          this.writeU8(144 + size2);
+        } else if (size2 < 65536) {
+          this.writeU8(220);
+          this.writeU16(size2);
+        } else if (size2 < 4294967296) {
+          this.writeU8(221);
+          this.writeU32(size2);
+        } else {
+          throw new Error(`Too large array: ${size2}`);
+        }
+        for (const item of object) {
+          this.doEncode(item, depth + 1);
+        }
+      }
+      countWithoutUndefined(object, keys) {
+        let count = 0;
+        for (const key of keys) {
+          if (object[key] !== void 0) {
+            count++;
+          }
+        }
+        return count;
+      }
+      encodeMap(object, depth) {
+        const keys = Object.keys(object);
+        if (this.sortKeys) {
+          keys.sort();
+        }
+        const size2 = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length;
+        if (size2 < 16) {
+          this.writeU8(128 + size2);
+        } else if (size2 < 65536) {
+          this.writeU8(222);
+          this.writeU16(size2);
+        } else if (size2 < 4294967296) {
+          this.writeU8(223);
+          this.writeU32(size2);
+        } else {
+          throw new Error(`Too large map object: ${size2}`);
+        }
+        for (const key of keys) {
+          const value = object[key];
+          if (!(this.ignoreUndefined && value === void 0)) {
+            this.encodeString(key);
+            this.doEncode(value, depth + 1);
+          }
+        }
+      }
+      encodeExtension(ext) {
+        if (typeof ext.data === "function") {
+          const data = ext.data(this.pos + 6);
+          const size3 = data.length;
+          if (size3 >= 4294967296) {
+            throw new Error(`Too large extension object: ${size3}`);
+          }
+          this.writeU8(201);
+          this.writeU32(size3);
+          this.writeI8(ext.type);
+          this.writeU8a(data);
+          return;
+        }
+        const size2 = ext.data.length;
+        if (size2 === 1) {
+          this.writeU8(212);
+        } else if (size2 === 2) {
+          this.writeU8(213);
+        } else if (size2 === 4) {
+          this.writeU8(214);
+        } else if (size2 === 8) {
+          this.writeU8(215);
+        } else if (size2 === 16) {
+          this.writeU8(216);
+        } else if (size2 < 256) {
+          this.writeU8(199);
+          this.writeU8(size2);
+        } else if (size2 < 65536) {
+          this.writeU8(200);
+          this.writeU16(size2);
+        } else if (size2 < 4294967296) {
+          this.writeU8(201);
+          this.writeU32(size2);
+        } else {
+          throw new Error(`Too large extension object: ${size2}`);
+        }
+        this.writeI8(ext.type);
+        this.writeU8a(ext.data);
+      }
+      writeU8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setUint8(this.pos, value);
+        this.pos++;
+      }
+      writeU8a(values) {
+        const size2 = values.length;
+        this.ensureBufferSizeToWrite(size2);
+        this.bytes.set(values, this.pos);
+        this.pos += size2;
+      }
+      writeI8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setInt8(this.pos, value);
+        this.pos++;
+      }
+      writeU16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setUint16(this.pos, value);
+        this.pos += 2;
+      }
+      writeI16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setInt16(this.pos, value);
+        this.pos += 2;
+      }
+      writeU32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setUint32(this.pos, value);
+        this.pos += 4;
+      }
+      writeI32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setInt32(this.pos, value);
+        this.pos += 4;
+      }
+      writeF32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setFloat32(this.pos, value);
+        this.pos += 4;
+      }
+      writeF64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setFloat64(this.pos, value);
+        this.pos += 8;
+      }
+      writeU64(value) {
+        this.ensureBufferSizeToWrite(8);
+        (0, int_ts_1.setUint64)(this.view, this.pos, value);
+        this.pos += 8;
+      }
+      writeI64(value) {
+        this.ensureBufferSizeToWrite(8);
+        (0, int_ts_1.setInt64)(this.view, this.pos, value);
+        this.pos += 8;
+      }
+      writeBigUint64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigUint64(this.pos, value);
+        this.pos += 8;
+      }
+      writeBigInt64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setBigInt64(this.pos, value);
+        this.pos += 8;
+      }
+    };
+    exports.Encoder = Encoder;
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/encode.cjs
+var require_encode = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/encode.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.encode = encode;
+    var Encoder_ts_1 = require_Encoder();
+    function encode(value, options) {
+      const encoder3 = new Encoder_ts_1.Encoder(options);
+      return encoder3.encodeSharedRef(value);
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/utils/prettyByte.cjs
+var require_prettyByte = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/utils/prettyByte.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.prettyByte = prettyByte;
+    function prettyByte(byte) {
+      return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`;
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/CachedKeyDecoder.cjs
+var require_CachedKeyDecoder = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/CachedKeyDecoder.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CachedKeyDecoder = void 0;
+    var utf8_ts_1 = require_utf8();
+    var DEFAULT_MAX_KEY_LENGTH = 16;
+    var DEFAULT_MAX_LENGTH_PER_KEY = 16;
+    var CachedKeyDecoder = class {
+      hit = 0;
+      miss = 0;
+      caches;
+      maxKeyLength;
+      maxLengthPerKey;
+      constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) {
+        this.maxKeyLength = maxKeyLength;
+        this.maxLengthPerKey = maxLengthPerKey;
+        this.caches = [];
+        for (let i = 0; i < this.maxKeyLength; i++) {
+          this.caches.push([]);
+        }
+      }
+      canBeCached(byteLength) {
+        return byteLength > 0 && byteLength <= this.maxKeyLength;
+      }
+      find(bytes, inputOffset, byteLength) {
+        const records = this.caches[byteLength - 1];
+        FIND_CHUNK: for (const record of records) {
+          const recordBytes = record.bytes;
+          for (let j = 0; j < byteLength; j++) {
+            if (recordBytes[j] !== bytes[inputOffset + j]) {
+              continue FIND_CHUNK;
+            }
+          }
+          return record.str;
+        }
+        return null;
+      }
+      store(bytes, value) {
+        const records = this.caches[bytes.length - 1];
+        const record = { bytes, str: value };
+        if (records.length >= this.maxLengthPerKey) {
+          records[Math.random() * records.length | 0] = record;
+        } else {
+          records.push(record);
+        }
+      }
+      decode(bytes, inputOffset, byteLength) {
+        const cachedValue = this.find(bytes, inputOffset, byteLength);
+        if (cachedValue != null) {
+          this.hit++;
+          return cachedValue;
+        }
+        this.miss++;
+        const str2 = (0, utf8_ts_1.utf8DecodeJs)(bytes, inputOffset, byteLength);
+        const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength);
+        this.store(slicedCopyOfBytes, str2);
+        return str2;
+      }
+    };
+    exports.CachedKeyDecoder = CachedKeyDecoder;
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/Decoder.cjs
+var require_Decoder = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/Decoder.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Decoder = void 0;
+    var prettyByte_ts_1 = require_prettyByte();
+    var ExtensionCodec_ts_1 = require_ExtensionCodec();
+    var int_ts_1 = require_int();
+    var utf8_ts_1 = require_utf8();
+    var typedArrays_ts_1 = require_typedArrays();
+    var CachedKeyDecoder_ts_1 = require_CachedKeyDecoder();
+    var DecodeError_ts_1 = require_DecodeError();
+    var STATE_ARRAY = "array";
+    var STATE_MAP_KEY = "map_key";
+    var STATE_MAP_VALUE = "map_value";
+    var mapKeyConverter = (key) => {
+      if (typeof key === "string" || typeof key === "number") {
+        return key;
+      }
+      throw new DecodeError_ts_1.DecodeError("The type of key must be string or number but " + typeof key);
+    };
+    var StackPool = class {
+      stack = [];
+      stackHeadPosition = -1;
+      get length() {
+        return this.stackHeadPosition + 1;
+      }
+      top() {
+        return this.stack[this.stackHeadPosition];
+      }
+      pushArrayState(size2) {
+        const state = this.getUninitializedStateFromPool();
+        state.type = STATE_ARRAY;
+        state.position = 0;
+        state.size = size2;
+        state.array = new Array(size2);
+      }
+      pushMapState(size2) {
+        const state = this.getUninitializedStateFromPool();
+        state.type = STATE_MAP_KEY;
+        state.readCount = 0;
+        state.size = size2;
+        state.map = {};
+      }
+      getUninitializedStateFromPool() {
+        this.stackHeadPosition++;
+        if (this.stackHeadPosition === this.stack.length) {
+          const partialState = {
+            type: void 0,
+            size: 0,
+            array: void 0,
+            position: 0,
+            readCount: 0,
+            map: void 0,
+            key: null
+          };
+          this.stack.push(partialState);
+        }
+        return this.stack[this.stackHeadPosition];
+      }
+      release(state) {
+        const topStackState = this.stack[this.stackHeadPosition];
+        if (topStackState !== state) {
+          throw new Error("Invalid stack state. Released state is not on top of the stack.");
+        }
+        if (state.type === STATE_ARRAY) {
+          const partialState = state;
+          partialState.size = 0;
+          partialState.array = void 0;
+          partialState.position = 0;
+          partialState.type = void 0;
+        }
+        if (state.type === STATE_MAP_KEY || state.type === STATE_MAP_VALUE) {
+          const partialState = state;
+          partialState.size = 0;
+          partialState.map = void 0;
+          partialState.readCount = 0;
+          partialState.type = void 0;
+        }
+        this.stackHeadPosition--;
+      }
+      reset() {
+        this.stack.length = 0;
+        this.stackHeadPosition = -1;
+      }
+    };
+    var HEAD_BYTE_REQUIRED = -1;
+    var EMPTY_VIEW = new DataView(new ArrayBuffer(0));
+    var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer);
+    try {
+      EMPTY_VIEW.getInt8(0);
+    } catch (e) {
+      if (!(e instanceof RangeError)) {
+        throw new Error("This module is not supported in the current JavaScript engine because DataView does not throw RangeError on out-of-bounds access");
+      }
+    }
+    var MORE_DATA = new RangeError("Insufficient data");
+    var sharedCachedKeyDecoder = new CachedKeyDecoder_ts_1.CachedKeyDecoder();
+    var Decoder = class _Decoder {
+      extensionCodec;
+      context;
+      useBigInt64;
+      rawStrings;
+      maxStrLength;
+      maxBinLength;
+      maxArrayLength;
+      maxMapLength;
+      maxExtLength;
+      keyDecoder;
+      mapKeyConverter;
+      totalPos = 0;
+      pos = 0;
+      view = EMPTY_VIEW;
+      bytes = EMPTY_BYTES;
+      headByte = HEAD_BYTE_REQUIRED;
+      stack = new StackPool();
+      entered = false;
+      constructor(options) {
+        this.extensionCodec = options?.extensionCodec ?? ExtensionCodec_ts_1.ExtensionCodec.defaultCodec;
+        this.context = options?.context;
+        this.useBigInt64 = options?.useBigInt64 ?? false;
+        this.rawStrings = options?.rawStrings ?? false;
+        this.maxStrLength = options?.maxStrLength ?? int_ts_1.UINT32_MAX;
+        this.maxBinLength = options?.maxBinLength ?? int_ts_1.UINT32_MAX;
+        this.maxArrayLength = options?.maxArrayLength ?? int_ts_1.UINT32_MAX;
+        this.maxMapLength = options?.maxMapLength ?? int_ts_1.UINT32_MAX;
+        this.maxExtLength = options?.maxExtLength ?? int_ts_1.UINT32_MAX;
+        this.keyDecoder = options?.keyDecoder !== void 0 ? options.keyDecoder : sharedCachedKeyDecoder;
+        this.mapKeyConverter = options?.mapKeyConverter ?? mapKeyConverter;
+      }
+      clone() {
+        return new _Decoder({
+          extensionCodec: this.extensionCodec,
+          context: this.context,
+          useBigInt64: this.useBigInt64,
+          rawStrings: this.rawStrings,
+          maxStrLength: this.maxStrLength,
+          maxBinLength: this.maxBinLength,
+          maxArrayLength: this.maxArrayLength,
+          maxMapLength: this.maxMapLength,
+          maxExtLength: this.maxExtLength,
+          keyDecoder: this.keyDecoder
+        });
+      }
+      reinitializeState() {
+        this.totalPos = 0;
+        this.headByte = HEAD_BYTE_REQUIRED;
+        this.stack.reset();
+      }
+      setBuffer(buffer) {
+        const bytes = (0, typedArrays_ts_1.ensureUint8Array)(buffer);
+        this.bytes = bytes;
+        this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.pos = 0;
+      }
+      appendBuffer(buffer) {
+        if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) {
+          this.setBuffer(buffer);
+        } else {
+          const remainingData = this.bytes.subarray(this.pos);
+          const newData = (0, typedArrays_ts_1.ensureUint8Array)(buffer);
+          const newBuffer = new Uint8Array(remainingData.length + newData.length);
+          newBuffer.set(remainingData);
+          newBuffer.set(newData, remainingData.length);
+          this.setBuffer(newBuffer);
+        }
+      }
+      hasRemaining(size2) {
+        return this.view.byteLength - this.pos >= size2;
+      }
+      createExtraByteError(posToShow) {
+        const { view, pos } = this;
+        return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`);
+      }
+      /**
+       * @throws {@link DecodeError}
+       * @throws {@link RangeError}
+       */
+      decode(buffer) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.decode(buffer);
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          const object = this.doDecodeSync();
+          if (this.hasRemaining(1)) {
+            throw this.createExtraByteError(this.pos);
+          }
+          return object;
+        } finally {
+          this.entered = false;
+        }
+      }
+      *decodeMulti(buffer) {
+        if (this.entered) {
+          const instance = this.clone();
+          yield* instance.decodeMulti(buffer);
+          return;
+        }
+        try {
+          this.entered = true;
+          this.reinitializeState();
+          this.setBuffer(buffer);
+          while (this.hasRemaining(1)) {
+            yield this.doDecodeSync();
+          }
+        } finally {
+          this.entered = false;
+        }
+      }
+      async decodeAsync(stream) {
+        if (this.entered) {
+          const instance = this.clone();
+          return instance.decodeAsync(stream);
+        }
+        try {
+          this.entered = true;
+          let decoded = false;
+          let object;
+          for await (const buffer of stream) {
+            if (decoded) {
+              this.entered = false;
+              throw this.createExtraByteError(this.totalPos);
+            }
+            this.appendBuffer(buffer);
+            try {
+              object = this.doDecodeSync();
+              decoded = true;
+            } catch (e) {
+              if (!(e instanceof RangeError)) {
+                throw e;
+              }
+            }
+            this.totalPos += this.pos;
+          }
+          if (decoded) {
+            if (this.hasRemaining(1)) {
+              throw this.createExtraByteError(this.totalPos);
+            }
+            return object;
+          }
+          const { headByte, pos, totalPos } = this;
+          throw new RangeError(`Insufficient data in parsing ${(0, prettyByte_ts_1.prettyByte)(headByte)} at ${totalPos} (${pos} in the current buffer)`);
+        } finally {
+          this.entered = false;
+        }
+      }
+      decodeArrayStream(stream) {
+        return this.decodeMultiAsync(stream, true);
+      }
+      decodeStream(stream) {
+        return this.decodeMultiAsync(stream, false);
+      }
+      async *decodeMultiAsync(stream, isArray) {
+        if (this.entered) {
+          const instance = this.clone();
+          yield* instance.decodeMultiAsync(stream, isArray);
+          return;
+        }
+        try {
+          this.entered = true;
+          let isArrayHeaderRequired = isArray;
+          let arrayItemsLeft = -1;
+          for await (const buffer of stream) {
+            if (isArray && arrayItemsLeft === 0) {
+              throw this.createExtraByteError(this.totalPos);
+            }
+            this.appendBuffer(buffer);
+            if (isArrayHeaderRequired) {
+              arrayItemsLeft = this.readArraySize();
+              isArrayHeaderRequired = false;
+              this.complete();
+            }
+            try {
+              while (true) {
+                yield this.doDecodeSync();
+                if (--arrayItemsLeft === 0) {
+                  break;
+                }
+              }
+            } catch (e) {
+              if (!(e instanceof RangeError)) {
+                throw e;
+              }
+            }
+            this.totalPos += this.pos;
+          }
+        } finally {
+          this.entered = false;
+        }
+      }
+      doDecodeSync() {
+        DECODE: while (true) {
+          const headByte = this.readHeadByte();
+          let object;
+          if (headByte >= 224) {
+            object = headByte - 256;
+          } else if (headByte < 192) {
+            if (headByte < 128) {
+              object = headByte;
+            } else if (headByte < 144) {
+              const size2 = headByte - 128;
+              if (size2 !== 0) {
+                this.pushMapState(size2);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = {};
+              }
+            } else if (headByte < 160) {
+              const size2 = headByte - 144;
+              if (size2 !== 0) {
+                this.pushArrayState(size2);
+                this.complete();
+                continue DECODE;
+              } else {
+                object = [];
+              }
+            } else {
+              const byteLength = headByte - 160;
+              object = this.decodeString(byteLength, 0);
+            }
+          } else if (headByte === 192) {
+            object = null;
+          } else if (headByte === 194) {
+            object = false;
+          } else if (headByte === 195) {
+            object = true;
+          } else if (headByte === 202) {
+            object = this.readF32();
+          } else if (headByte === 203) {
+            object = this.readF64();
+          } else if (headByte === 204) {
+            object = this.readU8();
+          } else if (headByte === 205) {
+            object = this.readU16();
+          } else if (headByte === 206) {
+            object = this.readU32();
+          } else if (headByte === 207) {
+            if (this.useBigInt64) {
+              object = this.readU64AsBigInt();
+            } else {
+              object = this.readU64();
+            }
+          } else if (headByte === 208) {
+            object = this.readI8();
+          } else if (headByte === 209) {
+            object = this.readI16();
+          } else if (headByte === 210) {
+            object = this.readI32();
+          } else if (headByte === 211) {
+            if (this.useBigInt64) {
+              object = this.readI64AsBigInt();
+            } else {
+              object = this.readI64();
+            }
+          } else if (headByte === 217) {
+            const byteLength = this.lookU8();
+            object = this.decodeString(byteLength, 1);
+          } else if (headByte === 218) {
+            const byteLength = this.lookU16();
+            object = this.decodeString(byteLength, 2);
+          } else if (headByte === 219) {
+            const byteLength = this.lookU32();
+            object = this.decodeString(byteLength, 4);
+          } else if (headByte === 220) {
+            const size2 = this.readU16();
+            if (size2 !== 0) {
+              this.pushArrayState(size2);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 221) {
+            const size2 = this.readU32();
+            if (size2 !== 0) {
+              this.pushArrayState(size2);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = [];
+            }
+          } else if (headByte === 222) {
+            const size2 = this.readU16();
+            if (size2 !== 0) {
+              this.pushMapState(size2);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 223) {
+            const size2 = this.readU32();
+            if (size2 !== 0) {
+              this.pushMapState(size2);
+              this.complete();
+              continue DECODE;
+            } else {
+              object = {};
+            }
+          } else if (headByte === 196) {
+            const size2 = this.lookU8();
+            object = this.decodeBinary(size2, 1);
+          } else if (headByte === 197) {
+            const size2 = this.lookU16();
+            object = this.decodeBinary(size2, 2);
+          } else if (headByte === 198) {
+            const size2 = this.lookU32();
+            object = this.decodeBinary(size2, 4);
+          } else if (headByte === 212) {
+            object = this.decodeExtension(1, 0);
+          } else if (headByte === 213) {
+            object = this.decodeExtension(2, 0);
+          } else if (headByte === 214) {
+            object = this.decodeExtension(4, 0);
+          } else if (headByte === 215) {
+            object = this.decodeExtension(8, 0);
+          } else if (headByte === 216) {
+            object = this.decodeExtension(16, 0);
+          } else if (headByte === 199) {
+            const size2 = this.lookU8();
+            object = this.decodeExtension(size2, 1);
+          } else if (headByte === 200) {
+            const size2 = this.lookU16();
+            object = this.decodeExtension(size2, 2);
+          } else if (headByte === 201) {
+            const size2 = this.lookU32();
+            object = this.decodeExtension(size2, 4);
+          } else {
+            throw new DecodeError_ts_1.DecodeError(`Unrecognized type byte: ${(0, prettyByte_ts_1.prettyByte)(headByte)}`);
+          }
+          this.complete();
+          const stack = this.stack;
+          while (stack.length > 0) {
+            const state = stack.top();
+            if (state.type === STATE_ARRAY) {
+              state.array[state.position] = object;
+              state.position++;
+              if (state.position === state.size) {
+                object = state.array;
+                stack.release(state);
+              } else {
+                continue DECODE;
+              }
+            } else if (state.type === STATE_MAP_KEY) {
+              if (object === "__proto__") {
+                throw new DecodeError_ts_1.DecodeError("The key __proto__ is not allowed");
+              }
+              state.key = this.mapKeyConverter(object);
+              state.type = STATE_MAP_VALUE;
+              continue DECODE;
+            } else {
+              state.map[state.key] = object;
+              state.readCount++;
+              if (state.readCount === state.size) {
+                object = state.map;
+                stack.release(state);
+              } else {
+                state.key = null;
+                state.type = STATE_MAP_KEY;
+                continue DECODE;
+              }
+            }
+          }
+          return object;
+        }
+      }
+      readHeadByte() {
+        if (this.headByte === HEAD_BYTE_REQUIRED) {
+          this.headByte = this.readU8();
+        }
+        return this.headByte;
+      }
+      complete() {
+        this.headByte = HEAD_BYTE_REQUIRED;
+      }
+      readArraySize() {
+        const headByte = this.readHeadByte();
+        switch (headByte) {
+          case 220:
+            return this.readU16();
+          case 221:
+            return this.readU32();
+          default: {
+            if (headByte < 160) {
+              return headByte - 144;
+            } else {
+              throw new DecodeError_ts_1.DecodeError(`Unrecognized array type byte: ${(0, prettyByte_ts_1.prettyByte)(headByte)}`);
+            }
+          }
+        }
+      }
+      pushMapState(size2) {
+        if (size2 > this.maxMapLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: map length (${size2}) > maxMapLengthLength (${this.maxMapLength})`);
+        }
+        this.stack.pushMapState(size2);
+      }
+      pushArrayState(size2) {
+        if (size2 > this.maxArrayLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: array length (${size2}) > maxArrayLength (${this.maxArrayLength})`);
+        }
+        this.stack.pushArrayState(size2);
+      }
+      decodeString(byteLength, headerOffset) {
+        if (!this.rawStrings || this.stateIsMapKey()) {
+          return this.decodeUtf8String(byteLength, headerOffset);
+        }
+        return this.decodeBinary(byteLength, headerOffset);
+      }
+      /**
+       * @throws {@link RangeError}
+       */
+      decodeUtf8String(byteLength, headerOffset) {
+        if (byteLength > this.maxStrLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`);
+        }
+        if (this.bytes.byteLength < this.pos + headerOffset + byteLength) {
+          throw MORE_DATA;
+        }
+        const offset = this.pos + headerOffset;
+        let object;
+        if (this.stateIsMapKey() && this.keyDecoder?.canBeCached(byteLength)) {
+          object = this.keyDecoder.decode(this.bytes, offset, byteLength);
+        } else {
+          object = (0, utf8_ts_1.utf8Decode)(this.bytes, offset, byteLength);
+        }
+        this.pos += headerOffset + byteLength;
+        return object;
+      }
+      stateIsMapKey() {
+        if (this.stack.length > 0) {
+          const state = this.stack.top();
+          return state.type === STATE_MAP_KEY;
+        }
+        return false;
+      }
+      /**
+       * @throws {@link RangeError}
+       */
+      decodeBinary(byteLength, headOffset) {
+        if (byteLength > this.maxBinLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`);
+        }
+        if (!this.hasRemaining(byteLength + headOffset)) {
+          throw MORE_DATA;
+        }
+        const offset = this.pos + headOffset;
+        const object = this.bytes.subarray(offset, offset + byteLength);
+        this.pos += headOffset + byteLength;
+        return object;
+      }
+      decodeExtension(size2, headOffset) {
+        if (size2 > this.maxExtLength) {
+          throw new DecodeError_ts_1.DecodeError(`Max length exceeded: ext length (${size2}) > maxExtLength (${this.maxExtLength})`);
+        }
+        const extType = this.view.getInt8(this.pos + headOffset);
+        const data = this.decodeBinary(
+          size2,
+          headOffset + 1
+          /* extType */
+        );
+        return this.extensionCodec.decode(data, extType, this.context);
+      }
+      lookU8() {
+        return this.view.getUint8(this.pos);
+      }
+      lookU16() {
+        return this.view.getUint16(this.pos);
+      }
+      lookU32() {
+        return this.view.getUint32(this.pos);
+      }
+      readU8() {
+        const value = this.view.getUint8(this.pos);
+        this.pos++;
+        return value;
+      }
+      readI8() {
+        const value = this.view.getInt8(this.pos);
+        this.pos++;
+        return value;
+      }
+      readU16() {
+        const value = this.view.getUint16(this.pos);
+        this.pos += 2;
+        return value;
+      }
+      readI16() {
+        const value = this.view.getInt16(this.pos);
+        this.pos += 2;
+        return value;
+      }
+      readU32() {
+        const value = this.view.getUint32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readI32() {
+        const value = this.view.getInt32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readU64() {
+        const value = (0, int_ts_1.getUint64)(this.view, this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readI64() {
+        const value = (0, int_ts_1.getInt64)(this.view, this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readU64AsBigInt() {
+        const value = this.view.getBigUint64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readI64AsBigInt() {
+        const value = this.view.getBigInt64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+      readF32() {
+        const value = this.view.getFloat32(this.pos);
+        this.pos += 4;
+        return value;
+      }
+      readF64() {
+        const value = this.view.getFloat64(this.pos);
+        this.pos += 8;
+        return value;
+      }
+    };
+    exports.Decoder = Decoder;
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/decode.cjs
+var require_decode = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/decode.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decode = decode;
+    exports.decodeMulti = decodeMulti;
+    var Decoder_ts_1 = require_Decoder();
+    function decode(buffer, options) {
+      const decoder = new Decoder_ts_1.Decoder(options);
+      return decoder.decode(buffer);
+    }
+    function decodeMulti(buffer, options) {
+      const decoder = new Decoder_ts_1.Decoder(options);
+      return decoder.decodeMulti(buffer);
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/utils/stream.cjs
+var require_stream = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/utils/stream.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isAsyncIterable = isAsyncIterable;
+    exports.asyncIterableFromStream = asyncIterableFromStream;
+    exports.ensureAsyncIterable = ensureAsyncIterable;
+    function isAsyncIterable(object) {
+      return object[Symbol.asyncIterator] != null;
+    }
+    async function* asyncIterableFromStream(stream) {
+      const reader = stream.getReader();
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            return;
+          }
+          yield value;
         }
+      } finally {
+        reader.releaseLock();
       }
-    }, sha256);
-    TAGGED_HASH_PREFIXES = {};
-    pointToBytes = (point) => point.toRawBytes(true).slice(1);
-    numTo32b = (n) => numberToBytesBE(n, 32);
-    modP = (x) => mod(x, secp256k1P);
-    modN = (x) => mod(x, secp256k1N);
-    Point = /* @__PURE__ */ (() => secp256k1.ProjectivePoint)();
-    GmulAdd = (Q, a, b) => Point.BASE.multiplyAndAddUnsafe(Q, a, b);
-    num = bytesToNumberBE;
-    schnorr = /* @__PURE__ */ (() => ({
-      getPublicKey: schnorrGetPublicKey,
-      sign: schnorrSign,
-      verify: schnorrVerify,
-      utils: {
-        randomPrivateKey: secp256k1.utils.randomPrivateKey,
-        lift_x,
-        pointToBytes,
-        numberToBytesBE,
-        bytesToNumberBE,
-        taggedHash,
-        mod
+    }
+    function ensureAsyncIterable(streamLike) {
+      if (isAsyncIterable(streamLike)) {
+        return streamLike;
+      } else {
+        return asyncIterableFromStream(streamLike);
       }
-    }))();
-    isoMap = /* @__PURE__ */ (() => isogenyMap(Fpk1, [
-      // xNum
-      [
-        "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7",
-        "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581",
-        "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262",
-        "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"
-      ],
-      // xDen
-      [
-        "0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b",
-        "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14",
-        "0x0000000000000000000000000000000000000000000000000000000000000001"
-        // LAST 1
-      ],
-      // yNum
-      [
-        "0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c",
-        "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3",
-        "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931",
-        "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"
-      ],
-      // yDen
-      [
-        "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b",
-        "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573",
-        "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f",
-        "0x0000000000000000000000000000000000000000000000000000000000000001"
-        // LAST 1
-      ]
-    ].map((i) => i.map((j) => BigInt(j)))))();
-    mapSWU = /* @__PURE__ */ (() => mapToCurveSimpleSWU(Fpk1, {
-      A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"),
-      B: BigInt("1771"),
-      Z: Fpk1.create(BigInt("-11"))
-    }))();
-    secp256k1_hasher = /* @__PURE__ */ (() => createHasher2(secp256k1.ProjectivePoint, (scalars) => {
-      const { x, y } = mapSWU(Fpk1.create(scalars[0]));
-      return isoMap(x, y);
-    }, {
-      DST: "secp256k1_XMD:SHA-256_SSWU_RO_",
-      encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_",
-      p: Fpk1.ORDER,
-      m: 1,
-      k: 128,
-      expand: "xmd",
-      hash: sha256
-    }))();
-    hashToCurve = /* @__PURE__ */ (() => secp256k1_hasher.hashToCurve)();
-    encodeToCurve = /* @__PURE__ */ (() => secp256k1_hasher.encodeToCurve)();
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/decodeAsync.cjs
+var require_decodeAsync = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/decodeAsync.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decodeAsync = decodeAsync;
+    exports.decodeArrayStream = decodeArrayStream;
+    exports.decodeMultiStream = decodeMultiStream;
+    var Decoder_ts_1 = require_Decoder();
+    var stream_ts_1 = require_stream();
+    async function decodeAsync(streamLike, options) {
+      const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+      const decoder = new Decoder_ts_1.Decoder(options);
+      return decoder.decodeAsync(stream);
+    }
+    function decodeArrayStream(streamLike, options) {
+      const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+      const decoder = new Decoder_ts_1.Decoder(options);
+      return decoder.decodeArrayStream(stream);
+    }
+    function decodeMultiStream(streamLike, options) {
+      const stream = (0, stream_ts_1.ensureAsyncIterable)(streamLike);
+      const decoder = new Decoder_ts_1.Decoder(options);
+      return decoder.decodeStream(stream);
+    }
+  }
+});
+
+// ../../node_modules/@msgpack/msgpack/dist.cjs/index.cjs
+var require_dist = __commonJS({
+  "../../node_modules/@msgpack/msgpack/dist.cjs/index.cjs"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decodeTimestampExtension = exports.encodeTimestampExtension = exports.decodeTimestampToTimeSpec = exports.encodeTimeSpecToTimestamp = exports.encodeDateToTimeSpec = exports.EXT_TIMESTAMP = exports.ExtData = exports.ExtensionCodec = exports.Encoder = exports.DecodeError = exports.Decoder = exports.decodeMultiStream = exports.decodeArrayStream = exports.decodeAsync = exports.decodeMulti = exports.decode = exports.encode = void 0;
+    var encode_ts_1 = require_encode();
+    Object.defineProperty(exports, "encode", { enumerable: true, get: function() {
+      return encode_ts_1.encode;
+    } });
+    var decode_ts_1 = require_decode();
+    Object.defineProperty(exports, "decode", { enumerable: true, get: function() {
+      return decode_ts_1.decode;
+    } });
+    Object.defineProperty(exports, "decodeMulti", { enumerable: true, get: function() {
+      return decode_ts_1.decodeMulti;
+    } });
+    var decodeAsync_ts_1 = require_decodeAsync();
+    Object.defineProperty(exports, "decodeAsync", { enumerable: true, get: function() {
+      return decodeAsync_ts_1.decodeAsync;
+    } });
+    Object.defineProperty(exports, "decodeArrayStream", { enumerable: true, get: function() {
+      return decodeAsync_ts_1.decodeArrayStream;
+    } });
+    Object.defineProperty(exports, "decodeMultiStream", { enumerable: true, get: function() {
+      return decodeAsync_ts_1.decodeMultiStream;
+    } });
+    var Decoder_ts_1 = require_Decoder();
+    Object.defineProperty(exports, "Decoder", { enumerable: true, get: function() {
+      return Decoder_ts_1.Decoder;
+    } });
+    var DecodeError_ts_1 = require_DecodeError();
+    Object.defineProperty(exports, "DecodeError", { enumerable: true, get: function() {
+      return DecodeError_ts_1.DecodeError;
+    } });
+    var Encoder_ts_1 = require_Encoder();
+    Object.defineProperty(exports, "Encoder", { enumerable: true, get: function() {
+      return Encoder_ts_1.Encoder;
+    } });
+    var ExtensionCodec_ts_1 = require_ExtensionCodec();
+    Object.defineProperty(exports, "ExtensionCodec", { enumerable: true, get: function() {
+      return ExtensionCodec_ts_1.ExtensionCodec;
+    } });
+    var ExtData_ts_1 = require_ExtData();
+    Object.defineProperty(exports, "ExtData", { enumerable: true, get: function() {
+      return ExtData_ts_1.ExtData;
+    } });
+    var timestamp_ts_1 = require_timestamp();
+    Object.defineProperty(exports, "EXT_TIMESTAMP", { enumerable: true, get: function() {
+      return timestamp_ts_1.EXT_TIMESTAMP;
+    } });
+    Object.defineProperty(exports, "encodeDateToTimeSpec", { enumerable: true, get: function() {
+      return timestamp_ts_1.encodeDateToTimeSpec;
+    } });
+    Object.defineProperty(exports, "encodeTimeSpecToTimestamp", { enumerable: true, get: function() {
+      return timestamp_ts_1.encodeTimeSpecToTimestamp;
+    } });
+    Object.defineProperty(exports, "decodeTimestampToTimeSpec", { enumerable: true, get: function() {
+      return timestamp_ts_1.decodeTimestampToTimeSpec;
+    } });
+    Object.defineProperty(exports, "encodeTimestampExtension", { enumerable: true, get: function() {
+      return timestamp_ts_1.encodeTimestampExtension;
+    } });
+    Object.defineProperty(exports, "decodeTimestampExtension", { enumerable: true, get: function() {
+      return timestamp_ts_1.decodeTimestampExtension;
+    } });
   }
 });
 
@@ -4455,7 +6610,7 @@ var init_secp256k1 = __esm({
 import "dotenv/config";
 import { promises as fs4 } from "node:fs";
 import { descriptions } from "@vultisig/client-shared";
-import { Chain as Chain13, parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
+import { Chain as Chain14, parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
 import chalk16 from "chalk";
 import { InvalidArgumentError, program as program2 } from "commander";
 
@@ -6993,8 +9148,19 @@ async function previewDryRun(vault, params, dryResult, to) {
     ...warnings.length > 0 ? { warning: warnings.join(". ") } : {}
   };
   if (isJsonOutput()) {
-    outputJson(result);
-    return result;
+    if (params.amount !== "max") {
+      outputJson(result);
+      return result;
+    }
+    const decimals = dryResult.keysignPayload.coin?.decimals;
+    if (decimals === void 0) throw new Error("Prepared transaction is missing coin decimals");
+    const jsonResult = {
+      ...result,
+      amount: formatBigintAmount(BigInt(dryResult.keysignPayload.toAmount), decimals),
+      isMax: true
+    };
+    outputJson(jsonResult);
+    return jsonResult;
   }
   info(`
 Dry-run preview:`);
@@ -8548,12 +10714,233 @@ async function recoverAddress({ hash, signature }) {
   return publicKeyToAddress(await recoverPublicKey({ hash, signature }));
 }
 
+// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
+init_encodeAbiParameters();
+init_concat();
+init_toHex();
+init_keccak256();
+
+// ../../node_modules/viem/_esm/utils/typedData.js
+init_abi();
+init_address();
+
+// ../../node_modules/viem/_esm/errors/typedData.js
+init_stringify();
+init_base();
+var InvalidDomainError = class extends BaseError {
+  constructor({ domain }) {
+    super(`Invalid domain "${stringify(domain)}".`, {
+      metaMessages: ["Must be a valid EIP-712 domain."]
+    });
+  }
+};
+var InvalidPrimaryTypeError = class extends BaseError {
+  constructor({ primaryType, types }) {
+    super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
+      docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
+      metaMessages: ["Check that the primary type is a key in `types`."]
+    });
+  }
+};
+var InvalidStructTypeError = class extends BaseError {
+  constructor({ type }) {
+    super(`Struct type "${type}" is invalid.`, {
+      metaMessages: ["Struct type must not be a Solidity type."],
+      name: "InvalidStructTypeError"
+    });
+  }
+};
+
+// ../../node_modules/viem/_esm/utils/typedData.js
+init_isAddress();
+init_size();
+init_toHex();
+init_regex();
+function validateTypedData(parameters) {
+  const { domain, message, primaryType, types } = parameters;
+  const validateData = (struct, data) => {
+    for (const param of struct) {
+      const { name, type } = param;
+      const value = data[name];
+      const integerMatch = type.match(integerRegex);
+      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
+        const [_type, base, size_] = integerMatch;
+        numberToHex(value, {
+          signed: base === "int",
+          size: Number.parseInt(size_, 10) / 8
+        });
+      }
+      if (type === "address" && typeof value === "string" && !isAddress(value))
+        throw new InvalidAddressError2({ address: value });
+      const bytesMatch = type.match(bytesRegex);
+      if (bytesMatch) {
+        const [_type, size_] = bytesMatch;
+        if (size_ && size(value) !== Number.parseInt(size_, 10))
+          throw new BytesSizeMismatchError({
+            expectedSize: Number.parseInt(size_, 10),
+            givenSize: size(value)
+          });
+      }
+      const struct2 = types[type];
+      if (struct2) {
+        validateReference(type);
+        validateData(struct2, value);
+      }
+    }
+  };
+  if (types.EIP712Domain && domain) {
+    if (typeof domain !== "object")
+      throw new InvalidDomainError({ domain });
+    validateData(types.EIP712Domain, domain);
+  }
+  if (primaryType !== "EIP712Domain") {
+    if (types[primaryType])
+      validateData(types[primaryType], message);
+    else
+      throw new InvalidPrimaryTypeError({ primaryType, types });
+  }
+}
+function getTypesForEIP712Domain({ domain }) {
+  return [
+    typeof domain?.name === "string" && { name: "name", type: "string" },
+    domain?.version && { name: "version", type: "string" },
+    (typeof domain?.chainId === "number" || typeof domain?.chainId === "bigint") && {
+      name: "chainId",
+      type: "uint256"
+    },
+    domain?.verifyingContract && {
+      name: "verifyingContract",
+      type: "address"
+    },
+    domain?.salt && { name: "salt", type: "bytes32" }
+  ].filter(Boolean);
+}
+function validateReference(type) {
+  if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
+    throw new InvalidStructTypeError({ type });
+}
+
+// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
+function hashTypedData(parameters) {
+  const { domain = {}, message, primaryType } = parameters;
+  const types = {
+    EIP712Domain: getTypesForEIP712Domain({ domain }),
+    ...parameters.types
+  };
+  validateTypedData({
+    domain,
+    message,
+    primaryType,
+    types
+  });
+  const parts = ["0x1901"];
+  if (domain)
+    parts.push(hashDomain({
+      domain,
+      types
+    }));
+  if (primaryType !== "EIP712Domain")
+    parts.push(hashStruct({
+      data: message,
+      primaryType,
+      types
+    }));
+  return keccak256(concat(parts));
+}
+function hashDomain({ domain, types }) {
+  return hashStruct({
+    data: domain,
+    primaryType: "EIP712Domain",
+    types
+  });
+}
+function hashStruct({ data, primaryType, types }) {
+  const encoded = encodeData({
+    data,
+    primaryType,
+    types
+  });
+  return keccak256(encoded);
+}
+function encodeData({ data, primaryType, types }) {
+  const encodedTypes = [{ type: "bytes32" }];
+  const encodedValues = [hashType({ primaryType, types })];
+  for (const field of types[primaryType]) {
+    const [type, value] = encodeField({
+      types,
+      name: field.name,
+      type: field.type,
+      value: data[field.name]
+    });
+    encodedTypes.push(type);
+    encodedValues.push(value);
+  }
+  return encodeAbiParameters(encodedTypes, encodedValues);
+}
+function hashType({ primaryType, types }) {
+  const encodedHashType = toHex(encodeType({ primaryType, types }));
+  return keccak256(encodedHashType);
+}
+function encodeType({ primaryType, types }) {
+  let result = "";
+  const unsortedDeps = findTypeDependencies({ primaryType, types });
+  unsortedDeps.delete(primaryType);
+  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
+  for (const type of deps) {
+    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
+  }
+  return result;
+}
+function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
+  const match = primaryType_.match(/^\w*/u);
+  const primaryType = match?.[0];
+  if (results.has(primaryType) || types[primaryType] === void 0) {
+    return results;
+  }
+  results.add(primaryType);
+  for (const field of types[primaryType]) {
+    findTypeDependencies({ primaryType: field.type, types }, results);
+  }
+  return results;
+}
+function encodeField({ types, name, type, value }) {
+  if (types[type] !== void 0) {
+    return [
+      { type: "bytes32" },
+      keccak256(encodeData({ data: value, primaryType: type, types }))
+    ];
+  }
+  if (type === "bytes")
+    return [{ type: "bytes32" }, keccak256(value)];
+  if (type === "string")
+    return [{ type: "bytes32" }, keccak256(toHex(value))];
+  if (type.lastIndexOf("]") === type.length - 1) {
+    const parsedType = type.slice(0, type.lastIndexOf("["));
+    const typeValuePairs = value.map((item) => encodeField({
+      name,
+      type: parsedType,
+      types,
+      value: item
+    }));
+    return [
+      { type: "bytes32" },
+      keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
+    ];
+  }
+  return [{ type }, value];
+}
+
 // ../../node_modules/viem/_esm/utils/unit/formatUnits.js
 init_Value();
 function formatUnits(value, decimals) {
   return format(value, decimals);
 }
 
+// ../../node_modules/viem/_esm/index.js
+init_concat();
+init_toBytes();
+init_keccak256();
+
 // src/commands/swap.ts
 async function executeSwapChains(ctx2) {
   const vault = await ctx2.ensureActiveVault();
@@ -8583,8 +10970,8 @@ async function executeSwapQuote(ctx2, options) {
   if (!result.dryRun) throw new Error("unreachable");
   spinner.succeed("Quote received");
   const quote = result.quote;
-  const semanticAmount = isMax ? amount : normalizeSwapAmount(amount, quote.fromCoin.decimals);
-  const fromAmountDisplay = isMax ? `${formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals)} (max)` : semanticAmount;
+  const semanticAmount = isMax ? formatBigintAmount(quote.maxSwapable, quote.fromCoin.decimals) : normalizeSwapAmount(amount, quote.fromCoin.decimals);
+  const fromAmountDisplay = isMax ? `${semanticAmount} (max)` : semanticAmount;
   if (isJsonOutput()) {
     outputJson({
       fromChain: options.fromChain,
@@ -9310,6 +11697,14 @@ var AskInterface = class {
       onBalanceSummary: (card) => {
         this.cards.push(card);
       },
+      onHlOrderConfirmation: (card) => {
+        this.cards.push(card);
+        this.outcome = {
+          kind: "blocked",
+          code: "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */,
+          detail: "Explicit approval is required before signing this Hyperliquid order."
+        };
+      },
       onYieldOpportunities: (card) => {
         this.yieldCards.push(card);
       },
@@ -9317,6 +11712,9 @@ var AskInterface = class {
         this.polymarketCards.push(card);
       },
       onTurnOutcome: (outcome) => {
+        if (this.outcome?.kind === "blocked" && this.outcome.code === "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */) {
+          return;
+        }
         this.outcome = outcome;
       },
       onProposedTransaction: (proposed) => {
@@ -9773,10 +12171,11 @@ import { getChainKind as getChainKind4 } from "@vultisig/sdk";
 
 // src/agent/executor.ts
 import {
-  Chain as Chain10,
+  Chain as Chain11,
   chainFeeCoin as chainFeeCoin2,
   computeEip712Hash,
   getChainKind as getChainKind3,
+  getEvmRpcUrl,
   parseThorSwapMemo,
   resolveChainReference,
   toCanonicalEvmSignature,
@@ -9940,6 +12339,234 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// src/agent/hlOrder.ts
+var import_msgpack = __toESM(require_dist(), 1);
+import { Chain as Chain10 } from "@vultisig/sdk";
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var HL_AGENT_TYPES = {
+  Agent: [
+    { name: "source", type: "string" },
+    { name: "connectionId", type: "bytes32" }
+  ]
+};
+function isExactStringMember(value, allowed) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function nonceBytes(nonce) {
+  if (!Number.isSafeInteger(nonce) || nonce < 0) throw new Error("HL_INVALID_NONCE");
+  const bytes = new Uint8Array(8);
+  let value = BigInt(nonce);
+  for (let i = 7; i >= 0; i--) {
+    bytes[i] = Number(value & 0xffn);
+    value >>= 8n;
+  }
+  return bytes;
+}
+function vaultMarker(vaultAddress) {
+  if (!vaultAddress) return new Uint8Array([0]);
+  if (!/^0x[0-9a-f]{40}$/i.test(vaultAddress)) throw new Error("HL_INVALID_VAULT_ADDRESS");
+  return concat([new Uint8Array([1]), hexToBytes(vaultAddress)]);
+}
+function computeHlDigest(step) {
+  const packed = (0, import_msgpack.encode)(step.action, { forceIntegerToFloat: false });
+  const connectionId = keccak256(concat([packed, nonceBytes(step.nonce), vaultMarker(step.vault_address)]));
+  return hashTypedData({
+    domain: {
+      name: "Exchange",
+      version: "1",
+      chainId: 1337,
+      verifyingContract: ZERO_ADDRESS
+    },
+    types: HL_AGENT_TYPES,
+    primaryType: "Agent",
+    message: { source: step.is_mainnet ? "a" : "b", connectionId }
+  });
+}
+function hasExactObjectKeys(value, allowed) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  const keys = Object.keys(value);
+  return keys.length === allowed.length && keys.every((key) => allowed.includes(key));
+}
+function isPlainRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function validateOrderAction(action, summary) {
+  if (!hasExactObjectKeys(action, ["type", "orders", "grouping"])) throw new Error("HL_INVALID_ORDER_ACTION_SCHEMA");
+  if (typeof summary.coin !== "string" || !summary.coin.trim()) throw new Error("HL_INVALID_COIN");
+  if (!Number.isInteger(summary.asset_index)) throw new Error("HL_INVALID_ASSET_INDEX");
+  if (!isExactStringMember(action.type, ["order"]) || !Array.isArray(action.orders) || action.orders.length !== 1) {
+    throw new Error("HL_INVALID_ORDER_ACTION");
+  }
+  if (!isExactStringMember(action.grouping, ["na"])) throw new Error("HL_INVALID_ORDER_GROUPING");
+  const order = action.orders[0];
+  if (!hasExactObjectKeys(order, ["a", "b", "p", "r", "s", "t"])) throw new Error("HL_INVALID_ORDER_SCHEMA");
+  if (!Number.isInteger(order.a) || typeof order.b !== "boolean") throw new Error("HL_INVALID_ORDER_ACTION");
+  if (order.a !== summary.asset_index) throw new Error("HL_ASSET_MISMATCH");
+  if (typeof order.p !== "string" || !Number.isFinite(Number(order.p)) || Number(order.p) <= 0) {
+    throw new Error("HL_INVALID_ORDER_PRICE");
+  }
+  if (typeof order.s !== "string" || !Number.isFinite(Number(order.s)) || Number(order.s) <= 0) {
+    throw new Error("HL_INVALID_ORDER_SIZE");
+  }
+  if (summary.size !== order.s) {
+    throw new Error("HL_ORDER_SIZE_MISMATCH");
+  }
+  if (summary.notional_usd !== multiplyDecimalStrings(order.p, order.s)) {
+    throw new Error("HL_INVALID_ORDER_NOTIONAL");
+  }
+  if (summary.price_cap !== order.p) throw new Error("HL_ORDER_PRICE_CAP_MISMATCH");
+  if (!hasExactObjectKeys(order.t, ["limit"])) throw new Error("HL_INVALID_ORDER_TYPE_SCHEMA");
+  const limit = order.t.limit;
+  if (!hasExactObjectKeys(limit, ["tif"])) throw new Error("HL_INVALID_LIMIT_SCHEMA");
+  const tif = limit.tif;
+  if (!isExactStringMember(tif, ["Ioc", "Gtc", "Alo"]) || tif !== summary.tif) throw new Error("HL_TIF_MISMATCH");
+  const expectedOrderType = tif === "Ioc" ? "market" : "limit";
+  if (summary.order_type !== expectedOrderType) throw new Error("HL_ORDER_TYPE_MISMATCH");
+  if (summary.limit_price !== (expectedOrderType === "limit" ? order.p : null))
+    throw new Error("HL_LIMIT_PRICE_MISMATCH");
+  if (order.r !== summary.reduce_only) throw new Error("HL_REDUCE_ONLY_MISMATCH");
+  if (summary.operation === "close" && order.r !== true) throw new Error("HL_CLOSE_NOT_REDUCE_ONLY");
+  const expectedBuy = summary.operation === "open" ? summary.side === "long" : summary.side === "short";
+  if (order.b !== expectedBuy) throw new Error("HL_ORDER_SIDE_MISMATCH");
+}
+function multiplyDecimalStrings(left, right) {
+  const parse = (value) => {
+    if (typeof value !== "string" || !/^\d+(?:\.\d+)?$/.test(value)) throw new Error("HL_INVALID_DECIMAL");
+    const [whole2, fraction2 = ""] = value.split(".");
+    return { digits: BigInt(`${whole2}${fraction2}`), scale: fraction2.length };
+  };
+  const a = parse(left);
+  const b = parse(right);
+  const scale = a.scale + b.scale;
+  const raw = (a.digits * b.digits).toString().padStart(scale + 1, "0");
+  if (scale === 0) return raw;
+  const whole = raw.slice(0, -scale);
+  const fraction = raw.slice(-scale).replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole;
+}
+function validateLeverageAction(action, summary) {
+  if (!hasExactObjectKeys(action, ["type", "asset", "isCross", "leverage"]))
+    throw new Error("HL_INVALID_LEVERAGE_ACTION_SCHEMA");
+  if (!isExactStringMember(action.type, ["updateLeverage"]) || !Number.isInteger(action.asset) || !Number.isInteger(action.leverage)) {
+    throw new Error("HL_INVALID_LEVERAGE_ACTION");
+  }
+  if (typeof action.isCross !== "boolean" || action.leverage !== summary.leverage) {
+    throw new Error("HL_LEVERAGE_MISMATCH");
+  }
+  if (action.asset !== summary.asset_index) throw new Error("HL_LEVERAGE_ASSET_MISMATCH");
+  if (action.leverage < 1 || action.leverage > 100) {
+    throw new Error("HL_INVALID_LEVERAGE");
+  }
+  const expectedCross = summary.margin_mode !== "isolated";
+  if (action.isCross !== expectedCross) throw new Error("HL_MARGIN_MODE_MISMATCH");
+}
+function validatePayloadShape(payload) {
+  if (!isPlainRecord(payload)) throw new Error("HL_INVALID_PAYLOAD");
+  if (!isPlainRecord(payload.summary)) throw new Error("HL_INVALID_SUMMARY");
+  if (!isPlainRecord(payload.asset_binding)) throw new Error("HL_INVALID_ASSET_BINDING");
+  if (!Array.isArray(payload.steps)) throw new Error("HL_INVALID_STEPS");
+  for (const key of ["operation", "side", "margin_mode", "reduce_only", "leverage"]) {
+    if (key in payload) throw new Error("HL_CONFLICTING_TOP_LEVEL_FIELD");
+  }
+}
+function validateSummary(summary) {
+  if (!isExactStringMember(summary.operation, ["open", "close"])) throw new Error("HL_INVALID_OPERATION");
+  if (!isExactStringMember(summary.side, ["long", "short"])) throw new Error("HL_INVALID_SIDE");
+  if (!isExactStringMember(summary.order_type, ["market", "limit"])) throw new Error("HL_INVALID_ORDER_TYPE");
+  if (!isExactStringMember(summary.tif, ["Ioc", "Gtc", "Alo"])) throw new Error("HL_INVALID_TIF");
+  if (typeof summary.coin !== "string" || !summary.coin.trim()) throw new Error("HL_INVALID_COIN");
+  if (!Number.isInteger(summary.asset_index)) throw new Error("HL_INVALID_ASSET_INDEX");
+  if (summary.margin_mode !== void 0 && !isExactStringMember(summary.margin_mode, ["cross", "isolated"])) {
+    throw new Error("HL_INVALID_MARGIN_MODE");
+  }
+  if (typeof summary.reduce_only !== "boolean") throw new Error("HL_INVALID_REDUCE_ONLY");
+}
+async function validateRequestBinding(payload, expected, vault, now) {
+  if (payload.order_ref !== expected.orderRef || payload.conversation_id !== expected.conversationId) {
+    throw new Error("HL_REFERENCE_MISMATCH");
+  }
+  if (typeof payload.owner_public_key !== "string") throw new Error("HL_INVALID_OWNER_PUBLIC_KEY");
+  if (payload.owner_public_key.toLowerCase() !== expected.publicKey.toLowerCase()) throw new Error("HL_OWNER_MISMATCH");
+  if (typeof payload.vault_address !== "string") throw new Error("HL_INVALID_VAULT_ADDRESS");
+  const localAddress = await vault.address(Chain10.Ethereum);
+  if (payload.vault_address.toLowerCase() !== localAddress.toLowerCase()) throw new Error("HL_VAULT_ADDRESS_MISMATCH");
+  if (typeof payload.expires_at !== "string") throw new Error("HL_INVALID_EXPIRY");
+  const expiry = Date.parse(payload.expires_at);
+  if (!Number.isFinite(expiry) || expiry <= now) throw new Error("HL_ORDER_EXPIRED");
+  if (expiry - now > 10 * 6e4) throw new Error("HL_EXPIRY_OUT_OF_RANGE");
+}
+function validateSteps(payload) {
+  if (payload.steps.length < 1 || payload.steps.length > 2) throw new Error("HL_INVALID_STEP_COUNT");
+  if (payload.steps.some((step) => !isPlainRecord(step) || !isPlainRecord(step.action)))
+    throw new Error("HL_INVALID_STEP");
+  if (payload.steps.some((step) => !isExactStringMember(step.kind, ["update_leverage", "order"])))
+    throw new Error("HL_INVALID_STEP_KIND");
+  if (payload.steps.some((step) => typeof step.is_mainnet !== "boolean")) throw new Error("HL_INVALID_NETWORK_FLAG");
+  const isMainnet = payload.steps[0].is_mainnet;
+  if (payload.steps.some((step) => step.is_mainnet !== isMainnet)) throw new Error("HL_NETWORK_MISMATCH");
+  return payload.steps.filter((step) => step.kind === "order");
+}
+function validateCeremony(payload, orderSteps) {
+  const leverageSteps = payload.steps.filter((step) => step.kind === "update_leverage");
+  if (payload.summary.operation === "open") {
+    if (payload.steps.length !== 2 || payload.steps[0]?.kind !== "update_leverage" || payload.steps[1]?.kind !== "order" || leverageSteps.length !== 1 || orderSteps.length !== 1 || payload.summary.leverage === void 0 || payload.summary.margin_mode === void 0 || payload.summary.reduce_only !== false)
+      throw new Error("HL_INVALID_OPEN_CEREMONY");
+    return;
+  }
+  if (payload.steps.length !== 1 || payload.steps[0]?.kind !== "order" || orderSteps.length !== 1 || leverageSteps.length !== 0 || payload.summary.leverage !== void 0 || payload.summary.margin_mode !== void 0 || payload.summary.reduce_only !== true)
+    throw new Error("HL_INVALID_CLOSE_CEREMONY");
+}
+function validateSignedSteps(payload) {
+  for (const step of payload.steps) {
+    if (typeof step.digest !== "string") throw new Error("HL_INVALID_DIGEST");
+    const computed = computeHlDigest(step);
+    if (computed.toLowerCase() !== step.digest.toLowerCase()) throw new Error("HL_DIGEST_MISMATCH");
+    if (step.kind === "order") validateOrderAction(step.action, payload.summary);
+    else validateLeverageAction(step.action, payload.summary);
+  }
+}
+async function validateHlSigningPayload(payload, expected, vault, now = Date.now()) {
+  validatePayloadShape(payload);
+  validateSummary(payload.summary);
+  await validateRequestBinding(payload, expected, vault, now);
+  const orderSteps = validateSteps(payload);
+  validateCeremony(payload, orderSteps);
+  if (payload.asset_binding.coin !== payload.summary.coin || payload.asset_binding.asset_index !== payload.summary.asset_index)
+    throw new Error("HL_ASSET_BINDING_MISMATCH");
+  validateSignedSteps(payload);
+  if (expected.digest && orderSteps[0]?.digest.toLowerCase() !== expected.digest.toLowerCase()) {
+    throw new Error("HL_EXPECTED_DIGEST_MISMATCH");
+  }
+}
+function formatHlConfirmation(payload) {
+  const s = payload.summary;
+  const network = payload.steps[0]?.is_mainnet === false ? "Testnet" : "Mainnet";
+  const leverage = s.leverage === void 0 ? "" : ` at ${s.leverage}x ${s.margin_mode ?? "cross"}`;
+  const price = s.limit_price === null ? `market max execution price $${s.price_cap}` : `limit $${s.limit_price}`;
+  return `Hyperliquid ${network} ${s.operation} ${s.side} ${s.size} ${s.coin} (asset #${s.asset_index}, signed notional $${s.notional_usd})${leverage}; ${s.order_type}/${s.tif}, ${price}, reduce-only=${s.reduce_only}. This signs and submits a live leveraged order.`;
+}
+async function pollHlOrderStatus(transport, params, initial, options = {}) {
+  if (initial.state !== "accepted" && initial.state !== "submitting") return initial;
+  const attempts = options.attempts ?? 20;
+  const sleep4 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let status = initial;
+  for (let i = 1; i < attempts && (status.state === "accepted" || status.state === "submitting"); i++) {
+    await sleep4(options.intervalMs ?? 1e3);
+    try {
+      status = await transport.getHlOrderStatus(params.orderRef, params.conversationId, params.publicKey);
+    } catch {
+    }
+  }
+  return status;
+}
+function isHlOrderFailure(status) {
+  return status.state === "rejected" || status.state === "cancelled";
+}
+
 // src/agent/executor.ts
 var EVM_CHAINS = /* @__PURE__ */ new Set([
   "Ethereum",
@@ -9956,21 +12583,7 @@ var EVM_CHAINS = /* @__PURE__ */ new Set([
   "Hyperliquid",
   "Sei"
 ]);
-var EVM_GAS_RPC = {
-  Ethereum: "https://ethereum-rpc.publicnode.com",
-  BSC: "https://bsc-dataseed.binance.org",
-  Polygon: "https://polygon-bor-rpc.publicnode.com",
-  Avalanche: "https://api.avax.network/ext/bc/C/rpc",
-  Arbitrum: "https://arb1.arbitrum.io/rpc",
-  Optimism: "https://mainnet.optimism.io",
-  Base: "https://mainnet.base.org",
-  Blast: "https://rpc.blast.io",
-  Zksync: "https://mainnet.era.zksync.io",
-  Mantle: "https://rpc.mantle.xyz",
-  CronosChain: "https://cronos-evm-rpc.publicnode.com",
-  Hyperliquid: "https://rpc.hyperliquid.xyz/evm",
-  Sei: "https://evm-rpc.sei-apis.com"
-};
+var isEvmChain = (chain) => EVM_CHAINS.has(chain);
 var AgentExecutor = class {
   vault;
   /** Owning SDK (optional); used for address book backed by app storage */
@@ -9996,6 +12609,7 @@ var AgentExecutor = class {
   // fingerprints so two different vaults sending an identical tx don't collide
   // in the single global journal (see BroadcastIntent.owner).
   vaultPublicKey;
+  consumedHlOrderRefs = /* @__PURE__ */ new Set();
   constructor(vault, verbose = false, vaultId, vultisig) {
     this.vault = vault;
     this.verbose = verbose;
@@ -10005,6 +12619,79 @@ var AgentExecutor = class {
       this.stateStore = new VaultStateStore(vaultId);
     }
   }
+  async retrieveHlOrder(transport, input, conversationId) {
+    const orderRef = typeof input.order_ref === "string" ? input.order_ref : "";
+    if (!/^[0-9a-f-]{16,64}$/i.test(orderRef)) throw new Error("HL_INVALID_ORDER_REFERENCE");
+    if (this.consumedHlOrderRefs.has(orderRef)) throw new Error("HL_ORDER_REFERENCE_REPLAYED");
+    const payload = await transport.retrieveHlOrderSigningPayload(orderRef, conversationId, this.vaultPublicKey);
+    this.consumedHlOrderRefs.add(orderRef);
+    await validateHlSigningPayload(
+      payload,
+      {
+        orderRef,
+        conversationId,
+        publicKey: this.vaultPublicKey,
+        digest: typeof input.digest === "string" ? input.digest : void 0
+      },
+      this.vault
+    );
+    return payload;
+  }
+  async signAndSubmitHlOrder(transport, payload) {
+    return this.runTool("hl_order", async () => {
+      if (this.vault.isEncrypted && !this.vault.isUnlocked?.() && this.password) {
+        await this.vault.unlock?.(this.password);
+      }
+      const expectedAddress = await this.vault.address(Chain11.Ethereum);
+      const signatures = [];
+      for (const step of payload.steps) {
+        const signed = await this.vault.signBytes({
+          data: step.digest,
+          chain: Chain11.Ethereum
+        });
+        const canonical = toCanonicalEvmSignature(signed.signature, signed.recovery ?? 0);
+        const v = canonical.recovery + 27;
+        const wireSignature = `0x${canonical.r}${canonical.s}${v.toString(16).padStart(2, "0")}`;
+        const recovered = await recoverAddress({
+          hash: step.digest,
+          signature: wireSignature
+        });
+        if (recovered.toLowerCase() !== expectedAddress.toLowerCase()) {
+          throw new Error("HL_SIGNATURE_RECOVERY_MISMATCH");
+        }
+        signatures.push({
+          kind: step.kind,
+          digest: step.digest,
+          r: `0x${canonical.r}`,
+          s: `0x${canonical.s}`,
+          v
+        });
+      }
+      const params = {
+        orderRef: payload.order_ref,
+        conversationId: payload.conversation_id,
+        publicKey: this.vaultPublicKey
+      };
+      const submitted = await transport.submitHlOrder(
+        params.orderRef,
+        params.conversationId,
+        params.publicKey,
+        signatures
+      );
+      const status = await pollHlOrderStatus(transport, params, submitted);
+      if (isHlOrderFailure(status)) {
+        throw new Error(`HL_ORDER_${status.state.toUpperCase()}: ${status.reason ?? "venue did not accept the order"}`);
+      }
+      return {
+        order_ref: payload.order_ref,
+        state: status.state,
+        order_id: status.order_id,
+        filled_size: status.filled_size,
+        average_price: status.average_price,
+        reason: status.reason
+      };
+    });
+  }
   setPassword(password) {
     this.password = password;
   }
@@ -10097,7 +12784,7 @@ var AgentExecutor = class {
         return false;
       }
       const chain2 = approvalChain;
-      if (!EVM_CHAINS.has(chain2)) {
+      if (!isEvmChain(chain2)) {
         if (this.verbose)
           process.stderr.write(
             `[executor] rejecting multi-leg envelope on non-EVM chain ${chain2}: signMultiLeg is EVM-only
@@ -10135,7 +12822,7 @@ var AgentExecutor = class {
     if (!nestedTx && txReadyData && typeof txReadyData === "object") {
       const txArgs = txReadyData.txArgs;
       if (txArgs && typeof txArgs === "object" && typeof txArgs.to === "string" && typeof txArgs.amount === "string") {
-        const chain2 = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
+        const chain2 = resolveChainFromTxReady(txReadyData) || Chain11.Ethereum;
         if (getChainKind3(chain2) !== "evm") {
           this.pendingPayloads.clear();
           this.pendingLegs = [];
@@ -10160,7 +12847,7 @@ var AgentExecutor = class {
 `);
       return false;
     }
-    const chain = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
+    const chain = resolveChainFromTxReady(txReadyData) || Chain11.Ethereum;
     this.pendingPayloads.clear();
     this.pendingLegs = [];
     this.pendingPayloads.set("latest", {
@@ -10454,7 +13141,9 @@ var AgentExecutor = class {
       }
       const isMultiLeg = !!payload.__multiLeg;
       const primaryIntent = isMultiLeg ? this.buildBroadcastIntent(payload, chain, { txArgs: payload.txArgs }) : this.buildBroadcastIntent(payload, chain);
-      const approveIntent = isMultiLeg ? this.buildBroadcastIntent(payload, chain, { txArgs: payload.approvalTxArgs }) : void 0;
+      const approveIntent = isMultiLeg ? this.buildBroadcastIntent(payload, chain, {
+        txArgs: payload.approvalTxArgs
+      }) : void 0;
       const primaryFp = computeFingerprint(primaryIntent);
       const approveFp = approveIntent ? computeFingerprint(approveIntent) : void 0;
       assertNoRecentDuplicate(primaryIntent, { force: this.forceBroadcast });
@@ -10545,7 +13234,7 @@ var AgentExecutor = class {
         `signNonEvmServerTx: dispatcher chain '${chain}' disagrees with envelope chain '${txArgs.chain}'`
       );
     }
-    if (txArgs.msg_type === "deposit" && (chain === Chain10.THORChain || chain === Chain10.MayaChain)) {
+    if (txArgs.msg_type === "deposit" && (chain === Chain11.THORChain || chain === Chain11.MayaChain)) {
       const memo = typeof txArgs.memo === "string" ? txArgs.memo : "";
       if (memo.startsWith("=:")) {
         return this.signThorMsgDepositSwap(serverTxData, chain);
@@ -10618,7 +13307,7 @@ var AgentExecutor = class {
       );
     }
     const toChain = parsed.toChain;
-    const fromSymbol = chain === Chain10.THORChain ? "RUNE" : "CACAO";
+    const fromSymbol = chain === Chain11.THORChain ? "RUNE" : "CACAO";
     const amountRaw = typeof txArgs.amount === "string" ? txArgs.amount : void 0;
     if (!amountRaw) {
       throw new VaultError3(
@@ -11000,7 +13689,7 @@ var AgentExecutor = class {
    * Releases any previously held lock first (e.g. from an abandoned build).
    */
   async acquireEvmLockIfNeeded(chain) {
-    if (!this.stateStore || !EVM_CHAINS.has(chain)) return;
+    if (!this.stateStore || !isEvmChain(chain)) return;
     await this.releaseEvmLock(chain);
     const release = await this.stateStore.acquireChainLock(chain);
     this.chainLockReleases.set(chain, release);
@@ -11029,7 +13718,7 @@ var AgentExecutor = class {
    * dropped and local state is stale.
    */
   async patchEvmNonce(chain, payload) {
-    if (!this.stateStore || !EVM_CHAINS.has(chain)) return;
+    if (!this.stateStore || !isEvmChain(chain)) return;
     const bs = payload.blockchainSpecific;
     if (!bs || bs.case !== "ethereumSpecific") return;
     const rpcNonce = bs.value.nonce;
@@ -11081,11 +13770,10 @@ var AgentExecutor = class {
    * Compensates for gas price drift between build time and sign time.
    */
   async patchEvmGas(chain, payload) {
-    if (!EVM_CHAINS.has(chain)) return;
+    if (!isEvmChain(chain)) return;
     const bs = payload.blockchainSpecific;
     if (!bs || bs.case !== "ethereumSpecific") return;
-    const rpcUrl = EVM_GAS_RPC[chain];
-    if (!rpcUrl) return;
+    const rpcUrl = getEvmRpcUrl(chain);
     try {
       const res = await fetch(rpcUrl, {
         method: "POST",
@@ -11127,8 +13815,8 @@ var AgentExecutor = class {
    * Returns null if the RPC call fails (non-fatal).
    */
   async fetchEvmPendingNonce(chain) {
-    const rpcUrl = EVM_GAS_RPC[chain];
-    if (!rpcUrl) return null;
+    if (!isEvmChain(chain)) return null;
+    const rpcUrl = getEvmRpcUrl(chain);
     try {
       const address = await this.vault.address(chain);
       const res = await fetch(rpcUrl, {
@@ -11156,7 +13844,7 @@ var AgentExecutor = class {
    * For approve+swap flows with N message hashes, the highest nonce used is base + N - 1.
    */
   recordEvmNonceFromPayload(chain, payload, numTxs) {
-    if (!this.stateStore || !EVM_CHAINS.has(chain)) return;
+    if (!this.stateStore || !isEvmChain(chain)) return;
     const bs = payload.blockchainSpecific;
     if (!bs || bs.case !== "ethereumSpecific") return;
     const baseNonce = bs.value.nonce;
@@ -11237,11 +13925,11 @@ var AgentExecutor = class {
 `);
     const chainName = params.chain;
     const chainId = domain.chainId;
-    let chain = Chain10.Ethereum;
+    let chain = Chain11.Ethereum;
     if (chainName) {
-      chain = resolveChain(chainName) || Chain10.Ethereum;
+      chain = resolveChain(chainName) || Chain11.Ethereum;
     } else if (chainId) {
-      chain = resolveChainId(chainId) || Chain10.Ethereum;
+      chain = resolveChainId(chainId) || Chain11.Ethereum;
     }
     const sigResult = await this.vault.signBytes({
       data: eip712Hash,
@@ -11465,7 +14153,7 @@ function asRecord(value) {
   }
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function isAddress(value) {
+function isAddress2(value) {
   return typeof value === "string" && /^0x[0-9a-fA-F]{40}$/.test(value);
 }
 function isCalldata(value) {
@@ -11485,7 +14173,7 @@ function normalizeGasLimit(value) {
   return void 0;
 }
 function extractLeg(obj) {
-  const to = isAddress(obj.to) ? obj.to : isAddress(obj.to_address) ? obj.to_address : void 0;
+  const to = isAddress2(obj.to) ? obj.to : isAddress2(obj.to_address) ? obj.to_address : void 0;
   const data = isCalldata(obj.data) ? obj.data : isCalldata(obj.calldata) ? obj.calldata : void 0;
   if (!to || !data) return null;
   const leg = { to, value: normalizeValue(obj.value), data };
@@ -11641,7 +14329,7 @@ function payloadLooksSignable(payload) {
 }
 function legSignable(legObj) {
   const nested = asRecord(legObj.tx) || asRecord(legObj.swap_tx) || asRecord(legObj.send_tx) || asRecord(legObj.txArgs?.tx);
-  if (nested && isAddress(nested.to)) return true;
+  if (nested && isAddress2(nested.to)) return true;
   const txArgs = asRecord(legObj.txArgs);
   if (txArgs && typeof txArgs.to === "string" && typeof txArgs.amount === "string") return true;
   return false;
@@ -11676,6 +14364,26 @@ var AgentStreamIdleTimeoutError = class extends Error {
   timeoutMs;
   code = "TIMEOUT" /* TIMEOUT */;
 };
+var HL_ORDER_BUILD_TOOLS = /* @__PURE__ */ new Set(["build_hyperliquid_open_position", "build_hyperliquid_close_position"]);
+function deriveHlOrderClientAction(toolName, output) {
+  if (!HL_ORDER_BUILD_TOOLS.has(toolName)) return null;
+  let value = output;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const result = value;
+  const expectedAction = toolName === "build_hyperliquid_open_position" ? "open" : "close";
+  const expectedReduceOnly = expectedAction === "close";
+  if (result.surface !== "hyperliquid_order" || result.status !== "ready_to_sign" || result.action !== expectedAction || typeof result.order_ref !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(result.order_ref) || typeof result.coin !== "string" || !Number.isInteger(result.asset_index) || typeof result.wire_size !== "string" || typeof result.price_cap !== "string" || typeof result.wire_notional_usd !== "string" || !["Ioc", "Gtc", "Alo"].includes(String(result.tif)) || result.reduce_only !== expectedReduceOnly) {
+    return null;
+  }
+  return { order_ref: result.order_ref };
+}
 function v1StatusFromType(type) {
   switch (type) {
     case "tool-input-start":
@@ -11838,7 +14546,10 @@ var AgentClient = class {
     try {
       res = await fetch(`${this.baseUrl}/auth/token`, {
         method: "POST",
-        headers: { "Content-Type": "application/json", ...this.profileHeader() },
+        headers: {
+          "Content-Type": "application/json",
+          ...this.profileHeader()
+        },
         body: JSON.stringify(req),
         signal: this.timeoutSignal()
       });
@@ -11858,7 +14569,9 @@ var AgentClient = class {
   // ============================================================================
   async healthCheck() {
     try {
-      const res = await fetch(`${this.baseUrl}/healthz`, { signal: this.timeoutSignal() });
+      const res = await fetch(`${this.baseUrl}/healthz`, {
+        signal: this.timeoutSignal()
+      });
       return res.ok;
     } catch {
       return false;
@@ -11884,6 +14597,28 @@ var AgentClient = class {
       public_key: publicKey
     });
   }
+  async retrieveHlOrderSigningPayload(orderRef, conversationId, publicKey) {
+    return this.post(
+      `/agent/hyperliquid/orders/${encodeURIComponent(orderRef)}/signing-payload`,
+      {
+        conversation_id: conversationId,
+        public_key: publicKey
+      }
+    );
+  }
+  async submitHlOrder(orderRef, conversationId, publicKey, signatures) {
+    return this.post(`/agent/hyperliquid/orders/${encodeURIComponent(orderRef)}/submit`, {
+      conversation_id: conversationId,
+      public_key: publicKey,
+      signatures
+    });
+  }
+  async getHlOrderStatus(orderRef, conversationId, publicKey) {
+    return this.post(`/agent/hyperliquid/orders/${encodeURIComponent(orderRef)}/status`, {
+      conversation_id: conversationId,
+      public_key: publicKey
+    });
+  }
   // ============================================================================
   // Messages - JSON mode
   // ============================================================================
@@ -12145,7 +14880,12 @@ var AgentClient = class {
 `);
     let warning = result.protocolWarnings[0];
     if (!warning) {
-      warning = { code: "PROTOCOL_DRIFT", message: "", count: 0, eventTypes: [] };
+      warning = {
+        code: "PROTOCOL_DRIFT",
+        message: "",
+        count: 0,
+        eventTypes: []
+      };
       result.protocolWarnings.push(warning);
     }
     warning.count += 1;
@@ -12207,8 +14947,20 @@ var AgentClient = class {
     const toolName = inlineName ?? (callId ? toolNameByCallId.get(callId) : void 0);
     const label = typeof parsed.label === "string" ? parsed.label : void 0;
     this.maybeEmitClientSideToolCall(parsed, callbacks, v1Type, callId, toolName);
-    const ok = deriveToolDoneOk(status, parsed.output, v1Type);
+    const hlOrderAction = status === "done" && toolName && HL_ORDER_BUILD_TOOLS.has(toolName) ? deriveHlOrderClientAction(toolName, parsed.output) : void 0;
+    const derivedOk = deriveToolDoneOk(status, parsed.output, v1Type);
+    const ok = hlOrderAction === null ? false : derivedOk;
     if (status && toolName) callbacks.onToolProgress?.(toolName, status, label, ok);
+    if (status === "done" && toolName && HL_ORDER_BUILD_TOOLS.has(toolName)) {
+      if (hlOrderAction && callId && callbacks.onClientSideToolCall) {
+        callbacks.onClientSideToolCall(`${callId}:hl_order`, "hl_order", hlOrderAction);
+      } else {
+        callbacks.onError?.(
+          "Hyperliquid preview was not delivered as a complete ready-to-sign action.",
+          "INVALID_INPUT" /* INVALID_INPUT */
+        );
+      }
+    }
     this.maybeSignToolOutput(status, toolName, parsed.output, callbacks, v1Type);
     if (status === "done" && callId) toolNameByCallId.delete(callId);
   }
@@ -12768,14 +15520,13 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import { homedir } from "node:os";
 import { dirname as dirname2, join as join3 } from "node:path";
+import { getVultisigConfigDir as getVultisigConfigDir3 } from "@vultisig/client-shared";
 var LOCK_RETRY_MS = 25;
 var LOCK_MAX_WAIT_MS2 = 5e3;
 var LOCK_STALE_MS2 = 3e4;
 function getTokenCachePath() {
-  const dir = process.env.VULTISIG_CONFIG_DIR ?? join3(homedir(), ".vultisig");
-  return join3(dir, "agent-tokens.json");
+  return join3(getVultisigConfigDir3(), "agent-tokens.json");
 }
 function tokenCacheKey(scope) {
   return JSON.stringify([scope.publicKey, scope.backendUrl.replace(/\/+$/, ""), scope.profile ?? ""]);
@@ -12911,7 +15662,7 @@ async function clearCachedToken(scope) {
 }
 
 // src/agent/session.ts
-var PASSWORD_REQUIRED_TOOLS = /* @__PURE__ */ new Set(["sign_typed_data", "sign_tx"]);
+var PASSWORD_REQUIRED_TOOLS = /* @__PURE__ */ new Set(["sign_typed_data", "sign_tx", "hl_order"]);
 var AUTO_SUBMIT_MARKERS = /* @__PURE__ */ new Set([
   "__pm_auto_submit",
   "__pm_auto_submit_batch",
@@ -12933,7 +15684,8 @@ var BACKEND_CLIENT_SIDE_TOOL_NAMES = [
   "delete_policy",
   "sign_typed_data",
   "polymarket_sign_bet",
-  "polymarket_sign_batch"
+  "polymarket_sign_batch",
+  "hl_order"
 ];
 var CLIENT_SIDE_DISPATCH_TOOL_NAMES = /* @__PURE__ */ new Set([
   ...BACKEND_CLIENT_SIDE_TOOL_NAMES,
@@ -12944,6 +15696,11 @@ var PROPOSED_SUMMARY_MAX_CHARS = 500;
 function capSigningSummary(summary) {
   return summary.length > PROPOSED_SUMMARY_MAX_CHARS ? `${summary.slice(0, PROPOSED_SUMMARY_MAX_CHARS)}\u2026` : summary;
 }
+function applyAgentMode(request, config) {
+  if (config.viaAgent || config.askMode) {
+    request.via_agent = true;
+  }
+}
 var RECOVERY_POLL_INTERVAL_MS = 2e3;
 var RECOVERY_MAX_POLLS = 90;
 var TX_CONFIRM_POLL_INTERVAL_MS = 3e3;
@@ -13017,6 +15774,9 @@ var AgentSession = class {
   pushService = null;
   // Flushed into context.recent_actions on the next outbound request.
   pendingToolResults = [];
+  terminalHlConfirmation = false;
+  firstHlOrderRef = null;
+  seenHlOrderRefs = /* @__PURE__ */ new Set();
   // Snapshot, taken the instant sendMessage's catch fires (BEFORE it clears the
   // queue), of whether an already-broadcast tx result was still UNDELIVERED to
   // the backend. This is the true "ack failed" signal: a successful broadcast
@@ -13151,7 +15911,9 @@ var AgentSession = class {
             new Error(
               `Session ${this.config.sessionId} could not be resumed (${err?.message ?? "unknown error"}); refusing to execute the request without its conversation context`
             ),
-            { code: isAuthError(err) ? "AUTH_FAILED" /* AUTH_FAILED */ : "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */ }
+            {
+              code: isAuthError(err) ? "AUTH_FAILED" /* AUTH_FAILED */ : "SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */
+            }
           );
         }
         this.conversationId = null;
@@ -13273,6 +16035,9 @@ var AgentSession = class {
       throw new Error("Session not initialized");
     }
     this.abortController = new AbortController();
+    this.terminalHlConfirmation = false;
+    this.firstHlOrderRef = null;
+    this.seenHlOrderRefs = /* @__PURE__ */ new Set();
     this.unacknowledgedBroadcastAtError = false;
     try {
       this.cachedContext = this.config.viaAgent || this.config.askMode ? await buildMinimalContext(this.vault) : await buildMessageContext(this.vault);
@@ -13317,9 +16082,7 @@ var AgentSession = class {
       // narrates. See cards.ts / backend types.go SupportedSurfaces.
       supported_surfaces: [...CLI_SUPPORTED_SURFACES]
     };
-    if (this.config.viaAgent || this.config.askMode) {
-      request.via_agent = true;
-    }
+    applyAgentMode(request, this.config);
     if (content) {
       request.content = content;
     }
@@ -13349,6 +16112,14 @@ var AgentSession = class {
         }
       },
       onClientSideToolCall: (toolCallId, toolName, input) => {
+        if (toolName === "hl_order") {
+          const orderRef = typeof input.order_ref === "string" ? input.order_ref : "";
+          if (this.firstHlOrderRef === null || this.firstHlOrderRef === void 0) {
+            this.firstHlOrderRef = orderRef;
+          } else if (this.firstHlOrderRef !== orderRef) {
+            return;
+          }
+        }
         const dispatch = dispatchChain.then(() => this.dispatchClientSideTool(toolCallId, toolName, input, ui));
         dispatchChain = dispatch.catch(() => {
         });
@@ -13420,6 +16191,11 @@ var AgentSession = class {
     if (pendingDispatches.length > 0) {
       await Promise.all(pendingDispatches);
     }
+    if (this.terminalHlConfirmation) {
+      this.pendingToolResults = this.pendingToolResults.filter((result) => result.tool !== "hl_order");
+      ui.onDone();
+      return;
+    }
     if (streamResult.disconnected && !streamResult.message) {
       ui.onReconnecting?.();
       await this.recoverDisconnectedTurn(streamResult, callbacks.onBalanceSummary);
@@ -13738,10 +16514,10 @@ var AgentSession = class {
    * by the executor (or a synthetic failure `RecentAction` if the password
    * prompt was declined).
    */
-  async runPasswordGatedTool(toolName, toolCallId, ui, body, input) {
+  async runPasswordGatedTool(toolName, toolCallId, ui, body, input, confirmationSummary) {
     let signingRecord;
     if (PASSWORD_REQUIRED_TOOLS.has(toolName)) {
-      const summary = (toolName === "sign_tx" ? this.executor.getPendingSummary() : null) ?? `${toolName}${input ? ` ${JSON.stringify(input)}` : ""}`;
+      const summary = confirmationSummary ?? (toolName === "sign_tx" ? this.executor.getPendingSummary() : null) ?? `${toolName}${input ? ` ${JSON.stringify(input)}` : ""}`;
       const approved = await ui.requestConfirmation(summary);
       if (!approved) {
         return reportDeclinedSigning(this.executor, toolName, toolCallId, summary, input, ui);
@@ -13805,6 +16581,51 @@ var AgentSession = class {
   // entries surface as a visible `[cli] unimplemented` warning + failure
   // RecentAction (never silent).
   async dispatchClientSideTool(toolCallId, toolName, input, ui) {
+    if (toolName === "hl_order") {
+      let recent2;
+      try {
+        const conversationId = this.conversationId;
+        if (!conversationId) throw new Error("HL_CONVERSATION_REQUIRED");
+        const orderRef = typeof input.order_ref === "string" ? input.order_ref : "";
+        if (this.firstHlOrderRef === null || this.firstHlOrderRef === void 0) {
+          this.firstHlOrderRef = orderRef;
+        } else if (this.firstHlOrderRef !== orderRef) {
+          return;
+        }
+        const seenRefs = this.seenHlOrderRefs ?? (this.seenHlOrderRefs = /* @__PURE__ */ new Set());
+        if (seenRefs.has(orderRef)) return;
+        seenRefs.add(orderRef);
+        const payload = await this.executor.retrieveHlOrder(this.client, input, conversationId);
+        recent2 = await this.runPasswordGatedTool(
+          toolName,
+          toolCallId,
+          ui,
+          () => this.executor.signAndSubmitHlOrder(this.client, payload),
+          input,
+          formatHlConfirmation(payload)
+        );
+        if (recent2.data?.code === "CONFIRMATION_REQUIRED" /* CONFIRMATION_REQUIRED */) {
+          const proposed = String(recent2.data.proposed ?? formatHlConfirmation(payload));
+          const card = {
+            surface: "hyperliquid_order_confirmation",
+            status: "confirmation_required",
+            order_ref: payload.order_ref,
+            ...payload.summary,
+            proposed
+          };
+          recent2.data.confirmation_card = card;
+          this.terminalHlConfirmation = true;
+          ui.onHlOrderConfirmation?.(card);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        recent2 = { tool: toolName, success: false, data: { error: message } };
+        ui.onToolCall(toolCallId, toolName, input);
+        ui.onToolResult(toolCallId, toolName, false, recent2.data, message);
+      }
+      if (!this.terminalHlConfirmation) this.pendingToolResults.push(recent2);
+      return;
+    }
     const handler = CLIENT_SIDE_TOOL_DISPATCH[toolName];
     if (!handler) {
       process.stderr.write(`[cli] unimplemented client-side tool: ${toolName}
@@ -13812,7 +16633,10 @@ var AgentSession = class {
       this.pendingToolResults.push({
         tool: toolName,
         success: false,
-        data: { code: "TOOL_UNSUPPORTED" /* TOOL_UNSUPPORTED */, error: `unimplemented in CLI: ${toolName}` }
+        data: {
+          code: "TOOL_UNSUPPORTED" /* TOOL_UNSUPPORTED */,
+          error: `unimplemented in CLI: ${toolName}`
+        }
       });
       return;
     }
@@ -14347,6 +17171,7 @@ function outputAskError(wantsJson, message, code, conversationId, result) {
     if (result?.toolCalls.length) data.tool_calls = result.toolCalls;
     if (result?.response) data.response = result.response;
     if (result?.warnings.length) data.warnings = result.warnings;
+    if (result?.cards.length) data.cards = result.cards;
     if (result?.outcome) data.outcome = result.outcome;
     if (result?.proposedTransaction) {
       data.confirmation_required = true;
@@ -14386,7 +17211,7 @@ var ACK_FAILED_MESSAGE = "A transaction was broadcast, but its post-broadcast re
 function hasCommittedBroadcast(result) {
   return !!result?.transactions.some((tx) => tx.hash.trim().length > 0 && tx.status !== "failed");
 }
-var SIGNING_TOOLS = /* @__PURE__ */ new Set(["sign_tx", "sign_typed_data"]);
+var SIGNING_TOOLS = /* @__PURE__ */ new Set(["sign_tx", "sign_typed_data", "hl_order"]);
 var CONFIRMATION_REQUIRED_MESSAGE = "The transaction was built but signing was not authorized, so nothing was signed or broadcast. Re-run with --yes to authorize signing.";
 function failedSigningError(result) {
   const failed = [...result.toolCalls].reverse().find((call) => SIGNING_TOOLS.has(call.action));
@@ -14464,9 +17289,15 @@ function outputAskHuman(result, confirmationRequired, proposed) {
   }
   writeSigningRecordLines(result.signingRecords, (line) => process.stdout.write(line));
   for (const card of result.cards) {
-    process.stdout.write(`
+    if (card.surface === "balance_summary") {
+      process.stdout.write(`
 ${renderBalanceSummaryCard(card)}
 `);
+    } else {
+      process.stdout.write(`
+confirmation:${card.proposed}
+`);
+    }
   }
   for (const card of result.yieldCards) {
     process.stdout.write(`
@@ -14708,7 +17539,7 @@ function formatDate(iso) {
 }
 
 // src/lib/version.ts
-import { getVultisigConfigDir as getVultisigConfigDir3 } from "@vultisig/client-shared";
+import { getVultisigConfigDir as getVultisigConfigDir4 } from "@vultisig/client-shared";
 import chalk11 from "chalk";
 import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
@@ -14716,7 +17547,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "4.5.0";
+    cachedVersion = "4.6.0";
     return cachedVersion;
   }
   try {
@@ -14729,7 +17560,7 @@ function getVersion() {
     return cachedVersion;
   }
 }
-var CACHE_DIR = join4(getVultisigConfigDir3(), "cache");
+var CACHE_DIR = join4(getVultisigConfigDir4(), "cache");
 var VERSION_CACHE_FILE = join4(CACHE_DIR, "version-check.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 function readVersionCache() {
@@ -14813,7 +17644,7 @@ function formatVersionShort() {
 }
 function formatVersionDetailed() {
   const lines = [];
-  const configDir = getVultisigConfigDir3();
+  const configDir = getVultisigConfigDir4();
   lines.push(chalk11.bold(`Vultisig CLI v${getVersion()}`));
   lines.push("");
   lines.push(`  Node.js:   ${process.version}`);
@@ -15176,7 +18007,7 @@ var EventBuffer = class {
 };
 
 // src/interactive/session.ts
-import { Chain as Chain12, fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
+import { Chain as Chain13, fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
 import chalk14 from "chalk";
 import ora3 from "ora";
 import * as readline3 from "readline";
@@ -16025,7 +18856,7 @@ Error: ${error2.message}`));
       } else if (rest[i] === "--destination-tag") {
         const tag = rest[i + 1];
         const parsedTag = Number(tag);
-        if (chain !== Chain12.Ripple || !/^(0|[1-9]\d*)$/.test(tag ?? "") || !Number.isSafeInteger(parsedTag) || parsedTag > 4294967295) {
+        if (chain !== Chain13.Ripple || !/^(0|[1-9]\d*)$/.test(tag ?? "") || !Number.isSafeInteger(parsedTag) || parsedTag > 4294967295) {
           throw new Error("Invalid XRP DestinationTag: expected an integer from 0 to 4294967295");
         }
         destinationTag = parsedTag;
@@ -16253,7 +19084,7 @@ Error: ${error2.message}`));
 };
 
 // src/lib/completion.ts
-import { getVultisigConfigDir as getVultisigConfigDir4 } from "@vultisig/client-shared";
+import { getVultisigConfigDir as getVultisigConfigDir5 } from "@vultisig/client-shared";
 import { SUPPORTED_CHAINS as SUPPORTED_CHAINS2 } from "@vultisig/sdk";
 import { program } from "commander";
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync5 } from "fs";
@@ -16280,7 +19111,7 @@ function getChains() {
 }
 function getVaultNames() {
   try {
-    const vaultDir = getVultisigConfigDir4();
+    const vaultDir = getVultisigConfigDir5();
     if (!existsSync3(vaultDir)) return [];
     const files = readdirSync(vaultDir);
     const names = [];
@@ -16533,10 +19364,10 @@ complete -c vsig -n "__fish_seen_subcommand_from import export" -a "(__fish_comp
 }
 
 // src/lib/config.ts
-import { getVultisigConfigDir as getVultisigConfigDir5 } from "@vultisig/client-shared";
+import { getVultisigConfigDir as getVultisigConfigDir6 } from "@vultisig/client-shared";
 import { FileStorage } from "@vultisig/sdk/node";
 function getConfigDir() {
-  return getVultisigConfigDir5();
+  return getVultisigConfigDir6();
 }
 function createVaultStorage() {
   return new FileStorage({ basePath: getConfigDir() });
@@ -16872,7 +19703,7 @@ See also: balance, tx-status`
       if (!amount && !options.max) throw new Error("Provide an amount or use --max");
       if (amount && options.max) throw new Error("Cannot specify both amount and --max");
       const chain = resolveChainOrThrow(chainStr);
-      if (options.destinationTag !== void 0 && chain !== Chain13.Ripple) {
+      if (options.destinationTag !== void 0 && chain !== Chain14.Ripple) {
         throw new Error("--destination-tag is only supported for XRP");
       }
       const destinationTag = options.destinationTag === void 0 ? void 0 : Number(options.destinationTag);