@t2000/sdk 1.4.0 → 1.6.0

package/dist/index.cjs

@@ -145,6 +145,32 @@ var init_errors = __esm({
 });
 
 // src/token-registry.ts
+var token_registry_exports = {};
+__export(token_registry_exports, {
+  COIN_REGISTRY: () => exports.COIN_REGISTRY,
+  ETH_TYPE: () => exports.ETH_TYPE,
+  IKA_TYPE: () => exports.IKA_TYPE,
+  LOFI_TYPE: () => exports.LOFI_TYPE,
+  MANIFEST_TYPE: () => exports.MANIFEST_TYPE,
+  NAVX_TYPE: () => exports.NAVX_TYPE,
+  SUI_TYPE: () => exports.SUI_TYPE,
+  TOKEN_MAP: () => exports.TOKEN_MAP,
+  USDC_TYPE: () => exports.USDC_TYPE,
+  USDE_TYPE: () => exports.USDE_TYPE,
+  USDSUI_TYPE: () => exports.USDSUI_TYPE,
+  USDT_TYPE: () => exports.USDT_TYPE,
+  WAL_TYPE: () => exports.WAL_TYPE,
+  WBTC_TYPE: () => exports.WBTC_TYPE,
+  getCoinMeta: () => getCoinMeta,
+  getDecimalsForCoinType: () => getDecimalsForCoinType,
+  getTier: () => getTier,
+  isInRegistry: () => isInRegistry,
+  isSupported: () => isSupported,
+  isTier1: () => isTier1,
+  isTier2: () => isTier2,
+  resolveSymbol: () => resolveSymbol,
+  resolveTokenType: () => resolveTokenType
+});
 function getCoinMeta(coinType) {
   return BY_TYPE.get(coinType);
 }
@@ -628,6 +654,8 @@ __export(volo_exports, {
   VOLO_PKG: () => exports.VOLO_PKG,
   VOLO_POOL: () => exports.VOLO_POOL,
   VSUI_TYPE: () => exports.VSUI_TYPE,
+  addStakeVSuiToTx: () => addStakeVSuiToTx,
+  addUnstakeVSuiToTx: () => addUnstakeVSuiToTx,
   buildStakeVSuiTx: () => buildStakeVSuiTx,
   buildUnstakeVSuiTx: () => buildUnstakeVSuiTx,
   getVoloStats: () => getVoloStats
@@ -667,7 +695,7 @@ async function buildStakeVSuiTx(_client, address, amountMist) {
   return tx;
 }
 async function buildUnstakeVSuiTx(client, address, amountMist) {
-  const coins = await fetchVSuiCoins(client, address);
+  const coins = await fetchCoinsByType(client, address, exports.VSUI_TYPE);
   if (coins.length === 0) {
     throw new Error("No vSUI found in wallet.");
   }
@@ -695,14 +723,81 @@ async function buildUnstakeVSuiTx(client, address, amountMist) {
   tx.transferObjects([suiCoin], address);
   return tx;
 }
-async function fetchVSuiCoins(client, address) {
+async function addStakeVSuiToTx(tx, client, address, input) {
+  if (input.amountMist < MIN_STAKE_MIST) {
+    throw new Error(`Minimum stake is 1 SUI (${MIN_STAKE_MIST} MIST). Got: ${input.amountMist}`);
+  }
+  let suiCoin;
+  if (input.inputCoin) {
+    suiCoin = input.inputCoin;
+  } else {
+    const coins = await fetchCoinsByType(client, address, exports.SUI_TYPE);
+    if (coins.length === 0) {
+      throw new Error("No SUI coins found in wallet");
+    }
+    const totalBalance = coins.reduce((sum, c) => sum + BigInt(c.balance), 0n);
+    if (totalBalance < input.amountMist) {
+      throw new Error(`Insufficient SUI: need ${input.amountMist} MIST, have ${totalBalance}`);
+    }
+    const primary = tx.object(coins[0].coinObjectId);
+    if (coins.length > 1) {
+      tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
+    }
+    [suiCoin] = tx.splitCoins(primary, [input.amountMist]);
+  }
+  const [vSuiCoin] = tx.moveCall({
+    target: `${exports.VOLO_PKG}::stake_pool::stake`,
+    arguments: [
+      tx.object(exports.VOLO_POOL),
+      tx.object(exports.VOLO_METADATA),
+      tx.object(SUI_SYSTEM_STATE),
+      suiCoin
+    ]
+  });
+  return { coin: vSuiCoin, effectiveAmountMist: input.amountMist };
+}
+async function addUnstakeVSuiToTx(tx, client, address, input) {
+  let vSuiCoin;
+  if (input.inputCoin) {
+    if (input.amountMist === "all") {
+      vSuiCoin = input.inputCoin;
+    } else {
+      [vSuiCoin] = tx.splitCoins(input.inputCoin, [input.amountMist]);
+    }
+  } else {
+    const coins = await fetchCoinsByType(client, address, exports.VSUI_TYPE);
+    if (coins.length === 0) {
+      throw new Error("No vSUI found in wallet.");
+    }
+    const primary = tx.object(coins[0].coinObjectId);
+    if (coins.length > 1) {
+      tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
+    }
+    if (input.amountMist === "all") {
+      vSuiCoin = primary;
+    } else {
+      [vSuiCoin] = tx.splitCoins(primary, [input.amountMist]);
+    }
+  }
+  const [suiCoin] = tx.moveCall({
+    target: `${exports.VOLO_PKG}::stake_pool::unstake`,
+    arguments: [
+      tx.object(exports.VOLO_POOL),
+      tx.object(exports.VOLO_METADATA),
+      tx.object(SUI_SYSTEM_STATE),
+      vSuiCoin
+    ]
+  });
+  return { coin: suiCoin, effectiveAmountMist: input.amountMist };
+}
+async function fetchCoinsByType(client, owner, coinType) {
   const all = [];
   let cursor;
   let hasNext = true;
   while (hasNext) {
     const page = await client.getCoins({
-      owner: address,
-      coinType: exports.VSUI_TYPE,
+      owner,
+      coinType,
       cursor: cursor ?? void 0
     });
     all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
@@ -714,6 +809,7 @@ async function fetchVSuiCoins(client, address) {
 exports.VOLO_PKG = void 0; exports.VOLO_POOL = void 0; exports.VOLO_METADATA = void 0; exports.VSUI_TYPE = void 0; var SUI_SYSTEM_STATE, MIN_STAKE_MIST, VOLO_STATS_URL;
 var init_volo = __esm({
   "src/protocols/volo.ts"() {
+    init_token_registry();
     exports.VOLO_PKG = "0x68d22cf8bdbcd11ecba1e094922873e4080d4d11133e2443fddda0bfd11dae20";
     exports.VOLO_POOL = "0x2d914e23d82fedef1b5f56a32d5c64bdcc3087ccfea2b4d6ea51a71f587840e5";
     exports.VOLO_METADATA = "0x680cd26af32b2bde8d3361e804c53ec1d1cfe24c7f039eb7f549e8dfde389a60";
@@ -729,6 +825,7 @@ var cetus_swap_exports = {};
 __export(cetus_swap_exports, {
   OVERLAY_FEE_RATE: () => exports.OVERLAY_FEE_RATE,
   TOKEN_MAP: () => exports.TOKEN_MAP,
+  addSwapToTx: () => addSwapToTx,
   buildSwapTx: () => buildSwapTx,
   findSwapRoute: () => findSwapRoute,
   resolveTokenType: () => resolveTokenType,
@@ -754,7 +851,8 @@ async function findSwapRoute(params) {
     from: params.from,
     target: params.to,
     amount: params.amount.toString(),
-    byAmountIn: params.byAmountIn
+    byAmountIn: params.byAmountIn,
+    ...params.providers ? { providers: params.providers } : {}
   };
   const routerData = await client.findRouters(findParams);
   if (!routerData) return null;
@@ -796,6 +894,85 @@ async function buildSwapTx(params) {
   });
   return outputCoin;
 }
+async function addSwapToTx(tx, client, address, input) {
+  const { T2000Error: T2000Error2 } = await Promise.resolve().then(() => (init_errors(), errors_exports));
+  const fromType = resolveTokenType(input.from);
+  const toType = resolveTokenType(input.to);
+  if (!fromType) throw new T2000Error2("ASSET_NOT_SUPPORTED", `Unknown token: ${input.from}. Provide the symbol (USDC, SUI, ...) or full coin type.`);
+  if (!toType) throw new T2000Error2("ASSET_NOT_SUPPORTED", `Unknown token: ${input.to}. Provide the symbol (USDC, SUI, ...) or full coin type.`);
+  if (fromType === toType) throw new T2000Error2("SWAP_FAILED", "Cannot swap a token to itself");
+  if (!Number.isFinite(input.amount) || input.amount <= 0) {
+    throw new T2000Error2("INVALID_AMOUNT", "Amount must be greater than zero");
+  }
+  const fromDecimals = getDecimalsForCoinType(fromType);
+  const toDecimals = getDecimalsForCoinType(toType);
+  const requestedRaw = BigInt(Math.floor(input.amount * 10 ** fromDecimals));
+  const slippage = Math.max(1e-3, Math.min(input.slippage ?? 0.01, 0.05));
+  const byAmountIn = input.byAmountIn ?? true;
+  let inputCoin;
+  let effectiveRaw;
+  if (input.inputCoin) {
+    inputCoin = input.inputCoin;
+    effectiveRaw = requestedRaw;
+  } else {
+    const { ids, totalBalance } = await fetchAllCoinsForSwap(client, address, fromType);
+    if (ids.length === 0) {
+      throw new T2000Error2("INSUFFICIENT_BALANCE", `No ${input.from} coins found in wallet`);
+    }
+    const swapAll = requestedRaw >= totalBalance;
+    effectiveRaw = swapAll ? totalBalance : requestedRaw;
+    const primary = tx.object(ids[0]);
+    if (ids.length > 1) {
+      tx.mergeCoins(primary, ids.slice(1).map((id) => tx.object(id)));
+    }
+    inputCoin = swapAll ? primary : tx.splitCoins(primary, [effectiveRaw])[0];
+  }
+  const route = await findSwapRoute({
+    walletAddress: address,
+    from: fromType,
+    to: toType,
+    amount: effectiveRaw,
+    byAmountIn,
+    overlayFee: input.overlayFee,
+    providers: input.providers
+  });
+  if (!route) {
+    throw new T2000Error2("SWAP_NO_ROUTE", `No swap route found for ${input.from} \u2192 ${input.to}`);
+  }
+  if (route.insufficientLiquidity) {
+    throw new T2000Error2("SWAP_NO_ROUTE", `Insufficient liquidity for ${input.from} \u2192 ${input.to}`);
+  }
+  const outputCoin = await buildSwapTx({
+    walletAddress: address,
+    route,
+    tx,
+    inputCoin,
+    slippage,
+    overlayFee: input.overlayFee
+  });
+  return {
+    coin: outputCoin,
+    effectiveAmountIn: Number(effectiveRaw) / 10 ** fromDecimals,
+    expectedAmountOut: Number(route.amountOut) / 10 ** toDecimals,
+    route
+  };
+}
+async function fetchAllCoinsForSwap(client, owner, coinType) {
+  const ids = [];
+  let totalBalance = 0n;
+  let cursor;
+  let hasNext = true;
+  while (hasNext) {
+    const page = await client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
+    for (const c of page.data) {
+      ids.push(c.coinObjectId);
+      totalBalance += BigInt(c.balance);
+    }
+    cursor = page.nextCursor;
+    hasNext = page.hasNextPage;
+  }
+  return { ids, totalBalance };
+}
 async function simulateSwap(params) {
   const client = getClient(params.walletAddress, params.overlayFee);
   try {
@@ -808,6 +985,7 @@ async function simulateSwap(params) {
 exports.OVERLAY_FEE_RATE = void 0; var clientCache;
 var init_cetus_swap = __esm({
   "src/protocols/cetus-swap.ts"() {
+    init_token_registry();
     init_token_registry();
     exports.OVERLAY_FEE_RATE = 1e-3;
     clientCache = /* @__PURE__ */ new Map();
@@ -1173,6 +1351,10 @@ async function buildSendTx({
   }
   return tx;
 }
+function addSendToTx(tx, coin, recipient) {
+  const validRecipient = validateAddress(recipient);
+  tx.transferObjects([coin], validRecipient);
+}
 
 // src/wallet/balance.ts
 var SUI_PRICE_FALLBACK = 1;
@@ -5315,7 +5497,10 @@ async function addSaveToTx(tx, _client, _address, coin, options = {}) {
 async function addRepayToTx(tx, client, address, coin, options = {}) {
   const asset = options.asset ?? "USDC";
   const assetInfo = resolveAssetInfo(asset);
-  await refreshOracle(tx, client, address, { skipPythUpdate: options.skipPythUpdate });
+  await refreshOracle(tx, client, address, {
+    skipPythUpdate: options.skipPythUpdate,
+    skipOracle: options.skipOracle
+  });
   try {
     await xe(tx, assetInfo.type, coin, { env: "prod" });
   } catch (err) {
@@ -5459,6 +5644,12 @@ async function addClaimRewardsToTx(tx, client, address) {
     return [];
   }
 }
+async function buildClaimRewardsTx(client, address) {
+  const tx = new transactions.Transaction();
+  tx.setSender(address);
+  const rewards = await addClaimRewardsToTx(tx, client, address);
+  return { tx, rewards };
+}
 function aggregateClaimableRewards(claimable) {
   const aggregated = /* @__PURE__ */ new Map();
   for (const c of claimable) {
@@ -7190,6 +7381,298 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
 // src/index.ts
 init_errors();
 
+// src/wallet/coinSelection.ts
+init_errors();
+async function fetchAllCoins(client, owner, coinType) {
+  const ids = [];
+  let totalBalance = 0n;
+  let cursor;
+  let hasNext = true;
+  while (hasNext) {
+    const page = await client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
+    for (const c of page.data) {
+      ids.push(c.coinObjectId);
+      totalBalance += BigInt(c.balance);
+    }
+    cursor = page.nextCursor;
+    hasNext = page.hasNextPage;
+  }
+  return { ids, totalBalance };
+}
+async function selectAndSplitCoin(tx, client, owner, coinType, amount, options = {}) {
+  const { ids, totalBalance } = await fetchAllCoins(client, owner, coinType);
+  if (ids.length === 0) {
+    throw new exports.T2000Error("INSUFFICIENT_BALANCE", `No coins found for ${coinType}`);
+  }
+  const allowSwapAll = options.allowSwapAll ?? true;
+  if (amount !== "all" && amount > totalBalance && !allowSwapAll) {
+    throw new exports.T2000Error("INSUFFICIENT_BALANCE", `Insufficient balance for ${coinType}`, {
+      available: totalBalance.toString(),
+      required: amount.toString()
+    });
+  }
+  const requested = amount === "all" ? totalBalance : amount;
+  const swapAll = amount === "all" || requested >= totalBalance;
+  const effectiveAmount = swapAll ? totalBalance : requested;
+  const primary = tx.object(ids[0]);
+  if (ids.length > 1) {
+    tx.mergeCoins(primary, ids.slice(1).map((id) => tx.object(id)));
+  }
+  const coin = swapAll ? primary : tx.splitCoins(primary, [effectiveAmount])[0];
+  return { coin, effectiveAmount, swapAll };
+}
+async function selectSuiCoin(tx, client, owner, amountMist, sponsoredContext) {
+  if (sponsoredContext) {
+    const { SUI_TYPE: SUI_TYPE2 } = await Promise.resolve().then(() => (init_token_registry(), token_registry_exports));
+    return selectAndSplitCoin(tx, client, owner, SUI_TYPE2, amountMist);
+  }
+  const [coin] = tx.splitCoins(tx.gas, [amountMist]);
+  return { coin, effectiveAmount: amountMist, swapAll: false };
+}
+init_cetus_swap();
+init_volo();
+init_token_registry();
+init_errors();
+var SPONSORED_PYTH_DEPENDENT_PROVIDERS = [
+  "HAEDALPMM",
+  "METASTABLE",
+  "OBRIC",
+  "STEAMM_OMM",
+  "STEAMM_OMM_V2",
+  "SEVENK",
+  "HAEDALHMMV2"
+];
+async function getSponsoredSwapProviders() {
+  const { getProvidersExcluding } = await import('@cetusprotocol/aggregator-sdk');
+  return getProvidersExcluding([...SPONSORED_PYTH_DEPENDENT_PROVIDERS]);
+}
+function resolveSaveableAsset(asset) {
+  if (!asset) return "USDC";
+  if (asset !== "USDC" && asset !== "USDsui") {
+    throw new exports.T2000Error("ASSET_NOT_SUPPORTED", `Saveable asset must be USDC or USDsui, got ${asset}`);
+  }
+  return asset;
+}
+var WRITE_APPENDER_REGISTRY = {
+  save_deposit: async (tx, input, ctx) => {
+    const asset = resolveSaveableAsset(input.asset);
+    const assetInfo = SUPPORTED_ASSETS[asset];
+    if (input.amount <= 0) {
+      throw new exports.T2000Error("INVALID_AMOUNT", "Save amount must be greater than zero");
+    }
+    const rawAmount = BigInt(Math.floor(input.amount * 10 ** assetInfo.decimals));
+    const { coin, effectiveAmount } = await selectAndSplitCoin(
+      tx,
+      ctx.client,
+      ctx.sender,
+      assetInfo.type,
+      rawAmount
+    );
+    await addSaveToTx(tx, ctx.client, ctx.sender, coin, { asset });
+    return {
+      toolName: "save_deposit",
+      effectiveAmount: Number(effectiveAmount) / 10 ** assetInfo.decimals,
+      asset
+    };
+  },
+  withdraw: async (tx, input, ctx) => {
+    const asset = resolveSaveableAsset(input.asset);
+    if (input.amount <= 0) {
+      throw new exports.T2000Error("INVALID_AMOUNT", "Withdraw amount must be greater than zero");
+    }
+    const { coin, effectiveAmount } = await addWithdrawToTx(
+      tx,
+      ctx.client,
+      ctx.sender,
+      input.amount,
+      { asset, skipPythUpdate: ctx.sponsoredContext }
+    );
+    tx.transferObjects([coin], ctx.sender);
+    return { toolName: "withdraw", effectiveAmount, asset };
+  },
+  borrow: async (tx, input, ctx) => {
+    const asset = resolveSaveableAsset(input.asset);
+    if (input.amount <= 0) {
+      throw new exports.T2000Error("INVALID_AMOUNT", "Borrow amount must be greater than zero");
+    }
+    const coin = await addBorrowToTx(
+      tx,
+      ctx.client,
+      ctx.sender,
+      input.amount,
+      { asset, skipPythUpdate: ctx.sponsoredContext }
+    );
+    tx.transferObjects([coin], ctx.sender);
+    return { toolName: "borrow", effectiveAmount: input.amount, asset };
+  },
+  repay_debt: async (tx, input, ctx) => {
+    const asset = resolveSaveableAsset(input.asset);
+    const assetInfo = SUPPORTED_ASSETS[asset];
+    if (input.amount <= 0) {
+      throw new exports.T2000Error("INVALID_AMOUNT", "Repay amount must be greater than zero");
+    }
+    const rawAmount = BigInt(Math.floor(input.amount * 10 ** assetInfo.decimals));
+    const { coin, effectiveAmount } = await selectAndSplitCoin(
+      tx,
+      ctx.client,
+      ctx.sender,
+      assetInfo.type,
+      rawAmount
+    );
+    await addRepayToTx(tx, ctx.client, ctx.sender, coin, {
+      asset,
+      skipOracle: ctx.sponsoredContext
+    });
+    return {
+      toolName: "repay_debt",
+      effectiveAmount: Number(effectiveAmount) / 10 ** assetInfo.decimals,
+      asset
+    };
+  },
+  send_transfer: async (tx, input, ctx) => {
+    const recipient = validateAddress(input.to);
+    const asset = input.asset ?? "USDC";
+    const assetInfo = SUPPORTED_ASSETS[asset];
+    if (!assetInfo) {
+      throw new exports.T2000Error("ASSET_NOT_SUPPORTED", `Asset ${asset} is not supported`);
+    }
+    if (input.amount <= 0) {
+      throw new exports.T2000Error("INVALID_AMOUNT", "Send amount must be greater than zero");
+    }
+    const rawAmount = BigInt(Math.floor(input.amount * 10 ** assetInfo.decimals));
+    let coin;
+    let effectiveRaw;
+    if (asset === "SUI") {
+      const result = await selectSuiCoin(tx, ctx.client, ctx.sender, rawAmount, ctx.sponsoredContext);
+      coin = result.coin;
+      effectiveRaw = result.effectiveAmount;
+    } else {
+      const result = await selectAndSplitCoin(tx, ctx.client, ctx.sender, assetInfo.type, rawAmount);
+      coin = result.coin;
+      effectiveRaw = result.effectiveAmount;
+    }
+    addSendToTx(tx, coin, recipient);
+    return {
+      toolName: "send_transfer",
+      effectiveAmount: Number(effectiveRaw) / 10 ** assetInfo.decimals,
+      recipient,
+      asset
+    };
+  },
+  swap_execute: async (tx, input, ctx) => {
+    const fromType = resolveTokenType(input.from);
+    const toType = resolveTokenType(input.to);
+    if (!fromType || !toType) {
+      throw new exports.T2000Error(
+        "ASSET_NOT_SUPPORTED",
+        `Unknown token in swap: from=${input.from}, to=${input.to}`
+      );
+    }
+    const providers = input.providers ?? (ctx.sponsoredContext ? await getSponsoredSwapProviders() : void 0);
+    const result = await addSwapToTx(tx, ctx.client, ctx.sender, {
+      from: input.from,
+      to: input.to,
+      amount: input.amount,
+      slippage: input.slippage,
+      byAmountIn: input.byAmountIn,
+      overlayFee: ctx.overlayFee,
+      providers
+    });
+    tx.transferObjects([result.coin], ctx.sender);
+    return {
+      toolName: "swap_execute",
+      effectiveAmountIn: result.effectiveAmountIn,
+      expectedAmountOut: result.expectedAmountOut,
+      route: result.route
+    };
+  },
+  claim_rewards: async (tx, _input, ctx) => {
+    const rewards = await addClaimRewardsToTx(tx, ctx.client, ctx.sender);
+    return { toolName: "claim_rewards", rewards };
+  },
+  volo_stake: async (tx, input, ctx) => {
+    if (input.amountSui <= 0) {
+      throw new exports.T2000Error("INVALID_AMOUNT", "Stake amount must be greater than zero");
+    }
+    const amountMist = BigInt(Math.floor(input.amountSui * 1e9));
+    const result = await addStakeVSuiToTx(tx, ctx.client, ctx.sender, { amountMist });
+    tx.transferObjects([result.coin], ctx.sender);
+    return { toolName: "volo_stake", effectiveAmountMist: result.effectiveAmountMist };
+  },
+  volo_unstake: async (tx, input, ctx) => {
+    const amountMist = input.amountVSui === "all" ? "all" : BigInt(Math.floor(input.amountVSui * 1e9));
+    if (amountMist !== "all" && amountMist <= 0n) {
+      throw new exports.T2000Error("INVALID_AMOUNT", "Unstake amount must be greater than zero");
+    }
+    const result = await addUnstakeVSuiToTx(tx, ctx.client, ctx.sender, { amountMist });
+    tx.transferObjects([result.coin], ctx.sender);
+    return { toolName: "volo_unstake", effectiveAmountMist: result.effectiveAmountMist };
+  }
+};
+function deriveAllowedAddressesFromPtb(tx) {
+  const addresses = /* @__PURE__ */ new Set();
+  const data = tx.getData();
+  for (const cmd of data.commands) {
+    const transferCmd = cmd.TransferObjects;
+    if (!transferCmd) continue;
+    const addressArg = transferCmd.address;
+    if (!addressArg) continue;
+    const addressInputIndex = addressArg.Input;
+    if (addressInputIndex === void 0) continue;
+    const input = data.inputs[addressInputIndex];
+    if (!input) continue;
+    const pureBytes = input.Pure?.bytes;
+    if (!pureBytes) continue;
+    try {
+      const bytes = base64ToBytes(pureBytes);
+      if (bytes.length !== 32) continue;
+      const hex = "0x" + Array.from(bytes).map((b2) => b2.toString(16).padStart(2, "0")).join("");
+      addresses.add(hex);
+    } catch {
+    }
+  }
+  return Array.from(addresses);
+}
+function base64ToBytes(b64) {
+  if (typeof Buffer !== "undefined") {
+    return Uint8Array.from(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+async function composeTx(opts) {
+  const tx = new transactions.Transaction();
+  tx.setSender(opts.sender);
+  const ctx = {
+    client: opts.client,
+    sender: opts.sender,
+    sponsoredContext: opts.sponsoredContext ?? false,
+    overlayFee: opts.overlayFee
+  };
+  const previews = [];
+  for (const step of opts.steps) {
+    const appender = WRITE_APPENDER_REGISTRY[step.toolName];
+    if (!appender) {
+      throw new exports.T2000Error(
+        "UNKNOWN",
+        `No fragment appender registered for tool '${step.toolName}'. Allowed: ${Object.keys(WRITE_APPENDER_REGISTRY).join(", ")}`
+      );
+    }
+    const preview = await appender(tx, step.input, ctx);
+    previews.push(preview);
+  }
+  const txKindBytes = await tx.build({ client: opts.client, onlyTransactionKind: true });
+  const derivedAllowedAddresses = deriveAllowedAddressesFromPtb(tx);
+  return {
+    tx,
+    txKindBytes,
+    derivedAllowedAddresses,
+    perStepPreviews: previews
+  };
+}
+
 // src/protocols/protocolFee.ts
 var FEE_RATES = {
   save: SAVE_FEE_BPS,
@@ -7431,10 +7914,17 @@ exports.SafeguardError = SafeguardError;
 exports.T2000 = T2000;
 exports.T2000_OVERLAY_FEE_WALLET = T2000_OVERLAY_FEE_WALLET;
 exports.USDC_DECIMALS = USDC_DECIMALS;
+exports.WRITE_APPENDER_REGISTRY = WRITE_APPENDER_REGISTRY;
 exports.ZkLoginSigner = ZkLoginSigner;
 exports.addFeeTransfer = addFeeTransfer;
+exports.addSendToTx = addSendToTx;
+exports.addStakeVSuiToTx = addStakeVSuiToTx;
+exports.addSwapToTx = addSwapToTx;
+exports.addUnstakeVSuiToTx = addUnstakeVSuiToTx;
 exports.allDescriptors = allDescriptors;
 exports.assertAllowedAsset = assertAllowedAsset;
+exports.buildClaimRewardsTx = buildClaimRewardsTx;
+exports.buildSendTx = buildSendTx;
 exports.buildStakeVSuiTx = buildStakeVSuiTx;
 exports.buildSwapTx = buildSwapTx;
 exports.buildUnstakeVSuiTx = buildUnstakeVSuiTx;
@@ -7442,11 +7932,14 @@ exports.calculateFee = calculateFee;
 exports.classifyAction = classifyAction;
 exports.classifyLabel = classifyLabel;
 exports.classifyTransaction = classifyTransaction;
+exports.composeTx = composeTx;
+exports.deriveAllowedAddressesFromPtb = deriveAllowedAddressesFromPtb;
 exports.exportPrivateKey = exportPrivateKey;
 exports.extractTransferDetails = extractTransferDetails;
 exports.extractTxCommands = extractTxCommands;
 exports.extractTxSender = extractTxSender;
 exports.fallbackLabel = fallbackLabel;
+exports.fetchAllCoins = fetchAllCoins;
 exports.findSwapRoute = findSwapRoute;
 exports.formatAssetAmount = formatAssetAmount;
 exports.formatSui = formatSui;
@@ -7483,6 +7976,8 @@ exports.refineLendingLabel = refineLendingLabel;
 exports.resolveSymbol = resolveSymbol;
 exports.resolveTokenType = resolveTokenType;
 exports.saveKey = saveKey;
+exports.selectAndSplitCoin = selectAndSplitCoin;
+exports.selectSuiCoin = selectSuiCoin;
 exports.simulateTransaction = simulateTransaction;
 exports.stableToRaw = stableToRaw;
 exports.suiToMist = suiToMist;