@vultisig/cli 4.4.0 → 4.5.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;
 };
@@ -1234,70 +1234,11 @@ var init_base = __esm({
   }
 });
 
-// ../../node_modules/viem/_esm/errors/abi.js
-var AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, BytesSizeMismatchError, InvalidAbiEncodingTypeError, InvalidArrayError;
-var init_abi = __esm({
-  "../../node_modules/viem/_esm/errors/abi.js"() {
-    init_size();
-    init_base();
-    AbiEncodingArrayLengthMismatchError = class extends BaseError {
-      constructor({ expectedLength, givenLength, type }) {
-        super([
-          `ABI encoding array length mismatch for type ${type}.`,
-          `Expected length: ${expectedLength}`,
-          `Given length: ${givenLength}`
-        ].join("\n"), { name: "AbiEncodingArrayLengthMismatchError" });
-      }
-    };
-    AbiEncodingBytesSizeMismatchError = class extends BaseError {
-      constructor({ expectedSize, value }) {
-        super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
-      }
-    };
-    AbiEncodingLengthMismatchError = class extends BaseError {
-      constructor({ expectedLength, givenLength }) {
-        super([
-          "ABI encoding params/values length mismatch.",
-          `Expected length (params): ${expectedLength}`,
-          `Given length (values): ${givenLength}`
-        ].join("\n"), { name: "AbiEncodingLengthMismatchError" });
-      }
-    };
-    BytesSizeMismatchError = class extends BaseError {
-      constructor({ expectedSize, givenSize }) {
-        super(`Expected bytes${expectedSize}, got bytes${givenSize}.`, {
-          name: "BytesSizeMismatchError"
-        });
-      }
-    };
-    InvalidAbiEncodingTypeError = class extends BaseError {
-      constructor(type, { docsPath }) {
-        super([
-          `Type "${type}" is not a valid encoding type.`,
-          "Please provide a valid ABI type."
-        ].join("\n"), { docsPath, name: "InvalidAbiEncodingType" });
-      }
-    };
-    InvalidArrayError = class extends BaseError {
-      constructor(value) {
-        super([`Value "${value}" is not a valid array.`].join("\n"), {
-          name: "InvalidArrayError"
-        });
-      }
-    };
-  }
-});
-
 // ../../node_modules/viem/_esm/errors/data.js
-var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
+var SizeExceedsPaddingSizeError;
 var init_data = __esm({
   "../../node_modules/viem/_esm/errors/data.js"() {
     init_base();
-    SliceOffsetOutOfBoundsError = class extends BaseError {
-      constructor({ offset, position, size: size2 }) {
-        super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
-      }
-    };
     SizeExceedsPaddingSizeError = class extends BaseError {
       constructor({ size: size2, targetSize, type }) {
         super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
@@ -1912,25 +1853,6 @@ var init_keccak256 = __esm({
   }
 });
 
-// ../../node_modules/viem/_esm/errors/address.js
-var InvalidAddressError2;
-var init_address = __esm({
-  "../../node_modules/viem/_esm/errors/address.js"() {
-    init_base();
-    InvalidAddressError2 = class extends BaseError {
-      constructor({ address }) {
-        super(`Address "${address}" is invalid.`, {
-          metaMessages: [
-            "- Address must be a hex value of 20 bytes (40 hex characters).",
-            "- Address must match its checksum counterpart."
-          ],
-          name: "InvalidAddressError"
-        });
-      }
-    };
-  }
-});
-
 // ../../node_modules/viem/_esm/utils/lru.js
 var LruMap;
 var init_lru = __esm({
@@ -1998,374 +1920,6 @@ var init_getAddress = __esm({
   }
 });
 
-// ../../node_modules/viem/_esm/utils/address/isAddress.js
-function isAddress(address, options) {
-  const { strict = true } = options ?? {};
-  const cacheKey = `${address}.${strict}`;
-  if (isAddressCache.has(cacheKey))
-    return isAddressCache.get(cacheKey);
-  const result = (() => {
-    if (!addressRegex.test(address))
-      return false;
-    if (address.toLowerCase() === address)
-      return true;
-    if (strict)
-      return checksumAddress(address) === address;
-    return true;
-  })();
-  isAddressCache.set(cacheKey, result);
-  return result;
-}
-var addressRegex, isAddressCache;
-var init_isAddress = __esm({
-  "../../node_modules/viem/_esm/utils/address/isAddress.js"() {
-    init_lru();
-    init_getAddress();
-    addressRegex = /^0x[a-fA-F0-9]{40}$/;
-    isAddressCache = /* @__PURE__ */ new LruMap(8192);
-  }
-});
-
-// ../../node_modules/viem/_esm/utils/data/concat.js
-function concat(values) {
-  if (typeof values[0] === "string")
-    return concatHex(values);
-  return concatBytes2(values);
-}
-function concatBytes2(values) {
-  let length = 0;
-  for (const arr of values) {
-    length += arr.length;
-  }
-  const result = new Uint8Array(length);
-  let offset = 0;
-  for (const arr of values) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-function concatHex(values) {
-  return `0x${values.reduce((acc, x) => acc + x.replace("0x", ""), "")}`;
-}
-var init_concat = __esm({
-  "../../node_modules/viem/_esm/utils/data/concat.js"() {
-  }
-});
-
-// ../../node_modules/viem/_esm/utils/data/slice.js
-function slice(value, start, end, { strict } = {}) {
-  if (isHex(value, { strict: false }))
-    return sliceHex(value, start, end, {
-      strict
-    });
-  return sliceBytes(value, start, end, {
-    strict
-  });
-}
-function assertStartOffset(value, start) {
-  if (typeof start === "number" && start > 0 && start > size(value) - 1)
-    throw new SliceOffsetOutOfBoundsError({
-      offset: start,
-      position: "start",
-      size: size(value)
-    });
-}
-function assertEndOffset(value, start, end) {
-  if (typeof start === "number" && typeof end === "number" && size(value) !== end - start) {
-    throw new SliceOffsetOutOfBoundsError({
-      offset: end,
-      position: "end",
-      size: size(value)
-    });
-  }
-}
-function sliceBytes(value_, start, end, { strict } = {}) {
-  assertStartOffset(value_, start);
-  const value = value_.slice(start, end);
-  if (strict)
-    assertEndOffset(value, start, end);
-  return value;
-}
-function sliceHex(value_, start, end, { strict } = {}) {
-  assertStartOffset(value_, start);
-  const value = `0x${value_.replace("0x", "").slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
-  if (strict)
-    assertEndOffset(value, start, end);
-  return value;
-}
-var init_slice = __esm({
-  "../../node_modules/viem/_esm/utils/data/slice.js"() {
-    init_data();
-    init_isHex();
-    init_size();
-  }
-});
-
-// ../../node_modules/viem/_esm/utils/regex.js
-var bytesRegex, integerRegex;
-var init_regex = __esm({
-  "../../node_modules/viem/_esm/utils/regex.js"() {
-    bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
-    integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
-  }
-});
-
-// ../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
-function encodeAbiParameters(params, values) {
-  if (params.length !== values.length)
-    throw new AbiEncodingLengthMismatchError({
-      expectedLength: params.length,
-      givenLength: values.length
-    });
-  const preparedParams = prepareParams({
-    params,
-    values
-  });
-  return encodeParams(preparedParams);
-}
-function prepareParams({ params, values }) {
-  const preparedParams = [];
-  for (let i = 0; i < params.length; i++) {
-    preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
-  }
-  return preparedParams;
-}
-function prepareParam({ param, value }) {
-  const arrayComponents = getArrayComponents(param.type);
-  if (arrayComponents) {
-    const [length, type] = arrayComponents;
-    return encodeArray(value, { length, param: { ...param, type } });
-  }
-  if (param.type === "tuple") {
-    return encodeTuple(value, {
-      param
-    });
-  }
-  if (param.type === "address") {
-    return encodeAddress(value);
-  }
-  if (param.type === "bool") {
-    return encodeBool(value);
-  }
-  if (param.type.startsWith("uint") || param.type.startsWith("int")) {
-    const signed = param.type.startsWith("int");
-    const [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
-    return encodeNumber(value, {
-      signed,
-      size: Number(size2)
-    });
-  }
-  if (param.type.startsWith("bytes")) {
-    return encodeBytes(value, { param });
-  }
-  if (param.type === "string") {
-    return encodeString(value);
-  }
-  throw new InvalidAbiEncodingTypeError(param.type, {
-    docsPath: "/docs/contract/encodeAbiParameters"
-  });
-}
-function encodeParams(preparedParams) {
-  let staticSize = 0;
-  for (let i = 0; i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic)
-      staticSize += 32;
-    else
-      staticSize += size(encoded);
-  }
-  const staticParams = [];
-  const dynamicParams = [];
-  let dynamicSize = 0;
-  for (let i = 0; i < preparedParams.length; i++) {
-    const { dynamic, encoded } = preparedParams[i];
-    if (dynamic) {
-      staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
-      dynamicParams.push(encoded);
-      dynamicSize += size(encoded);
-    } else {
-      staticParams.push(encoded);
-    }
-  }
-  return concatHex([...staticParams, ...dynamicParams]);
-}
-function encodeAddress(value) {
-  if (!isAddress(value))
-    throw new InvalidAddressError2({ address: value });
-  return { dynamic: false, encoded: padHex(value.toLowerCase()) };
-}
-function encodeArray(value, { length, param }) {
-  const dynamic = length === null;
-  if (!Array.isArray(value))
-    throw new InvalidArrayError(value);
-  if (!dynamic && value.length !== length)
-    throw new AbiEncodingArrayLengthMismatchError({
-      expectedLength: length,
-      givenLength: value.length,
-      type: `${param.type}[${length}]`
-    });
-  let dynamicChild = value.length === 0 && isDynamicType(param);
-  const preparedParams = [];
-  for (let i = 0; i < value.length; i++) {
-    const preparedParam = prepareParam({ param, value: value[i] });
-    if (preparedParam.dynamic)
-      dynamicChild = true;
-    preparedParams.push(preparedParam);
-  }
-  if (dynamic || dynamicChild) {
-    const data = encodeParams(preparedParams);
-    if (dynamic) {
-      const length2 = numberToHex(preparedParams.length, { size: 32 });
-      return {
-        dynamic: true,
-        encoded: concatHex([length2, data])
-      };
-    }
-    if (dynamicChild)
-      return { dynamic: true, encoded: data };
-  }
-  return {
-    dynamic: false,
-    encoded: concatHex(preparedParams.map(({ encoded }) => encoded))
-  };
-}
-function encodeBytes(value, { param }) {
-  const [, paramSize] = param.type.split("bytes");
-  const bytesSize = size(value);
-  if (!paramSize) {
-    let value_ = value;
-    if (bytesSize % 32 !== 0)
-      value_ = padHex(value_, {
-        dir: "right",
-        size: Math.ceil((value.length - 2) / 2 / 32) * 32
-      });
-    return {
-      dynamic: true,
-      encoded: concatHex([
-        padHex(numberToHex(bytesSize, { size: 32 })),
-        value_
-      ])
-    };
-  }
-  if (bytesSize !== Number.parseInt(paramSize, 10))
-    throw new AbiEncodingBytesSizeMismatchError({
-      expectedSize: Number.parseInt(paramSize, 10),
-      value
-    });
-  return { dynamic: false, encoded: padHex(value, { dir: "right" }) };
-}
-function encodeBool(value) {
-  if (typeof value !== "boolean")
-    throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
-  return { dynamic: false, encoded: padHex(boolToHex(value)) };
-}
-function encodeNumber(value, { signed, size: size2 = 256 }) {
-  if (typeof size2 === "number") {
-    const max = 2n ** (BigInt(size2) - (signed ? 1n : 0n)) - 1n;
-    const min = signed ? -max - 1n : 0n;
-    if (value > max || value < min)
-      throw new IntegerOutOfRangeError({
-        max: max.toString(),
-        min: min.toString(),
-        signed,
-        size: size2 / 8,
-        value: value.toString()
-      });
-  }
-  return {
-    dynamic: false,
-    encoded: numberToHex(value, {
-      size: 32,
-      signed
-    })
-  };
-}
-function encodeString(value) {
-  const hexValue = stringToHex(value);
-  const partsLength = Math.ceil(size(hexValue) / 32);
-  const parts = [];
-  for (let i = 0; i < partsLength; i++) {
-    parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
-      dir: "right"
-    }));
-  }
-  return {
-    dynamic: true,
-    encoded: concatHex([
-      padHex(numberToHex(size(hexValue), { size: 32 })),
-      ...parts
-    ])
-  };
-}
-function encodeTuple(value, { param }) {
-  let dynamic = false;
-  const preparedParams = [];
-  for (let i = 0; i < param.components.length; i++) {
-    const param_ = param.components[i];
-    const index = Array.isArray(value) ? i : param_.name;
-    const preparedParam = prepareParam({
-      param: param_,
-      value: value[index]
-    });
-    preparedParams.push(preparedParam);
-    if (preparedParam.dynamic)
-      dynamic = true;
-  }
-  return {
-    dynamic,
-    encoded: dynamic ? encodeParams(preparedParams) : concatHex(preparedParams.map(({ encoded }) => encoded))
-  };
-}
-function getArrayComponents(type) {
-  const matches = type.match(/^(.*)\[(\d+)?\]$/);
-  return matches ? (
-    // Return `null` if the array is dynamic.
-    [matches[2] ? Number(matches[2]) : null, matches[1]]
-  ) : void 0;
-}
-function isDynamicType(param) {
-  const { type } = param;
-  if (type === "string")
-    return true;
-  if (type === "bytes")
-    return true;
-  if (type.endsWith("[]"))
-    return true;
-  if (type === "tuple")
-    return param.components.some(isDynamicType);
-  const arrayComponents = getArrayComponents(type);
-  if (arrayComponents)
-    return isDynamicType({ ...param, type: arrayComponents[1] });
-  return false;
-}
-var init_encodeAbiParameters = __esm({
-  "../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
-    init_abi();
-    init_address();
-    init_base();
-    init_encoding();
-    init_isAddress();
-    init_concat();
-    init_pad();
-    init_size();
-    init_slice();
-    init_toHex();
-    init_regex();
-  }
-});
-
-// ../../node_modules/viem/_esm/utils/stringify.js
-var stringify;
-var init_stringify = __esm({
-  "../../node_modules/viem/_esm/utils/stringify.js"() {
-    stringify = (value, replacer, space) => JSON.stringify(value, (key, value_) => {
-      const value2 = typeof value_ === "bigint" ? value_.toString() : value_;
-      return typeof replacer === "function" ? replacer(key, value2) : value2;
-    }, space);
-  }
-});
-
 // ../../node_modules/viem/_esm/utils/unit/Value.js
 function format(value, decimals = 0) {
   if (!Number.isInteger(decimals) || decimals < 0)
@@ -2382,69 +1936,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}\`.`);
@@ -2898,7 +2392,7 @@ function ensureBytes(title, hex, expectedLength) {
     throw new Error(title + " of length " + expectedLength + " expected, got " + len);
   return res;
 }
-function concatBytes3(...arrays) {
+function concatBytes2(...arrays) {
   let sum = 0;
   for (let i = 0; i < arrays.length; i++) {
     const a = arrays[i];
@@ -2966,7 +2460,7 @@ function createHmacDrbg(hashLen, qByteLen, hmacFn) {
       out.push(sl);
       len += v.length;
     }
-    return concatBytes3(...out);
+    return concatBytes2(...out);
   };
   const genUntil = (seed, pred) => {
     reset();
@@ -3598,7 +3092,7 @@ function weierstrassPoints(opts) {
   const Fn = Field(CURVE.n, CURVE.nBitLength);
   const toBytes3 = CURVE.toBytes || ((_c, point, _isCompressed) => {
     const a = point.toAffine();
-    return concatBytes3(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+    return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
   });
   const fromBytes = CURVE.fromBytes || ((bytes) => {
     const tail = bytes.subarray(1);
@@ -4024,7 +3518,7 @@ function weierstrass(curveDef) {
     toBytes(_c, point, isCompressed) {
       const a = point.toAffine();
       const x = Fp.toBytes(a.x);
-      const cat = concatBytes3;
+      const cat = concatBytes2;
       abool("isCompressed", isCompressed);
       if (isCompressed) {
         return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
@@ -4071,7 +3565,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);
@@ -4237,7 +3731,7 @@ function weierstrass(curveDef) {
       const e = ent === true ? randomBytes4(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e));
     }
-    const seed = concatBytes3(...seedArgs);
+    const seed = concatBytes2(...seedArgs);
     const m = h1int;
     function k2sig(kBytes) {
       const k = bits2int(kBytes);
@@ -4600,22 +4094,22 @@ function expand_message_xmd(msg, DST, lenInBytes, H) {
   abytes2(DST);
   anum(lenInBytes);
   if (DST.length > 255)
-    DST = H(concatBytes3(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
+    DST = H(concatBytes2(utf8ToBytes2("H2C-OVERSIZE-DST-"), DST));
   const { outputLen: b_in_bytes, blockLen: r_in_bytes } = H;
   const ell = Math.ceil(lenInBytes / b_in_bytes);
   if (lenInBytes > 65535 || ell > 255)
     throw new Error("expand_message_xmd: invalid lenInBytes");
-  const DST_prime = concatBytes3(DST, i2osp(DST.length, 1));
+  const DST_prime = concatBytes2(DST, i2osp(DST.length, 1));
   const Z_pad = i2osp(0, r_in_bytes);
   const l_i_b_str = i2osp(lenInBytes, 2);
   const b = new Array(ell);
-  const b_0 = H(concatBytes3(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
-  b[0] = H(concatBytes3(b_0, i2osp(1, 1), DST_prime));
+  const b_0 = H(concatBytes2(Z_pad, msg, l_i_b_str, i2osp(0, 1), DST_prime));
+  b[0] = H(concatBytes2(b_0, i2osp(1, 1), DST_prime));
   for (let i = 1; i <= ell; i++) {
     const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
-    b[i] = H(concatBytes3(...args));
+    b[i] = H(concatBytes2(...args));
   }
-  const pseudo_random_bytes = concatBytes3(...b);
+  const pseudo_random_bytes = concatBytes2(...b);
   return pseudo_random_bytes.slice(0, lenInBytes);
 }
 function expand_message_xof(msg, DST, lenInBytes, k, H) {
@@ -4761,10 +4255,10 @@ function taggedHash(tag, ...messages) {
   let tagP = TAGGED_HASH_PREFIXES[tag];
   if (tagP === void 0) {
     const tagH = sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
-    tagP = concatBytes3(tagH, tagH);
+    tagP = concatBytes2(tagH, tagH);
     TAGGED_HASH_PREFIXES[tag] = tagP;
   }
-  return sha256(concatBytes3(tagP, ...messages));
+  return sha256(concatBytes2(tagP, ...messages));
 }
 function schnorrGetExtPubKey(priv) {
   let d_ = secp256k1.utils.normPrivateKeyToScalar(priv);
@@ -4961,7 +4455,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 Chain13, parseKeygenQR, Vultisig as Vultisig6 } from "@vultisig/sdk";
 import chalk16 from "chalk";
 import { InvalidArgumentError, program as program2 } from "commander";
 
@@ -6016,7 +5510,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 +5519,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 +5826,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 +6447,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 +6591,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 +6599,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 +6618,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 +6925,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 +6947,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 +6964,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 +6983,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,
@@ -7615,7 +7000,9 @@ async function previewDryRun(vault, params, dryResult, to) {
 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 +7018,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 +7059,8 @@ async function sendTransaction(vault, params) {
       params.chain,
       preview.memo,
       preview.destinationTag,
-      gas
+      gas,
+      dryResult.contractAddress
     );
   }
   if (!params.yes) {
@@ -7727,23 +7115,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 +7153,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 +7327,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 +7410,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 +7442,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 +8497,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();
@@ -9155,333 +8548,12 @@ async function recoverAddress({ hash, signature }) {
   return publicKeyToAddress(await recoverPublicKey({ hash, signature }));
 }
 
-// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
-init_encodeAbiParameters();
-init_concat();
-init_toHex();
-init_keccak256();
-
-// ../../node_modules/viem/_esm/utils/typedData.js
-init_abi();
-init_address();
-
-// ../../node_modules/viem/_esm/errors/typedData.js
-init_stringify();
-init_base();
-var InvalidDomainError = class extends BaseError {
-  constructor({ domain }) {
-    super(`Invalid domain "${stringify(domain)}".`, {
-      metaMessages: ["Must be a valid EIP-712 domain."]
-    });
-  }
-};
-var InvalidPrimaryTypeError = class extends BaseError {
-  constructor({ primaryType, types }) {
-    super(`Invalid primary type \`${primaryType}\` must be one of \`${JSON.stringify(Object.keys(types))}\`.`, {
-      docsPath: "/api/glossary/Errors#typeddatainvalidprimarytypeerror",
-      metaMessages: ["Check that the primary type is a key in `types`."]
-    });
-  }
-};
-var InvalidStructTypeError = class extends BaseError {
-  constructor({ type }) {
-    super(`Struct type "${type}" is invalid.`, {
-      metaMessages: ["Struct type must not be a Solidity type."],
-      name: "InvalidStructTypeError"
-    });
-  }
-};
-
-// ../../node_modules/viem/_esm/utils/typedData.js
-init_isAddress();
-init_size();
-init_toHex();
-init_regex();
-function validateTypedData(parameters) {
-  const { domain, message, primaryType, types } = parameters;
-  const validateData = (struct, data) => {
-    for (const param of struct) {
-      const { name, type } = param;
-      const value = data[name];
-      const integerMatch = type.match(integerRegex);
-      if (integerMatch && (typeof value === "number" || typeof value === "bigint")) {
-        const [_type, base, size_] = integerMatch;
-        numberToHex(value, {
-          signed: base === "int",
-          size: Number.parseInt(size_, 10) / 8
-        });
-      }
-      if (type === "address" && typeof value === "string" && !isAddress(value))
-        throw new InvalidAddressError2({ address: value });
-      const bytesMatch = type.match(bytesRegex);
-      if (bytesMatch) {
-        const [_type, size_] = bytesMatch;
-        if (size_ && size(value) !== Number.parseInt(size_, 10))
-          throw new BytesSizeMismatchError({
-            expectedSize: Number.parseInt(size_, 10),
-            givenSize: size(value)
-          });
-      }
-      const struct2 = types[type];
-      if (struct2) {
-        validateReference(type);
-        validateData(struct2, value);
-      }
-    }
-  };
-  if (types.EIP712Domain && domain) {
-    if (typeof domain !== "object")
-      throw new InvalidDomainError({ domain });
-    validateData(types.EIP712Domain, domain);
-  }
-  if (primaryType !== "EIP712Domain") {
-    if (types[primaryType])
-      validateData(types[primaryType], message);
-    else
-      throw new InvalidPrimaryTypeError({ primaryType, types });
-  }
-}
-function getTypesForEIP712Domain({ domain }) {
-  return [
-    typeof domain?.name === "string" && { name: "name", type: "string" },
-    domain?.version && { name: "version", type: "string" },
-    (typeof domain?.chainId === "number" || typeof domain?.chainId === "bigint") && {
-      name: "chainId",
-      type: "uint256"
-    },
-    domain?.verifyingContract && {
-      name: "verifyingContract",
-      type: "address"
-    },
-    domain?.salt && { name: "salt", type: "bytes32" }
-  ].filter(Boolean);
-}
-function validateReference(type) {
-  if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
-    throw new InvalidStructTypeError({ type });
-}
-
-// ../../node_modules/viem/_esm/utils/signature/hashTypedData.js
-function hashTypedData(parameters) {
-  const { domain = {}, message, primaryType } = parameters;
-  const types = {
-    EIP712Domain: getTypesForEIP712Domain({ domain }),
-    ...parameters.types
-  };
-  validateTypedData({
-    domain,
-    message,
-    primaryType,
-    types
-  });
-  const parts = ["0x1901"];
-  if (domain)
-    parts.push(hashDomain({
-      domain,
-      types
-    }));
-  if (primaryType !== "EIP712Domain")
-    parts.push(hashStruct({
-      data: message,
-      primaryType,
-      types
-    }));
-  return keccak256(concat(parts));
-}
-function hashDomain({ domain, types }) {
-  return hashStruct({
-    data: domain,
-    primaryType: "EIP712Domain",
-    types
-  });
-}
-function hashStruct({ data, primaryType, types }) {
-  const encoded = encodeData({
-    data,
-    primaryType,
-    types
-  });
-  return keccak256(encoded);
-}
-function encodeData({ data, primaryType, types }) {
-  const encodedTypes = [{ type: "bytes32" }];
-  const encodedValues = [hashType({ primaryType, types })];
-  for (const field of types[primaryType]) {
-    const [type, value] = encodeField({
-      types,
-      name: field.name,
-      type: field.type,
-      value: data[field.name]
-    });
-    encodedTypes.push(type);
-    encodedValues.push(value);
-  }
-  return encodeAbiParameters(encodedTypes, encodedValues);
-}
-function hashType({ primaryType, types }) {
-  const encodedHashType = toHex(encodeType({ primaryType, types }));
-  return keccak256(encodedHashType);
-}
-function encodeType({ primaryType, types }) {
-  let result = "";
-  const unsortedDeps = findTypeDependencies({ primaryType, types });
-  unsortedDeps.delete(primaryType);
-  const deps = [primaryType, ...Array.from(unsortedDeps).sort()];
-  for (const type of deps) {
-    result += `${type}(${types[type].map(({ name, type: t }) => `${t} ${name}`).join(",")})`;
-  }
-  return result;
-}
-function findTypeDependencies({ primaryType: primaryType_, types }, results = /* @__PURE__ */ new Set()) {
-  const match = primaryType_.match(/^\w*/u);
-  const primaryType = match?.[0];
-  if (results.has(primaryType) || types[primaryType] === void 0) {
-    return results;
-  }
-  results.add(primaryType);
-  for (const field of types[primaryType]) {
-    findTypeDependencies({ primaryType: field.type, types }, results);
-  }
-  return results;
-}
-function encodeField({ types, name, type, value }) {
-  if (types[type] !== void 0) {
-    return [
-      { type: "bytes32" },
-      keccak256(encodeData({ data: value, primaryType: type, types }))
-    ];
-  }
-  if (type === "bytes")
-    return [{ type: "bytes32" }, keccak256(value)];
-  if (type === "string")
-    return [{ type: "bytes32" }, keccak256(toHex(value))];
-  if (type.lastIndexOf("]") === type.length - 1) {
-    const parsedType = type.slice(0, type.lastIndexOf("["));
-    const typeValuePairs = value.map((item) => encodeField({
-      name,
-      type: parsedType,
-      types,
-      value: item
-    }));
-    return [
-      { type: "bytes32" },
-      keccak256(encodeAbiParameters(typeValuePairs.map(([t]) => t), typeValuePairs.map(([, v]) => v)))
-    ];
-  }
-  return [{ type }, value];
-}
-
 // ../../node_modules/viem/_esm/utils/unit/formatUnits.js
 init_Value();
 function formatUnits(value, decimals) {
   return format(value, decimals);
 }
 
-// ../../node_modules/viem/_esm/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);
-};
-
 // src/commands/swap.ts
 async function executeSwapChains(ctx2) {
   const vault = await ctx2.ensureActiveVault();
@@ -9676,7 +8748,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 +8819,7 @@ async function executeAddressBook(ctx2, options = {}) {
         type: "select",
         name: "chain",
         message: "Select chain:",
-        choices: Object.values(Chain9)
+        choices: Object.values(Chain8)
       });
     }
     if (!address) {
@@ -10348,11 +9420,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 +9441,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");
       }
@@ -10701,11 +9773,13 @@ import { getChainKind as getChainKind4 } from "@vultisig/sdk";
 
 // src/agent/executor.ts
 import {
-  Chain as Chain11,
-  chainFeeCoin,
+  Chain as Chain10,
+  chainFeeCoin as chainFeeCoin2,
+  computeEip712Hash,
   getChainKind as getChainKind3,
   parseThorSwapMemo,
   resolveChainReference,
+  toCanonicalEvmSignature,
   VaultError as VaultError3,
   VaultErrorCode as VaultErrorCode3,
   Vultisig as VultisigSdk
@@ -11061,7 +10135,7 @@ var AgentExecutor = class {
     if (!nestedTx && txReadyData && typeof txReadyData === "object") {
       const txArgs = txReadyData.txArgs;
       if (txArgs && typeof txArgs === "object" && typeof txArgs.to === "string" && typeof txArgs.amount === "string") {
-        const chain2 = resolveChainFromTxReady(txReadyData) || Chain11.Ethereum;
+        const chain2 = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
         if (getChainKind3(chain2) !== "evm") {
           this.pendingPayloads.clear();
           this.pendingLegs = [];
@@ -11086,7 +10160,7 @@ var AgentExecutor = class {
 `);
       return false;
     }
-    const chain = resolveChainFromTxReady(txReadyData) || Chain11.Ethereum;
+    const chain = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
     this.pendingPayloads.clear();
     this.pendingLegs = [];
     this.pendingPayloads.set("latest", {
@@ -11471,7 +10545,7 @@ var AgentExecutor = class {
         `signNonEvmServerTx: dispatcher chain '${chain}' disagrees with envelope chain '${txArgs.chain}'`
       );
     }
-    if (txArgs.msg_type === "deposit" && (chain === Chain11.THORChain || chain === Chain11.MayaChain)) {
+    if (txArgs.msg_type === "deposit" && (chain === Chain10.THORChain || chain === Chain10.MayaChain)) {
       const memo = typeof txArgs.memo === "string" ? txArgs.memo : "";
       if (memo.startsWith("=:")) {
         return this.signThorMsgDepositSwap(serverTxData, chain);
@@ -11544,7 +10618,7 @@ var AgentExecutor = class {
       );
     }
     const toChain = parsed.toChain;
-    const fromSymbol = chain === Chain11.THORChain ? "RUNE" : "CACAO";
+    const fromSymbol = chain === Chain10.THORChain ? "RUNE" : "CACAO";
     const amountRaw = typeof txArgs.amount === "string" ? txArgs.amount : void 0;
     if (!amountRaw) {
       throw new VaultError3(
@@ -12158,16 +11232,16 @@ 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;
     const chainId = domain.chainId;
-    let chain = Chain11.Ethereum;
+    let chain = Chain10.Ethereum;
     if (chainName) {
-      chain = resolveChain(chainName) || Chain11.Ethereum;
+      chain = resolveChain(chainName) || Chain10.Ethereum;
     } else if (chainId) {
-      chain = resolveChainId(chainId) || Chain11.Ethereum;
+      chain = resolveChainId(chainId) || Chain10.Ethereum;
     }
     const sigResult = await this.vault.signBytes({
       data: eip712Hash,
@@ -12322,7 +11396,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 +11425,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 +11435,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";
@@ -12459,7 +11465,7 @@ function asRecord(value) {
   }
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function isAddress2(value) {
+function isAddress(value) {
   return typeof value === "string" && /^0x[0-9a-fA-F]{40}$/.test(value);
 }
 function isCalldata(value) {
@@ -12479,7 +11485,7 @@ function normalizeGasLimit(value) {
   return void 0;
 }
 function extractLeg(obj) {
-  const to = isAddress2(obj.to) ? obj.to : isAddress2(obj.to_address) ? obj.to_address : void 0;
+  const to = isAddress(obj.to) ? obj.to : isAddress(obj.to_address) ? obj.to_address : void 0;
   const data = isCalldata(obj.data) ? obj.data : isCalldata(obj.calldata) ? obj.calldata : void 0;
   if (!to || !data) return null;
   const leg = { to, value: normalizeValue(obj.value), data };
@@ -12635,7 +11641,7 @@ function payloadLooksSignable(payload) {
 }
 function legSignable(legObj) {
   const nested = asRecord(legObj.tx) || asRecord(legObj.swap_tx) || asRecord(legObj.send_tx) || asRecord(legObj.txArgs?.tx);
-  if (nested && isAddress2(nested.to)) return true;
+  if (nested && isAddress(nested.to)) return true;
   const txArgs = asRecord(legObj.txArgs);
   if (txArgs && typeof txArgs.to === "string" && typeof txArgs.amount === "string") return true;
   return false;
@@ -13421,7 +12427,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 +12488,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 +12539,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";
@@ -15077,7 +14028,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();
@@ -15765,7 +14716,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "4.4.0";
+    cachedVersion = "4.5.0";
     return cachedVersion;
   }
   try {
@@ -16225,7 +15176,7 @@ var EventBuffer = class {
 };
 
 // src/interactive/session.ts
-import { Chain as Chain14, fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
+import { Chain as Chain12, fiatCurrencies as fiatCurrencies3 } from "@vultisig/sdk";
 import chalk14 from "chalk";
 import ora3 from "ora";
 import * as readline3 from "readline";
@@ -17027,7 +15978,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 +16008,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 +16025,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 !== Chain12.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 +16050,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 +16089,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 +16111,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 +16137,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 +16178,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++;
       }
     }
@@ -17896,7 +16847,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 +16871,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 !== Chain13.Ripple) {
         throw new Error("--destination-tag is only supported for XRP");
       }
       const destinationTag = options.destinationTag === void 0 ? void 0 : Number(options.destinationTag);
@@ -17955,7 +16906,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 +16922,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 +16932,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 +16956,7 @@ Examples:
       );
     }
     const params = resolveTxStatusParams({
-      chain: findChainByName(options.chain) || options.chain,
+      chain: resolveChainOrThrow(options.chain),
       txHash: options.txHash,
       noWait: !options.wait,
       timeoutSec
@@ -18081,7 +17032,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 +17049,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 +17168,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,