@vultisig/cli 0.22.4 → 0.22.7

package/dist/index.js

@@ -1449,980 +1449,6 @@ var init_formatUnits = __esm({
   }
 });
 
-// ../../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://gateway.liquify.com/chain/thorchain_midgard";
-    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://gateway.liquify.com/chain/thorchain_api",
-      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();
-  }
-});
-
 // src/index.ts
 import "dotenv/config";
 import { promises as fs4 } from "node:fs";
@@ -4514,8 +3540,9 @@ async function executeVaults(ctx2) {
   spinner.succeed("Vaults loaded");
   if (isJsonOutput()) {
     const activeVault2 = ctx2.getActiveVault();
+    const sorted = [...vaults].sort((a, b) => a.id === activeVault2?.id ? -1 : b.id === activeVault2?.id ? 1 : 0);
     outputJson({
-      vaults: vaults.map((v) => ({
+      vaults: sorted.map((v) => ({
         id: v.id,
         name: v.name,
         type: v.type,
@@ -5824,10 +4851,10 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
   });
   const messageHash = computePersonalSignHash(authMessage);
   let lastError = null;
-  for (let attempt2 = 1; attempt2 <= maxAttempts; attempt2++) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
-      if (attempt2 > 1) {
-        process.stderr.write(`  Retry ${attempt2}/${maxAttempts}...
+      if (attempt > 1) {
+        process.stderr.write(`  Retry ${attempt}/${maxAttempts}...
 `);
       }
       const signature = await vault.signBytes({ data: Buffer.from(messageHash), chain: Chain7.Ethereum }, {});
@@ -5844,7 +4871,7 @@ async function authenticateVault(client, vault, password, maxAttempts = 3) {
       };
     } catch (err) {
       lastError = err;
-      if (attempt2 < maxAttempts && err.message?.includes("timeout")) {
+      if (attempt < maxAttempts && err.message?.includes("timeout")) {
         continue;
       }
       throw err;
@@ -6368,22 +5395,413 @@ function getNativeTokenDecimals(chain) {
   return decimals[chain] || 18;
 }
 
-// src/agent/executor.ts
-import { Chain as Chain10, evmCall, Vultisig as VultisigSdk } from "@vultisig/sdk";
+// ../../packages/core/chain/dist/Chain.js
+var EthereumL2Chain = {
+  Arbitrum: "Arbitrum",
+  Base: "Base",
+  Blast: "Blast",
+  Optimism: "Optimism",
+  Zksync: "Zksync",
+  Mantle: "Mantle"
+};
+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 Chain9 = {
+  ...EvmChain,
+  ...UtxoChain,
+  ...CosmosChain,
+  ...OtherChain
+};
+var UtxoBasedChain = [
+  ...Object.values(UtxoChain),
+  OtherChain.Cardano
+];
+var defaultChains = [
+  Chain9.Bitcoin,
+  Chain9.Ethereum,
+  Chain9.THORChain,
+  Chain9.Solana,
+  Chain9.BSC
+];
 
-// ../../node_modules/viem/_esm/index.js
-init_formatUnits();
+// ../../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",
+  [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 getChainKind(chain) {
+  return chainKindRecord[chain];
+}
 
-// src/core/VaultStateStore.ts
-import * as fs2 from "node:fs";
-import * as os from "node:os";
-import * as path2 from "node:path";
-var LOCK_STALE_MS = 6e4;
-var LOCK_RETRY_INIT_MS = 100;
-var LOCK_MAX_WAIT_MS = 3e4;
-var STATE_TTL_MS = 10 * 6e4;
-var VaultStateStore = class {
-  baseDir;
+// ../../packages/lib/utils/dist/record/recordMap.js
+function recordMap(record, fn) {
+  return Object.fromEntries(Object.entries(record).map(([key, value]) => [
+    key,
+    fn(value, key)
+  ]));
+}
+
+// ../../packages/lib/utils/dist/record/makeRecord/index.js
+var makeRecord = (keys, getValue) => {
+  const record = {};
+  keys.forEach((key, index) => {
+    record[key] = getValue(key, index);
+  });
+  return record;
+};
+
+// ../../packages/core/chain/dist/chains/cosmos/thor/kujira-merge/index.js
+var kujiraCoinsMigratedToThorChain = [
+  "kuji",
+  "rkuji",
+  "fuzn",
+  "nstk",
+  "wink",
+  "lvn"
+];
+var kujiraCoinsMigratedToThorChainMetadata = {
+  kuji: {
+    ticker: "KUJI",
+    logo: "kuji",
+    priceProviderId: "kujira"
+  },
+  rkuji: {
+    ticker: "rKUJI",
+    logo: "rkuji.png",
+    priceProviderId: "kujira"
+  },
+  fuzn: {
+    ticker: "FUZN",
+    logo: "fuzn.png",
+    priceProviderId: "fuzion"
+  },
+  lvn: {
+    ticker: "LVN",
+    logo: "levana",
+    priceProviderId: "levana-protocol"
+  },
+  nstk: {
+    ticker: "NSTK",
+    logo: "nstk.png",
+    priceProviderId: "unstake-fi"
+  },
+  wink: {
+    ticker: "WINK",
+    logo: "wink.png",
+    priceProviderId: "winkhub"
+  }
+};
+var kujiraCoinMigratedToThorChainDestinationId = makeRecord(kujiraCoinsMigratedToThorChain, (id) => `thor.${id}`);
+
+// ../../packages/core/chain/dist/coin/chainFeeCoin.js
+var ether = {
+  ticker: "ETH",
+  logo: "eth",
+  decimals: 18,
+  priceProviderId: "ethereum"
+};
+var leanChainFeeCoin = {
+  [Chain9.Bitcoin]: {
+    ticker: "BTC",
+    logo: "btc",
+    decimals: 8,
+    priceProviderId: "bitcoin"
+  },
+  [Chain9.BitcoinCash]: {
+    ticker: "BCH",
+    logo: "bch",
+    decimals: 8,
+    priceProviderId: "bitcoin-cash"
+  },
+  [Chain9.Litecoin]: {
+    ticker: "LTC",
+    logo: "ltc",
+    decimals: 8,
+    priceProviderId: "litecoin"
+  },
+  [Chain9.Dogecoin]: {
+    ticker: "DOGE",
+    logo: "doge",
+    decimals: 8,
+    priceProviderId: "dogecoin"
+  },
+  [Chain9.Dash]: {
+    ticker: "DASH",
+    logo: "dash",
+    decimals: 8,
+    priceProviderId: "dash"
+  },
+  [Chain9.Ripple]: {
+    ticker: "XRP",
+    logo: "xrp",
+    decimals: 6,
+    priceProviderId: "ripple"
+  },
+  [Chain9.THORChain]: {
+    ticker: "RUNE",
+    logo: "rune",
+    decimals: 8,
+    priceProviderId: "thorchain"
+  },
+  [Chain9.MayaChain]: {
+    ticker: "CACAO",
+    logo: "cacao",
+    decimals: 10,
+    priceProviderId: "cacao"
+  },
+  [Chain9.Solana]: {
+    ticker: "SOL",
+    logo: "solana",
+    decimals: 9,
+    priceProviderId: "solana"
+  },
+  [Chain9.Ton]: {
+    ticker: "TON",
+    logo: "ton",
+    decimals: 9,
+    priceProviderId: "the-open-network"
+  },
+  [Chain9.Ethereum]: ether,
+  [Chain9.Avalanche]: {
+    ticker: "AVAX",
+    logo: "avax",
+    decimals: 18,
+    priceProviderId: "avalanche-2"
+  },
+  [Chain9.BSC]: {
+    ticker: "BNB",
+    logo: "bsc",
+    decimals: 18,
+    priceProviderId: "binancecoin"
+  },
+  [Chain9.Polygon]: {
+    ticker: "POL",
+    logo: "polygon",
+    decimals: 18,
+    priceProviderId: "polygon-ecosystem-token"
+  },
+  [Chain9.CronosChain]: {
+    ticker: "CRO",
+    logo: "cro",
+    decimals: 18,
+    priceProviderId: "crypto-com-chain"
+  },
+  [Chain9.Dydx]: {
+    ticker: "DYDX",
+    logo: "dydx",
+    decimals: 18,
+    priceProviderId: "dydx-chain"
+  },
+  [Chain9.Kujira]: {
+    ...kujiraCoinsMigratedToThorChainMetadata.kuji,
+    decimals: 6
+  },
+  [Chain9.Terra]: {
+    ticker: "LUNA",
+    logo: "luna",
+    decimals: 6,
+    priceProviderId: "terra-luna-2"
+  },
+  [Chain9.TerraClassic]: {
+    ticker: "LUNC",
+    logo: "lunc",
+    decimals: 6,
+    priceProviderId: "terra-luna"
+  },
+  [Chain9.Sui]: {
+    ticker: "SUI",
+    logo: "sui",
+    decimals: 9,
+    priceProviderId: "sui"
+  },
+  [Chain9.Polkadot]: {
+    ticker: "DOT",
+    logo: "dot",
+    decimals: 10,
+    priceProviderId: "polkadot"
+  },
+  [Chain9.Bittensor]: {
+    ticker: "TAO",
+    logo: "bittensor",
+    decimals: 9,
+    priceProviderId: "bittensor"
+  },
+  [Chain9.Noble]: {
+    ticker: "USDC",
+    logo: "noble",
+    decimals: 6,
+    priceProviderId: "usd-coin"
+  },
+  [Chain9.Akash]: {
+    ticker: "AKT",
+    logo: "akash",
+    decimals: 6,
+    priceProviderId: "akash-network"
+  },
+  [Chain9.Cosmos]: {
+    ticker: "ATOM",
+    logo: "atom",
+    decimals: 6,
+    priceProviderId: "cosmos"
+  },
+  [Chain9.Osmosis]: {
+    ticker: "OSMO",
+    logo: "osmo",
+    decimals: 6,
+    priceProviderId: "osmosis"
+  },
+  [Chain9.Tron]: {
+    ticker: "TRX",
+    logo: "tron",
+    decimals: 6,
+    priceProviderId: "tron"
+  },
+  ...recordMap(EthereumL2Chain, () => ether),
+  [Chain9.Zcash]: {
+    ticker: "ZEC",
+    logo: "zec",
+    decimals: 8,
+    priceProviderId: "zcash"
+  },
+  [Chain9.Cardano]: {
+    ticker: "ADA",
+    logo: "ada",
+    decimals: 6,
+    priceProviderId: "cardano"
+  },
+  [Chain9.Mantle]: {
+    ticker: "MNT",
+    logo: "mantle",
+    decimals: 18,
+    priceProviderId: "mantle"
+  },
+  [Chain9.Hyperliquid]: {
+    ticker: "HYPE",
+    logo: "hyperliquid",
+    decimals: 18,
+    priceProviderId: "hyperliquid"
+  },
+  [Chain9.Sei]: {
+    ticker: "SEI",
+    logo: "sei",
+    decimals: 18,
+    priceProviderId: "sei-network"
+  },
+  [Chain9.QBTC]: {
+    ticker: "QBTC",
+    logo: "qbtc",
+    decimals: 6,
+    priceProviderId: "qbtc-testnet"
+  }
+};
+var chainFeeCoin = recordMap(leanChainFeeCoin, (coin, chain) => ({
+  ...coin,
+  chain
+}));
+
+// src/agent/executor.ts
+import { Chain as Chain10, VaultError as VaultError3, VaultErrorCode as VaultErrorCode3, Vultisig as VultisigSdk } from "@vultisig/sdk";
+
+// ../../node_modules/viem/_esm/index.js
+init_formatUnits();
+
+// src/core/VaultStateStore.ts
+import * as fs2 from "node:fs";
+import * as os from "node:os";
+import * as path2 from "node:path";
+var LOCK_STALE_MS = 6e4;
+var LOCK_RETRY_INIT_MS = 100;
+var LOCK_MAX_WAIT_MS = 3e4;
+var STATE_TTL_MS = 10 * 6e4;
+var VaultStateStore = class {
+  baseDir;
   constructor(vaultId) {
     const safeId = vaultId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 40);
     if (!safeId) {
@@ -6529,30 +5947,46 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/agent/types.ts
-var AUTO_EXECUTE_ACTIONS = /* @__PURE__ */ new Set([
-  "vault_chain",
-  "vault_coin",
-  "address_book",
-  "get_address_book",
-  "get_balances",
-  "search_token",
-  "list_vaults",
-  "build_swap_tx",
-  "build_send_tx",
-  "build_custom_tx",
-  "build_tx",
-  "sign_tx",
-  "sign_typed_data",
-  "read_evm_contract",
-  "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"]);
-
 // src/agent/executor.ts
+var THOR_MEMO_CHAIN_TO_ENUM = {
+  BTC: Chain10.Bitcoin,
+  ETH: Chain10.Ethereum,
+  BSC: Chain10.BSC,
+  AVAX: Chain10.Avalanche,
+  BASE: Chain10.Base,
+  // L2 — THORChain routinely quotes Base destinations (PR #439 review finding 1)
+  ARB: Chain10.Arbitrum,
+  // L1-via-bridge path (PR #439 review finding 1)
+  BCH: Chain10.BitcoinCash,
+  LTC: Chain10.Litecoin,
+  DOGE: Chain10.Dogecoin,
+  GAIA: Chain10.Cosmos,
+  THOR: Chain10.THORChain,
+  RUNE: Chain10.THORChain,
+  XRP: Chain10.Ripple,
+  DASH: Chain10.Dash,
+  ZEC: Chain10.Zcash,
+  MAYA: Chain10.MayaChain,
+  CACAO: Chain10.MayaChain
+};
+var THOR_MEMO_ASSET_SHORTCUTS = {
+  b: "BTC.BTC",
+  e: "ETH.ETH",
+  s: "BSC.BNB",
+  a: "AVAX.AVAX",
+  c: "BCH.BCH",
+  l: "LTC.LTC",
+  d: "DOGE.DOGE",
+  g: "GAIA.ATOM",
+  r: "THOR.RUNE",
+  x: "XRP.XRP",
+  cacao: "MAYA.CACAO",
+  dash: "DASH.DASH",
+  zec: "ZEC.ZEC"
+  // BASE / ARB don't have documented single-letter shortcuts; THORChain
+  // emits these as the full CHAIN.ASSET form in memos. Listed in
+  // THOR_MEMO_CHAIN_TO_ENUM only.
+};
 var EVM_CHAINS = /* @__PURE__ */ new Set([
   "Ethereum",
   "BSC",
@@ -6583,11 +6017,17 @@ var EVM_GAS_RPC = {
   Hyperliquid: "https://rpc.hyperliquid.xyz/evm",
   Sei: "https://evm-rpc.sei-apis.com"
 };
-var AgentExecutor = class _AgentExecutor {
+var AgentExecutor = class {
   vault;
   /** Owning SDK (optional); used for address book backed by app storage */
   vultisig;
   pendingPayloads = /* @__PURE__ */ new Map();
+  /**
+   * Buffered legs for a 2-leg mcp-ts execute_* envelope (approve + main).
+   * Populated by storeServerTransaction when both `approvalTxArgs` and
+   * `txArgs` are present; consumed and cleared by signMultiLeg.
+   */
+  pendingLegs = [];
   password = null;
   verbose;
   stateStore = null;
@@ -6617,13 +6057,46 @@ var AgentExecutor = class _AgentExecutor {
         `[executor] storeServerTransaction called, keys: ${Object.keys(txReadyData || {}).join(",")}
 `
       );
-    if (txReadyData?.approvalTxArgs) {
-      if (this.verbose)
-        process.stderr.write(
-          `[executor] skipping multi-leg execute_swap envelope (approvalTxArgs present): not yet supported in sdk-cli \u2014 Phase B
+    if (txReadyData?.approvalTxArgs && txReadyData?.txArgs) {
+      const approvalChain = resolveChainFromTxReady(txReadyData.approvalTxArgs);
+      const mainChain = resolveChainFromTxReady(txReadyData.txArgs);
+      const parentChain = resolveChainFromTxReady(txReadyData);
+      if (!approvalChain || !mainChain || approvalChain !== mainChain || parentChain && parentChain !== approvalChain) {
+        if (this.verbose)
+          process.stderr.write(
+            `[executor] rejecting multi-leg envelope with inconsistent chain metadata: parent=${parentChain ?? "unresolved"} approval=${approvalChain ?? "unresolved"} main=${mainChain ?? "unresolved"}
 `
-        );
-      return false;
+          );
+        return false;
+      }
+      const chain2 = approvalChain;
+      if (!EVM_CHAINS.has(chain2)) {
+        if (this.verbose)
+          process.stderr.write(
+            `[executor] rejecting multi-leg envelope on non-EVM chain ${chain2}: signMultiLeg is EVM-only
+`
+          );
+        return false;
+      }
+      this.pendingLegs = [
+        {
+          txArgs: txReadyData.approvalTxArgs,
+          parent: txReadyData,
+          kind: "approve"
+        },
+        { txArgs: txReadyData.txArgs, parent: txReadyData, kind: "main" }
+      ];
+      this.pendingPayloads.clear();
+      this.pendingPayloads.set("latest", {
+        payload: { __serverTx: true, __multiLeg: true, ...txReadyData },
+        coin: { chain: chain2, address: "", decimals: 18, ticker: "" },
+        chain: chain2,
+        timestamp: Date.now()
+      });
+      if (this.verbose)
+        process.stderr.write(`[executor] stored multi-leg envelope: chain=${chain2}, legs=2 (approve, main)
+`);
+      return true;
     }
     const nestedTx = extractNestedTx(txReadyData);
     if (nestedTx?.status === "error" || nestedTx?.error) {
@@ -6632,6 +6105,27 @@ var AgentExecutor = class _AgentExecutor {
 `);
       return false;
     }
+    if (!nestedTx && txReadyData && typeof txReadyData === "object") {
+      const txArgs = txReadyData.txArgs;
+      if (txArgs && typeof txArgs === "object" && typeof txArgs.to === "string" && typeof txArgs.amount === "string") {
+        const chain2 = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
+        if (getChainKind(chain2) !== "evm") {
+          this.pendingPayloads.clear();
+          this.pendingPayloads.set("latest", {
+            payload: { __serverTx: true, ...txReadyData },
+            coin: { chain: chain2, address: "", decimals: 18, ticker: "" },
+            chain: chain2,
+            timestamp: Date.now()
+          });
+          if (this.verbose)
+            process.stderr.write(
+              `[executor] Stored non-EVM server tx for chain ${chain2} (kind=${getChainKind(chain2)})
+`
+            );
+          return true;
+        }
+      }
+    }
     if (!nestedTx) {
       if (this.verbose)
         process.stderr.write(`[executor] storeServerTransaction: no swap_tx/send_tx/tx/txArgs.tx found in data
@@ -6656,137 +6150,78 @@ var AgentExecutor = class _AgentExecutor {
   hasPendingTransaction() {
     return this.pendingPayloads.has("latest");
   }
-  shouldAutoExecute(action) {
-    return action.auto_execute === true || AUTO_EXECUTE_ACTIONS.has(action.type);
-  }
-  requiresPassword(action) {
-    return PASSWORD_REQUIRED_ACTIONS.has(action.type);
-  }
   /**
-   * Execute a single action and return the result.
+   * Wrap a per-tool handler body with normalised success/failure → RecentAction
+   * conversion. Replaces the legacy executeAction → ActionResult adapter that
+   * the dispatch chokepoint used before this refactor.
    */
-  async executeAction(action) {
+  async runTool(toolName, body) {
     try {
-      const data = await this.dispatch(action);
-      return {
-        action: action.type,
-        action_id: action.id,
-        success: true,
-        data
-      };
+      const data = await body();
+      return { tool: toolName, success: true, data };
     } catch (err) {
       const { code, message } = normalizeAgentError(err);
-      return {
-        action: action.type,
-        action_id: action.id,
-        success: false,
-        error: message,
-        code
-      };
-    }
-  }
-  async dispatch(action) {
-    if (this.verbose) process.stderr.write(`[dispatch] action.type=${action.type} action.id=${action.id}
-`);
-    const params = action.params || {};
-    switch (action.type) {
-      case "get_balances":
-        return this.getBalances(params);
-      case "vault_chain":
-        return this.vaultChain(params);
-      case "vault_coin":
-        return this.vaultCoin(params);
-      case "build_send_tx":
-        return this.buildSendTx(params);
-      case "build_swap_tx":
-        return this.buildSwapTx(params);
-      case "build_tx":
-      case "build_custom_tx":
-        return this.buildTx(params);
-      case "sign_tx":
-        return this.signTx(params);
-      case "get_address_book":
-        return this.getAddressBook(params);
-      case "address_book":
-        return this.addressBook(params);
-      case "search_token":
-        return this.searchToken(params);
-      case "list_vaults":
-        return this.listVaults();
-      case "sign_typed_data":
-        return this.signTypedData(params);
-      case "scan_tx":
-        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.`
-        );
-    }
-  }
-  // ============================================================================
-  // Balance & Portfolio
-  // ============================================================================
-  async getBalances(params) {
-    const chainFilter = params.chain;
-    const tickerFilter = params.ticker;
-    const balanceRecord = await this.vault.balances();
-    let entries = Object.entries(balanceRecord).map(([key, b]) => ({
-      chain: b.chainId || key.split(":")[0] || "",
-      symbol: b.symbol || "",
-      amount: b.formattedAmount || b.amount?.toString() || "0",
-      decimals: b.decimals || 18,
-      raw_amount: b.amount?.toString()
-    }));
-    if (chainFilter) {
-      const chain = resolveChain(chainFilter);
-      if (chain) {
-        entries = entries.filter((b) => b.chain.toLowerCase() === chain.toLowerCase());
-      }
-    }
-    if (tickerFilter) {
-      entries = entries.filter((b) => b.symbol.toLowerCase() === tickerFilter.toLowerCase());
+      return { tool: toolName, success: false, data: { error: message, code } };
     }
-    return { balances: entries };
   }
   // ============================================================================
   // Chain & Token Management
   // ============================================================================
   // vault_chain dispatcher — backend shape:
   //   { action: "add" | "remove", chains: [{ chain }] }
-  // Single-chain (`chain` only) and legacy string arrays are tolerated for
-  // forward compatibility / hand-rolled callers.
-  async vaultChain(params) {
-    const action = params.action;
-    switch (action) {
-      case "add":
-        return this.addChainImpl(params);
-      case "remove":
-        return this.removeChainImpl(params);
-      default:
-        throw new Error(`vault_chain: unknown action: ${action ?? "(missing)"}`);
-    }
+  // Discriminator wrapper: routes to addChain / removeChain so the resulting
+  // RecentAction is tagged tool: 'vault_chain' (matching what the agent emits)
+  // rather than the per-action method's tool name.
+  async vaultChain(toolCallId, input) {
+    return this.runTool("vault_chain", async () => {
+      const action = input.action;
+      switch (action) {
+        case "add":
+          return this.addChainImpl(input);
+        case "remove":
+          return this.removeChainImpl(input);
+        default:
+          throw new Error(`vault_chain: unknown action: ${action ?? "(missing)"}`);
+      }
+    });
   }
   // vault_coin dispatcher — backend shape:
-  //   { action: "add" | "remove", coins: [{ chain, ticker, contract_address?, decimals?, ... }] }
-  async vaultCoin(params) {
-    const action = params.action;
-    switch (action) {
-      case "add":
-        return this.addCoinImpl(params);
-      case "remove":
-        return this.removeCoinImpl(params);
-      default:
-        throw new Error(`vault_coin: unknown action: ${action ?? "(missing)"}`);
-    }
+  //   { action: "add" | "remove", coins: [{ chain, ticker, contract_address?, ... }] }
+  async vaultCoin(toolCallId, input) {
+    return this.runTool("vault_coin", async () => {
+      const action = input.action;
+      switch (action) {
+        case "add":
+          return this.addCoinImpl(input);
+        case "remove":
+          return this.removeCoinImpl(input);
+        default:
+          throw new Error(`vault_coin: unknown action: ${action ?? "(missing)"}`);
+      }
+    });
+  }
+  // address_book dispatcher — backend shape:
+  //   { action: "add" | "remove", entry: { name, chain, address } }
+  async addressBook(toolCallId, input) {
+    return this.runTool("address_book", async () => {
+      const action = input.action;
+      switch (action) {
+        case "add":
+          return this.addAddressBookImpl(input);
+        case "remove":
+          return this.removeAddressBookImpl(input);
+        default:
+          throw new Error(`address_book: unknown action: ${action ?? "(missing)"}`);
+      }
+    });
   }
+  async addChain(_toolCallId, input) {
+    return this.runTool("add_chain", () => this.addChainImpl(input));
+  }
+  // Backend `vault_chain { action: "add", chains: [...] }` and legacy
+  // single-chain calls both flow through this impl. The public `addChain`
+  // wrapper above tags results as `tool: 'add_chain'`; the new `vaultChain`
+  // wrapper (above) tags them as `tool: 'vault_chain'`.
   async addChainImpl(params) {
     const chains = params.chains;
     if (chains && Array.isArray(chains)) {
@@ -6839,7 +6274,7 @@ var AgentExecutor = class _AgentExecutor {
           id: t.contract_address || t.contractAddress || "",
           symbol: symbol2,
           name: t.name || symbol2,
-          decimals: t.decimals || 18,
+          decimals: t.decimals ?? 18,
           contractAddress: t.contract_address || t.contractAddress,
           chainId: chain2.toString()
         });
@@ -6855,7 +6290,7 @@ var AgentExecutor = class _AgentExecutor {
       id: params.contract_address || params.contractAddress || "",
       symbol,
       name: params.name || symbol,
-      decimals: params.decimals || 18,
+      decimals: params.decimals ?? 18,
       contractAddress: params.contract_address || params.contractAddress,
       chainId: chain.toString()
     });
@@ -6883,465 +6318,59 @@ var AgentExecutor = class _AgentExecutor {
     const chain = resolveChain(chainName);
     if (!chain) throw new Error(`Unknown chain: ${chainName}`);
     const tokenId = params.contract_address || params.contractAddress || params.token_id || params.id;
-    if (!tokenId) {
-      throw new Error(`vault_coin remove: missing contract_address for coin on ${chainName}`);
-    }
-    await this.vault.removeToken(chain, tokenId);
-    return { chain: chain.toString(), removed: true };
-  }
-  // ============================================================================
-  // Transaction Building
-  // ============================================================================
-  async buildSendTx(params) {
-    const chainName = params.chain || params.from_chain;
-    const chain = resolveChain(chainName);
-    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
-    const symbol = params.symbol || params.ticker;
-    const toAddress = params.address || params.to || params.destination;
-    const amountStr = params.amount;
-    if (!toAddress) throw new Error("Destination address is required");
-    if (!amountStr) throw new Error("Amount is required");
-    await this.acquireEvmLockIfNeeded(chain);
-    try {
-      const address = await this.vault.address(chain);
-      const balance = await this.vault.balance(chain, params.token_id);
-      const coin = {
-        chain,
-        address,
-        decimals: balance.decimals,
-        ticker: symbol || balance.symbol,
-        id: params.token_id
-      };
-      const amount = parseAmount(amountStr, balance.decimals);
-      const memo = params.memo;
-      const payload = await this.vault.prepareSendTx({
-        coin,
-        receiver: toAddress,
-        amount,
-        memo
-      });
-      await this.patchEvmNonce(chain, payload);
-      const messageHashes = await this.vault.extractMessageHashes(payload);
-      this.pendingPayloads.clear();
-      const payloadId = `tx_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      this.pendingPayloads.set(payloadId, {
-        payload,
-        coin,
-        chain,
-        timestamp: Date.now()
-      });
-      this.pendingPayloads.set("latest", {
-        payload,
-        coin,
-        chain,
-        timestamp: Date.now()
-      });
-      return {
-        keysign_payload: payloadId,
-        from_chain: chain.toString(),
-        from_symbol: coin.ticker,
-        amount: amountStr,
-        sender: address,
-        destination: toAddress,
-        memo: memo || void 0,
-        message_hashes: messageHashes,
-        tx_details: {
-          chain: chain.toString(),
-          from: address,
-          to: toAddress,
-          amount: amountStr,
-          symbol: coin.ticker
-        }
-      };
-    } catch (err) {
-      await this.releaseEvmLock(chain);
-      throw err;
-    }
-  }
-  async buildSwapTx(params) {
-    if (this.verbose)
-      process.stderr.write(`[build_swap_tx] called with params: ${JSON.stringify(params).slice(0, 500)}
-`);
-    const fromChainName = params.from_chain || params.chain;
-    const toChainName = params.to_chain;
-    const fromChain = resolveChain(fromChainName);
-    const toChain = toChainName ? resolveChain(toChainName) : null;
-    if (!fromChain) throw new Error(`Unknown from_chain: ${fromChainName}`);
-    await this.acquireEvmLockIfNeeded(fromChain);
-    try {
-      const amountStr = params.amount;
-      const fromSymbol = params.from_symbol || params.from_token || "";
-      const toSymbol = params.to_symbol || params.to_token || "";
-      const fromToken = params.from_contract || params.from_token_id;
-      const toToken = params.to_contract || params.to_token_id;
-      const fromCoin = { chain: fromChain, token: fromToken || void 0 };
-      const toCoin = {
-        chain: toChain || fromChain,
-        token: toToken || void 0
-      };
-      const quote = await this.vault.getSwapQuote({
-        fromCoin,
-        toCoin,
-        amount: amountStr
-      });
-      const swapResult = await this.vault.prepareSwapTx({
-        fromCoin,
-        toCoin,
-        amount: amountStr,
-        swapQuote: quote,
-        autoApprove: true
-      });
-      const chain = fromChain;
-      const payload = swapResult.keysignPayload;
-      await this.patchEvmNonce(chain, payload);
-      const messageHashes = await this.vault.extractMessageHashes(payload);
-      this.pendingPayloads.clear();
-      const payloadId = `swap_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      this.pendingPayloads.set(payloadId, {
-        payload,
-        coin: { chain, address: "", decimals: 18, ticker: fromSymbol },
-        chain,
-        timestamp: Date.now()
-      });
-      this.pendingPayloads.set("latest", {
-        payload,
-        coin: { chain, address: "", decimals: 18, ticker: fromSymbol },
-        chain,
-        timestamp: Date.now()
-      });
-      return {
-        keysign_payload: payloadId,
-        from_chain: fromChain.toString(),
-        to_chain: (toChain || fromChain).toString(),
-        from_symbol: fromSymbol,
-        to_symbol: toSymbol,
-        amount: amountStr,
-        estimated_output: quote.estimatedOutput?.toString(),
-        provider: quote.provider,
-        message_hashes: messageHashes
-      };
-    } catch (err) {
-      await this.releaseEvmLock(fromChain);
-      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.function_name && params.contract_address) {
-      return this.buildContractCallTx(params);
-    }
-    if (params.data || params.calldata || params.hex_payload) {
-      const txData = {
-        to: params.to || params.address || params.contract,
-        value: params.value || "0",
-        data: params.data || params.calldata || params.hex_payload,
-        chain: params.chain,
-        chain_id: params.chain_id
-      };
-      const stored = this.storeServerTransaction({
-        tx: txData,
-        chain: params.chain,
-        from_chain: params.chain
-      });
-      if (!stored) {
-        throw new Error("Could not stage calldata transaction for signing (invalid or empty tx payload)");
-      }
-      const chain = resolveChain(params.chain) || Chain10.Ethereum;
-      const address = await this.vault.address(chain);
-      return {
-        status: "ready",
-        chain: chain.toString(),
-        from: address,
-        to: txData.to,
-        value: txData.value,
-        has_calldata: true,
-        message: "Transaction built. Ready to sign."
-      };
-    }
-    if (params.contract_address && !params.function_name) {
-      const provided = Object.keys(params).join(", ");
-      throw new Error(
-        `build_custom_tx requires function_name and params for contract calls. Got: ${provided}. Missing: function_name, params.`
-      );
-    }
-    throw new Error(
-      `build_custom_tx: unrecognized params shape. Expected function_name + contract_address for ABI-encoding. Server-built calldata should arrive via tx_ready, not via action params. Got keys: ${Object.keys(params).join(", ")}`
-    );
-  }
-  /**
-   * Build, sign, and broadcast an EVM contract call transaction from structured params.
-   * Encodes function_name + typed params into ABI calldata, then signs via signServerTx.
-   */
-  async buildContractCallTx(params) {
-    const chainName = params.chain || "Ethereum";
-    const chain = resolveChain(chainName);
-    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
-    const contractAddress = params.contract_address;
-    const functionName = params.function_name;
-    const typedParams = params.params;
-    const value = params.value || "0";
-    const calldata = await encodeContractCall(functionName, typedParams || []);
-    if (this.verbose)
-      process.stderr.write(
-        `[build_contract_tx] ${functionName}(${(typedParams || []).map((p) => p.type).join(",")}) on ${contractAddress} chain=${chain}
-`
-      );
-    const serverTxData = {
-      __serverTx: true,
-      tx: {
-        to: contractAddress,
-        value,
-        data: calldata
-      },
-      chain: chainName,
-      from_chain: chainName
-    };
-    this.pendingPayloads.set("latest", {
-      payload: serverTxData,
-      coin: { chain, address: "", decimals: 18, ticker: "" },
-      chain,
-      timestamp: Date.now()
-    });
-    return this.signServerTx(serverTxData, chain, { chain: chainName });
+    if (!tokenId) {
+      throw new Error(`vault_coin remove: missing contract_address for coin on ${chainName}`);
+    }
+    await this.vault.removeToken(chain, tokenId);
+    return { chain: chain.toString(), removed: true };
+  }
+  async removeChain(_toolCallId, input) {
+    return this.runTool("remove_chain", () => this.removeChainImpl(input));
+  }
+  async addCoin(_toolCallId, input) {
+    return this.runTool("add_coin", () => this.addCoinImpl(input));
+  }
+  async removeCoin(_toolCallId, input) {
+    return this.runTool("remove_coin", () => this.removeCoinImpl(input));
   }
   // ============================================================================
   // Transaction Signing
   // ============================================================================
-  async signTx(params) {
-    if (this.verbose) process.stderr.write(`[sign_tx] params: ${JSON.stringify(params).slice(0, 500)}
-`);
-    if (this.verbose)
-      process.stderr.write(`[sign_tx] pendingPayloads keys: ${[...this.pendingPayloads.keys()].join(", ")}
+  /**
+   * Sign and broadcast a transaction previously buffered by
+   * {@link storeServerTransaction} via the `tx_ready` SSE channel. Returns
+   * a `RecentAction` to be flushed in the next `context.recent_actions`.
+   *
+   * Replaces the legacy `signTx(action.params)` path: there is no longer an
+   * action wrapper, no `keysign_payload` lookup (the buffer always uses
+   * the `'latest'` slot), and no SDK-built keysignPayload branch (the live
+   * client-side tools no longer produce SDK-built payloads — those went
+   * away with `buildSendTx`/`buildSwapTx`).
+   */
+  async signTxFromBuffer(_toolCallId) {
+    return this.runTool("sign_tx", async () => {
+      if (this.verbose)
+        process.stderr.write(`[sign_tx] pendingPayloads keys: ${[...this.pendingPayloads.keys()].join(", ")}
 `);
-    const payloadId = params.keysign_payload || params.payload_id || "latest";
-    const stored = this.pendingPayloads.get(payloadId);
-    if (!stored) {
-      throw new Error("No pending transaction to sign. Build a transaction first.");
-    }
-    const { payload, chain } = stored;
-    if (payload.__serverTx) {
+      const stored = this.pendingPayloads.get("latest");
+      if (!stored) {
+        throw new Error("No pending transaction to sign. Build a transaction first.");
+      }
+      const { payload, chain } = stored;
+      if (!payload.__serverTx) {
+        throw new Error("Pending transaction is not a server-built tx (no __serverTx flag).");
+      }
       let result;
-      if (chain === "Solana" && (payload.swap_tx || payload.provider)) {
+      if (payload.__multiLeg) {
+        if (this.pendingLegs.length !== 2) {
+          throw new VaultError3(
+            VaultErrorCode3.InvalidConfig,
+            `signMultiLeg: expected 2 pending legs, got ${this.pendingLegs.length}`
+          );
+        }
+        result = await this.signMultiLeg(payload, chain, {});
+      }
+      if (!result && chain === "Solana" && (payload.swap_tx || payload.provider)) {
         try {
           result = await this.buildAndSignSolanaSwapLocally(payload);
         } catch (e) {
@@ -7354,62 +6383,176 @@ var AgentExecutor = class _AgentExecutor {
           }
         }
       }
-      if (!result) result = await this.signServerTx(payload, chain, params);
+      if (!result) result = await this.signServerTx(payload, chain, {});
       if (payload.sequence_id) result.sequence_id = payload.sequence_id;
       return result;
+    });
+  }
+  /**
+   * Dispatch a server-built tx_ready envelope to the chain-kind-specific
+   * signer. EVM stays in `signEvmServerTx` (the existing PR #422 + PR #435
+   * code, with EVM nonce/lock plumbing). Non-EVM kinds parse the envelope
+   * via `parseNonEvmEnvelope` and route through `vault.send`, which is
+   * already chain-agnostic via `VaultBase.prepareSendTx` virtuals.
+   *
+   * Phase D — see task `100526-sdk-cli-non-evm-signing.md`.
+   */
+  async signServerTx(serverTxData, defaultChain, params) {
+    const chain = resolveChainFromTxReady(serverTxData) || defaultChain;
+    const chainKind = getChainKind(chain);
+    if (chainKind === "evm") {
+      return this.signEvmServerTx(serverTxData, defaultChain, params);
     }
-    return this.signSdkTx(payload, chain, payloadId);
+    return this.signNonEvmServerTx(serverTxData, chain);
   }
   /**
-   * Sign and broadcast an SDK-built transaction (keysign payload from local build methods).
+   * Non-EVM signing path: parse the agent's tx_ready envelope into a
+   * `vault.send`-shaped argument bag and call through. The SDK already
+   * handles per-chain prepare/sign/broadcast internally via
+   * `VaultBase.prepareSendTx` virtuals — sdk-cli only owns envelope
+   * parsing here, not chain-specific signing logic.
+   *
+   * THORChain / MayaChain MsgDeposit envelopes (msg_type='deposit',
+   * to='') are routed through `vault.swap` because the agent's intent
+   * is a swap — the memo (`=:CHAIN.ASSET:DEST::v0:slippage`) carries
+   * the routing. We parse the memo to reconstruct vault.swap's
+   * fromChain / fromSymbol / toChain / toSymbol / amount args. The SDK
+   * then builds the MsgDeposit cosmos tx internally. Vultiagent uses an
+   * equivalent custom helper (`buildSignBroadcastThorchainLpDeposit`);
+   * we reuse the public `vault.swap` surface to avoid expanding the SDK.
    */
-  async signSdkTx(payload, chain, _payloadId) {
-    try {
-      if (this.vault.isEncrypted && !this.vault.isUnlocked?.()) {
-        if (this.password) {
-          await this.vault.unlock?.(this.password);
-        }
+  async signNonEvmServerTx(serverTxData, chain) {
+    if (this.vault.isEncrypted && !this.vault.isUnlocked?.()) {
+      if (this.password) {
+        await this.vault.unlock?.(this.password);
       }
-      await this.patchEvmGas(chain, payload);
-      const messageHashes = await this.vault.extractMessageHashes(payload);
-      const signature = await this.vault.sign(
-        {
-          transaction: payload,
-          chain: payload.coin?.chain || chain,
-          messageHashes
-        },
-        {}
+    }
+    const txArgs = serverTxData?.txArgs ?? {};
+    if (typeof txArgs.chain === "string" && txArgs.chain !== chain) {
+      throw new VaultError3(
+        VaultErrorCode3.InvalidConfig,
+        `signNonEvmServerTx: dispatcher chain '${chain}' disagrees with envelope chain '${txArgs.chain}'`
       );
-      const txHash = await this.vault.broadcastTx({
-        chain,
-        keysignPayload: payload,
-        signature
-      });
-      this.evmLastBroadcast.set(chain.toString(), Date.now());
-      try {
-        this.recordEvmNonceFromPayload(chain, payload, messageHashes.length);
-      } catch (nonceErr) {
-        console.warn(`[nonce] failed to persist nonce for ${chain}:`, nonceErr);
-      }
-      await this.releaseEvmLock(chain);
-      this.pendingPayloads.clear();
-      const explorerUrl = VultisigSdk.getTxExplorerUrl(chain, txHash);
-      return {
-        tx_hash: txHash,
-        chain: chain.toString(),
-        status: "pending",
-        explorer_url: explorerUrl
-      };
-    } catch (err) {
-      await this.releaseEvmLock(chain);
-      throw err;
     }
+    if (txArgs.msg_type === "deposit" && (chain === Chain10.THORChain || chain === Chain10.MayaChain)) {
+      return this.signThorMsgDepositSwap(serverTxData, chain);
+    }
+    const args = parseNonEvmEnvelope(serverTxData, chain);
+    if (this.verbose)
+      process.stderr.write(
+        `[sign_non_evm_server_tx] chain=${chain}, to=${args.to}, amount=${args.amount}${args.symbol ? ` ${args.symbol}` : ""}, memo=${args.memo ? `"${args.memo}"` : "(none)"}
+`
+      );
+    const result = await this.vault.send({
+      chain,
+      to: args.to,
+      amount: args.amount,
+      symbol: args.symbol,
+      memo: args.memo
+    });
+    if (result.dryRun) {
+      throw new VaultError3(
+        VaultErrorCode3.InvalidConfig,
+        "signNonEvmServerTx: vault.send unexpectedly returned dryRun result"
+      );
+    }
+    this.pendingPayloads.clear();
+    const broadcast = result;
+    const explorerUrl = VultisigSdk.getTxExplorerUrl(chain, broadcast.txHash);
+    return {
+      tx_hash: broadcast.txHash,
+      chain: chain.toString(),
+      status: "pending",
+      explorer_url: explorerUrl
+    };
   }
   /**
-   * Sign and broadcast a server-built transaction (raw EVM tx from tx_ready SSE).
-   * Uses vault.prepareSendTx with memo field to carry the calldata.
+   * Sign and broadcast a THORChain / MayaChain MsgDeposit-style swap
+   * envelope by reconstructing `vault.swap` args from the memo.
+   *
+   * The agent emits envelopes shaped:
+   *   { txArgs: { chain: 'THORChain', tx_encoding: 'cosmos-msg',
+   *               to: '', amount: '<base>', denom: 'rune',
+   *               memo: '=:DEST_CHAIN.DEST_ASSET:DEST_ADDR::v0:slippage_bps',
+   *               msg_type: 'deposit' } }
+   *
+   * The memo is THORChain's standard swap memo. We parse out the
+   * destination chain + asset, look up the corresponding `Chain` enum,
+   * then call `vault.swap` which builds the MsgDeposit internally.
+   *
+   * IMPORTANT — destination address handling: `vault.swap` re-derives the
+   * destination address from `vault.address(toChain)` when fetching the
+   * native swap quote (see `findSwapQuote` → `getNativeSwapQuote` —
+   * `destination: to.address`). It does NOT honor the destination address
+   * encoded in the envelope's memo. As a fund-safety guard we therefore
+   * require the memo's destination address to match the vault's own
+   * destination address (self-swap) and throw otherwise — see Phase D
+   * review F1. Cross-account routing must wait on a Phase E SDK extension
+   * that lets `vault.swap` accept a user-supplied destination.
    */
-  async signServerTx(serverTxData, defaultChain, params) {
+  async signThorMsgDepositSwap(serverTxData, chain) {
+    const txArgs = serverTxData?.txArgs ?? {};
+    const memo = typeof txArgs.memo === "string" ? txArgs.memo : "";
+    const parsed = parseThorSwapMemo(memo);
+    const toChain = THOR_MEMO_CHAIN_TO_ENUM[parsed.destChainCode];
+    if (!toChain) {
+      throw new VaultError3(
+        VaultErrorCode3.UnsupportedChain,
+        `signThorMsgDepositSwap: unsupported destination chain code '${parsed.destChainCode}' in memo '${memo}'.`
+      );
+    }
+    const vaultDestAddress = await this.vault.address(toChain);
+    const normalizeForCompare = (addr) => EVM_CHAINS.has(toChain) ? addr.toLowerCase() : addr;
+    if (parsed.destAddress && normalizeForCompare(parsed.destAddress) !== normalizeForCompare(vaultDestAddress)) {
+      throw new VaultError3(
+        VaultErrorCode3.NotImplemented,
+        `signThorMsgDepositSwap: memo destination '${parsed.destAddress}' does not match vault address '${vaultDestAddress}' on ${toChain}. Phase D only supports self-swaps; cross-account routing requires a Phase E SDK extension that passes the user-supplied destination through to vault.swap.`
+      );
+    }
+    const fromSymbol = chain === Chain10.THORChain ? "RUNE" : "CACAO";
+    const amountRaw = typeof txArgs.amount === "string" ? txArgs.amount : void 0;
+    if (!amountRaw) {
+      throw new VaultError3(
+        VaultErrorCode3.InvalidConfig,
+        `signThorMsgDepositSwap: missing or non-string 'amount' field on ${chain} envelope`
+      );
+    }
+    const amountDecimal = convertBaseUnitsToDecimal(chain, amountRaw, "signThorMsgDepositSwap");
+    if (this.verbose)
+      process.stderr.write(
+        `[sign_thor_msg_deposit_swap] ${fromSymbol}@${chain} \u2192 ${parsed.destAsset}@${toChain}, amount=${amountDecimal}, memo='${memo}'
+`
+      );
+    const result = await this.vault.swap({
+      fromChain: chain,
+      fromSymbol,
+      toChain,
+      toSymbol: parsed.destAsset,
+      amount: amountDecimal
+    });
+    if (result.dryRun) {
+      throw new VaultError3(
+        VaultErrorCode3.InvalidConfig,
+        "signThorMsgDepositSwap: vault.swap unexpectedly returned dryRun result"
+      );
+    }
+    this.pendingPayloads.clear();
+    const broadcast = result;
+    const explorerUrl = VultisigSdk.getTxExplorerUrl(chain, broadcast.txHash);
+    return {
+      tx_hash: broadcast.txHash,
+      chain: chain.toString(),
+      status: "pending",
+      explorer_url: explorerUrl
+    };
+  }
+  /**
+   * Sign and broadcast a server-built EVM transaction (raw EVM tx from
+   * tx_ready SSE). Uses vault.prepareSendTx with memo field to carry the
+   * calldata, plus EVM-specific nonce/lock plumbing that Phase B's
+   * `signMultiLeg` depends on for back-to-back approve+main broadcasts.
+   */
+  async signEvmServerTx(serverTxData, defaultChain, params) {
     const swapTx = extractNestedTx(serverTxData);
     if (!swapTx?.to) {
       throw new Error("Server transaction missing required fields (to)");
@@ -7503,6 +6646,97 @@ var AgentExecutor = class _AgentExecutor {
       throw err;
     }
   }
+  /**
+   * Sign and broadcast a 2-leg ERC-20 approve + main flow originating from
+   * mcp-ts `execute_*` envelopes that carry both `approvalTxArgs` and
+   * `txArgs`. Mirrors vultiagent's `useTransactionFlow`: leg 1 (approve) is
+   * signed and broadcast first, the receipt is awaited, then leg 2 (main)
+   * is signed and broadcast. Fails closed if the approve doesn't confirm
+   * — the main leg is NEVER broadcast against a stale or failed allowance.
+   *
+   * Phase B is intentionally EVM-only; non-EVM 2-leg flows are not a real
+   * shape on mcp-ts today (Pattern 1 / Pattern 2 multi-leg flows are split
+   * server-side via sequence_id and don't traverse this path).
+   */
+  async signMultiLeg(_payload, chain, params) {
+    const [approveLeg, mainLeg] = this.pendingLegs;
+    try {
+      const approveEnvelope = {
+        ...approveLeg.parent,
+        txArgs: approveLeg.txArgs,
+        approvalTxArgs: void 0,
+        __multiLeg: void 0,
+        swap_tx: void 0,
+        send_tx: void 0,
+        tx: void 0
+      };
+      const approveResult = await this.signServerTx(approveEnvelope, chain, params);
+      const approveTxHash = approveResult.tx_hash;
+      if (!approveTxHash) {
+        throw new VaultError3(VaultErrorCode3.BroadcastFailed, "signMultiLeg: approve leg returned no tx_hash");
+      }
+      if (this.verbose)
+        process.stderr.write(`[signMultiLeg] approve broadcast: ${approveTxHash}, waiting for receipt...
+`);
+      try {
+        await this.waitForEvmReceipt(chain, approveTxHash, { timeoutSec: 90 });
+      } catch (err) {
+        throw new VaultError3(
+          VaultErrorCode3.Timeout,
+          `signMultiLeg: approve leg ${approveTxHash} did not confirm: ${err?.message ?? err}`,
+          err instanceof Error ? err : void 0
+        );
+      }
+      if (this.verbose) process.stderr.write(`[signMultiLeg] approve confirmed, broadcasting main leg
+`);
+      const mainEnvelope = {
+        ...mainLeg.parent,
+        txArgs: mainLeg.txArgs,
+        approvalTxArgs: void 0,
+        __multiLeg: void 0,
+        swap_tx: void 0,
+        send_tx: void 0,
+        tx: void 0
+      };
+      const mainResult = await this.signServerTx(mainEnvelope, chain, params);
+      return {
+        tx_hash: mainResult.tx_hash,
+        approval_tx_hash: approveTxHash,
+        chain: mainResult.chain,
+        status: "pending",
+        explorer_url: mainResult.explorer_url
+      };
+    } finally {
+      this.pendingLegs = [];
+    }
+  }
+  /**
+   * Poll vault.getTxStatus until the EVM tx confirms or the timeout fires.
+   * Mirrors VaultBase's private `waitForConfirmation` (used by `vault.swap`
+   * for its own approve-before-swap flow) — kept at the executor layer here
+   * so we can stub it from unit tests without exposing private SDK methods.
+   *
+   * Throws on timeout or on receipt status === 'error' (revert). Returns on
+   * success.
+   */
+  async waitForEvmReceipt(chain, txHash, opts) {
+    const intervalMs = 3e3;
+    const deadline = Date.now() + opts.timeoutSec * 1e3;
+    while (Date.now() < deadline) {
+      try {
+        const result = await this.vault.getTxStatus({ chain, txHash });
+        if (result?.status === "success") return;
+        if (result?.status === "error") {
+          throw new VaultError3(VaultErrorCode3.BroadcastFailed, `approve tx reverted (${txHash})`);
+        }
+      } catch (e) {
+        if (e instanceof VaultError3 && e.code === VaultErrorCode3.BroadcastFailed) throw e;
+        if (e?.message?.includes("reverted")) throw e;
+      }
+      await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    throw new VaultError3(VaultErrorCode3.Timeout, `approve tx ${txHash} not confirmed within ${opts.timeoutSec}s`);
+  }
   /**
    * Build, sign, and broadcast a Solana swap locally using the SDK's swap flow.
    * Uses swap params from the tx_ready event to call vault.getSwapQuote → prepareSwapTx.
@@ -7769,37 +7003,39 @@ var AgentExecutor = class _AgentExecutor {
    * - Payloads array: { payloads: [{id, domain, types, message, primaryType, chain}, ...] }
    *   Used by Polymarket which requires signing both an Order and a ClobAuth.
    */
-  async signTypedData(params) {
-    if (this.vault.isEncrypted && !this.vault.isUnlocked?.()) {
-      if (this.password) {
-        await this.vault.unlock?.(this.password);
+  async signTypedData(_toolCallId, input) {
+    return this.runTool("sign_typed_data", async () => {
+      if (this.vault.isEncrypted && !this.vault.isUnlocked?.()) {
+        if (this.password) {
+          await this.vault.unlock?.(this.password);
+        }
       }
-    }
-    const payloads = params.payloads;
-    if (payloads && Array.isArray(payloads)) {
-      if (this.verbose) process.stderr.write(`[sign_typed_data] payloads mode, ${payloads.length} items
+      const payloads = input.payloads;
+      if (payloads && Array.isArray(payloads)) {
+        if (this.verbose) process.stderr.write(`[sign_typed_data] payloads mode, ${payloads.length} items
 `);
-      const signatures = [];
-      for (let i = 0; i < payloads.length; i++) {
-        const payload = payloads[i];
-        const id = payload.id || payload.name || "default";
-        if (i > 0) {
-          if (this.verbose) process.stderr.write(`[sign_typed_data] waiting 5s between MPC sessions...
+        const signatures = [];
+        for (let i = 0; i < payloads.length; i++) {
+          const payload = payloads[i];
+          const id = payload.id || payload.name || "default";
+          if (i > 0) {
+            if (this.verbose) process.stderr.write(`[sign_typed_data] waiting 5s between MPC sessions...
 `);
-          await new Promise((r) => setTimeout(r, 5e3));
-        }
-        const sig = await this.signSingleTypedData(payload);
-        signatures.push({ id, ...sig });
-        if (this.verbose) process.stderr.write(`[sign_typed_data] signed payload "${id}"
+            await new Promise((r) => setTimeout(r, 5e3));
+          }
+          const sig = await this.signSingleTypedData(payload);
+          signatures.push({ id, ...sig });
+          if (this.verbose) process.stderr.write(`[sign_typed_data] signed payload "${id}"
 `);
+        }
+        return {
+          signatures,
+          pm_order_ref: input.pm_order_ref,
+          auto_submit: !!(input.__pm_auto_submit || input.auto_submit)
+        };
       }
-      return {
-        signatures,
-        pm_order_ref: params.pm_order_ref,
-        auto_submit: !!(params.__pm_auto_submit || params.auto_submit)
-      };
-    }
-    return this.signSingleTypedData(params);
+      return this.signSingleTypedData(input);
+    });
   }
   /**
    * Sign a single EIP-712 typed data object.
@@ -7848,33 +7084,20 @@ var AgentExecutor = class _AgentExecutor {
   }
   // ============================================================================
   // Address Book
+  //
+  // Live client-side tools — server-side `address_book_*` runs through MCP
+  // for read; mutating writes have no local implementation yet.
   // ============================================================================
-  async getAddressBook(params) {
-    if (!this.vultisig) {
-      throw new Error(
-        "get_address_book requires the CLI SDK instance. Ensure AgentConfig.vultisig is set when creating the session."
-      );
-    }
-    const chainName = params.chain || params.chain_name;
-    const chain = chainName ? resolveChain(chainName) : void 0;
-    if (chainName && !chain) {
-      throw new Error(`Unknown chain: ${chainName}`);
-    }
-    return await this.vultisig.getAddressBook(chain);
+  async addressBookAdd(_toolCallId, input) {
+    return this.runTool("address_book_add", () => this.addAddressBookImpl(input));
   }
-  // address_book dispatcher — backend shape:
-  //   { action: "add" | "remove", entry: { name, chain, address } }
-  async addressBook(params) {
-    const action = params.action;
-    switch (action) {
-      case "add":
-        return this.addAddressBookImpl(params);
-      case "remove":
-        return this.removeAddressBookImpl(params);
-      default:
-        throw new Error(`address_book: unknown action: ${action ?? "(missing)"}`);
-    }
+  async addressBookRemove(_toolCallId, input) {
+    return this.runTool("address_book_remove", () => this.removeAddressBookImpl(input));
   }
+  // Backend `address_book { action: "add", entry: {...} }` flows through
+  // this impl. The public `addressBookAdd` wrapper above tags results as
+  // `tool: 'address_book_add'`; the new `addressBook` wrapper tags them as
+  // `tool: 'address_book'` (matching the discriminator tool the backend emits).
   async addAddressBookImpl(params) {
     if (!this.vultisig) {
       throw new Error(
@@ -7938,110 +7161,7 @@ var AgentExecutor = class _AgentExecutor {
     await this.vultisig.removeAddressBookEntry([{ chain, address }]);
     return { removed: { chain: chain.toString(), address } };
   }
-  // ============================================================================
-  // Token Search & Other
-  // ============================================================================
-  async searchToken(params) {
-    const query = String(params.query ?? params.q ?? "").trim().toLowerCase();
-    if (!query) {
-      return { tokens: [] };
-    }
-    const limit = 20;
-    const chainName = params.chain;
-    const tokenMatchesQuery = (t) => {
-      const tick = t.ticker.toLowerCase();
-      const addr = (t.contractAddress ?? "").toLowerCase();
-      const pid = (t.priceProviderId ?? "").toLowerCase();
-      return tick.includes(query) || addr.includes(query) || pid.includes(query);
-    };
-    if (chainName) {
-      const chain = resolveChain(chainName);
-      if (!chain) throw new Error(`Unknown chain: ${chainName}`);
-      const tokens = VultisigSdk.getKnownTokens(chain).filter(tokenMatchesQuery).slice(0, limit);
-      return { tokens };
-    }
-    const out = [];
-    for (const c of Object.values(Chain10)) {
-      for (const t of VultisigSdk.getKnownTokens(c)) {
-        if (!tokenMatchesQuery(t)) continue;
-        out.push(t);
-        if (out.length >= limit) return { tokens: out };
-      }
-    }
-    return { tokens: out };
-  }
-  async listVaults() {
-    return {
-      vaults: [
-        {
-          name: this.vault.name,
-          id: this.vault.id,
-          type: this.vault.type,
-          chains: this.vault.chains.map((c) => c.toString())
-        }
-      ]
-    };
-  }
-  async scanTx(_params) {
-    throw new Error("scan_tx is not yet implemented locally. The backend may handle this action server-side.");
-  }
-  async readEvmContract(params) {
-    const chainName = params.chain;
-    if (!chainName) throw new Error("read_evm_contract requires chain");
-    const contractRaw = params.contract_address || params.contractAddress;
-    if (!contractRaw) throw new Error("read_evm_contract requires contract_address");
-    const functionName = params.function_name || params.functionName;
-    if (!functionName) throw new Error("read_evm_contract requires function_name");
-    const chain = resolveChain(chainName);
-    if (!chain) throw new Error(`Unknown chain: ${chainName}`);
-    if (!EVM_CHAINS.has(chain)) {
-      throw new Error(`read_evm_contract only supports EVM chains (got ${chain})`);
-    }
-    const callParams = params.params ?? [];
-    const data = await encodeContractCall(functionName, callParams);
-    const addr = contractRaw.startsWith("0x") ? contractRaw : `0x${contractRaw}`;
-    const to = addr;
-    const from = params.from;
-    const result = await evmCall(chain, { to, data, from });
-    return { result };
-  }
 };
-async function encodeContractCall(functionName, params) {
-  const baseName = functionName.includes("(") ? functionName.split("(")[0] : functionName;
-  const types = params.map((p) => p.type);
-  const sig = `${baseName}(${types.join(",")})`;
-  const selector = await keccak256Selector(sig);
-  let encoded = "";
-  for (const param of params) {
-    encoded += abiEncodeParam(param.type, param.value);
-  }
-  return "0x" + selector + encoded;
-}
-async function keccak256Selector(sig) {
-  const { keccak_256: keccak_2562 } = await Promise.resolve().then(() => (init_sha3(), sha3_exports));
-  const hash = keccak_2562(new TextEncoder().encode(sig));
-  return Buffer.from(hash).toString("hex").slice(0, 8);
-}
-function abiEncodeParam(type, value) {
-  if (type === "address") {
-    const addr = value.startsWith("0x") ? value.slice(2) : value;
-    return addr.toLowerCase().padStart(64, "0");
-  }
-  if (type.startsWith("uint") || type.startsWith("int")) {
-    const n = BigInt(value);
-    const hex = n.toString(16);
-    return hex.padStart(64, "0");
-  }
-  if (type === "bool") {
-    return (value === "true" || value === "1" ? "1" : "0").padStart(64, "0");
-  }
-  if (type === "bytes32") {
-    const b2 = value.startsWith("0x") ? value.slice(2) : value;
-    return b2.padEnd(64, "0");
-  }
-  const b = value.startsWith("0x") ? value.slice(2) : Buffer.from(value).toString("hex");
-  return b.padStart(64, "0");
-}
 function resolveChain(name) {
   if (!name) return null;
   if (Object.values(Chain10).includes(name)) {
@@ -8079,11 +7199,6 @@ function resolveChain(name) {
   }
   return null;
 }
-function parseAmount(amountStr, decimals) {
-  const [whole, frac = ""] = amountStr.split(".");
-  const paddedFrac = frac.slice(0, decimals).padEnd(decimals, "0");
-  return BigInt(whole || "0") * 10n ** BigInt(decimals) + BigInt(paddedFrac || "0");
-}
 function resolveChainFromTxReady(txReadyData) {
   if (txReadyData.chain) {
     const chain = resolveChain(txReadyData.chain);
@@ -8115,6 +7230,75 @@ function resolveChainFromTxReady(txReadyData) {
 function extractNestedTx(txReadyData) {
   return txReadyData?.swap_tx || txReadyData?.send_tx || txReadyData?.tx || txReadyData?.txArgs?.tx;
 }
+var MAX_AMOUNT_DIGITS = 26;
+function convertBaseUnitsToDecimal(chain, amountRaw, context) {
+  if (amountRaw.length > MAX_AMOUNT_DIGITS) {
+    throw new VaultError3(
+      VaultErrorCode3.InvalidAmount,
+      `${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;
+  if (decimals === void 0) {
+    throw new VaultError3(VaultErrorCode3.UnsupportedChain, `${context}: no native decimals registered for ${chain}`);
+  }
+  try {
+    return formatUnits(BigInt(amountRaw), decimals);
+  } catch (err) {
+    throw new VaultError3(
+      VaultErrorCode3.InvalidAmount,
+      `${context}: failed to convert amount '${amountRaw}' for ${chain}: ${err?.message ?? err}`
+    );
+  }
+}
+function parseNonEvmEnvelope(serverTxData, chain) {
+  const txArgs = serverTxData?.txArgs ?? serverTxData;
+  if (!txArgs || typeof txArgs !== "object") {
+    throw new VaultError3(VaultErrorCode3.InvalidConfig, "parseNonEvmEnvelope: envelope missing txArgs");
+  }
+  const to = typeof txArgs.to === "string" ? txArgs.to : void 0;
+  if (!to) {
+    throw new VaultError3(VaultErrorCode3.InvalidConfig, `parseNonEvmEnvelope: missing 'to' field for ${chain}`);
+  }
+  const amountRaw = typeof txArgs.amount === "string" ? txArgs.amount : void 0;
+  if (!amountRaw) {
+    throw new VaultError3(VaultErrorCode3.InvalidConfig, `parseNonEvmEnvelope: missing 'amount' field for ${chain}`);
+  }
+  const amountDecimal = convertBaseUnitsToDecimal(chain, amountRaw, "parseNonEvmEnvelope");
+  let symbol;
+  const tokenResolved = serverTxData?.resolved?.labels?.token_resolved;
+  const nativeTicker = chainFeeCoin[chain]?.ticker;
+  if (typeof tokenResolved === "string" && tokenResolved !== nativeTicker) {
+    symbol = tokenResolved;
+  }
+  const memo = typeof txArgs.memo === "string" && txArgs.memo.length > 0 ? txArgs.memo : void 0;
+  return { chain, to, amount: amountDecimal, symbol, memo };
+}
+function parseThorSwapMemo(memo) {
+  if (!memo.startsWith("=:")) {
+    throw new VaultError3(
+      VaultErrorCode3.NotImplemented,
+      `parseThorSwapMemo: only swap memos (=:CHAIN.ASSET:DEST...) supported on this path; got memo='${memo}'. LP / non-swap MsgDeposit flows route through different SDK helpers (Phase E follow-up).`
+    );
+  }
+  const memoBody = memo.slice(2);
+  const parts = memoBody.split(":");
+  let chainAsset = parts[0];
+  if (chainAsset && !chainAsset.includes(".")) {
+    const expanded = THOR_MEMO_ASSET_SHORTCUTS[chainAsset.toLowerCase()];
+    if (expanded) chainAsset = expanded;
+  }
+  if (!chainAsset || !chainAsset.includes(".")) {
+    throw new VaultError3(
+      VaultErrorCode3.InvalidConfig,
+      `parseThorSwapMemo: malformed swap memo '${memo}': missing CHAIN.ASSET in first segment.`
+    );
+  }
+  const [destChainCode, destAssetRaw] = chainAsset.split(".");
+  const destAsset = destAssetRaw?.split("-")[0] ?? "";
+  const destAddress = typeof parts[1] === "string" ? parts[1] : "";
+  return { destChainCode, destAsset, destAddress };
+}
 function resolveChainId(chainId) {
   const id = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
   if (isNaN(id)) return null;
@@ -8507,22 +7691,14 @@ import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, wri
 import { homedir as homedir2 } from "node:os";
 import { join as join2 } from "node:path";
 import { MemoryStorage, PushNotificationService } from "@vultisig/sdk";
+var PASSWORD_REQUIRED_TOOLS = /* @__PURE__ */ new Set(["sign_typed_data", "sign_tx"]);
 var CLIENT_SIDE_TOOL_DISPATCH = {
-  sign_typed_data: "sign_typed_data",
-  vault_coin: "vault_coin",
-  vault_chain: "vault_chain",
-  address_book: "address_book"
+  sign_typed_data: (ex, id, input) => ex.signTypedData(id, input),
+  vault_coin: (ex, id, input) => ex.vaultCoin(id, input),
+  vault_chain: (ex, id, input) => ex.vaultChain(id, input),
+  address_book: (ex, id, input) => ex.addressBook(id, input)
 };
 var MAX_MESSAGE_LOOP_DEPTH = 16;
-function actionResultToRecentAction(r) {
-  if (r.success) {
-    return { tool: r.action, success: true, data: r.data ?? {} };
-  }
-  const data = { ...r.data ?? {} };
-  if (r.error) data.error = r.error;
-  if (r.code) data.code = r.code;
-  return { tool: r.action, success: false, data };
-}
 var AgentSession = class {
   client;
   vault;
@@ -8779,21 +7955,22 @@ var AgentSession = class {
           `[session] ${serverTxStoredFromStream} stored server tx from tx_ready, signing client-side
 `
         );
-      const signAction = {
-        id: `tx_sign_${Date.now()}`,
-        type: "sign_tx",
-        title: "Sign transaction",
-        params: {},
-        auto_execute: true
-      };
-      const results = await this.executeActions([signAction], ui);
-      if (results.length > 0) {
-        for (const result of results) {
-          this.pendingToolResults.push(actionResultToRecentAction(result));
-        }
-        await this.processMessageLoop(null, ui, depth + 1);
-        return;
+      const signToolCallId = `tx_sign_${Date.now()}`;
+      const recent = await this.runPasswordGatedTool(
+        "sign_tx",
+        signToolCallId,
+        ui,
+        () => this.executor.signTxFromBuffer(signToolCallId)
+      );
+      this.pendingToolResults.push(recent);
+      if (recent.success && recent.data) {
+        const txHash = recent.data.tx_hash;
+        const chain = recent.data.chain;
+        const explorerUrl = recent.data.explorer_url;
+        if (txHash) ui.onTxStatus(txHash, chain || "", "pending", explorerUrl);
       }
+      await this.processMessageLoop(null, ui, depth + 1);
+      return;
     }
     if (this.pendingToolResults.length > 0) {
       await this.processMessageLoop(null, ui, depth + 1);
@@ -8801,12 +7978,59 @@ var AgentSession = class {
     }
     ui.onDone();
   }
-  // Routes client-side tool calls through executeAction. Missing registry
+  /**
+   * Wrap a per-tool dispatch with the password-prompt gate (for tools in
+   * {@link PASSWORD_REQUIRED_TOOLS}) and `ui.onToolCall` /
+   * `ui.onToolResult` lifecycle events. Returns the `RecentAction` produced
+   * by the executor (or a synthetic failure `RecentAction` if the password
+   * prompt was declined).
+   */
+  async runPasswordGatedTool(toolName, toolCallId, ui, body, input) {
+    let promptedPassword;
+    if (PASSWORD_REQUIRED_TOOLS.has(toolName) && !this.config.password) {
+      try {
+        promptedPassword = await ui.requestPassword();
+        this.executor.setPassword(promptedPassword);
+      } catch {
+        const failure = {
+          tool: toolName,
+          success: false,
+          data: { error: "Password not provided", code: "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */ }
+        };
+        ui.onToolCall(toolCallId, toolName, input);
+        ui.onToolResult(
+          toolCallId,
+          toolName,
+          false,
+          failure.data,
+          "Password not provided",
+          "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
+        );
+        return failure;
+      }
+    }
+    ui.onToolCall(toolCallId, toolName, input);
+    let recent;
+    try {
+      recent = await body();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      recent = { tool: toolName, success: false, data: { error: message } };
+    }
+    const errorMsg = recent.data?.error ?? void 0;
+    const errorCode = recent.data?.code ?? void 0;
+    ui.onToolResult(toolCallId, toolName, recent.success, recent.data, errorMsg, errorCode);
+    if (promptedPassword && recent.success) {
+      this.config.password = promptedPassword;
+    }
+    return recent;
+  }
+  // Routes client-side tool calls through the per-tool registry. Missing
   // entries surface as a visible `[cli] unimplemented` warning + failure
   // RecentAction (never silent).
   async dispatchClientSideTool(toolCallId, toolName, input, ui) {
-    const actionType = CLIENT_SIDE_TOOL_DISPATCH[toolName];
-    if (!actionType) {
+    const handler = CLIENT_SIDE_TOOL_DISPATCH[toolName];
+    if (!handler) {
       process.stderr.write(`[cli] unimplemented client-side tool: ${toolName}
 `);
       this.pendingToolResults.push({
@@ -8816,76 +8040,26 @@ var AgentSession = class {
       });
       return;
     }
-    const action = {
-      id: toolCallId,
-      type: actionType,
-      title: toolName,
-      params: input,
-      auto_execute: true
-    };
+    let recent;
     try {
-      const results = await this.executeActions([action], ui);
-      const result = results[0];
-      if (result) {
-        const recent = actionResultToRecentAction(result);
-        if (recent.data === void 0) recent.data = {};
-        for (const key of Object.keys(input)) {
-          if (key.startsWith("__") || key === "pm_order_ref") {
-            recent.data[key] = input[key];
-          }
-        }
-        this.pendingToolResults.push(recent);
-      }
+      recent = await this.runPasswordGatedTool(
+        toolName,
+        toolCallId,
+        ui,
+        () => handler(this.executor, toolCallId, input),
+        input
+      );
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      this.pendingToolResults.push({
-        tool: toolName,
-        success: false,
-        data: { error: message }
-      });
+      recent = { tool: toolName, success: false, data: { error: message } };
     }
-  }
-  /**
-   * Execute a list of actions, handling password requirements.
-   */
-  async executeActions(actions, ui) {
-    const results = [];
-    for (const action of actions) {
-      if (!this.executor.shouldAutoExecute(action)) {
-        continue;
-      }
-      if (PASSWORD_REQUIRED_ACTIONS.has(action.type)) {
-        if (!this.config.password) {
-          try {
-            const password = await ui.requestPassword();
-            this.executor.setPassword(password);
-            this.config.password = password;
-          } catch {
-            results.push({
-              action: action.type,
-              action_id: action.id,
-              success: false,
-              error: "Password not provided",
-              code: "PASSWORD_REQUIRED" /* PASSWORD_REQUIRED */
-            });
-            continue;
-          }
-        }
-      }
-      ui.onToolCall(action.id, action.type, action.params);
-      const result = await this.executor.executeAction(action);
-      results.push(result);
-      ui.onToolResult(action.id, action.type, result.success, result.data, result.error, result.code);
-      if (action.type === "sign_tx" && result.success && result.data) {
-        const txHash = result.data.tx_hash;
-        const chain = result.data.chain;
-        const explorerUrl = result.data.explorer_url;
-        if (txHash) {
-          ui.onTxStatus(txHash, chain, "pending", explorerUrl);
-        }
+    if (recent.data === void 0) recent.data = {};
+    for (const key of Object.keys(input)) {
+      if (key.startsWith("__") || key === "pm_order_ref") {
+        recent.data[key] = input[key];
       }
     }
-    return results;
+    this.pendingToolResults.push(recent);
   }
   /**
    * Cancel the current operation.
@@ -9503,7 +8677,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "0.22.4";
+    cachedVersion = "0.22.7";
     return cachedVersion;
   }
   try {