@vultisig/cli 0.22.4 → 0.22.5

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;
@@ -6369,7 +5396,7 @@ function getNativeTokenDecimals(chain) {
 }
 
 // src/agent/executor.ts
-import { Chain as Chain10, evmCall, Vultisig as VultisigSdk } from "@vultisig/sdk";
+import { Chain as Chain9, Vultisig as VultisigSdk } from "@vultisig/sdk";
 
 // ../../node_modules/viem/_esm/index.js
 init_formatUnits();
@@ -6529,29 +5556,6 @@ 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 EVM_CHAINS = /* @__PURE__ */ new Set([
   "Ethereum",
@@ -6583,7 +5587,7 @@ 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;
@@ -6638,7 +5642,7 @@ var AgentExecutor = class _AgentExecutor {
 `);
       return false;
     }
-    const chain = resolveChainFromTxReady(txReadyData) || Chain10.Ethereum;
+    const chain = resolveChainFromTxReady(txReadyData) || Chain9.Ethereum;
     this.pendingPayloads.clear();
     this.pendingPayloads.set("latest", {
       payload: { __serverTx: true, ...txReadyData },
@@ -6656,137 +5660,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());
-      }
+      return { tool: toolName, success: false, data: { error: message, code } };
     }
-    if (tickerFilter) {
-      entries = entries.filter((b) => b.symbol.toLowerCase() === tickerFilter.toLowerCase());
-    }
-    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 +5784,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 +5800,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()
     });
@@ -6889,457 +5834,42 @@ var AgentExecutor = class _AgentExecutor {
     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 removeChain(_toolCallId, input) {
+    return this.runTool("remove_chain", () => this.removeChainImpl(input));
   }
-  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;
-    }
+  async addCoin(_toolCallId, input) {
+    return this.runTool("add_coin", () => this.addCoinImpl(input));
+  }
+  async removeCoin(_toolCallId, input) {
+    return this.runTool("remove_coin", () => this.removeCoinImpl(input));
   }
   // ============================================================================
-  // THORChain LP (RUNE-side asym add / remove via prepareSendTx + memo)
+  // Transaction Signing
   // ============================================================================
   /**
-   * Pool stats from Midgard (no signing). Optional `pool` filters to one row.
+   * 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 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
-      });
+  async signTxFromBuffer(_toolCallId) {
+    return this.runTool("sign_tx", async () => {
+      if (this.verbose)
+        process.stderr.write(`[sign_tx] pendingPayloads keys: ${[...this.pendingPayloads.keys()].join(", ")}
+`);
+      const stored = this.pendingPayloads.get("latest");
       if (!stored) {
-        throw new Error("Could not stage calldata transaction for signing (invalid or empty tx payload)");
+        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).");
       }
-      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 });
-  }
-  // ============================================================================
-  // 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(", ")}
-`);
-    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) {
       let result;
       if (chain === "Solana" && (payload.swap_tx || payload.provider)) {
         try {
@@ -7354,56 +5884,10 @@ 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;
-    }
-    return this.signSdkTx(payload, chain, payloadId);
-  }
-  /**
-   * Sign and broadcast an SDK-built transaction (keysign payload from local build methods).
-   */
-  async signSdkTx(payload, chain, _payloadId) {
-    try {
-      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 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;
-    }
+    });
   }
   /**
    * Sign and broadcast a server-built transaction (raw EVM tx from tx_ready SSE).
@@ -7769,37 +6253,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.
@@ -7819,11 +6305,11 @@ var AgentExecutor = class _AgentExecutor {
 `);
     const chainName = params.chain;
     const chainId = domain.chainId;
-    let chain = Chain10.Ethereum;
+    let chain = Chain9.Ethereum;
     if (chainName) {
-      chain = resolveChain(chainName) || Chain10.Ethereum;
+      chain = resolveChain(chainName) || Chain9.Ethereum;
     } else if (chainId) {
-      chain = resolveChainId(chainId) || Chain10.Ethereum;
+      chain = resolveChainId(chainId) || Chain9.Ethereum;
     }
     const sigResult = await this.vault.signBytes({
       data: eip712Hash,
@@ -7848,33 +6334,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,117 +6411,14 @@ 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)) {
+  if (Object.values(Chain9).includes(name)) {
     return name;
   }
   const lower = name.toLowerCase();
-  for (const [, value] of Object.entries(Chain10)) {
+  for (const [, value] of Object.entries(Chain9)) {
     if (typeof value === "string" && value.toLowerCase() === lower) {
       return value;
     }
@@ -8074,16 +6444,11 @@ function resolveChain(name) {
     xrp: "Ripple"
   };
   const aliased = aliases[lower];
-  if (aliased && Object.values(Chain10).includes(aliased)) {
+  if (aliased && Object.values(Chain9).includes(aliased)) {
     return aliased;
   }
   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);
@@ -8119,16 +6484,16 @@ function resolveChainId(chainId) {
   const id = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
   if (isNaN(id)) return null;
   const chainIdMap = {
-    1: Chain10.Ethereum,
-    56: Chain10.BSC,
-    137: Chain10.Polygon,
-    43114: Chain10.Avalanche,
-    42161: Chain10.Arbitrum,
-    10: Chain10.Optimism,
-    8453: Chain10.Base,
-    81457: Chain10.Blast,
-    324: Chain10.Zksync,
-    25: Chain10.CronosChain
+    1: Chain9.Ethereum,
+    56: Chain9.BSC,
+    137: Chain9.Polygon,
+    43114: Chain9.Avalanche,
+    42161: Chain9.Arbitrum,
+    10: Chain9.Optimism,
+    8453: Chain9.Base,
+    81457: Chain9.Blast,
+    324: Chain9.Zksync,
+    25: Chain9.CronosChain
   };
   return chainIdMap[id] || null;
 }
@@ -8507,22 +6872,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 +7136,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 +7159,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 +7221,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 +7858,7 @@ var cachedVersion = null;
 function getVersion() {
   if (cachedVersion) return cachedVersion;
   if (true) {
-    cachedVersion = "0.22.4";
+    cachedVersion = "0.22.5";
     return cachedVersion;
   }
   try {
@@ -9786,7 +8141,7 @@ function readArgValue(args, optionName) {
 }
 
 // src/interactive/completer.ts
-import { Chain as Chain11 } from "@vultisig/sdk";
+import { Chain as Chain10 } from "@vultisig/sdk";
 import fs3 from "fs";
 import path3 from "path";
 var COMMANDS = [
@@ -9930,7 +8285,7 @@ function completeVaultName(ctx2, partial) {
   return [show, partial];
 }
 function completeChainName(partial) {
-  const allChains = Object.values(Chain11);
+  const allChains = Object.values(Chain10);
   const partialLower = partial.toLowerCase();
   const matches = allChains.filter((chain) => chain.toLowerCase().startsWith(partialLower));
   matches.sort();
@@ -9938,7 +8293,7 @@ function completeChainName(partial) {
   return [show, partial];
 }
 function findChainByName(name) {
-  const allChains = Object.values(Chain11);
+  const allChains = Object.values(Chain10);
   const nameLower = name.toLowerCase();
   const found = allChains.find((chain) => chain.toLowerCase() === nameLower);
   return found ? found : null;