@vultisig/cli 4.4.0 → 4.6.0

package/dist/index.js

@@ -24,11 +24,11 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from2, except, desc) => {
-  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
       if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
   return to;
 };
@@ -2382,69 +2382,9 @@ function format(value, decimals = 0) {
   fraction = fraction.replace(/(0+)$/, "");
   return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
 }
-function from(value, decimals = 0) {
-  if (!Number.isInteger(decimals) || decimals < 0)
-    throw new InvalidDecimalsError({ decimals });
-  if (!/^-?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)$/.test(value))
-    throw new InvalidDecimalNumberError({ value });
-  let [integer = "", fraction = "0"] = value.split(".");
-  const negative = integer.startsWith("-");
-  if (negative)
-    integer = integer.slice(1);
-  if (integer === "")
-    integer = "0";
-  fraction = fraction.replace(/(0+)$/, "");
-  if (decimals === 0) {
-    if (fraction.length > 0 && Number.parseInt(fraction[0], 10) >= 5)
-      integer = `${BigInt(integer) + 1n}`;
-    fraction = "";
-  } else if (fraction.length > decimals) {
-    const left = fraction.slice(0, decimals);
-    const roundDigit = Number.parseInt(fraction.slice(decimals, decimals + 1), 10);
-    if (roundDigit >= 5) {
-      const carried = carry(left);
-      if (carried.length > decimals) {
-        fraction = carried.slice(1);
-        integer = `${BigInt(integer) + 1n}`;
-      } else {
-        fraction = carried;
-      }
-    } else {
-      fraction = left;
-    }
-  } else {
-    fraction = fraction.padEnd(decimals, "0");
-  }
-  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
-}
-function carry(digits) {
-  const out = digits.split("");
-  let i = out.length - 1;
-  while (i >= 0) {
-    const d = Number.parseInt(out[i], 10) + 1;
-    if (d < 10) {
-      out[i] = String(d);
-      return out.join("");
-    }
-    out[i] = "0";
-    i--;
-  }
-  return `1${out.join("")}`;
-}
-var InvalidDecimalNumberError, InvalidDecimalsError;
+var InvalidDecimalsError;
 var init_Value = __esm({
   "../../node_modules/viem/_esm/utils/unit/Value.js"() {
-    InvalidDecimalNumberError = class extends Error {
-      constructor({ value }) {
-        super(`Value \`${value}\` is not a valid decimal number.`);
-        Object.defineProperty(this, "name", {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value: "Value.InvalidDecimalNumberError"
-        });
-      }
-    };
     InvalidDecimalsError = class extends Error {
       constructor({ decimals }) {
         super(`\`decimals\` must be a non-negative integer. Got \`${decimals}\`.`);
@@ -4071,7 +4011,7 @@ function weierstrass(curveDef) {
   function normalizeS(s) {
     return isBiggerThanHalfOrder(s) ? modN2(-s) : s;
   }
-  const slcNum = (b, from2, to) => bytesToNumberBE(b.slice(from2, to));
+  const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
   class Signature {
     constructor(r, s, recovery) {
       aInRange("r", r, _1n5, CURVE_ORDER);
@@ -4903,57 +4843,1766 @@ var init_secp256k1 = __esm({
         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)();
+    }))();
+    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();
+      }
+    }
+    function ensureAsyncIterable(streamLike) {
+      if (isAsyncIterable(streamLike)) {
+        return streamLike;
+      } else {
+        return asyncIterableFromStream(streamLike);
+      }
+    }
+  }
+});
+
+// ../../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;
+    } });
   }
 });
 
@@ -4961,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 Chain15, 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";
 
@@ -6016,7 +7665,7 @@ function displayVaultInfo(vault) {
   printResult(`  Chain Code:    ${vault.hexChainCode.substring(0, 20)}...
 `);
 }
-function displayTransactionPreview(fromAddress, toAddress, amount, symbol, chain, memo, destinationTag, gas) {
+function displayTransactionPreview(fromAddress, toAddress, amount, symbol, chain, memo, destinationTag, gas, contractAddress) {
   if (gas) {
     const bigIntReplacer2 = (_k, v) => typeof v === "bigint" ? v.toString() : v;
     info(chalk2.blue(`
@@ -6025,7 +7674,7 @@ Estimated gas: ${JSON.stringify(gas, bigIntReplacer2, 2)}`));
   printResult(chalk2.cyan("\nTransaction Preview:"));
   printResult(`  From:   ${fromAddress}`);
   printResult(`  To:     ${toAddress}`);
-  printResult(`  Amount: ${amount} ${symbol}`);
+  printResult(`  Amount: ${amount} ${symbol}${contractAddress ? ` (${escapeTerminalControls(contractAddress)})` : ""}`);
   printResult(`  Chain:  ${chain}`);
   if (memo) {
     printResult(`  Memo:   ${escapeTerminalControls(memo)}`);
@@ -6332,123 +7981,8 @@ function shouldAutoSelectActiveVault(hasActiveVault, corruptPointer, vaultCount)
   return !hasActiveVault && !corruptPointer && vaultCount > 0;
 }
 
-// ../../packages/core/chain/dist/Chain.js
-var EthereumL2Chain = {
-  Arbitrum: "Arbitrum",
-  Base: "Base",
-  Blast: "Blast",
-  Optimism: "Optimism",
-  Zksync: "Zksync",
-  Mantle: "Mantle",
-  Robinhood: "Robinhood"
-};
-var EvmChain = {
-  ...EthereumL2Chain,
-  Avalanche: "Avalanche",
-  CronosChain: "CronosChain",
-  BSC: "BSC",
-  Ethereum: "Ethereum",
-  Polygon: "Polygon",
-  Hyperliquid: "Hyperliquid",
-  Sei: "Sei"
-};
-var UtxoChain;
-(function(UtxoChain2) {
-  UtxoChain2["Bitcoin"] = "Bitcoin";
-  UtxoChain2["BitcoinCash"] = "Bitcoin-Cash";
-  UtxoChain2["Litecoin"] = "Litecoin";
-  UtxoChain2["Dogecoin"] = "Dogecoin";
-  UtxoChain2["Dash"] = "Dash";
-  UtxoChain2["Zcash"] = "Zcash";
-})(UtxoChain || (UtxoChain = {}));
-var cosmosChainsByKind = {
-  ibcEnabled: {
-    Cosmos: "Cosmos",
-    Osmosis: "Osmosis",
-    Dydx: "Dydx",
-    Kujira: "Kujira",
-    Terra: "Terra",
-    TerraClassic: "TerraClassic",
-    Noble: "Noble",
-    Akash: "Akash"
-  },
-  vaultBased: {
-    THORChain: "THORChain",
-    MayaChain: "MayaChain"
-  }
-};
-var IbcEnabledCosmosChain = cosmosChainsByKind.ibcEnabled;
-var VaultBasedCosmosChain = cosmosChainsByKind.vaultBased;
-var CosmosChain = {
-  ...IbcEnabledCosmosChain,
-  ...VaultBasedCosmosChain
-};
-var OtherChain;
-(function(OtherChain2) {
-  OtherChain2["Sui"] = "Sui";
-  OtherChain2["Solana"] = "Solana";
-  OtherChain2["Polkadot"] = "Polkadot";
-  OtherChain2["Bittensor"] = "Bittensor";
-  OtherChain2["Ton"] = "Ton";
-  OtherChain2["Ripple"] = "Ripple";
-  OtherChain2["Tron"] = "Tron";
-  OtherChain2["Cardano"] = "Cardano";
-  OtherChain2["QBTC"] = "QBTC";
-})(OtherChain || (OtherChain = {}));
-var Chain2 = {
-  ...EvmChain,
-  ...UtxoChain,
-  ...CosmosChain,
-  ...OtherChain
-};
-var UtxoBasedChain = [...Object.values(UtxoChain), OtherChain.Cardano];
-var defaultChains = [Chain2.Bitcoin, Chain2.Ethereum, Chain2.THORChain, Chain2.Solana, Chain2.BSC];
-
-// ../../packages/core/chain/dist/ChainKind.js
-var chainKindRecord = {
-  [EvmChain.Arbitrum]: "evm",
-  [EvmChain.Avalanche]: "evm",
-  [EvmChain.Base]: "evm",
-  [EvmChain.CronosChain]: "evm",
-  [EvmChain.BSC]: "evm",
-  [EvmChain.Blast]: "evm",
-  [EvmChain.Ethereum]: "evm",
-  [EvmChain.Optimism]: "evm",
-  [EvmChain.Polygon]: "evm",
-  [EvmChain.Zksync]: "evm",
-  [EvmChain.Mantle]: "evm",
-  [EvmChain.Hyperliquid]: "evm",
-  [EvmChain.Sei]: "evm",
-  [EvmChain.Robinhood]: "evm",
-  [UtxoChain.Bitcoin]: "utxo",
-  [UtxoChain.BitcoinCash]: "utxo",
-  [UtxoChain.Litecoin]: "utxo",
-  [UtxoChain.Dogecoin]: "utxo",
-  [UtxoChain.Dash]: "utxo",
-  [UtxoChain.Zcash]: "utxo",
-  [CosmosChain.THORChain]: "cosmos",
-  [CosmosChain.Cosmos]: "cosmos",
-  [CosmosChain.Osmosis]: "cosmos",
-  [CosmosChain.MayaChain]: "cosmos",
-  [CosmosChain.Dydx]: "cosmos",
-  [CosmosChain.Kujira]: "cosmos",
-  [CosmosChain.Terra]: "cosmos",
-  [CosmosChain.TerraClassic]: "cosmos",
-  [CosmosChain.Noble]: "cosmos",
-  [CosmosChain.Akash]: "cosmos",
-  [OtherChain.Sui]: "sui",
-  [OtherChain.Solana]: "solana",
-  [OtherChain.Polkadot]: "polkadot",
-  [OtherChain.Bittensor]: "bittensor",
-  [OtherChain.Ton]: "ton",
-  [OtherChain.Ripple]: "ripple",
-  [OtherChain.Tron]: "tron",
-  [OtherChain.Cardano]: "cardano",
-  [OtherChain.QBTC]: "qbtc"
-};
-function getChainKind2(chain) {
-  return chainKindRecord[chain];
-}
+// src/core/broadcastGuard.ts
+import { getChainKind as getChainKind2 } from "@vultisig/sdk";
 
 // src/agent/broadcastJournal.ts
 import { createHash } from "node:crypto";
@@ -7068,7 +8602,7 @@ async function guardedBroadcast(intent, force, broadcast) {
 }
 
 // src/interactive/completer.ts
-import { Chain as Chain3 } from "@vultisig/sdk";
+import { Chain as Chain2 } from "@vultisig/sdk";
 import fs from "fs";
 import path from "path";
 var COMMANDS = [
@@ -7212,7 +8746,7 @@ function completeVaultName(ctx2, partial) {
   return [show, partial];
 }
 function completeChainName(partial) {
-  const allChains = Object.values(Chain3);
+  const allChains = Object.values(Chain2);
   const partialLower = partial.toLowerCase();
   const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
   matches.sort();
@@ -7220,7 +8754,7 @@ function completeChainName(partial) {
   return [show, partial];
 }
 function findChainByName(name) {
-  const allChains = Object.values(Chain3);
+  const allChains = Object.values(Chain2);
   const nameLower = name.toLowerCase();
   const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
   return found ? found : null;
@@ -7239,6 +8773,10 @@ function resolveChainOrThrow(input, label = "chain") {
   }
   return chain;
 }
+function resolveOptionalChainOrThrow(input, label = "chain") {
+  if (input === void 0 || input === null) return void 0;
+  return resolveChainOrThrow(input, label);
+}
 
 // src/core/config-store.ts
 import { getConfigPath, loadConfig, saveConfig } from "@vultisig/client-shared";
@@ -7542,10 +9080,10 @@ var resolveDestinationTag = ({ destinationTag, memo }) => {
 };
 
 // src/commands/transaction.ts
-import { Chain as Chain4, Vultisig as Vultisig2 } from "@vultisig/sdk";
+import { Chain as Chain3, Vultisig as Vultisig2 } from "@vultisig/sdk";
 var getSendPreviewDetails = (chain, keysignPayload) => {
   let memo = keysignPayload.memo || void 0;
-  if (chain !== Chain4.Ripple) {
+  if (chain !== Chain3.Ripple) {
     return { memo, destinationTag: void 0 };
   }
   const rippleSpecific = keysignPayload.blockchainSpecific;
@@ -7564,7 +9102,7 @@ var getSendPreviewDetails = (chain, keysignPayload) => {
 };
 async function executeSend(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain4).includes(params.chain)) {
+  if (!Object.values(Chain3).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   const isMax = params.amount === "max";
@@ -7581,12 +9119,13 @@ async function previewDryRun(vault, params, dryResult, to) {
     dryResult.keysignPayload
   );
   const isTokenSend = balance.tokenId !== void 0;
-  const feeBalance = isTokenSend ? await vault.balance(params.chain).catch(() => void 0) : void 0;
+  const shouldCheckNativeFeeBalance = isTokenSend && params.amount !== "max";
+  const feeBalance = shouldCheckNativeFeeBalance ? await vault.balance(params.chain).catch(() => void 0) : void 0;
   const warnings = [];
   if (hasInsufficientBalance) {
     warnings.push(`Insufficient balance: you have ${balance.formattedAmount} ${balance.symbol}`);
   }
-  if (isTokenSend && feeBalance === void 0) {
+  if (shouldCheckNativeFeeBalance && feeBalance === void 0) {
     warnings.push(`Could not check your ${dryResult.feeSymbol} balance for the network fee`);
   } else if (feeBalance && parseFloat(dryResult.fee) > parseFloat(feeBalance.formattedAmount)) {
     warnings.push(
@@ -7599,6 +9138,7 @@ async function previewDryRun(vault, params, dryResult, to) {
     to,
     amount: params.amount,
     symbol: balance.symbol,
+    ...dryResult.contractAddress ? { contractAddress: dryResult.contractAddress } : {},
     fee: dryResult.fee,
     feeSymbol: dryResult.feeSymbol,
     total: dryResult.total,
@@ -7608,14 +9148,27 @@ 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:`);
   info(`  Chain:   ${result.chain}`);
   info(`  To:      ${result.to}`);
-  info(`  Amount:  ${result.amount} ${result.symbol}`);
+  info(
+    `  Amount:  ${result.amount} ${result.symbol}${result.contractAddress ? ` (${escapeTerminalControls(result.contractAddress)})` : ""}`
+  );
   if (result.destinationTag !== void 0) info(`  Destination tag: ${result.destinationTag}`);
   if (result.memo) info(`  Memo:    ${escapeTerminalControls(result.memo)}`);
   info(`  Fee:     ${result.fee} ${result.feeSymbol}`);
@@ -7631,7 +9184,7 @@ async function sendTransaction(vault, params) {
       "Pass --yes to confirm, or --dry-run to preview without signing."
     );
   }
-  const rippleDestination = params.chain === Chain4.Ripple ? normalizeRippleDestination(params.to) : { address: params.to };
+  const rippleDestination = params.chain === Chain3.Ripple ? normalizeRippleDestination(params.to) : { address: params.to };
   const to = rippleDestination.address;
   if (params.destinationTag !== void 0 && rippleDestination.destinationTag !== void 0 && params.destinationTag !== rippleDestination.destinationTag) {
     throw new Error(
@@ -7672,7 +9225,8 @@ async function sendTransaction(vault, params) {
       params.chain,
       preview.memo,
       preview.destinationTag,
-      gas
+      gas,
+      dryResult.contractAddress
     );
   }
   if (!params.yes) {
@@ -7727,23 +9281,32 @@ async function sendTransaction(vault, params) {
 
 // src/commands/execute.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
-import { buildCosmosWasmExecuteMsg, Vultisig as Vultisig3 } from "@vultisig/sdk";
-var COSMOS_CHAIN_CONFIG = {
-  THORChain: {
-    chainId: "thorchain-1",
-    prefix: "thor",
-    denom: "rune",
-    decimals: 8,
-    gasLimit: "500000"
-  },
-  MayaChain: {
-    chainId: "mayachain-mainnet-v1",
-    prefix: "maya",
-    denom: "cacao",
-    decimals: 10,
-    gasLimit: "500000"
+import {
+  buildCosmosWasmExecuteMsg,
+  Chain as Chain4,
+  chainFeeCoin,
+  cosmosFeeCoinDenom,
+  getCosmosGasLimit,
+  Vultisig as Vultisig3
+} from "@vultisig/sdk";
+var SUPPORTED_COSMWASM_CHAINS = [Chain4.THORChain, Chain4.MayaChain];
+function getCosmosChainConfig(chain) {
+  if (!SUPPORTED_COSMWASM_CHAINS.includes(chain)) {
+    throw new Error(
+      `Chain ${chain} does not support CosmWasm execute. Supported chains: ${SUPPORTED_COSMWASM_CHAINS.join(", ")}`
+    );
   }
-};
+  const supportedChain = chain;
+  const feeCoin = chainFeeCoin[supportedChain];
+  const denom = cosmosFeeCoinDenom[supportedChain];
+  const gasLimit = getCosmosGasLimit({ chain: supportedChain, id: denom }).toString();
+  return {
+    denom,
+    decimals: feeCoin.decimals,
+    ticker: feeCoin.ticker,
+    gasLimit
+  };
+}
 function parseFunds(fundsStr) {
   if (!fundsStr) return [];
   return fundsStr.split(",").map((fund) => {
@@ -7756,14 +9319,7 @@ function parseFunds(fundsStr) {
 }
 async function executeExecute(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  const chainConfig = COSMOS_CHAIN_CONFIG[params.chain];
-  if (!chainConfig) {
-    throw new Error(
-      `Chain ${params.chain} does not support CosmWasm execute. Supported chains: ${Object.keys(
-        COSMOS_CHAIN_CONFIG
-      ).join(", ")}`
-    );
-  }
+  const chainConfig = getCosmosChainConfig(params.chain);
   let msg;
   try {
     msg = JSON.parse(params.msg);
@@ -7937,10 +9493,10 @@ Or use this URL: ${qrPayload}
 
 // src/commands/sign.ts
 var import_qrcode_terminal2 = __toESM(require_main(), 1);
-import { Chain as Chain6 } from "@vultisig/sdk";
+import { Chain as Chain5 } from "@vultisig/sdk";
 async function executeSignBytes(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain6).includes(params.chain)) {
+  if (!Object.values(Chain5).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   return signBytes(vault, params);
@@ -8020,10 +9576,10 @@ Or use this URL: ${qrPayload}
 }
 
 // src/commands/broadcast.ts
-import { Chain as Chain7, Vultisig as Vultisig4 } from "@vultisig/sdk";
+import { Chain as Chain6, Vultisig as Vultisig4 } from "@vultisig/sdk";
 async function executeBroadcast(ctx2, params) {
   const vault = await ctx2.ensureActiveVault();
-  if (!Object.values(Chain7).includes(params.chain)) {
+  if (!Object.values(Chain6).includes(params.chain)) {
     throw new Error(`Invalid chain: ${params.chain}`);
   }
   const broadcastSpinner = createSpinner("Broadcasting transaction...");
@@ -8052,9 +9608,9 @@ async function executeBroadcast(ctx2, params) {
 }
 
 // src/commands/tx-status.ts
-import { Chain as Chain8, isValidTxHash, Vultisig as Vultisig5 } from "@vultisig/sdk";
+import { Chain as Chain7, isValidTxHash, Vultisig as Vultisig5 } from "@vultisig/sdk";
 function resolveTxStatusParams(params) {
-  if (!Object.values(Chain8).includes(params.chain)) {
+  if (!Object.values(Chain7).includes(params.chain)) {
     throw new InvalidInputError(`Invalid chain: ${params.chain}`);
   }
   if (!isValidTxHash(params.chain, params.txHash)) {
@@ -9107,6 +10663,9 @@ Please specify more characters of the vault ID.`
   throw new Error(`Vault not found: "${idOrName}"`);
 }
 
+// src/commands/swap.ts
+import { toChainAmount } from "@vultisig/sdk";
+
 // ../../node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
 init_getAddress();
 init_keccak256();
@@ -9377,110 +10936,10 @@ function formatUnits(value, decimals) {
   return format(value, decimals);
 }
 
-// ../../node_modules/viem/_esm/utils/unit/parseUnits.js
-init_Value();
-function parseUnits(value, decimals) {
-  return from(value, decimals);
-}
-
-// ../../packages/core/chain/dist/amount/toChainAmount.js
-var ChainAmountParseError = class extends Error {
-  name = "ChainAmountParseError";
-  constructor(message) {
-    super(message);
-  }
-};
-var SCIENTIFIC_DECIMAL = /^([+-]?)(?:(\d+)\.?(\d*)|\.(\d+))[eE]([+-]?\d+)$/i;
-var MAX_SCALE_ABS = 10000n;
-var padFractionDigits = (frac, totalLen) => {
-  const need = totalLen - BigInt(frac.length);
-  if (need <= 0n) {
-    return frac;
-  }
-  if (need <= BigInt(Number.MAX_SAFE_INTEGER)) {
-    return `${"0".repeat(Number(need))}${frac}`;
-  }
-  let out = frac;
-  while (BigInt(out.length) < totalLen) {
-    out = `0${out}`;
-  }
-  return out;
-};
-var expandScientificNotationToDecimalString = (s) => {
-  const m = SCIENTIFIC_DECIMAL.exec(s.trim());
-  if (!m) {
-    throw new ChainAmountParseError(`Invalid amount: "${s}"`);
-  }
-  const signNeg = m[1] === "-";
-  let digitStr;
-  let fracLen;
-  if (m[4] !== void 0) {
-    digitStr = m[4];
-    fracLen = digitStr.length;
-  } else {
-    digitStr = `${m[2] ?? ""}${m[3] ?? ""}`;
-    fracLen = (m[3] ?? "").length;
-  }
-  if (!/^\d+$/.test(digitStr)) {
-    throw new ChainAmountParseError(`Invalid amount: "${s}"`);
-  }
-  const expStr = m[5] ?? "";
-  if (expStr === "" || expStr === "+" || expStr === "-") {
-    throw new ChainAmountParseError(`Invalid amount: "${s}"`);
-  }
-  const allDigits = BigInt(digitStr);
-  const exp = BigInt(expStr);
-  const scale = exp - BigInt(fracLen);
-  const scaleAbs = scale < 0n ? -scale : scale;
-  if (scaleAbs > MAX_SCALE_ABS) {
-    throw new ChainAmountParseError(`Amount exponent out of supported range: "${s}"`);
-  }
-  let absResult;
-  if (scale >= 0n) {
-    const mult = 10n ** scale;
-    absResult = (allDigits * mult).toString();
-  } else {
-    const k = -scale;
-    const divisor = 10n ** k;
-    const intPart = allDigits / divisor;
-    const rem = allDigits % divisor;
-    const frac = padFractionDigits(rem.toString(), k);
-    absResult = intPart === 0n ? `0.${frac}` : `${intPart.toString()}.${frac}`;
-  }
-  if (signNeg && allDigits !== 0n) {
-    return `-${absResult}`;
-  }
-  return absResult;
-};
-var formatNumberAmount = (amount) => {
-  const str2 = amount.toString();
-  return /[eE]/.test(str2) ? expandScientificNotationToDecimalString(str2) : str2;
-};
-var truncateToDecimals = (s, decimals) => {
-  const dotIdx = s.indexOf(".");
-  if (dotIdx === -1)
-    return s;
-  if (decimals === 0)
-    return s.slice(0, dotIdx);
-  const fracPart = s.slice(dotIdx + 1);
-  if (fracPart.length <= decimals)
-    return s;
-  return `${s.slice(0, dotIdx + 1)}${fracPart.slice(0, decimals)}`;
-};
-var toChainAmount = (amount, decimals) => {
-  if (typeof amount === "string") {
-    const trimmed = amount.trim();
-    if (!trimmed) {
-      throw new ChainAmountParseError("Amount cannot be empty");
-    }
-    if (/[eE]/.test(trimmed)) {
-      const expanded = expandScientificNotationToDecimalString(trimmed);
-      return parseUnits(truncateToDecimals(expanded, decimals), decimals);
-    }
-    return parseUnits(truncateToDecimals(trimmed, decimals), decimals);
-  }
-  return parseUnits(truncateToDecimals(formatNumberAmount(amount), decimals), decimals);
-};
+// ../../node_modules/viem/_esm/index.js
+init_concat();
+init_toBytes();
+init_keccak256();
 
 // src/commands/swap.ts
 async function executeSwapChains(ctx2) {
@@ -9511,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,
@@ -9676,7 +11135,7 @@ async function executeSwap(ctx2, options) {
 }
 
 // src/commands/settings.ts
-import { Chain as Chain9, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
+import { Chain as Chain8, fiatCurrencies as fiatCurrencies2, fiatCurrencyNameRecord as fiatCurrencyNameRecord3 } from "@vultisig/sdk";
 import chalk6 from "chalk";
 async function executeCurrency(ctx2, newCurrency) {
   const vault = await ctx2.ensureActiveVault();
@@ -9747,7 +11206,7 @@ async function executeAddressBook(ctx2, options = {}) {
         type: "select",
         name: "chain",
         message: "Select chain:",
-        choices: Object.values(Chain9)
+        choices: Object.values(Chain8)
       });
     }
     if (!address) {
@@ -10238,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);
       },
@@ -10245,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) => {
@@ -10348,11 +11818,11 @@ var AskInterface = class {
 
 // src/agent/auth.ts
 import { randomBytes as randomBytes3 } from "node:crypto";
-import { Chain as Chain10, computePersonalSignHash, formatEcdsaSignature65 } from "@vultisig/sdk";
+import { Chain as Chain9, computePersonalSignHash, formatEcdsaSignature65 } from "@vultisig/sdk";
 async function authenticateVault(client, vault, password, maxAttempts = 3) {
   const publicKey = vault.publicKeys.ecdsa;
   const chainCode = vault.hexChainCode;
-  const ethAddress = await vault.address(Chain10.Ethereum);
+  const ethAddress = await vault.address(Chain9.Ethereum);
   const nonce = "0x" + randomBytes3(16).toString("hex");
   const expiresAt = new Date(Date.now() + 15 * 60 * 1e3).toISOString();
   const authMessage = JSON.stringify({
@@ -10369,7 +11839,7 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
         process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
 `);
       }
-      const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain10.Ethereum }, {});
+      const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain9.Ethereum }, {});
       if (signature.recovery === void 0) {
         throw new Error("Agent authentication requires an ECDSA recovery id");
       }
@@ -10702,10 +12172,13 @@ import { getChainKind as getChainKind4 } from "@vultisig/sdk";
 // src/agent/executor.ts
 import {
   Chain as Chain11,
-  chainFeeCoin,
+  chainFeeCoin as chainFeeCoin2,
+  computeEip712Hash,
   getChainKind as getChainKind3,
+  getEvmRpcUrl,
   parseThorSwapMemo,
   resolveChainReference,
+  toCanonicalEvmSignature,
   VaultError as VaultError3,
   VaultErrorCode as VaultErrorCode3,
   Vultisig as VultisigSdk
@@ -10866,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",
@@ -10882,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 */
@@ -10922,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;
@@ -10931,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;
   }
@@ -11023,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
@@ -11380,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 });
@@ -11926,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);
@@ -11955,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;
@@ -12007,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",
@@ -12053,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, {
@@ -12082,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;
@@ -12158,7 +13920,7 @@ var AgentExecutor = class {
     }
     if (this.verbose) process.stderr.write(`[sign_typed_data] primaryType=${primaryType} domain.name=${domain.name}
 `);
-    const eip712Hash = computeEIP712Hash(domain, types, primaryType, message);
+    const eip712Hash = computeEip712Hash(domain, types, primaryType, message);
     if (this.verbose) process.stderr.write(`[sign_typed_data] hash=${eip712Hash}
 `);
     const chainName = params.chain;
@@ -12322,7 +14084,7 @@ function convertBaseUnitsToDecimal(chain, amountRaw, context) {
       `${context}: amount '${amountRaw}' for ${chain} exceeds ${MAX_AMOUNT_DIGITS}-digit safety bound. Likely a quote-side bug. Refusing to sign.`
     );
   }
-  const decimals = chainFeeCoin[chain]?.decimals;
+  const decimals = chainFeeCoin2[chain]?.decimals;
   if (decimals === void 0) {
     throw new VaultError3(VaultErrorCode3.UnsupportedChain, `${context}: no native decimals registered for ${chain}`);
   }
@@ -12351,7 +14113,7 @@ function parseNonEvmEnvelope(serverTxData, chain) {
   const amountDecimal = convertBaseUnitsToDecimal(chain, amountRaw, "parseNonEvmEnvelope");
   let symbol;
   const tokenResolved = serverTxData?.resolved?.labels?.token_resolved;
-  const nativeTicker = chainFeeCoin[chain]?.ticker;
+  const nativeTicker = chainFeeCoin2[chain]?.ticker;
   if (typeof tokenResolved === "string" && tokenResolved !== nativeTicker) {
     symbol = tokenResolved;
   }
@@ -12361,74 +14123,6 @@ function parseNonEvmEnvelope(serverTxData, chain) {
 function resolveChainId(chainId) {
   return resolveChainReference(chainId) ?? null;
 }
-function computeEIP712Hash(domain, types, primaryType, message) {
-  const messageTypes = { ...types };
-  delete messageTypes.EIP712Domain;
-  const normalizedDomain = domain.chainId !== void 0 ? { ...domain, chainId: coerceChainId(domain.chainId) } : domain;
-  return hashTypedData({
-    domain: normalizedDomain,
-    types: messageTypes,
-    primaryType,
-    message
-  });
-}
-function coerceChainId(raw) {
-  if (typeof raw === "number" || typeof raw === "bigint") return raw;
-  const s = String(raw).trim();
-  if (s === "") {
-    throw new Error("EIP-712 domain.chainId is empty");
-  }
-  if (/^[0-9]+$/.test(s) || /^0x[0-9a-fA-F]+$/.test(s)) {
-    const big = BigInt(s);
-    return big <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(big) : big;
-  }
-  throw new Error(`EIP-712 domain.chainId not parseable: ${String(raw)}`);
-}
-var SECP256K1_N = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n;
-function toCanonicalEvmSignature(sigHex, recovery) {
-  const { r, s } = parseDERSignature(sigHex);
-  const sBig = BigInt("0x" + s);
-  if (sBig > SECP256K1_N >> 1n) {
-    const folded = SECP256K1_N - sBig;
-    return { r, s: folded.toString(16).padStart(64, "0"), recovery: recovery ^ 1 };
-  }
-  return { r, s, recovery };
-}
-function parseDERSignature(sigHex) {
-  const raw = sigHex.startsWith("0x") ? sigHex.slice(2) : sigHex;
-  if (raw.length === 128) {
-    return { r: raw.slice(0, 64), s: raw.slice(64) };
-  }
-  let offset = 0;
-  if (raw.slice(offset, offset + 2) !== "30") {
-    return {
-      r: raw.slice(0, 64).padStart(64, "0"),
-      s: raw.slice(64).padStart(64, "0")
-    };
-  }
-  offset += 2;
-  offset += 2;
-  if (raw.slice(offset, offset + 2) !== "02") throw new Error("Invalid DER: expected 02 for R");
-  offset += 2;
-  const rLen = parseInt(raw.slice(offset, offset + 2), 16);
-  offset += 2;
-  let rHex = raw.slice(offset, offset + rLen * 2);
-  offset += rLen * 2;
-  if (rHex.length > 64 && rHex.startsWith("00")) {
-    rHex = rHex.slice(rHex.length - 64);
-  }
-  rHex = rHex.padStart(64, "0");
-  if (raw.slice(offset, offset + 2) !== "02") throw new Error("Invalid DER: expected 02 for S");
-  offset += 2;
-  const sLen = parseInt(raw.slice(offset, offset + 2), 16);
-  offset += 2;
-  let sHex = raw.slice(offset, offset + sLen * 2);
-  if (sHex.length > 64 && sHex.startsWith("00")) {
-    sHex = sHex.slice(sHex.length - 64);
-  }
-  sHex = sHex.padStart(64, "0");
-  return { r: rHex, s: sHex };
-}
 
 // src/agent/toolOutputSigning.ts
 var POLYMARKET_DEPOSIT_TOOL = "polymarket_deposit";
@@ -12670,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":
@@ -12832,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()
       });
@@ -12852,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;
@@ -12878,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
   // ============================================================================
@@ -13139,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;
@@ -13201,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);
   }
@@ -13421,7 +15179,7 @@ var AgentClient = class {
 };
 
 // src/agent/context.ts
-import { Chain as Chain13 } from "@vultisig/sdk";
+import { chainFeeCoin as chainFeeCoin3 } from "@vultisig/sdk";
 function applyChainPublicKeys(vault, context) {
   const raw = vault.data.chainPublicKeys;
   if (!raw) return;
@@ -13482,11 +15240,12 @@ async function buildMessageContext(vault) {
     const coins = [];
     const chains = vault.chains;
     for (const chain of chains) {
+      const nativeCoin = chainFeeCoin3[chain];
       coins.push({
         chain: chain.toString(),
-        ticker: getNativeTokenTicker(chain),
+        ticker: nativeCoin?.ticker ?? chain.toString(),
         is_native_token: true,
-        decimals: getNativeTokenDecimals(chain)
+        decimals: nativeCoin?.decimals ?? 18
       });
       const tokens = vault.tokens[chain] || [];
       for (const token of tokens) {
@@ -13532,62 +15291,6 @@ async function buildMinimalContext(vault) {
   }
   return context;
 }
-function getNativeTokenTicker(chain) {
-  const tickers = {
-    [Chain13.Ethereum]: "ETH",
-    [Chain13.Bitcoin]: "BTC",
-    [Chain13.Solana]: "SOL",
-    [Chain13.THORChain]: "RUNE",
-    [Chain13.Cosmos]: "ATOM",
-    [Chain13.Avalanche]: "AVAX",
-    [Chain13.BSC]: "BNB",
-    [Chain13.Polygon]: "MATIC",
-    [Chain13.Arbitrum]: "ETH",
-    [Chain13.Optimism]: "ETH",
-    [Chain13.Base]: "ETH",
-    [Chain13.Blast]: "ETH",
-    [Chain13.Litecoin]: "LTC",
-    [Chain13.Dogecoin]: "DOGE",
-    [Chain13.Dash]: "DASH",
-    [Chain13.MayaChain]: "CACAO",
-    [Chain13.Polkadot]: "DOT",
-    [Chain13.Sui]: "SUI",
-    [Chain13.Ton]: "TON",
-    [Chain13.Tron]: "TRX",
-    [Chain13.Ripple]: "XRP",
-    [Chain13.Dydx]: "DYDX",
-    [Chain13.Osmosis]: "OSMO",
-    [Chain13.Terra]: "LUNA",
-    [Chain13.Noble]: "USDC",
-    [Chain13.Kujira]: "KUJI",
-    [Chain13.Zksync]: "ETH",
-    [Chain13.CronosChain]: "CRO"
-  };
-  return tickers[chain] || chain.toString();
-}
-function getNativeTokenDecimals(chain) {
-  const decimals = {
-    [Chain13.Bitcoin]: 8,
-    [Chain13.Litecoin]: 8,
-    [Chain13.Dogecoin]: 8,
-    [Chain13.Dash]: 8,
-    [Chain13.Solana]: 9,
-    [Chain13.Sui]: 9,
-    [Chain13.Ton]: 9,
-    [Chain13.Polkadot]: 10,
-    [Chain13.Cosmos]: 6,
-    [Chain13.THORChain]: 8,
-    [Chain13.MayaChain]: 10,
-    [Chain13.Osmosis]: 6,
-    [Chain13.Dydx]: 18,
-    [Chain13.Tron]: 6,
-    [Chain13.Ripple]: 6,
-    [Chain13.Noble]: 6,
-    [Chain13.Kujira]: 6,
-    [Chain13.Terra]: 6
-  };
-  return decimals[chain] || 18;
-}
 
 // src/agent/pipe.ts
 import * as readline from "node:readline";
@@ -13817,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 ?? ""]);
@@ -13960,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",
@@ -13982,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,
@@ -13993,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;
@@ -14066,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
@@ -14200,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;
@@ -14322,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);
@@ -14366,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;
     }
@@ -14398,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(() => {
         });
@@ -14469,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);
@@ -14787,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);
@@ -14854,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}
@@ -14861,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;
     }
@@ -15077,7 +16852,7 @@ var ChatTUI = class {
       },
       onAssistantMessage: (content) => {
         if (this.isStreaming) {
-          process.stdout.write(renderMarkdown(this.currentStreamText) + "\n");
+          process.stdout.write(renderMarkdown(content || this.currentStreamText) + "\n");
           this.isStreaming = false;
         } else if (content && content !== this.currentStreamText) {
           const ts = this.timestamp();
@@ -15396,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;
@@ -15435,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));
@@ -15513,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(`
@@ -15757,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";
@@ -15765,7 +17547,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "4.4.0";
+    cachedVersion = "4.6.0";
     return cachedVersion;
   }
   try {
@@ -15778,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() {
@@ -15862,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}`);
@@ -16225,7 +18007,7 @@ var EventBuffer = class {
 };
 
 // src/interactive/session.ts
-import { Chain as Chain14, 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";
@@ -17027,7 +18809,7 @@ Error: ${error2.message}`));
     const raw = args.includes("--raw");
     await this.withCancellation(
       () => executeBalance(this.ctx, {
-        chain: chainStr ? findChainByName(chainStr) || chainStr : void 0,
+        chain: resolveOptionalChainOrThrow(chainStr),
         includeTokens,
         raw
       })
@@ -17057,7 +18839,7 @@ Error: ${error2.message}`));
       return;
     }
     const [chainStr, to, amount, ...rest] = args;
-    const chain = findChainByName(chainStr) || chainStr;
+    const chain = resolveChainOrThrow(chainStr);
     let tokenId;
     let memo;
     let destinationTag;
@@ -17074,7 +18856,7 @@ Error: ${error2.message}`));
       } else if (rest[i] === "--destination-tag") {
         const tag = rest[i + 1];
         const parsedTag = Number(tag);
-        if (chain !== Chain14.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;
@@ -17099,7 +18881,7 @@ Error: ${error2.message}`));
       return;
     }
     const [chainStr, txHash, ...rest] = args;
-    const chain = findChainByName(chainStr) || chainStr;
+    const chain = resolveChainOrThrow(chainStr);
     const noWait = rest.includes("--no-wait");
     await this.withCancellation(() => executeTxStatus(this.ctx, { chain, txHash, noWait }));
   }
@@ -17138,7 +18920,7 @@ Error: ${error2.message}`));
       return;
     }
     const chainStr = args[0];
-    const chain = findChainByName(chainStr) || chainStr;
+    const chain = resolveChainOrThrow(chainStr);
     let add;
     let remove;
     for (let i = 1; i < args.length; i++) {
@@ -17160,8 +18942,8 @@ Error: ${error2.message}`));
       return;
     }
     const [fromChainStr, toChainStr, amountStr, ...rest] = args;
-    const fromChain = findChainByName(fromChainStr) || fromChainStr;
-    const toChain = findChainByName(toChainStr) || toChainStr;
+    const fromChain = resolveChainOrThrow(fromChainStr, "source chain");
+    const toChain = resolveChainOrThrow(toChainStr, "destination chain");
     const amount = amountStr;
     let fromToken;
     let toToken;
@@ -17186,8 +18968,8 @@ Error: ${error2.message}`));
       return;
     }
     const [fromChainStr, toChainStr, amountStr, ...rest] = args;
-    const fromChain = findChainByName(fromChainStr) || fromChainStr;
-    const toChain = findChainByName(toChainStr) || toChainStr;
+    const fromChain = resolveChainOrThrow(fromChainStr, "source chain");
+    const toChain = resolveChainOrThrow(toChainStr, "destination chain");
     const amount = amountStr;
     let fromToken;
     let toToken;
@@ -17227,7 +19009,7 @@ Error: ${error2.message}`));
         remove = args[i + 1];
         i++;
       } else if (args[i] === "--chain" && i + 1 < args.length) {
-        chain = findChainByName(args[i + 1]) || args[i + 1];
+        chain = resolveChainOrThrow(args[i + 1], "chain");
         i++;
       }
     }
@@ -17302,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";
@@ -17329,7 +19111,7 @@ function getChains() {
 }
 function getVaultNames() {
   try {
-    const vaultDir = getVultisigConfigDir4();
+    const vaultDir = getVultisigConfigDir5();
     if (!existsSync3(vaultDir)) return [];
     const files = readdirSync(vaultDir);
     const names = [];
@@ -17582,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() });
@@ -17896,7 +19678,7 @@ Examples:
   withExit(async (chainStr, options) => {
     const context = await init(program2.opts().vault);
     await executeBalance(context, {
-      chain: chainStr ? findChainByName(chainStr) || chainStr : void 0,
+      chain: resolveOptionalChainOrThrow(chainStr),
       includeTokens: options.tokens,
       raw: options.raw
     });
@@ -17920,8 +19702,8 @@ See also: balance, tx-status`
     async (chainStr, to, amount, options) => {
       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 = findChainByName(chainStr) || chainStr;
-      if (options.destinationTag !== void 0 && chain !== Chain15.Ripple) {
+      const chain = resolveChainOrThrow(chainStr);
+      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);
@@ -17955,7 +19737,7 @@ Examples:
     async (chainStr, contract, msg, options) => {
       const context = await init(program2.opts().vault, options.password);
       await executeExecute(context, {
-        chain: findChainByName(chainStr) || chainStr,
+        chain: resolveChainOrThrow(chainStr),
         contract,
         msg,
         funds: options.funds,
@@ -17971,7 +19753,7 @@ program2.command("sign").description("Sign pre-hashed bytes (for externally cons
   withExit(async (options) => {
     const context = await init(program2.opts().vault, options.password);
     await executeSignBytes(context, {
-      chain: findChainByName(options.chain) || options.chain,
+      chain: resolveChainOrThrow(options.chain),
       bytes: options.bytes,
       password: options.password
     });
@@ -17981,7 +19763,7 @@ program2.command("broadcast").description("Broadcast a pre-signed raw transactio
   withExit(async (options) => {
     const context = await init(program2.opts().vault);
     await executeBroadcast(context, {
-      chain: findChainByName(options.chain) || options.chain,
+      chain: resolveChainOrThrow(options.chain),
       rawTx: options.rawTx
     });
   })
@@ -18005,7 +19787,7 @@ Examples:
       );
     }
     const params = resolveTxStatusParams({
-      chain: findChainByName(options.chain) || options.chain,
+      chain: resolveChainOrThrow(options.chain),
       txHash: options.txHash,
       noWait: !options.wait,
       timeoutSec
@@ -18081,7 +19863,7 @@ program2.command("address-book").description("Manage address book entries").opti
     await executeAddressBook(context, {
       add: options.add,
       remove: options.remove,
-      chain: options.chain ? findChainByName(options.chain) || options.chain : void 0,
+      chain: resolveOptionalChainOrThrow(options.chain),
       address: options.address,
       name: options.name
     });
@@ -18098,9 +19880,9 @@ Examples:
   withExit(async (options) => {
     const context = await init(program2.opts().vault);
     await executeChains(context, {
-      add: options.add ? findChainByName(options.add) || options.add : void 0,
+      add: resolveOptionalChainOrThrow(options.add, "chain"),
       addAll: options.addAll,
-      remove: options.remove ? findChainByName(options.remove) || options.remove : void 0
+      remove: resolveOptionalChainOrThrow(options.remove, "chain")
     });
   })
 );
@@ -18217,8 +19999,8 @@ See also: swap-quote, swap-chains, balance`
       if (amountStr && options.max) throw new Error("Cannot specify both amount and --max");
       const context = await init(program2.opts().vault);
       await executeSwap(context, {
-        fromChain: findChainByName(fromChainStr) || fromChainStr,
-        toChain: findChainByName(toChainStr) || toChainStr,
+        fromChain: resolveChainOrThrow(fromChainStr, "source chain"),
+        toChain: resolveChainOrThrow(toChainStr, "destination chain"),
         amount: options.max ? "max" : amountStr,
         fromToken: options.fromToken,
         toToken: options.toToken,