@t2000/sdk 0.3.0 → 0.4.1

package/dist/index.cjs

@@ -11,8 +11,8 @@ var path = require('path');
 var os = require('os');
 var transactions = require('@mysten/sui/transactions');
 var lending = require('@naviprotocol/lending');
-var suiClmmSdk = require('@cetusprotocol/sui-clmm-sdk');
 var bcs = require('@mysten/sui/bcs');
+var aggregatorSdk = require('@cetusprotocol/aggregator-sdk');
 
 // src/t2000.ts
 
@@ -524,8 +524,8 @@ async function buildRepayTx(client, address, amount) {
   await lending.repayCoinPTB(tx, USDC_TYPE, coinObj, { ...ENV, amount: rawAmount });
   return tx;
 }
-async function getHealthFactor(client, keypair) {
-  const address = keypair.getPublicKey().toSuiAddress();
+async function getHealthFactor(client, addressOrKeypair) {
+  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
   const [healthFactor, state, pool] = await Promise.all([
     lending.getHealthFactor(address, clientOpt(client, true)),
     lending.getLendingState(address, clientOpt(client, true)),
@@ -557,8 +557,8 @@ async function getRates(client) {
     return { USDC: { saveApy: 4, borrowApy: 6 } };
   }
 }
-async function getPositions(client, keypair) {
-  const address = keypair.getPublicKey().toSuiAddress();
+async function getPositions(client, addressOrKeypair) {
+  const address = typeof addressOrKeypair === "string" ? addressOrKeypair : addressOrKeypair.getPublicKey().toSuiAddress();
   const state = await lending.getLendingState(address, clientOpt(client, true));
   const positions = [];
   for (const pos of state) {
@@ -586,8 +586,8 @@ async function getPositions(client, keypair) {
   }
   return { positions };
 }
-async function maxWithdrawAmount(client, keypair) {
-  const hf = await getHealthFactor(client, keypair);
+async function maxWithdrawAmount(client, addressOrKeypair) {
+  const hf = await getHealthFactor(client, addressOrKeypair);
   const ltv = hf.liquidationThreshold > 0 ? hf.liquidationThreshold : 0.75;
   let maxAmount;
   if (hf.borrowed === 0) {
@@ -603,8 +603,8 @@ async function maxWithdrawAmount(client, keypair) {
     currentHF: hf.healthFactor
   };
 }
-async function maxBorrowAmount(client, keypair) {
-  const hf = await getHealthFactor(client, keypair);
+async function maxBorrowAmount(client, addressOrKeypair) {
+  const hf = await getHealthFactor(client, addressOrKeypair);
   const ltv = hf.liquidationThreshold > 0 ? hf.liquidationThreshold : 0.75;
   const maxAmount = Math.max(0, hf.supplied * ltv / MIN_HEALTH_FACTOR - hf.borrowed);
   return {
@@ -613,108 +613,6 @@ async function maxBorrowAmount(client, keypair) {
     currentHF: hf.healthFactor
   };
 }
-var DEFAULT_SLIPPAGE_BPS = 300;
-function isA2B(from) {
-  return from === "USDC";
-}
-var _cetusSDK = null;
-function getCetusSDK() {
-  if (!_cetusSDK) {
-    _cetusSDK = suiClmmSdk.CetusClmmSDK.createSDK({ env: "mainnet" });
-  }
-  return _cetusSDK;
-}
-async function buildSwapTx(params) {
-  const { client, address, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
-  const a2b = isA2B(fromAsset);
-  const fromInfo = SUPPORTED_ASSETS[fromAsset];
-  const toInfo = SUPPORTED_ASSETS[toAsset];
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const sdk = getCetusSDK();
-  sdk.setSenderAddress(address);
-  const pool = await sdk.Pool.getPool(CETUS_USDC_SUI_POOL);
-  const preSwapResult = await sdk.Swap.preSwap({
-    pool,
-    current_sqrt_price: pool.current_sqrt_price,
-    coin_type_a: pool.coin_type_a,
-    coin_type_b: pool.coin_type_b,
-    decimals_a: 6,
-    decimals_b: 9,
-    a2b,
-    by_amount_in: true,
-    amount: rawAmount.toString()
-  });
-  const estimatedOut = Number(preSwapResult.estimated_amount_out);
-  const slippageFactor = (1e4 - maxSlippageBps) / 1e4;
-  const amountLimit = Math.floor(estimatedOut * slippageFactor);
-  const swapPayload = await sdk.Swap.createSwapPayload({
-    pool_id: pool.id,
-    coin_type_a: pool.coin_type_a,
-    coin_type_b: pool.coin_type_b,
-    a2b,
-    by_amount_in: true,
-    amount: preSwapResult.amount.toString(),
-    amount_limit: amountLimit.toString()
-  });
-  return {
-    tx: swapPayload,
-    estimatedOut,
-    toDecimals: toInfo.decimals
-  };
-}
-async function getPoolPrice(client) {
-  try {
-    const pool = await client.getObject({
-      id: CETUS_USDC_SUI_POOL,
-      options: { showContent: true }
-    });
-    if (pool.data?.content?.dataType === "moveObject") {
-      const fields = pool.data.content.fields;
-      const currentSqrtPrice = BigInt(String(fields.current_sqrt_price ?? "0"));
-      if (currentSqrtPrice > 0n) {
-        const Q64 = 2n ** 64n;
-        const sqrtPriceFloat = Number(currentSqrtPrice) / Number(Q64);
-        const rawPrice = sqrtPriceFloat * sqrtPriceFloat;
-        const suiPriceUsd = 1e3 / rawPrice;
-        if (suiPriceUsd > 0.01 && suiPriceUsd < 1e3) return suiPriceUsd;
-      }
-    }
-  } catch {
-  }
-  return 3.5;
-}
-async function getSwapQuote(client, fromAsset, toAsset, amount) {
-  const a2b = isA2B(fromAsset);
-  const fromInfo = SUPPORTED_ASSETS[fromAsset];
-  const toInfo = SUPPORTED_ASSETS[toAsset];
-  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
-  const poolPrice = await getPoolPrice(client);
-  try {
-    const sdk = getCetusSDK();
-    const pool = await sdk.Pool.getPool(CETUS_USDC_SUI_POOL);
-    const preSwapResult = await sdk.Swap.preSwap({
-      pool,
-      current_sqrt_price: pool.current_sqrt_price,
-      coin_type_a: pool.coin_type_a,
-      coin_type_b: pool.coin_type_b,
-      decimals_a: 6,
-      decimals_b: 9,
-      a2b,
-      by_amount_in: true,
-      amount: rawAmount.toString()
-    });
-    const expectedOutput = Number(preSwapResult.estimated_amount_out) / 10 ** toInfo.decimals;
-    return { expectedOutput, priceImpact: 0, poolPrice };
-  } catch {
-    let expectedOutput;
-    if (fromAsset === "USDC") {
-      expectedOutput = amount / poolPrice;
-    } else {
-      expectedOutput = amount * poolPrice;
-    }
-    return { expectedOutput, priceImpact: 0, poolPrice };
-  }
-}
 
 // src/protocols/yieldTracker.ts
 async function getEarnings(client, keypair) {
@@ -926,6 +824,298 @@ async function attack(client, signer, sentinelId, prompt, feeMist) {
     feePaid: Number(fee) / Number(MIST_PER_SUI)
   };
 }
+
+// src/adapters/registry.ts
+var ProtocolRegistry = class {
+  lending = /* @__PURE__ */ new Map();
+  swap = /* @__PURE__ */ new Map();
+  registerLending(adapter) {
+    this.lending.set(adapter.id, adapter);
+  }
+  registerSwap(adapter) {
+    this.swap.set(adapter.id, adapter);
+  }
+  async bestSaveRate(asset) {
+    const candidates = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      if (!adapter.capabilities.includes("save")) continue;
+      try {
+        const rate = await adapter.getRates(asset);
+        candidates.push({ adapter, rate });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new Error(`No lending adapter supports saving ${asset}`);
+    }
+    candidates.sort((a, b) => b.rate.saveApy - a.rate.saveApy);
+    return candidates[0];
+  }
+  async bestBorrowRate(asset, opts) {
+    const candidates = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      if (!adapter.capabilities.includes("borrow")) continue;
+      if (opts?.requireSameAssetBorrow && !adapter.supportsSameAssetBorrow) continue;
+      try {
+        const rate = await adapter.getRates(asset);
+        candidates.push({ adapter, rate });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new Error(`No lending adapter supports borrowing ${asset}`);
+    }
+    candidates.sort((a, b) => a.rate.borrowApy - b.rate.borrowApy);
+    return candidates[0];
+  }
+  async bestSwapQuote(from, to, amount) {
+    const candidates = [];
+    for (const adapter of this.swap.values()) {
+      const pairs = adapter.getSupportedPairs();
+      if (!pairs.some((p) => p.from === from && p.to === to)) continue;
+      try {
+        const quote = await adapter.getQuote(from, to, amount);
+        candidates.push({ adapter, quote });
+      } catch {
+      }
+    }
+    if (candidates.length === 0) {
+      throw new Error(`No swap adapter supports ${from} \u2192 ${to}`);
+    }
+    candidates.sort((a, b) => b.quote.expectedOutput - a.quote.expectedOutput);
+    return candidates[0];
+  }
+  async allRates(asset) {
+    const results = [];
+    for (const adapter of this.lending.values()) {
+      if (!adapter.supportedAssets.includes(asset)) continue;
+      try {
+        const rates = await adapter.getRates(asset);
+        results.push({ protocol: adapter.name, protocolId: adapter.id, rates });
+      } catch {
+      }
+    }
+    return results;
+  }
+  async allPositions(address) {
+    const results = [];
+    for (const adapter of this.lending.values()) {
+      try {
+        const positions = await adapter.getPositions(address);
+        if (positions.supplies.length > 0 || positions.borrows.length > 0) {
+          results.push({ protocol: adapter.name, protocolId: adapter.id, positions });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  getLending(id) {
+    return this.lending.get(id);
+  }
+  getSwap(id) {
+    return this.swap.get(id);
+  }
+  listLending() {
+    return [...this.lending.values()];
+  }
+  listSwap() {
+    return [...this.swap.values()];
+  }
+};
+
+// src/adapters/navi.ts
+var NaviAdapter = class {
+  id = "navi";
+  name = "NAVI Protocol";
+  version = "1.0.0";
+  capabilities = ["save", "withdraw", "borrow", "repay"];
+  supportedAssets = ["USDC"];
+  supportsSameAssetBorrow = true;
+  client;
+  async init(client) {
+    this.client = client;
+  }
+  initSync(client) {
+    this.client = client;
+  }
+  async getRates(asset) {
+    const rates = await getRates(this.client);
+    const key = asset.toUpperCase();
+    const r = rates[key];
+    if (!r) throw new Error(`NAVI does not support ${asset}`);
+    return { asset, saveApy: r.saveApy, borrowApy: r.borrowApy };
+  }
+  async getPositions(address) {
+    const result = await getPositions(this.client, address);
+    return {
+      supplies: result.positions.filter((p) => p.type === "save").map((p) => ({ asset: p.asset, amount: p.amount, apy: p.apy })),
+      borrows: result.positions.filter((p) => p.type === "borrow").map((p) => ({ asset: p.asset, amount: p.amount, apy: p.apy }))
+    };
+  }
+  async getHealth(address) {
+    return getHealthFactor(this.client, address);
+  }
+  async buildSaveTx(address, amount, _asset, options) {
+    const tx = await buildSaveTx(this.client, address, amount, options);
+    return { tx };
+  }
+  async buildWithdrawTx(address, amount, _asset) {
+    const result = await buildWithdrawTx(this.client, address, amount);
+    return { tx: result.tx, effectiveAmount: result.effectiveAmount };
+  }
+  async buildBorrowTx(address, amount, _asset, options) {
+    const tx = await buildBorrowTx(this.client, address, amount, options);
+    return { tx };
+  }
+  async buildRepayTx(address, amount, _asset) {
+    const tx = await buildRepayTx(this.client, address, amount);
+    return { tx };
+  }
+  async maxWithdraw(address, _asset) {
+    return maxWithdrawAmount(this.client, address);
+  }
+  async maxBorrow(address, _asset) {
+    return maxBorrowAmount(this.client, address);
+  }
+};
+var DEFAULT_SLIPPAGE_BPS = 300;
+function createAggregatorClient(client, signer) {
+  return new aggregatorSdk.AggregatorClient({
+    client,
+    signer,
+    env: aggregatorSdk.Env.Mainnet
+  });
+}
+async function buildSwapTx(params) {
+  const { client, address, fromAsset, toAsset, amount, maxSlippageBps = DEFAULT_SLIPPAGE_BPS } = params;
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const aggClient = createAggregatorClient(client, address);
+  const result = await aggClient.findRouters({
+    from: fromInfo.type,
+    target: toInfo.type,
+    amount: rawAmount,
+    byAmountIn: true
+  });
+  if (!result || result.insufficientLiquidity) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      `No swap route found for ${fromAsset} \u2192 ${toAsset}`
+    );
+  }
+  const tx = new transactions.Transaction();
+  const slippage = maxSlippageBps / 1e4;
+  await aggClient.fastRouterSwap({
+    router: result,
+    txb: tx,
+    slippage
+  });
+  const estimatedOut = Number(result.amountOut.toString());
+  return {
+    tx,
+    estimatedOut,
+    toDecimals: toInfo.decimals
+  };
+}
+async function getPoolPrice(client) {
+  try {
+    const pool = await client.getObject({
+      id: CETUS_USDC_SUI_POOL,
+      options: { showContent: true }
+    });
+    if (pool.data?.content?.dataType === "moveObject") {
+      const fields = pool.data.content.fields;
+      const currentSqrtPrice = BigInt(String(fields.current_sqrt_price ?? "0"));
+      if (currentSqrtPrice > 0n) {
+        const Q64 = 2n ** 64n;
+        const sqrtPriceFloat = Number(currentSqrtPrice) / Number(Q64);
+        const rawPrice = sqrtPriceFloat * sqrtPriceFloat;
+        const suiPriceUsd = 1e3 / rawPrice;
+        if (suiPriceUsd > 0.01 && suiPriceUsd < 1e3) return suiPriceUsd;
+      }
+    }
+  } catch {
+  }
+  return 3.5;
+}
+async function getSwapQuote(client, fromAsset, toAsset, amount) {
+  const fromInfo = SUPPORTED_ASSETS[fromAsset];
+  const toInfo = SUPPORTED_ASSETS[toAsset];
+  const rawAmount = BigInt(Math.floor(amount * 10 ** fromInfo.decimals));
+  const poolPrice = await getPoolPrice(client);
+  try {
+    const aggClient = createAggregatorClient(client);
+    const result = await aggClient.findRouters({
+      from: fromInfo.type,
+      target: toInfo.type,
+      amount: rawAmount,
+      byAmountIn: true
+    });
+    if (!result || result.insufficientLiquidity) {
+      return fallbackQuote(fromAsset, amount, poolPrice);
+    }
+    const expectedOutput = Number(result.amountOut.toString()) / 10 ** toInfo.decimals;
+    const priceImpact = result.deviationRatio ?? 0;
+    return { expectedOutput, priceImpact, poolPrice };
+  } catch {
+    return fallbackQuote(fromAsset, amount, poolPrice);
+  }
+}
+function fallbackQuote(fromAsset, amount, poolPrice) {
+  const expectedOutput = fromAsset === "USDC" ? amount / poolPrice : amount * poolPrice;
+  return { expectedOutput, priceImpact: 0, poolPrice };
+}
+
+// src/adapters/cetus.ts
+var CetusAdapter = class {
+  id = "cetus";
+  name = "Cetus";
+  version = "1.0.0";
+  capabilities = ["swap"];
+  client;
+  async init(client) {
+    this.client = client;
+  }
+  initSync(client) {
+    this.client = client;
+  }
+  async getQuote(from, to, amount) {
+    return getSwapQuote(
+      this.client,
+      from.toUpperCase(),
+      to.toUpperCase(),
+      amount
+    );
+  }
+  async buildSwapTx(address, from, to, amount, maxSlippageBps) {
+    const result = await buildSwapTx({
+      client: this.client,
+      address,
+      fromAsset: from.toUpperCase(),
+      toAsset: to.toUpperCase(),
+      amount,
+      maxSlippageBps
+    });
+    return {
+      tx: result.tx,
+      estimatedOut: result.estimatedOut,
+      toDecimals: result.toDecimals
+    };
+  }
+  getSupportedPairs() {
+    return [
+      { from: "USDC", to: "SUI" },
+      { from: "SUI", to: "USDC" }
+    ];
+  }
+  async getPoolPrice() {
+    return getPoolPrice(this.client);
+  }
+};
 function hasLeadingZeroBits(hash, bits) {
   const fullBytes = Math.floor(bits / 8);
   const remainingBits = bits % 8;
@@ -1158,11 +1348,23 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   keypair;
   client;
   _address;
-  constructor(keypair, client) {
+  registry;
+  constructor(keypair, client, registry) {
     super();
     this.keypair = keypair;
     this.client = client;
     this._address = getAddress(keypair);
+    this.registry = registry ?? _T2000.createDefaultRegistry(client);
+  }
+  static createDefaultRegistry(client) {
+    const registry = new ProtocolRegistry();
+    const naviAdapter = new NaviAdapter();
+    naviAdapter.initSync(client);
+    registry.registerLending(naviAdapter);
+    const cetusAdapter = new CetusAdapter();
+    cetusAdapter.initSync(client);
+    registry.registerSwap(cetusAdapter);
+    return registry;
   }
   static async create(options = {}) {
     const { keyPath, pin, passphrase, network = DEFAULT_NETWORK, rpcUrl, sponsored, name } = options;
@@ -1283,6 +1485,11 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   exportKey() {
     return exportPrivateKey(this.keypair);
   }
+  async registerAdapter(adapter) {
+    await adapter.init(this.client);
+    if ("buildSaveTx" in adapter) this.registry.registerLending(adapter);
+    if ("buildSwapTx" in adapter) this.registry.registerSwap(adapter);
+  }
   // -- Savings --
   async save(params) {
     const asset = (params.asset ?? "USDC").toUpperCase();
@@ -1305,12 +1512,12 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     }
     const fee = calculateFee("save", amount);
     const saveAmount = amount;
-    const gasResult = await executeWithGas(
-      this.client,
-      this.keypair,
-      () => buildSaveTx(this.client, this._address, saveAmount, { collectFee: true })
-    );
-    const rates = await getRates(this.client);
+    const adapter = await this.resolveLending(params.protocol, asset, "save");
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const { tx } = await adapter.buildSaveTx(this._address, saveAmount, asset, { collectFee: true });
+      return tx;
+    });
+    const rates = await adapter.getRates(asset);
     reportFee(this._address, "save", fee.amount, fee.rate, gasResult.digest);
     this.emitBalanceChange("USDC", saveAmount, "save", gasResult.digest);
     let savingsBalance = saveAmount;
@@ -1323,7 +1530,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       success: true,
       tx: gasResult.digest,
       amount: saveAmount,
-      apy: rates.USDC.saveApy,
+      apy: rates.saveApy,
       fee: fee.amount,
       gasCost: gasResult.gasCostSui,
       gasMethod: gasResult.gasMethod,
@@ -1335,18 +1542,19 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     if (asset !== "USDC") {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for withdraw. Got: ${asset}`);
     }
+    const adapter = await this.resolveLending(params.protocol, asset, "withdraw");
     let amount;
     if (params.amount === "all") {
-      const maxResult = await this.maxWithdraw();
+      const maxResult = await adapter.maxWithdraw(this._address, asset);
       amount = maxResult.maxAmount;
       if (amount <= 0) {
         throw new T2000Error("NO_COLLATERAL", "No savings to withdraw");
       }
     } else {
       amount = params.amount;
-      const hf = await this.healthFactor();
+      const hf = await adapter.getHealth(this._address);
       if (hf.borrowed > 0) {
-        const maxResult = await this.maxWithdraw();
+        const maxResult = await adapter.maxWithdraw(this._address, asset);
         if (amount > maxResult.maxAmount) {
           throw new T2000Error(
             "WITHDRAW_WOULD_LIQUIDATE",
@@ -1363,7 +1571,7 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     const withdrawAmount = amount;
     let effectiveAmount = withdrawAmount;
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const built = await buildWithdrawTx(this.client, this._address, withdrawAmount);
+      const built = await adapter.buildWithdrawTx(this._address, withdrawAmount, asset);
       effectiveAmount = built.effectiveAmount;
       return built.tx;
     });
@@ -1377,7 +1585,8 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async maxWithdraw() {
-    return maxWithdrawAmount(this.client, this.keypair);
+    const adapter = await this.resolveLending(void 0, "USDC", "withdraw");
+    return adapter.maxWithdraw(this._address, "USDC");
   }
   // -- Borrowing --
   async borrow(params) {
@@ -1385,7 +1594,8 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     if (asset !== "USDC") {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for borrow. Got: ${asset}`);
     }
-    const maxResult = await this.maxBorrow();
+    const adapter = await this.resolveLending(params.protocol, asset, "borrow");
+    const maxResult = await adapter.maxBorrow(this._address, asset);
     if (params.amount > maxResult.maxAmount) {
       throw new T2000Error("HEALTH_FACTOR_TOO_LOW", `Max safe borrow: $${maxResult.maxAmount.toFixed(2)}`, {
         maxBorrow: maxResult.maxAmount,
@@ -1394,12 +1604,11 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     }
     const fee = calculateFee("borrow", params.amount);
     const borrowAmount = params.amount;
-    const gasResult = await executeWithGas(
-      this.client,
-      this.keypair,
-      () => buildBorrowTx(this.client, this._address, borrowAmount, { collectFee: true })
-    );
-    const hf = await getHealthFactor(this.client, this.keypair);
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const { tx } = await adapter.buildBorrowTx(this._address, borrowAmount, asset, { collectFee: true });
+      return tx;
+    });
+    const hf = await adapter.getHealth(this._address);
     reportFee(this._address, "borrow", fee.amount, fee.rate, gasResult.digest);
     this.emitBalanceChange("USDC", borrowAmount, "borrow", gasResult.digest);
     return {
@@ -1417,9 +1626,10 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     if (asset !== "USDC") {
       throw new T2000Error("ASSET_NOT_SUPPORTED", `Only USDC is supported for repay. Got: ${asset}`);
     }
+    const adapter = await this.resolveLending(params.protocol, asset, "repay");
     let amount;
     if (params.amount === "all") {
-      const hf2 = await this.healthFactor();
+      const hf2 = await adapter.getHealth(this._address);
       amount = hf2.borrowed;
       if (amount <= 0) {
         throw new T2000Error("NO_COLLATERAL", "No outstanding borrow to repay");
@@ -1428,12 +1638,11 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
       amount = params.amount;
     }
     const repayAmount = amount;
-    const gasResult = await executeWithGas(
-      this.client,
-      this.keypair,
-      () => buildRepayTx(this.client, this._address, repayAmount)
-    );
-    const hf = await getHealthFactor(this.client, this.keypair);
+    const gasResult = await executeWithGas(this.client, this.keypair, async () => {
+      const { tx } = await adapter.buildRepayTx(this._address, repayAmount, asset);
+      return tx;
+    });
+    const hf = await adapter.getHealth(this._address);
     this.emitBalanceChange("USDC", repayAmount, "repay", gasResult.digest);
     return {
       success: true,
@@ -1445,10 +1654,12 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     };
   }
   async maxBorrow() {
-    return maxBorrowAmount(this.client, this.keypair);
+    const adapter = await this.resolveLending(void 0, "USDC", "borrow");
+    return adapter.maxBorrow(this._address, "USDC");
   }
   async healthFactor() {
-    const hf = await getHealthFactor(this.client, this.keypair);
+    const adapter = await this.resolveLending(void 0, "USDC", "save");
+    const hf = await adapter.getHealth(this._address);
     if (hf.healthFactor < 1.2) {
       this.emit("healthCritical", { healthFactor: hf.healthFactor, threshold: 1.5, severity: "critical" });
     } else if (hf.healthFactor < 2) {
@@ -1466,23 +1677,26 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     if (fromAsset === toAsset) {
       throw new T2000Error("INVALID_AMOUNT", "Cannot swap same asset");
     }
+    let adapter;
+    if (params.protocol) {
+      const found = this.registry.getSwap(params.protocol);
+      if (!found) throw new T2000Error("ASSET_NOT_SUPPORTED", `Swap adapter '${params.protocol}' not found`);
+      adapter = found;
+    } else {
+      const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
+      adapter = best.adapter;
+    }
     const fee = calculateFee("swap", params.amount);
     const swapAmount = params.amount;
     const slippageBps = params.maxSlippage ? params.maxSlippage * 100 : void 0;
     let swapMeta = { estimatedOut: 0, toDecimals: 0 };
     const gasResult = await executeWithGas(this.client, this.keypair, async () => {
-      const built = await buildSwapTx({
-        client: this.client,
-        address: this._address,
-        fromAsset,
-        toAsset,
-        amount: swapAmount,
-        maxSlippageBps: slippageBps
-      });
+      const built = await adapter.buildSwapTx(this._address, fromAsset, toAsset, swapAmount, slippageBps);
       swapMeta = { estimatedOut: built.estimatedOut, toDecimals: built.toDecimals };
       return built.tx;
     });
     const toInfo = SUPPORTED_ASSETS[toAsset];
+    await this.client.waitForTransaction({ digest: gasResult.digest });
     const txDetail = await this.client.getTransactionBlock({
       digest: gasResult.digest,
       options: { showBalanceChanges: true }
@@ -1517,17 +1731,39 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
   async swapQuote(params) {
     const fromAsset = params.from.toUpperCase();
     const toAsset = params.to.toUpperCase();
-    const quote = await getSwapQuote(this.client, fromAsset, toAsset, params.amount);
+    const best = await this.registry.bestSwapQuote(fromAsset, toAsset, params.amount);
     const fee = calculateFee("swap", params.amount);
-    return { ...quote, fee: { amount: fee.amount, rate: fee.rate } };
+    return { ...best.quote, fee: { amount: fee.amount, rate: fee.rate } };
   }
   // -- Info --
   async positions() {
-    return getPositions(this.client, this.keypair);
+    const allPositions = await this.registry.allPositions(this._address);
+    const positions = allPositions.flatMap(
+      (p) => [
+        ...p.positions.supplies.map((s) => ({
+          protocol: p.protocolId,
+          asset: s.asset,
+          type: "save",
+          amount: s.amount,
+          apy: s.apy
+        })),
+        ...p.positions.borrows.map((b) => ({
+          protocol: p.protocolId,
+          asset: b.asset,
+          type: "borrow",
+          amount: b.amount,
+          apy: b.apy
+        }))
+      ]
+    );
+    return { positions };
   }
   async rates() {
     return getRates(this.client);
   }
+  async allRates(asset = "USDC") {
+    return this.registry.allRates(asset);
+  }
   async earnings() {
     const result = await getEarnings(this.client, this.keypair);
     if (result.totalYieldEarned > 0) {
@@ -1554,6 +1790,29 @@ var T2000 = class _T2000 extends eventemitter3.EventEmitter {
     return attack(this.client, this.keypair, id, prompt, fee);
   }
   // -- Helpers --
+  async resolveLending(protocol, asset, capability) {
+    if (protocol) {
+      const adapter = this.registry.getLending(protocol);
+      if (!adapter) throw new T2000Error("ASSET_NOT_SUPPORTED", `Lending adapter '${protocol}' not found`);
+      return adapter;
+    }
+    if (capability === "save") {
+      const { adapter } = await this.registry.bestSaveRate(asset);
+      return adapter;
+    }
+    if (capability === "borrow" || capability === "repay") {
+      const adapters2 = this.registry.listLending().filter(
+        (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability) && (capability !== "borrow" || a.supportsSameAssetBorrow)
+      );
+      if (adapters2.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+      return adapters2[0];
+    }
+    const adapters = this.registry.listLending().filter(
+      (a) => a.supportedAssets.includes(asset) && a.capabilities.includes(capability)
+    );
+    if (adapters.length === 0) throw new T2000Error("ASSET_NOT_SUPPORTED", `No adapter supports ${capability} ${asset}`);
+    return adapters[0];
+  }
   emitBalanceChange(asset, amount, cause, tx) {
     this.emit("balanceChange", { asset, previous: 0, current: 0, cause, tx });
   }
@@ -1651,14 +1910,308 @@ function parseMoveAbort(errorStr) {
   }
   return { reason: errorStr };
 }
+var USDC_TYPE2 = SUPPORTED_ASSETS.USDC.type;
+SUPPORTED_ASSETS.USDC.decimals;
+var WAD = 1e18;
+var MIN_HEALTH_FACTOR2 = 1.5;
+function interpolateRate(utilBreakpoints, aprBreakpoints, utilizationPct) {
+  if (utilBreakpoints.length === 0) return 0;
+  if (utilizationPct <= utilBreakpoints[0]) return aprBreakpoints[0];
+  if (utilizationPct >= utilBreakpoints[utilBreakpoints.length - 1]) {
+    return aprBreakpoints[aprBreakpoints.length - 1];
+  }
+  for (let i = 1; i < utilBreakpoints.length; i++) {
+    if (utilizationPct <= utilBreakpoints[i]) {
+      const t = (utilizationPct - utilBreakpoints[i - 1]) / (utilBreakpoints[i] - utilBreakpoints[i - 1]);
+      return aprBreakpoints[i - 1] + t * (aprBreakpoints[i] - aprBreakpoints[i - 1]);
+    }
+  }
+  return aprBreakpoints[aprBreakpoints.length - 1];
+}
+function computeRatesFromReserve(reserve) {
+  const decimals = reserve.mintDecimals;
+  const available = Number(reserve.availableAmount) / 10 ** decimals;
+  const borrowed = Number(reserve.borrowedAmount.value) / WAD / 10 ** decimals;
+  const totalDeposited = available + borrowed;
+  const utilizationPct = totalDeposited > 0 ? borrowed / totalDeposited * 100 : 0;
+  const config = reserve.config.element;
+  if (!config) return { borrowAprPct: 0, depositAprPct: 0, utilizationPct: 0 };
+  const utils = config.interestRateUtils.map(Number);
+  const aprs = config.interestRateAprs.map((a) => Number(a) / 100);
+  const borrowAprPct = interpolateRate(utils, aprs, utilizationPct);
+  const spreadFeeBps = Number(config.spreadFeeBps);
+  const depositAprPct = utilizationPct / 100 * (borrowAprPct / 100) * (1 - spreadFeeBps / 1e4) * 100;
+  return { borrowAprPct, depositAprPct, utilizationPct };
+}
+function cTokenRatio(reserve) {
+  if (reserve.ctokenSupply === 0n) return 1;
+  const available = Number(reserve.availableAmount);
+  const borrowed = Number(reserve.borrowedAmount.value) / WAD;
+  const spreadFees = Number(reserve.unclaimedSpreadFees.value) / WAD;
+  const totalSupply = available + borrowed - spreadFees;
+  return totalSupply / Number(reserve.ctokenSupply);
+}
+var SuilendAdapter = class {
+  id = "suilend";
+  name = "Suilend";
+  version = "1.0.0";
+  capabilities = ["save", "withdraw"];
+  supportedAssets = ["USDC"];
+  supportsSameAssetBorrow = false;
+  client;
+  suilend;
+  lendingMarketType;
+  initialized = false;
+  async init(client) {
+    let sdk;
+    try {
+      sdk = await import('@suilend/sdk');
+    } catch {
+      throw new T2000Error(
+        "PROTOCOL_UNAVAILABLE",
+        "Suilend SDK not installed. Run: npm install @suilend/sdk@^1"
+      );
+    }
+    this.client = client;
+    this.lendingMarketType = sdk.LENDING_MARKET_TYPE;
+    try {
+      this.suilend = await sdk.SuilendClient.initialize(
+        sdk.LENDING_MARKET_ID,
+        sdk.LENDING_MARKET_TYPE,
+        client
+      );
+    } catch (err) {
+      throw new T2000Error(
+        "PROTOCOL_UNAVAILABLE",
+        `Failed to initialize Suilend: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    this.initialized = true;
+  }
+  ensureInit() {
+    if (!this.initialized) {
+      throw new T2000Error(
+        "PROTOCOL_UNAVAILABLE",
+        "SuilendAdapter not initialized. Call init() first."
+      );
+    }
+  }
+  findReserve(asset) {
+    const upper = asset.toUpperCase();
+    let coinType;
+    if (upper === "USDC") coinType = USDC_TYPE2;
+    else if (upper === "SUI") coinType = "0x2::sui::SUI";
+    else if (asset.includes("::")) coinType = asset;
+    else return void 0;
+    try {
+      const normalized = utils.normalizeStructTag(coinType);
+      return this.suilend.lendingMarket.reserves.find(
+        (r) => utils.normalizeStructTag(r.coinType.name) === normalized
+      );
+    } catch {
+      return void 0;
+    }
+  }
+  async getObligationCaps(address) {
+    const SuilendClientStatic = (await import('@suilend/sdk')).SuilendClient;
+    return SuilendClientStatic.getObligationOwnerCaps(
+      address,
+      [this.lendingMarketType],
+      this.client
+    );
+  }
+  resolveSymbol(coinType) {
+    const normalized = utils.normalizeStructTag(coinType);
+    if (normalized === utils.normalizeStructTag(USDC_TYPE2)) return "USDC";
+    if (normalized === utils.normalizeStructTag("0x2::sui::SUI")) return "SUI";
+    const parts = coinType.split("::");
+    return parts[parts.length - 1] || "UNKNOWN";
+  }
+  async getRates(asset) {
+    this.ensureInit();
+    const reserve = this.findReserve(asset);
+    if (!reserve) {
+      throw new T2000Error("ASSET_NOT_SUPPORTED", `Suilend does not support ${asset}`);
+    }
+    const { borrowAprPct, depositAprPct } = computeRatesFromReserve(reserve);
+    return {
+      asset,
+      saveApy: depositAprPct,
+      borrowApy: borrowAprPct
+    };
+  }
+  async getPositions(address) {
+    this.ensureInit();
+    const supplies = [];
+    const borrows = [];
+    const caps = await this.getObligationCaps(address);
+    if (caps.length === 0) return { supplies, borrows };
+    const obligation = await this.suilend.getObligation(caps[0].obligationId);
+    for (const deposit of obligation.deposits) {
+      const coinType = utils.normalizeStructTag(deposit.coinType.name);
+      const reserve = this.suilend.lendingMarket.reserves.find(
+        (r) => utils.normalizeStructTag(r.coinType.name) === coinType
+      );
+      if (!reserve) continue;
+      const ctokenAmount = Number(deposit.depositedCtokenAmount.toString());
+      const ratio = cTokenRatio(reserve);
+      const amount = ctokenAmount * ratio / 10 ** reserve.mintDecimals;
+      const { depositAprPct } = computeRatesFromReserve(reserve);
+      supplies.push({ asset: this.resolveSymbol(coinType), amount, apy: depositAprPct });
+    }
+    for (const borrow of obligation.borrows) {
+      const coinType = utils.normalizeStructTag(borrow.coinType.name);
+      const reserve = this.suilend.lendingMarket.reserves.find(
+        (r) => utils.normalizeStructTag(r.coinType.name) === coinType
+      );
+      if (!reserve) continue;
+      const rawBorrowed = Number(borrow.borrowedAmount.value.toString()) / WAD;
+      const amount = rawBorrowed / 10 ** reserve.mintDecimals;
+      const reserveRate = Number(reserve.cumulativeBorrowRate.value.toString()) / WAD;
+      const posRate = Number(borrow.cumulativeBorrowRate.value.toString()) / WAD;
+      const compounded = posRate > 0 ? amount * (reserveRate / posRate) : amount;
+      const { borrowAprPct } = computeRatesFromReserve(reserve);
+      borrows.push({ asset: this.resolveSymbol(coinType), amount: compounded, apy: borrowAprPct });
+    }
+    return { supplies, borrows };
+  }
+  async getHealth(address) {
+    this.ensureInit();
+    const caps = await this.getObligationCaps(address);
+    if (caps.length === 0) {
+      return { healthFactor: Infinity, supplied: 0, borrowed: 0, maxBorrow: 0, liquidationThreshold: 0 };
+    }
+    const positions = await this.getPositions(address);
+    const supplied = positions.supplies.reduce((s, p) => s + p.amount, 0);
+    const borrowed = positions.borrows.reduce((s, p) => s + p.amount, 0);
+    const reserve = this.findReserve("USDC");
+    const closeLtv = reserve?.config?.element?.closeLtvPct ?? 75;
+    const openLtv = reserve?.config?.element?.openLtvPct ?? 70;
+    const liqThreshold = closeLtv / 100;
+    const healthFactor = borrowed > 0 ? supplied * liqThreshold / borrowed : Infinity;
+    const maxBorrow = Math.max(0, supplied * (openLtv / 100) - borrowed);
+    return { healthFactor, supplied, borrowed, maxBorrow, liquidationThreshold: liqThreshold };
+  }
+  async buildSaveTx(address, amount, _asset, options) {
+    this.ensureInit();
+    const rawAmount = usdcToRaw(amount).toString();
+    const tx = new transactions.Transaction();
+    tx.setSender(address);
+    const caps = await this.getObligationCaps(address);
+    let capRef;
+    if (caps.length === 0) {
+      const [newCap] = this.suilend.createObligation(tx);
+      capRef = newCap;
+    } else {
+      capRef = caps[0].id;
+    }
+    const allCoins = await this.fetchAllCoins(address, USDC_TYPE2);
+    if (allCoins.length === 0) {
+      throw new T2000Error("INSUFFICIENT_BALANCE", "No USDC coins found");
+    }
+    const primaryCoinId = allCoins[0].coinObjectId;
+    if (allCoins.length > 1) {
+      tx.mergeCoins(
+        tx.object(primaryCoinId),
+        allCoins.slice(1).map((c) => tx.object(c.coinObjectId))
+      );
+    }
+    const [depositCoin] = tx.splitCoins(tx.object(primaryCoinId), [rawAmount]);
+    if (options?.collectFee) {
+      addCollectFeeToTx(tx, depositCoin, "save");
+    }
+    this.suilend.deposit(depositCoin, USDC_TYPE2, capRef, tx);
+    return { tx };
+  }
+  async buildWithdrawTx(address, amount, _asset) {
+    this.ensureInit();
+    const caps = await this.getObligationCaps(address);
+    if (caps.length === 0) {
+      throw new T2000Error("NO_COLLATERAL", "No Suilend position found");
+    }
+    const positions = await this.getPositions(address);
+    const usdcSupply = positions.supplies.find((s) => s.asset === "USDC");
+    const deposited = usdcSupply?.amount ?? 0;
+    const effectiveAmount = Math.min(amount, deposited);
+    if (effectiveAmount <= 0) {
+      throw new T2000Error("NO_COLLATERAL", "Nothing to withdraw from Suilend");
+    }
+    const rawAmount = usdcToRaw(effectiveAmount).toString();
+    const tx = new transactions.Transaction();
+    tx.setSender(address);
+    await this.suilend.withdrawAndSendToUser(
+      address,
+      caps[0].id,
+      caps[0].obligationId,
+      USDC_TYPE2,
+      rawAmount,
+      tx
+    );
+    return { tx, effectiveAmount };
+  }
+  async buildBorrowTx(_address, _amount, _asset, _options) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      "SuilendAdapter.buildBorrowTx() not available \u2014 Suilend requires different collateral/borrow assets. Deferred to Phase 10."
+    );
+  }
+  async buildRepayTx(_address, _amount, _asset) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      "SuilendAdapter.buildRepayTx() not available \u2014 deferred to Phase 10."
+    );
+  }
+  async maxWithdraw(address, _asset) {
+    this.ensureInit();
+    const health = await this.getHealth(address);
+    let maxAmount;
+    if (health.borrowed === 0) {
+      maxAmount = health.supplied;
+    } else {
+      maxAmount = Math.max(
+        0,
+        health.supplied - health.borrowed * MIN_HEALTH_FACTOR2 / health.liquidationThreshold
+      );
+    }
+    const remainingSupply = health.supplied - maxAmount;
+    const hfAfter = health.borrowed > 0 ? remainingSupply * health.liquidationThreshold / health.borrowed : Infinity;
+    return {
+      maxAmount,
+      healthFactorAfter: hfAfter,
+      currentHF: health.healthFactor
+    };
+  }
+  async maxBorrow(_address, _asset) {
+    throw new T2000Error(
+      "ASSET_NOT_SUPPORTED",
+      "SuilendAdapter.maxBorrow() not available \u2014 deferred to Phase 10."
+    );
+  }
+  async fetchAllCoins(owner, coinType) {
+    const all = [];
+    let cursor = null;
+    let hasNext = true;
+    while (hasNext) {
+      const page = await this.client.getCoins({ owner, coinType, cursor: cursor ?? void 0 });
+      all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
+      cursor = page.nextCursor;
+      hasNext = page.hasNextPage;
+    }
+    return all;
+  }
+};
 
 exports.BPS_DENOMINATOR = BPS_DENOMINATOR;
 exports.CLOCK_ID = CLOCK_ID;
+exports.CetusAdapter = CetusAdapter;
 exports.DEFAULT_NETWORK = DEFAULT_NETWORK;
 exports.MIST_PER_SUI = MIST_PER_SUI;
+exports.NaviAdapter = NaviAdapter;
+exports.ProtocolRegistry = ProtocolRegistry;
 exports.SENTINEL = SENTINEL;
 exports.SUI_DECIMALS = SUI_DECIMALS;
 exports.SUPPORTED_ASSETS = SUPPORTED_ASSETS;
+exports.SuilendAdapter = SuilendAdapter;
 exports.T2000 = T2000;
 exports.T2000Error = T2000Error;
 exports.USDC_DECIMALS = USDC_DECIMALS;