@vultisig/cli 0.16.0 → 0.17.0

package/dist/index.js

@@ -1430,7 +1430,7 @@ var init_sha3 = __esm({
   }
 });
 
-// node_modules/viem/_esm/utils/unit/formatUnits.js
+// ../../node_modules/viem/_esm/utils/unit/formatUnits.js
 function formatUnits(value, decimals) {
   let display = value.toString();
   const negative = display.startsWith("-");
@@ -1445,7 +1445,981 @@ function formatUnits(value, decimals) {
   return `${negative ? "-" : ""}${integer || "0"}${fraction ? `.${fraction}` : ""}`;
 }
 var init_formatUnits = __esm({
-  "node_modules/viem/_esm/utils/unit/formatUnits.js"() {
+  "../../node_modules/viem/_esm/utils/unit/formatUnits.js"() {
+  }
+});
+
+// ../../packages/lib/utils/dist/promise/isPromise.js
+function isPromise(value) {
+  return !!value && typeof value.then === "function";
+}
+var init_isPromise = __esm({
+  "../../packages/lib/utils/dist/promise/isPromise.js"() {
+  }
+});
+
+// ../../packages/lib/utils/dist/attempt.js
+function attempt(input) {
+  if (typeof input === "function") {
+    try {
+      const result = input();
+      if (isPromise(result)) {
+        return attempt(result);
+      }
+      return { data: result };
+    } catch (error2) {
+      return { error: error2 };
+    }
+  } else {
+    return input.then((data) => ({ data }), (error2) => ({ error: error2 }));
+  }
+}
+function withFallback(result, fallback) {
+  if (isPromise(result)) {
+    return result.then((res) => {
+      if ("error" in res) {
+        return fallback;
+      }
+      return res.data;
+    });
+  }
+  if ("error" in result) {
+    return fallback;
+  }
+  return result.data;
+}
+var init_attempt = __esm({
+  "../../packages/lib/utils/dist/attempt.js"() {
+    init_isPromise();
+  }
+});
+
+// ../../packages/lib/utils/dist/error/extractErrorMsg/index.js
+var extractErrorMsg;
+var init_extractErrorMsg = __esm({
+  "../../packages/lib/utils/dist/error/extractErrorMsg/index.js"() {
+    init_attempt();
+    extractErrorMsg = (err) => {
+      if (typeof err === "string") {
+        return err;
+      }
+      if (typeof err === "number" || typeof err === "boolean") {
+        return String(err);
+      }
+      if (typeof err === "object" && err && "message" in err) {
+        return extractErrorMsg(err.message);
+      }
+      return withFallback(attempt(() => JSON.stringify(err)), "Unknown Error");
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/array/isEmpty/index.js
+var isEmpty;
+var init_isEmpty = __esm({
+  "../../packages/lib/utils/dist/array/isEmpty/index.js"() {
+    isEmpty = (items) => items.length === 0;
+  }
+});
+
+// ../../packages/lib/utils/dist/promise/asyncFallbackChain/index.js
+var asyncFallbackChain;
+var init_asyncFallbackChain = __esm({
+  "../../packages/lib/utils/dist/promise/asyncFallbackChain/index.js"() {
+    init_isEmpty();
+    asyncFallbackChain = async (...functions) => {
+      if (isEmpty(functions)) {
+        throw new Error("No functions provided");
+      }
+      try {
+        const result = await functions[0]();
+        return result;
+      } catch (error2) {
+        if (functions.length <= 1) {
+          throw error2;
+        }
+        return asyncFallbackChain(...functions.slice(1));
+      }
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/fetch/HttpResponseError.js
+var HttpResponseError;
+var init_HttpResponseError = __esm({
+  "../../packages/lib/utils/dist/fetch/HttpResponseError.js"() {
+    HttpResponseError = class extends Error {
+      status;
+      statusText;
+      url;
+      body;
+      constructor(opts) {
+        super(opts.message);
+        this.name = "HttpResponseError";
+        this.status = opts.status;
+        this.statusText = opts.statusText;
+        this.url = opts.url;
+        this.body = opts.body;
+      }
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/fetch/assertFetchResponse.js
+var assertFetchResponse;
+var init_assertFetchResponse = __esm({
+  "../../packages/lib/utils/dist/fetch/assertFetchResponse.js"() {
+    init_extractErrorMsg();
+    init_asyncFallbackChain();
+    init_HttpResponseError();
+    assertFetchResponse = async (response) => {
+      if (!response.ok) {
+        const body = await asyncFallbackChain(async () => response.json(), async () => response.text(), async () => `HTTP ${response.status} ${response.statusText || "Error"}: Request failed for ${response.url}`);
+        const msg = extractErrorMsg(body);
+        throw new HttpResponseError({
+          message: msg,
+          status: response.status,
+          statusText: response.statusText,
+          url: response.url,
+          body
+        });
+      }
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/record/getRecordKeys/index.js
+var getRecordKeys;
+var init_getRecordKeys = __esm({
+  "../../packages/lib/utils/dist/record/getRecordKeys/index.js"() {
+    getRecordKeys = (record) => {
+      return Object.keys(record);
+    };
+  }
+});
+
+// ../../packages/lib/utils/dist/record/withoutUndefinedFields.js
+function withoutUndefinedFields(record) {
+  const result = {};
+  getRecordKeys(record).forEach((key) => {
+    const typedKey = key;
+    const value = record[typedKey];
+    if (value !== void 0) {
+      result[typedKey] = value;
+    }
+  });
+  return result;
+}
+var init_withoutUndefinedFields = __esm({
+  "../../packages/lib/utils/dist/record/withoutUndefinedFields.js"() {
+    init_getRecordKeys();
+  }
+});
+
+// ../../packages/lib/utils/dist/query/queryUrl.js
+async function queryUrl(url, options = {}) {
+  const { responseType = "json", body, headers, method } = options;
+  const response = await fetch(url, withoutUndefinedFields({
+    method: method ?? (body ? "POST" : "GET"),
+    headers: withoutUndefinedFields({
+      ...headers,
+      "Content-Type": body ? "application/json" : void 0
+    }),
+    body: processBody(body)
+  }));
+  await assertFetchResponse(response);
+  if (responseType !== "none") {
+    return response[responseType]();
+  }
+}
+var processBody;
+var init_queryUrl = __esm({
+  "../../packages/lib/utils/dist/query/queryUrl.js"() {
+    init_assertFetchResponse();
+    init_withoutUndefinedFields();
+    processBody = (body) => {
+      if (body === void 0) {
+        return void 0;
+      }
+      if (typeof body === "string") {
+        return body;
+      }
+      return JSON.stringify(body);
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/pools.js
+var thorchainMidgardBaseUrl, POOL_ID_RE, assertValidPoolId, isValidPoolId, normalizePool, getThorchainPools;
+var init_pools = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/pools.js"() {
+    init_queryUrl();
+    thorchainMidgardBaseUrl = "https://midgard.ninerealms.com";
+    POOL_ID_RE = /^[A-Z0-9]+\.[A-Z0-9]+(-[A-Z0-9]+)?$/;
+    assertValidPoolId = (pool) => {
+      if (typeof pool !== "string" || pool.length === 0) {
+        throw new Error(`assertValidPoolId: pool id must be a non-empty string, got ${typeof pool} ${pool === "" ? '""' : ""}`);
+      }
+      if (!POOL_ID_RE.test(pool)) {
+        throw new Error(`assertValidPoolId: ${JSON.stringify(pool)} is not a valid THORChain pool id. Expected uppercase CHAIN.ASSET (e.g. "BTC.BTC") or CHAIN.ASSET-CONTRACT (e.g. "ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48").`);
+      }
+    };
+    isValidPoolId = (pool) => {
+      if (typeof pool !== "string" || pool.length === 0)
+        return false;
+      return POOL_ID_RE.test(pool);
+    };
+    normalizePool = (raw) => ({
+      asset: raw.asset ?? "",
+      status: raw.status ?? "",
+      assetDepth: raw.assetDepth ?? "0",
+      runeDepth: raw.runeDepth ?? "0",
+      liquidityUnits: raw.liquidityUnits ?? "0",
+      volume24h: raw.volume24h ?? "0",
+      annualPercentageRate: raw.annualPercentageRate ?? "0"
+    });
+    getThorchainPools = async (options = {}) => {
+      const status = options.status === void 0 ? "available" : options.status;
+      const url = status === null ? `${thorchainMidgardBaseUrl}/v2/pools` : `${thorchainMidgardBaseUrl}/v2/pools?status=${encodeURIComponent(status)}`;
+      const raw = await queryUrl(url);
+      if (!Array.isArray(raw)) {
+        throw new Error(`getThorchainPools: expected an array from ${url}, got ${typeof raw}`);
+      }
+      return raw.map(normalizePool);
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/memo.js
+var assertMemoSegmentSafe, addLpMemo, removeLpMemo;
+var init_memo = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/memo.js"() {
+    init_pools();
+    assertMemoSegmentSafe = (value, fieldName) => {
+      if (typeof value !== "string") {
+        throw new Error(`${fieldName} must be a string, got ${typeof value}`);
+      }
+      if (value.includes(":")) {
+        throw new Error(`${fieldName} must not contain \`:\` (would inject extra memo segments), got ${JSON.stringify(value)}`);
+      }
+      if (/\s/.test(value)) {
+        throw new Error(`${fieldName} must not contain whitespace, got ${JSON.stringify(value)}`);
+      }
+    };
+    addLpMemo = ({ pool, pairedAddress }) => {
+      assertValidPoolId(pool);
+      if (pairedAddress && pairedAddress.length > 0) {
+        assertMemoSegmentSafe(pairedAddress, "pairedAddress");
+        return `+:${pool}:${pairedAddress}`;
+      }
+      return `+:${pool}`;
+    };
+    removeLpMemo = ({ pool, basisPoints, withdrawToAsset }) => {
+      assertValidPoolId(pool);
+      if (!Number.isInteger(basisPoints) || basisPoints < 1 || basisPoints > 1e4) {
+        throw new Error(`removeLpMemo: basisPoints must be an integer in [1, 10000], got ${basisPoints}`);
+      }
+      if (withdrawToAsset && withdrawToAsset.length > 0) {
+        assertMemoSegmentSafe(withdrawToAsset, "withdrawToAsset");
+        return `-:${pool}:${basisPoints}:${withdrawToAsset}`;
+      }
+      return `-:${pool}:${basisPoints}`;
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/payload.js
+var LP_REMOVE_DUST_RUNE_BASE_UNITS, isPositiveBaseUnitString, buildThorchainLpAddPayload, buildThorchainLpRemovePayload;
+var init_payload = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/payload.js"() {
+    init_memo();
+    LP_REMOVE_DUST_RUNE_BASE_UNITS = "2000000";
+    isPositiveBaseUnitString = (value) => /^\d+$/.test(value) && BigInt(value) > 0n;
+    buildThorchainLpAddPayload = ({ pool, amountRuneBaseUnits, pairedAddress }) => {
+      if (!isPositiveBaseUnitString(amountRuneBaseUnits)) {
+        throw new Error(`buildThorchainLpAddPayload: amountRuneBaseUnits must be a positive integer string, got ${amountRuneBaseUnits}`);
+      }
+      const memo = addLpMemo({ pool, pairedAddress });
+      return {
+        kind: "thorchain_lp_add",
+        chain: "THORChain",
+        denom: "rune",
+        amount: amountRuneBaseUnits,
+        memo,
+        pool,
+        ...pairedAddress ? { pairedAddress } : {}
+      };
+    };
+    buildThorchainLpRemovePayload = ({ pool, basisPoints, withdrawToAsset }) => {
+      if (!Number.isInteger(basisPoints) || basisPoints < 1 || basisPoints > 1e4) {
+        throw new Error(`buildThorchainLpRemovePayload: basisPoints must be an integer in [1, 10000], got ${basisPoints}`);
+      }
+      const memo = removeLpMemo({ pool, basisPoints, withdrawToAsset });
+      return {
+        kind: "thorchain_lp_remove",
+        chain: "THORChain",
+        denom: "rune",
+        amount: LP_REMOVE_DUST_RUNE_BASE_UNITS,
+        memo,
+        pool,
+        basisPoints,
+        ...withdrawToAsset ? { withdrawToAsset } : {}
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/Chain.js
+var EthereumL2Chain, EvmChain, UtxoChain, cosmosChainsByKind, IbcEnabledCosmosChain, VaultBasedCosmosChain, CosmosChain, OtherChain, Chain9, UtxoBasedChain, defaultChains;
+var init_Chain = __esm({
+  "../../packages/core/chain/dist/Chain.js"() {
+    EthereumL2Chain = {
+      Arbitrum: "Arbitrum",
+      Base: "Base",
+      Blast: "Blast",
+      Optimism: "Optimism",
+      Zksync: "Zksync",
+      Mantle: "Mantle"
+    };
+    EvmChain = {
+      ...EthereumL2Chain,
+      Avalanche: "Avalanche",
+      CronosChain: "CronosChain",
+      BSC: "BSC",
+      Ethereum: "Ethereum",
+      Polygon: "Polygon",
+      Hyperliquid: "Hyperliquid",
+      Sei: "Sei"
+    };
+    (function(UtxoChain2) {
+      UtxoChain2["Bitcoin"] = "Bitcoin";
+      UtxoChain2["BitcoinCash"] = "Bitcoin-Cash";
+      UtxoChain2["Litecoin"] = "Litecoin";
+      UtxoChain2["Dogecoin"] = "Dogecoin";
+      UtxoChain2["Dash"] = "Dash";
+      UtxoChain2["Zcash"] = "Zcash";
+    })(UtxoChain || (UtxoChain = {}));
+    cosmosChainsByKind = {
+      ibcEnabled: {
+        Cosmos: "Cosmos",
+        Osmosis: "Osmosis",
+        Dydx: "Dydx",
+        Kujira: "Kujira",
+        Terra: "Terra",
+        TerraClassic: "TerraClassic",
+        Noble: "Noble",
+        Akash: "Akash"
+      },
+      vaultBased: {
+        THORChain: "THORChain",
+        MayaChain: "MayaChain"
+      }
+    };
+    IbcEnabledCosmosChain = cosmosChainsByKind.ibcEnabled;
+    VaultBasedCosmosChain = cosmosChainsByKind.vaultBased;
+    CosmosChain = {
+      ...IbcEnabledCosmosChain,
+      ...VaultBasedCosmosChain
+    };
+    (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 = {}));
+    Chain9 = {
+      ...EvmChain,
+      ...UtxoChain,
+      ...CosmosChain,
+      ...OtherChain
+    };
+    UtxoBasedChain = [
+      ...Object.values(UtxoChain),
+      OtherChain.Cardano
+    ];
+    defaultChains = [
+      Chain9.Bitcoin,
+      Chain9.Ethereum,
+      Chain9.THORChain,
+      Chain9.Solana,
+      Chain9.BSC
+    ];
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/cosmosRpcUrl.js
+var cosmosRpcUrl;
+var init_cosmosRpcUrl = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/cosmosRpcUrl.js"() {
+    cosmosRpcUrl = {
+      Cosmos: "https://cosmos-rest.publicnode.com",
+      Osmosis: "https://osmosis-rest.publicnode.com",
+      Dydx: "https://dydx-rest.publicnode.com",
+      Kujira: "https://kujira-rest.publicnode.com",
+      Terra: "https://terra-lcd.publicnode.com",
+      TerraClassic: "https://terra-classic-lcd.publicnode.com",
+      Noble: "https://noble-api.polkachu.com",
+      THORChain: "https://thornode.thorchain.network",
+      MayaChain: "https://mayanode.mayachain.info",
+      Akash: "https://akash-rest.publicnode.com"
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/memberPool.js
+var isNonZeroBaseUnit, normalizeMemberPool;
+var init_memberPool = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/memberPool.js"() {
+    isNonZeroBaseUnit = (value) => {
+      if (!value)
+        return false;
+      try {
+        return BigInt(value) > 0n;
+      } catch {
+        return false;
+      }
+    };
+    normalizeMemberPool = (raw) => ({
+      pool: raw.pool ?? "",
+      liquidityUnits: raw.liquidityUnits ?? "0",
+      runeAdded: raw.runeAdded ?? "0",
+      assetAdded: raw.assetAdded ?? "0",
+      runePending: raw.runePending ?? "0",
+      assetPending: raw.assetPending ?? "0",
+      runeAddress: raw.runeAddress ?? "",
+      assetAddress: raw.assetAddress ?? "",
+      dateLastAdded: raw.dateLastAdded ?? "0",
+      lastAddHeight: "",
+      isPending: isNonZeroBaseUnit(raw.runePending) || isNonZeroBaseUnit(raw.assetPending)
+    });
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/position.js
+var isMidgardNotFoundError, getThorchainLpPosition, getThorchainLpPositionFromThornode;
+var init_position = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/position.js"() {
+    init_Chain();
+    init_cosmosRpcUrl();
+    init_HttpResponseError();
+    init_queryUrl();
+    init_memberPool();
+    init_pools();
+    isMidgardNotFoundError = (err) => err instanceof HttpResponseError && err.status === 404;
+    getThorchainLpPosition = async ({ thorAddress, pool }) => {
+      assertValidPoolId(pool);
+      const url = `${thorchainMidgardBaseUrl}/v2/member/${encodeURIComponent(thorAddress)}`;
+      let midgardNotFound = false;
+      let raw = {};
+      try {
+        raw = await queryUrl(url);
+      } catch (err) {
+        if (isMidgardNotFoundError(err)) {
+          midgardNotFound = true;
+        } else {
+          throw err;
+        }
+      }
+      if (!midgardNotFound) {
+        const pools = Array.isArray(raw.pools) ? raw.pools : [];
+        const found = pools.find((p) => p.pool === pool);
+        if (found)
+          return normalizeMemberPool(found);
+      }
+      return getThorchainLpPositionFromThornode({ thorAddress, pool });
+    };
+    getThorchainLpPositionFromThornode = async ({ thorAddress, pool }) => {
+      assertValidPoolId(pool);
+      const url = `${cosmosRpcUrl[Chain9.THORChain]}/thorchain/pool/${encodeURIComponent(pool)}/liquidity_provider/${encodeURIComponent(thorAddress)}`;
+      let raw;
+      try {
+        raw = await queryUrl(url);
+      } catch (err) {
+        if (err instanceof HttpResponseError && err.status === 404)
+          return null;
+        throw err;
+      }
+      const units = raw.units ?? "0";
+      const pendingRune = raw.pending_rune ?? "0";
+      const pendingAsset = raw.pending_asset ?? "0";
+      if (!isNonZeroBaseUnit(units) && !isNonZeroBaseUnit(pendingRune) && !isNonZeroBaseUnit(pendingAsset)) {
+        return null;
+      }
+      return {
+        pool: raw.asset ?? pool,
+        liquidityUnits: units,
+        // Thornode doesn't track historical added amounts — those are a
+        // Midgard-only enrichment. Surface them as 0; the caller can still
+        // act on units/pending.
+        runeAdded: "0",
+        assetAdded: "0",
+        runePending: pendingRune,
+        assetPending: pendingAsset,
+        runeAddress: raw.rune_address ?? thorAddress,
+        assetAddress: raw.asset_address ?? "",
+        // Thornode exposes the last-add block height, not a Unix timestamp.
+        // Keep `dateLastAdded` semantically Unix-seconds-or-0 and expose the
+        // block height via the dedicated `lastAddHeight` field so lockup
+        // checks can use either source.
+        dateLastAdded: "0",
+        lastAddHeight: typeof raw.last_add_height === "number" ? String(raw.last_add_height) : "",
+        isPending: isNonZeroBaseUnit(pendingRune) || isNonZeroBaseUnit(pendingAsset)
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/validation.js
+var extractPoolStatus, poolPauseMimirKey, getThorchainMimir, assertPoolDepositable;
+var init_validation = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/validation.js"() {
+    init_Chain();
+    init_cosmosRpcUrl();
+    init_queryUrl();
+    init_pools();
+    extractPoolStatus = (raw) => {
+      if (raw && typeof raw === "object" && "status" in raw) {
+        const status = raw.status;
+        return typeof status === "string" ? status : void 0;
+      }
+      return void 0;
+    };
+    poolPauseMimirKey = (pool) => {
+      const dotIdx = pool.indexOf(".");
+      if (dotIdx <= 0 || dotIdx >= pool.length - 1) {
+        throw new Error(`poolPauseMimirKey: invalid pool id ${pool}`);
+      }
+      const chain = pool.slice(0, dotIdx);
+      const asset = pool.slice(dotIdx + 1);
+      return `PAUSELPDEPOSIT-${chain}-${asset}`;
+    };
+    getThorchainMimir = async () => {
+      const url = `${cosmosRpcUrl[Chain9.THORChain]}/thorchain/mimir`;
+      const raw = await queryUrl(url);
+      if (!raw || typeof raw !== "object") {
+        throw new Error(`getThorchainMimir: unexpected response shape from ${url}`);
+      }
+      const out = {};
+      for (const [k, v] of Object.entries(raw)) {
+        if (typeof v === "number" && Number.isFinite(v)) {
+          out[k] = v;
+        } else if (typeof v === "string" && /^-?\d+$/.test(v)) {
+          out[k] = Number(v);
+        }
+      }
+      return out;
+    };
+    assertPoolDepositable = async (pool) => {
+      assertValidPoolId(pool);
+      const [poolRaw, mimir] = await Promise.all([
+        queryUrl(`${cosmosRpcUrl[Chain9.THORChain]}/thorchain/pool/${encodeURIComponent(pool)}`),
+        getThorchainMimir()
+      ]);
+      const status = extractPoolStatus(poolRaw);
+      if (status === void 0) {
+        throw new Error(`assertPoolDepositable: pool ${pool} response from thornode did not include a string \`status\` field`);
+      }
+      if (status !== "Available") {
+        throw new Error(`assertPoolDepositable: pool ${pool} status is ${status}, must be Available for LP add`);
+      }
+      const pauseKey = poolPauseMimirKey(pool);
+      const pauseValue = mimir[pauseKey];
+      if (typeof pauseValue === "number" && pauseValue > 0) {
+        throw new Error(`assertPoolDepositable: pool ${pool} has LP deposits paused on-chain via mimir ${pauseKey}=${pauseValue}. THORChain validators have disabled new adds for this pool; any tx would be rejected at handler execution time.`);
+      }
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/thorchainLp.js
+var thorchainLpChainCode;
+var init_thorchainLp = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/thorchainLp.js"() {
+    init_Chain();
+    thorchainLpChainCode = {
+      [Chain9.Avalanche]: "AVAX",
+      [Chain9.Base]: "BASE",
+      [Chain9.BitcoinCash]: "BCH",
+      [Chain9.BSC]: "BSC",
+      [Chain9.Bitcoin]: "BTC",
+      [Chain9.Dash]: "DASH",
+      [Chain9.Dogecoin]: "DOGE",
+      [Chain9.Ethereum]: "ETH",
+      [Chain9.Cosmos]: "GAIA",
+      [Chain9.Kujira]: "KUJI",
+      [Chain9.Litecoin]: "LTC",
+      [Chain9.THORChain]: "THOR",
+      [Chain9.Tron]: "TRON",
+      [Chain9.Ripple]: "XRP",
+      [Chain9.Arbitrum]: "ARB",
+      [Chain9.Zcash]: "ZEC"
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/lpChainMap.js
+var lpChainMap, chainPrefixToChain, chainToLpPrefix;
+var init_lpChainMap = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/lpChainMap.js"() {
+    init_thorchainLp();
+    lpChainMap = Object.freeze(Object.entries(thorchainLpChainCode).reduce((acc, [chainKey, prefix]) => {
+      if (prefix) {
+        acc[prefix] = chainKey;
+      }
+      return acc;
+    }, {}));
+    chainPrefixToChain = (prefix) => lpChainMap[prefix.toUpperCase()];
+    chainToLpPrefix = (chain) => thorchainLpChainCode[chain];
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/pairing.js
+var resolvePairedAddressForLpAdd;
+var init_pairing = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/pairing.js"() {
+    init_Chain();
+    init_lpChainMap();
+    init_pools();
+    resolvePairedAddressForLpAdd = ({ pool, side, vaultAddresses }) => {
+      assertValidPoolId(pool);
+      const [chainPrefix] = pool.split(".");
+      if (!chainPrefix)
+        return void 0;
+      const assetChain = chainPrefixToChain(chainPrefix);
+      if (!assetChain)
+        return void 0;
+      if (side === "asset") {
+        return vaultAddresses[Chain9.THORChain];
+      }
+      return vaultAddresses[assetChain];
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/math.js
+var assertBaseUnitString, getLiquidityUnits, getPoolShare, getLpAddSlippage, estimateLpAdd;
+var init_math = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/math.js"() {
+    init_Chain();
+    init_cosmosRpcUrl();
+    init_queryUrl();
+    init_pools();
+    assertBaseUnitString = (value, fieldName) => {
+      if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${fieldName} must be a non-empty base-unit string, got ${typeof value === "string" ? JSON.stringify(value) : typeof value}`);
+      }
+      if (!/^\d+$/.test(value)) {
+        throw new Error(`${fieldName} must be a non-negative integer base-unit string, got ${JSON.stringify(value)}`);
+      }
+      return BigInt(value);
+    };
+    getLiquidityUnits = ({ pool, assetAmountBaseUnit, runeAmountBaseUnit }) => {
+      const P = assertBaseUnitString(pool.poolUnits, "pool.poolUnits");
+      const R = assertBaseUnitString(pool.runeDepth, "pool.runeDepth");
+      const A = assertBaseUnitString(pool.assetDepth, "pool.assetDepth");
+      const r = assertBaseUnitString(runeAmountBaseUnit, "runeAmountBaseUnit");
+      const a = assertBaseUnitString(assetAmountBaseUnit, "assetAmountBaseUnit");
+      if (R === 0n || A === 0n || P === 0n) {
+        return "0";
+      }
+      const numerator = P * (R * a + r * A);
+      const denominator = 2n * R * A;
+      return (numerator / denominator).toString();
+    };
+    getPoolShare = ({ pool, liquidityUnits }) => {
+      const P = assertBaseUnitString(pool.poolUnits, "pool.poolUnits");
+      const L = assertBaseUnitString(liquidityUnits, "liquidityUnits");
+      if (P === 0n || L === 0n) {
+        return { poolShareDecimal: "0" };
+      }
+      const totalAfter = P + L;
+      const SCALE = 10n ** 18n;
+      const scaled = L * SCALE / totalAfter;
+      const decimal = scaled.toString().padStart(19, "0");
+      const intPart = decimal.slice(0, -18) || "0";
+      const fracPart = decimal.slice(-18).replace(/0+$/, "");
+      return {
+        poolShareDecimal: fracPart.length > 0 ? `${intPart}.${fracPart}` : intPart
+      };
+    };
+    getLpAddSlippage = ({ pool, assetAmountBaseUnit, runeAmountBaseUnit }) => {
+      const R = assertBaseUnitString(pool.runeDepth, "pool.runeDepth");
+      const A = assertBaseUnitString(pool.assetDepth, "pool.assetDepth");
+      const r = assertBaseUnitString(runeAmountBaseUnit, "runeAmountBaseUnit");
+      const a = assertBaseUnitString(assetAmountBaseUnit, "assetAmountBaseUnit");
+      if (R === 0n || A === 0n) {
+        return { decimalPercent: "0", slippageInRuneBaseUnit: "0" };
+      }
+      const ra = R * a;
+      const ar = A * r;
+      const numerator = ra > ar ? ra - ar : ar - ra;
+      const denominator = A * r + R * A;
+      if (denominator === 0n) {
+        return { decimalPercent: "0", slippageInRuneBaseUnit: "0" };
+      }
+      const SCALE = 10n ** 18n;
+      const scaled = numerator * SCALE / denominator;
+      const decimal = scaled.toString().padStart(19, "0");
+      const intPart = decimal.slice(0, -18) || "0";
+      const fracPart = decimal.slice(-18).replace(/0+$/, "");
+      const decimalPercent = fracPart.length > 0 ? `${intPart}.${fracPart}` : intPart;
+      const imbalanceNumerator = ra > ar ? ra - ar : ar - ra;
+      const imbalanceInRune = A === 0n ? 0n : imbalanceNumerator / (2n * A);
+      const slippageInRune = imbalanceInRune * scaled / SCALE;
+      return {
+        decimalPercent,
+        slippageInRuneBaseUnit: slippageInRune.toString()
+      };
+    };
+    estimateLpAdd = async ({ pool, assetAmountBaseUnit, runeAmountBaseUnit, thornodeBaseUrl }) => {
+      assertValidPoolId(pool);
+      const base = thornodeBaseUrl ?? cosmosRpcUrl[Chain9.THORChain];
+      const url = `${base}/thorchain/pool/${encodeURIComponent(pool)}`;
+      const raw = await queryUrl(url);
+      if (!raw || typeof raw !== "object" || typeof raw.balance_asset !== "string" || typeof raw.balance_rune !== "string") {
+        throw new Error(`estimateLpAdd: pool ${pool} response from ${url} missing balance fields`);
+      }
+      const poolUnitsRaw = raw.pool_units ?? raw.LP_units;
+      if (typeof poolUnitsRaw !== "string" || poolUnitsRaw.length === 0) {
+        throw new Error(`estimateLpAdd: pool ${pool} response from ${url} missing pool_units / LP_units`);
+      }
+      const poolState = {
+        assetDepth: raw.balance_asset,
+        runeDepth: raw.balance_rune,
+        poolUnits: poolUnitsRaw
+      };
+      const liquidityUnits = getLiquidityUnits({
+        pool: poolState,
+        assetAmountBaseUnit,
+        runeAmountBaseUnit
+      });
+      const share = getPoolShare({
+        pool: poolState,
+        liquidityUnits
+      });
+      const slip = getLpAddSlippage({
+        pool: poolState,
+        assetAmountBaseUnit,
+        runeAmountBaseUnit
+      });
+      const R = BigInt(poolState.runeDepth);
+      const A = BigInt(poolState.assetDepth);
+      const P = BigInt(poolState.poolUnits);
+      const r = BigInt(runeAmountBaseUnit);
+      const a = BigInt(assetAmountBaseUnit);
+      const L = BigInt(liquidityUnits);
+      const totalAfter = P + L;
+      const runeDepthAfter = R + r;
+      const assetDepthAfter = A + a;
+      const runeShareBaseUnit = totalAfter === 0n ? "0" : (runeDepthAfter * L / totalAfter).toString();
+      const assetShareBaseUnit = totalAfter === 0n ? "0" : (assetDepthAfter * L / totalAfter).toString();
+      return {
+        liquidityUnits,
+        poolShareDecimal: share.poolShareDecimal,
+        runeShareBaseUnit,
+        assetShareBaseUnit,
+        slippageDecimal: slip.decimalPercent,
+        slippageRuneBaseUnit: slip.slippageInRuneBaseUnit
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/positions.js
+var getThorchainLpPositions;
+var init_positions = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/positions.js"() {
+    init_HttpResponseError();
+    init_queryUrl();
+    init_memberPool();
+    init_pools();
+    getThorchainLpPositions = async ({ thorAddress }) => {
+      const url = `${thorchainMidgardBaseUrl}/v2/member/${encodeURIComponent(thorAddress)}`;
+      let raw;
+      try {
+        raw = await queryUrl(url);
+      } catch (err) {
+        if (err instanceof HttpResponseError && err.status === 404)
+          return [];
+        throw err;
+      }
+      if (!raw || typeof raw !== "object") {
+        throw new Error(`getThorchainLpPositions: unexpected Midgard response shape from ${url}`);
+      }
+      if (raw.pools === void 0) {
+        return [];
+      }
+      if (!Array.isArray(raw.pools)) {
+        throw new Error(`getThorchainLpPositions: Midgard response ${url} has non-array \`pools\` field`);
+      }
+      return raw.pools.map(normalizeMemberPool);
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/lockup.js
+var THORCHAIN_BLOCK_TIME_SECONDS, getThorchainLpLockupSeconds, getLpWithdrawReadiness;
+var init_lockup = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/lockup.js"() {
+    init_validation();
+    THORCHAIN_BLOCK_TIME_SECONDS = 6;
+    getThorchainLpLockupSeconds = async () => {
+      const mimir = await getThorchainMimir();
+      const blocks = mimir["LIQUIDITYLOCKUPBLOCKS"];
+      if (typeof blocks !== "number" || !Number.isFinite(blocks) || blocks < 0) {
+        throw new Error(`getThorchainLpLockupSeconds: mimir did not include a valid LIQUIDITYLOCKUPBLOCKS value`);
+      }
+      return blocks * THORCHAIN_BLOCK_TIME_SECONDS;
+    };
+    getLpWithdrawReadiness = async ({ position, lockupSeconds: providedLockupSeconds, nowUnix = Math.floor(Date.now() / 1e3) }) => {
+      const lockupSeconds = providedLockupSeconds ?? await getThorchainLpLockupSeconds();
+      const lastAdded = Number(position.dateLastAdded);
+      if (!Number.isFinite(lastAdded) || lastAdded <= 0) {
+        return {
+          isWithdrawable: true,
+          unlockAtUnix: 0,
+          remainingSeconds: 0
+        };
+      }
+      const unlockAtUnix = lastAdded + lockupSeconds;
+      const remainingSeconds = Math.max(unlockAtUnix - nowUnix, 0);
+      return {
+        isWithdrawable: remainingSeconds === 0,
+        unlockAtUnix,
+        remainingSeconds
+      };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/getThorchainInboundAddress.js
+var getThorchainInboundAddress_exports = {};
+__export(getThorchainInboundAddress_exports, {
+  getThorchainInboundAddress: () => getThorchainInboundAddress
+});
+var thorchainInboundAddressApi, getThorchainInboundAddress;
+var init_getThorchainInboundAddress = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/getThorchainInboundAddress.js"() {
+    init_queryUrl();
+    init_Chain();
+    init_cosmosRpcUrl();
+    thorchainInboundAddressApi = `${cosmosRpcUrl[Chain9.THORChain]}/thorchain/inbound_addresses`;
+    getThorchainInboundAddress = () => queryUrl(thorchainInboundAddressApi);
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/halts.js
+var buildStatus, getThorchainLpHaltStatusAll, getThorchainLpHaltStatus, getThorchainLpPoolPauseStatus;
+var init_halts = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/halts.js"() {
+    init_getThorchainInboundAddress();
+    init_validation();
+    buildStatus = (raw) => {
+      const reasons = [];
+      if (raw.halted)
+        reasons.push(`${raw.chain} chain is halted`);
+      if (raw.global_trading_paused)
+        reasons.push("global trading paused");
+      if (raw.chain_trading_paused)
+        reasons.push(`${raw.chain} chain trading paused`);
+      if (raw.chain_lp_actions_paused)
+        reasons.push(`${raw.chain} LP actions paused`);
+      const depositable = !raw.halted && !raw.chain_lp_actions_paused && !raw.chain_trading_paused && !raw.global_trading_paused;
+      const withdrawable = !raw.halted && !raw.chain_lp_actions_paused;
+      return {
+        chain: raw.chain,
+        depositable,
+        withdrawable,
+        reasons,
+        raw: {
+          halted: raw.halted,
+          chain_trading_paused: raw.chain_trading_paused,
+          chain_lp_actions_paused: raw.chain_lp_actions_paused,
+          global_trading_paused: raw.global_trading_paused
+        }
+      };
+    };
+    getThorchainLpHaltStatusAll = async () => {
+      const addresses = await getThorchainInboundAddress();
+      return addresses.map((a) => buildStatus({
+        chain: a.chain,
+        halted: a.halted,
+        chain_trading_paused: a.chain_trading_paused,
+        chain_lp_actions_paused: a.chain_lp_actions_paused,
+        global_trading_paused: a.global_trading_paused
+      }));
+    };
+    getThorchainLpHaltStatus = async (chain) => {
+      const all = await getThorchainLpHaltStatusAll();
+      const upper = chain.toUpperCase();
+      const match = all.find((s) => s.chain.toUpperCase() === upper);
+      if (!match) {
+        throw new Error(`getThorchainLpHaltStatus: chain ${chain} not found in inbound_addresses`);
+      }
+      return match;
+    };
+    getThorchainLpPoolPauseStatus = async (pool) => {
+      const mimir = await getThorchainMimir();
+      const mimirKey = poolPauseMimirKey(pool);
+      const mimirValue = mimir[mimirKey];
+      if (typeof mimirValue === "number" && mimirValue > 0) {
+        return { paused: true, mimirKey, mimirValue };
+      }
+      return { paused: false };
+    };
+  }
+});
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/lp/index.js
+var lp_exports = {};
+__export(lp_exports, {
+  THORCHAIN_BLOCK_TIME_SECONDS: () => THORCHAIN_BLOCK_TIME_SECONDS,
+  addLpMemo: () => addLpMemo,
+  assertPoolDepositable: () => assertPoolDepositable,
+  assertValidPoolId: () => assertValidPoolId,
+  buildThorchainLpAddPayload: () => buildThorchainLpAddPayload,
+  buildThorchainLpRemovePayload: () => buildThorchainLpRemovePayload,
+  chainPrefixToChain: () => chainPrefixToChain,
+  chainToLpPrefix: () => chainToLpPrefix,
+  estimateLpAdd: () => estimateLpAdd,
+  getLiquidityUnits: () => getLiquidityUnits,
+  getLpAddSlippage: () => getLpAddSlippage,
+  getLpWithdrawReadiness: () => getLpWithdrawReadiness,
+  getPoolShare: () => getPoolShare,
+  getThorchainLpHaltStatus: () => getThorchainLpHaltStatus,
+  getThorchainLpHaltStatusAll: () => getThorchainLpHaltStatusAll,
+  getThorchainLpLockupSeconds: () => getThorchainLpLockupSeconds,
+  getThorchainLpPoolPauseStatus: () => getThorchainLpPoolPauseStatus,
+  getThorchainLpPosition: () => getThorchainLpPosition,
+  getThorchainLpPositionFromThornode: () => getThorchainLpPositionFromThornode,
+  getThorchainLpPositions: () => getThorchainLpPositions,
+  getThorchainMimir: () => getThorchainMimir,
+  getThorchainPools: () => getThorchainPools,
+  isValidPoolId: () => isValidPoolId,
+  lpChainMap: () => lpChainMap,
+  poolPauseMimirKey: () => poolPauseMimirKey,
+  removeLpMemo: () => removeLpMemo,
+  resolvePairedAddressForLpAdd: () => resolvePairedAddressForLpAdd,
+  thorchainMidgardBaseUrl: () => thorchainMidgardBaseUrl
+});
+var init_lp = __esm({
+  "../../packages/core/chain/dist/chains/cosmos/thor/lp/index.js"() {
+    init_memo();
+    init_payload();
+    init_pools();
+    init_position();
+    init_validation();
+    init_pairing();
+    init_lpChainMap();
+    init_math();
+    init_positions();
+    init_lockup();
+    init_halts();
   }
 });
 
@@ -4850,10 +5824,10 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
   });
   const messageHash = computePersonalSignHash(authMessage);
   let lastError = null;
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+  for (let attempt2 = 1; attempt2 <= maxAttempts; attempt2++) {
     try {
-      if (attempt > 1) {
-        process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
+      if (attempt2 > 1) {
+        process.stderr.write(`  Retry ${attempt2}/${maxAttempts}...
 `);
       }
       const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain7.Ethereum }, {});
@@ -4870,7 +5844,7 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
       };
     } catch (err) {
       lastError = err;
-      if (attempt < maxAttempts && err.message?.includes("timeout")) {
+      if (attempt2 < maxAttempts && err.message?.includes("timeout")) {
         continue;
       }
       throw err;
@@ -4931,6 +5905,18 @@ function padTo32Bytes(buf) {
 }
 
 // src/agent/client.ts
+function v1StatusFromType(type) {
+  switch (type) {
+    case "tool-input-start":
+    case "tool-input-available":
+    case "tool-input-delta":
+      return "running";
+    case "tool-output-available":
+      return "done";
+    default:
+      return void 0;
+  }
+}
 function sseErrorToMessage(value) {
   if (value == null) return "";
   if (typeof value === "string") return value;
@@ -5034,6 +6020,7 @@ var AgentClient = class {
       transactions: [],
       message: null
     };
+    const toolNameByCallId = /* @__PURE__ */ new Map();
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -5048,7 +6035,7 @@ var AgentClient = class {
         currentData += (currentData ? "\n" : "") + stripLeadingSpace(line.slice(5));
       } else if (line === "") {
         if (currentData) {
-          this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks);
+          this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId);
         }
         currentEvent = "";
         currentData = "";
@@ -5068,7 +6055,7 @@ var AgentClient = class {
         if (done) {
           if (trailing) processLine(trailing);
           if (currentData) {
-            this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks);
+            this.handleSSEEvent(currentEvent || "message", currentData, result, callbacks, toolNameByCallId);
           }
           break;
         }
@@ -5078,71 +6065,75 @@ var AgentClient = class {
     }
     return result;
   }
-  handleSSEEvent(event, data, result, callbacks) {
+  handleSSEEvent(event, data, result, callbacks, toolNameByCallId) {
     try {
-      const rawParsed = JSON.parse(data);
-      let resolvedEvent = event;
-      let parsed = rawParsed;
-      if (event === "message" && typeof rawParsed?.type === "string") {
-        const v1Type = rawParsed.type;
-        if (v1Type === "text-delta") {
-          resolvedEvent = "text_delta";
-        } else if (v1Type === "finish") {
-          resolvedEvent = "done";
-        } else if (v1Type === "error") {
-          resolvedEvent = "error";
-          parsed = { error: rawParsed.errorText ?? rawParsed.error };
-        } else if (v1Type.startsWith("data-")) {
-          resolvedEvent = v1Type.slice(5);
-          if (rawParsed.data && typeof rawParsed.data === "object" && !Array.isArray(rawParsed.data)) {
-            parsed = rawParsed.data;
-          }
-        } else {
-          resolvedEvent = v1Type;
-          if (this.verbose) process.stderr.write(`[SSE:unmapped v1 type: ${v1Type}]
-`);
-        }
-      }
-      switch (resolvedEvent) {
+      const parsed = JSON.parse(data);
+      const v1Type = typeof parsed?.type === "string" && parsed.type.length > 0 ? parsed.type : null;
+      const routingEvent = v1Type ? this.mapV1EventType(v1Type) : event;
+      const v1Data = typeof parsed?.type === "string" && parsed.type.startsWith("data-") ? parsed.data : null;
+      switch (routingEvent) {
         case "text_delta":
           if (typeof parsed.delta === "string") {
             result.fullText += parsed.delta;
             callbacks.onTextDelta?.(parsed.delta);
           }
           break;
-        case "tool_progress":
+        case "tool_progress": {
           if (this.verbose) process.stderr.write(`[SSE:tool_progress] raw: ${data.slice(0, 1e3)}
 `);
-          callbacks.onToolProgress?.(parsed.tool, parsed.status, parsed.label);
+          const v1Status = v1StatusFromType(v1Type);
+          const status = parsed.status ?? v1Status;
+          const callId = typeof parsed.toolCallId === "string" ? parsed.toolCallId : null;
+          const rawInlineName = parsed.tool ?? parsed.toolName;
+          const inlineName = typeof rawInlineName === "string" && rawInlineName.length > 0 ? rawInlineName : void 0;
+          if (callId && inlineName) {
+            toolNameByCallId.set(callId, inlineName);
+          }
+          const toolName = inlineName ?? (callId ? toolNameByCallId.get(callId) : void 0);
+          const label = typeof parsed.label === "string" ? parsed.label : void 0;
+          if (status && toolName) {
+            callbacks.onToolProgress?.(toolName, status, label);
+          }
+          if (status === "done" && callId) toolNameByCallId.delete(callId);
           break;
-        case "title":
-          callbacks.onTitle?.(parsed.title);
+        }
+        case "title": {
+          const title = v1Data?.title ?? parsed.title;
+          if (typeof title === "string") callbacks.onTitle?.(title);
           break;
-        case "actions":
+        }
+        case "actions": {
           if (this.verbose) process.stderr.write(`[SSE:actions] raw: ${data.slice(0, 1e3)}
 `);
-          result.actions.push(...parsed.actions || []);
-          callbacks.onActions?.(parsed.actions || []);
+          const actions = v1Data?.actions ?? parsed.actions ?? [];
+          result.actions.push(...actions);
+          callbacks.onActions?.(actions);
           break;
-        case "suggestions":
-          result.suggestions.push(...parsed.suggestions || []);
-          callbacks.onSuggestions?.(parsed.suggestions || []);
+        }
+        case "suggestions": {
+          const suggestions = v1Data?.suggestions ?? parsed.suggestions ?? [];
+          result.suggestions.push(...suggestions);
+          callbacks.onSuggestions?.(suggestions);
           break;
+        }
         case "tx_ready":
           if (this.verbose) process.stderr.write(`[SSE:tx_ready] raw: ${data.slice(0, 2e3)}
 `);
           {
-            const txReady = parsed;
+            const txReady = v1Data ?? parsed;
             result.transactions.push(txReady);
             callbacks.onTxReady?.(txReady);
           }
           break;
-        case "message":
-          result.message = parsed.message || parsed;
+        case "message": {
+          const msg = v1Data?.message ?? parsed.message ?? parsed;
+          result.message = msg;
           callbacks.onMessage?.(result.message);
           break;
+        }
         case "error": {
-          const msg = sseErrorToMessage(parsed.error);
+          const errorText = typeof parsed.errorText === "string" ? parsed.errorText : parsed.error;
+          const msg = sseErrorToMessage(errorText);
           const codeFromBackend = typeof parsed.code === "string" && isAgentErrorCode(parsed.code) ? parsed.code : inferAgentErrorCodeFromMessage(msg);
           callbacks.onError?.(msg, codeFromBackend);
           break;
@@ -5159,6 +6150,37 @@ var AgentClient = class {
       }
     }
   }
+  // Maps a V1 `type` field to the legacy event bucket used by handleSSEEvent's
+  // switch. Frame-level types (start, text-start, text-end, finish-step) and
+  // non-critical telemetry (data-tokens, data-usage, data-confirmation) route
+  // to 'ignore' which is a no-op.
+  mapV1EventType(type) {
+    switch (type) {
+      case "text-delta":
+        return "text_delta";
+      case "tool-input-start":
+      case "tool-input-available":
+      case "tool-input-delta":
+      case "tool-output-available":
+        return "tool_progress";
+      case "data-title":
+        return "title";
+      case "data-actions":
+        return "actions";
+      case "data-suggestions":
+        return "suggestions";
+      case "data-tx_ready":
+        return "tx_ready";
+      case "data-message":
+        return "message";
+      case "error":
+        return "error";
+      case "finish":
+        return "done";
+      default:
+        return "ignore";
+    }
+  }
   // ============================================================================
   // Calldata
   // ============================================================================
@@ -5353,9 +6375,9 @@ function getNativeTokenDecimals(chain) {
 }
 
 // src/agent/executor.ts
-import { Chain as Chain9, evmCall, fiatCurrencies as fiatCurrencies3, Vultisig as VultisigSdk } from "@vultisig/sdk";
+import { Chain as Chain10, evmCall, fiatCurrencies as fiatCurrencies3, Vultisig as VultisigSdk } from "@vultisig/sdk";
 
-// node_modules/viem/_esm/index.js
+// ../../node_modules/viem/_esm/index.js
 init_formatUnits();
 
 // src/core/VaultStateStore.ts
@@ -5533,7 +6555,10 @@ var AUTO_EXECUTE_ACTIONS = /* @__PURE__ */ new Set([
   "sign_tx",
   "sign_typed_data",
   "read_evm_contract",
-  "scan_tx"
+  "scan_tx",
+  "thorchain_pool_info",
+  "thorchain_add_liquidity",
+  "thorchain_remove_liquidity"
 ]);
 var PASSWORD_REQUIRED_ACTIONS = /* @__PURE__ */ new Set(["sign_tx", "sign_typed_data", "build_custom_tx"]);
 
@@ -5568,7 +6593,7 @@ var EVM_GAS_RPC = {
   Hyperliquid: "https://rpc.hyperliquid.xyz/evm",
   Sei: "https://evm-rpc.sei-apis.com"
 };
-var AgentExecutor = class {
+var AgentExecutor = class _AgentExecutor {
   vault;
   /** Owning SDK (optional); used for address book backed by app storage */
   vultisig;
@@ -5619,7 +6644,7 @@ var AgentExecutor = class {
 `);
       return false;
     }
-    const chain = resolveChainFromTxReady(txReadyData) || Chain9.Ethereum;
+    const chain = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
     this.pendingPayloads.clear();
     this.pendingPayloads.set("latest", {
       payload: { __serverTx: true, ...txReadyData },
@@ -5708,6 +6733,12 @@ var AgentExecutor = class {
         return this.scanTx(params);
       case "read_evm_contract":
         return this.readEvmContract(params);
+      case "thorchain_pool_info":
+        return this.thorchainPoolInfo(params);
+      case "thorchain_add_liquidity":
+        return this.thorchainAddLiquidity(params);
+      case "thorchain_remove_liquidity":
+        return this.thorchainRemoveLiquidity(params);
       default:
         throw new Error(
           `Action type '${action.type}' is not implemented locally. The backend may handle this action server-side.`
@@ -5977,6 +7008,227 @@ var AgentExecutor = class {
       throw err;
     }
   }
+  // ============================================================================
+  // THORChain LP (RUNE-side asym add / remove via prepareSendTx + memo)
+  // ============================================================================
+  /**
+   * Pool stats from Midgard (no signing). Optional `pool` filters to one row.
+   */
+  async thorchainPoolInfo(params) {
+    const { assertValidPoolId: assertValidPoolId2, getThorchainPools: getThorchainPools2, thorchainMidgardBaseUrl: thorchainMidgardBaseUrl2 } = await Promise.resolve().then(() => (init_lp(), lp_exports));
+    const statusRaw = params.status;
+    let poolFetchOpts = {};
+    if (statusRaw === null || String(statusRaw).toLowerCase() === "all") {
+      poolFetchOpts = { status: null };
+    } else if (statusRaw !== void 0) {
+      poolFetchOpts = { status: String(statusRaw) };
+    }
+    const pools = await getThorchainPools2(poolFetchOpts);
+    const poolArg = params.pool;
+    if (poolArg) {
+      const normalized = poolArg.trim().toUpperCase();
+      assertValidPoolId2(normalized);
+      const row = pools.find((p) => p.asset.toUpperCase() === normalized);
+      return {
+        found: !!row,
+        pool_id: normalized,
+        summary: row ?? null,
+        midgard: thorchainMidgardBaseUrl2
+      };
+    }
+    const limitRaw = params.limit;
+    const limit = Math.min(500, Math.max(1, typeof limitRaw === "number" ? limitRaw : Number(limitRaw) || 80));
+    return {
+      pools: pools.slice(0, limit),
+      total: pools.length,
+      midgard: thorchainMidgardBaseUrl2
+    };
+  }
+  async thorchainAddLiquidity(params) {
+    const { assertValidPoolId: assertValidPoolId2, buildThorchainLpAddPayload: buildThorchainLpAddPayload2, resolvePairedAddressForLpAdd: resolvePairedAddressForLpAdd2 } = await Promise.resolve().then(() => (init_lp(), lp_exports));
+    const { getThorchainInboundAddress: getThorchainInboundAddress2 } = await Promise.resolve().then(() => (init_getThorchainInboundAddress(), getThorchainInboundAddress_exports));
+    const pool = this.normalizeThorchainPoolId(params.pool, assertValidPoolId2);
+    const amountStr = String(params.amount ?? "").trim();
+    if (!amountStr) {
+      throw new Error('amount is required (RUNE amount as a decimal string, e.g. "0.25")');
+    }
+    if (!/^\d+(\.\d+)?$/.test(amountStr)) {
+      throw new Error('amount must be a positive decimal string (no sign or scientific notation), e.g. "0.25"');
+    }
+    const [, frac = ""] = amountStr.split(".");
+    if (frac.length > 8) {
+      throw new Error("RUNE amount supports at most 8 decimal places");
+    }
+    const amountRuneBaseUnits = parseAmount(amountStr, 8);
+    if (amountRuneBaseUnits <= 0n) {
+      throw new Error("amount must be greater than zero");
+    }
+    let pairedAddress = params.paired_address?.trim() || void 0;
+    const autoPairRaw = params.auto_pair ?? params.autoPair;
+    const autoPairDisabled = autoPairRaw === false || autoPairRaw === 0 || typeof autoPairRaw === "string" && ["false", "0"].includes(autoPairRaw.toLowerCase());
+    const autoPair = !pairedAddress && !autoPairDisabled;
+    if (autoPair) {
+      const vaultAddresses = await this.buildVaultAddressMap();
+      pairedAddress = resolvePairedAddressForLpAdd2({
+        pool,
+        side: "rune",
+        vaultAddresses
+      }) || void 0;
+    }
+    const lpPayload = buildThorchainLpAddPayload2({
+      pool,
+      amountRuneBaseUnits: amountRuneBaseUnits.toString(),
+      ...pairedAddress ? { pairedAddress } : {}
+    });
+    const receiver = await this.getThorchainNativeInboundAddress(getThorchainInboundAddress2);
+    const address = await this.vault.address(Chain10.THORChain);
+    const coin = {
+      chain: Chain10.THORChain,
+      address,
+      decimals: 8,
+      ticker: "RUNE"
+    };
+    const payload = await this.vault.prepareSendTx({
+      coin,
+      receiver,
+      amount: BigInt(lpPayload.amount),
+      memo: lpPayload.memo
+    });
+    const messageHashes = await this.vault.extractMessageHashes(payload);
+    this.pendingPayloads.clear();
+    const payloadId = `tc_lp_add_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.pendingPayloads.set(payloadId, {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    this.pendingPayloads.set("latest", {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    return {
+      keysign_payload: payloadId,
+      chain: "THORChain",
+      pool: lpPayload.pool,
+      memo: lpPayload.memo,
+      amount_rune: amountStr,
+      paired_address: pairedAddress,
+      inbound_receiver: receiver,
+      sender: address,
+      message_hashes: messageHashes
+    };
+  }
+  async thorchainRemoveLiquidity(params) {
+    const { assertValidPoolId: assertValidPoolId2, buildThorchainLpRemovePayload: buildThorchainLpRemovePayload2 } = await Promise.resolve().then(() => (init_lp(), lp_exports));
+    const { getThorchainInboundAddress: getThorchainInboundAddress2 } = await Promise.resolve().then(() => (init_getThorchainInboundAddress(), getThorchainInboundAddress_exports));
+    const pool = this.normalizeThorchainPoolId(params.pool, assertValidPoolId2);
+    let basisPoints;
+    if (params.basis_points != null) {
+      basisPoints = Number(params.basis_points);
+    } else if (params.basisPoints != null) {
+      basisPoints = Number(params.basisPoints);
+    }
+    if (basisPoints == null && params.withdraw_percent != null) {
+      const pct = Number(params.withdraw_percent);
+      if (Number.isFinite(pct)) {
+        basisPoints = Math.round(pct * 100);
+      }
+    }
+    if (basisPoints == null || !Number.isInteger(basisPoints)) {
+      throw new Error("basis_points (integer 1\u201310000) or withdraw_percent (0.01\u2013100, maps to basis points) is required");
+    }
+    let withdrawToAsset = params.withdraw_to_asset?.trim();
+    if (!withdrawToAsset && params.withdrawToAsset) {
+      withdrawToAsset = String(params.withdrawToAsset).trim();
+    }
+    if (withdrawToAsset) {
+      withdrawToAsset = withdrawToAsset.toUpperCase();
+    }
+    const lpPayload = buildThorchainLpRemovePayload2({
+      pool,
+      basisPoints,
+      ...withdrawToAsset ? { withdrawToAsset } : {}
+    });
+    const receiver = await this.getThorchainNativeInboundAddress(getThorchainInboundAddress2);
+    const address = await this.vault.address(Chain10.THORChain);
+    const coin = {
+      chain: Chain10.THORChain,
+      address,
+      decimals: 8,
+      ticker: "RUNE"
+    };
+    const payload = await this.vault.prepareSendTx({
+      coin,
+      receiver,
+      amount: BigInt(lpPayload.amount),
+      memo: lpPayload.memo
+    });
+    const messageHashes = await this.vault.extractMessageHashes(payload);
+    this.pendingPayloads.clear();
+    const payloadId = `tc_lp_rm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    this.pendingPayloads.set(payloadId, {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    this.pendingPayloads.set("latest", {
+      payload,
+      coin,
+      chain: Chain10.THORChain,
+      timestamp: Date.now()
+    });
+    return {
+      keysign_payload: payloadId,
+      chain: "THORChain",
+      pool: lpPayload.pool,
+      memo: lpPayload.memo,
+      basis_points: basisPoints,
+      withdraw_to_asset: withdrawToAsset || void 0,
+      dust_rune_base_units: lpPayload.amount,
+      inbound_receiver: receiver,
+      sender: address,
+      message_hashes: messageHashes
+    };
+  }
+  normalizeThorchainPoolId(raw, assertValidPoolId2) {
+    const pool = String(raw ?? "").trim();
+    if (!pool) {
+      throw new Error('pool is required (e.g. "BTC.BTC")');
+    }
+    const upper = pool.toUpperCase();
+    assertValidPoolId2(upper);
+    return upper;
+  }
+  async buildVaultAddressMap() {
+    const map = {};
+    for (const c of this.vault.chains) {
+      try {
+        map[c] = await this.vault.address(c);
+      } catch {
+      }
+    }
+    return map;
+  }
+  /** THORChain protocol vault for native RUNE deposits (SWAP/LP memos). Matches SDK e2e fixture. */
+  static THORCHAIN_RUNE_DEPOSIT_ADDRESS = "thor1g98cy3n9mmjrpn0sxmn63lztelera37n8n67c0";
+  async getThorchainNativeInboundAddress(getInbound) {
+    const rows = await getInbound();
+    const thor = rows.find((r) => r.chain.toUpperCase() === "THOR");
+    if (thor?.address) {
+      return thor.address;
+    }
+    if (this.verbose) {
+      process.stderr.write(
+        `[thorchain_lp] THOR inbound row missing; using static RUNE deposit vault ${_AgentExecutor.THORCHAIN_RUNE_DEPOSIT_ADDRESS}
+`
+      );
+    }
+    return _AgentExecutor.THORCHAIN_RUNE_DEPOSIT_ADDRESS;
+  }
   async buildTx(params) {
     if (params.calldata_id && !params.data && this.backendClient) {
       const id = params.calldata_id;
@@ -6008,7 +7260,7 @@ var AgentExecutor = class {
       if (!stored) {
         throw new Error("Could not stage calldata transaction for signing (invalid or empty tx payload)");
       }
-      const chain = resolveChain(params.chain) || Chain9.Ethereum;
+      const chain = resolveChain(params.chain) || Chain10.Ethereum;
       const address = await this.vault.address(chain);
       return {
         status: "ready",
@@ -6559,11 +7811,11 @@ var AgentExecutor = class {
 `);
     const chainName = params.chain;
     const chainId = domain.chainId;
-    let chain = Chain9.Ethereum;
+    let chain = Chain10.Ethereum;
     if (chainName) {
-      chain = resolveChain(chainName) || Chain9.Ethereum;
+      chain = resolveChain(chainName) || Chain10.Ethereum;
     } else if (chainId) {
-      chain = resolveChainId(chainId) || Chain9.Ethereum;
+      chain = resolveChainId(chainId) || Chain10.Ethereum;
     }
     const sigResult = await this.vault.signBytes({
       data: eip712Hash,
@@ -6633,7 +7885,7 @@ var AgentExecutor = class {
       return { tokens };
     }
     const out = [];
-    for (const c of Object.values(Chain9)) {
+    for (const c of Object.values(Chain10)) {
       for (const t of VultisigSdk.getKnownTokens(c)) {
         if (!tokenMatchesQuery(t)) continue;
         out.push(t);
@@ -6716,11 +7968,11 @@ function abiEncodeParam(type, value) {
 }
 function resolveChain(name) {
   if (!name) return null;
-  if (Object.values(Chain9).includes(name)) {
+  if (Object.values(Chain10).includes(name)) {
     return name;
   }
   const lower = name.toLowerCase();
-  for (const [, value] of Object.entries(Chain9)) {
+  for (const [, value] of Object.entries(Chain10)) {
     if (typeof value === "string" && value.toLowerCase() === lower) {
       return value;
     }
@@ -6746,7 +7998,7 @@ function resolveChain(name) {
     xrp: "Ripple"
   };
   const aliased = aliases[lower];
-  if (aliased && Object.values(Chain9).includes(aliased)) {
+  if (aliased && Object.values(Chain10).includes(aliased)) {
     return aliased;
   }
   return null;
@@ -6780,16 +8032,16 @@ function resolveChainId(chainId) {
   const id = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
   if (isNaN(id)) return null;
   const chainIdMap = {
-    1: Chain9.Ethereum,
-    56: Chain9.BSC,
-    137: Chain9.Polygon,
-    43114: Chain9.Avalanche,
-    42161: Chain9.Arbitrum,
-    10: Chain9.Optimism,
-    8453: Chain9.Base,
-    81457: Chain9.Blast,
-    324: Chain9.Zksync,
-    25: Chain9.CronosChain
+    1: Chain10.Ethereum,
+    56: Chain10.BSC,
+    137: Chain10.Polygon,
+    43114: Chain10.Avalanche,
+    42161: Chain10.Arbitrum,
+    10: Chain10.Optimism,
+    8453: Chain10.Base,
+    81457: Chain10.Blast,
+    324: Chain10.Zksync,
+    25: Chain10.CronosChain
   };
   return chainIdMap[id] || null;
 }
@@ -8091,7 +9343,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "0.16.0";
+    cachedVersion = "0.17.0";
     return cachedVersion;
   }
   try {
@@ -8374,7 +9626,7 @@ function readArgValue(args, optionName) {
 }
 
 // src/interactive/completer.ts
-import { Chain as Chain10 } from "@vultisig/sdk";
+import { Chain as Chain11 } from "@vultisig/sdk";
 import fs3 from "fs";
 import path3 from "path";
 var COMMANDS = [
@@ -8518,7 +9770,7 @@ function completeVaultName(ctx2, partial) {
   return [show, partial];
 }
 function completeChainName(partial) {
-  const allChains = Object.values(Chain10);
+  const allChains = Object.values(Chain11);
   const partialLower = partial.toLowerCase();
   const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
   matches.sort();
@@ -8526,7 +9778,7 @@ function completeChainName(partial) {
   return [show, partial];
 }
 function findChainByName(name) {
-  const allChains = Object.values(Chain10);
+  const allChains = Object.values(Chain11);
   const nameLower = name.toLowerCase();
   const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
   return found ? found : null;