@t2000/sdk 0.17.21 → 0.17.23

package/dist/protocols/navi.js

@@ -0,0 +1,945 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { bcs } from '@mysten/sui/bcs';
+import { SUPPORTED_ASSETS, STABLE_ASSETS } from '../constants.js';
+import { T2000Error } from '../errors.js';
+import { stableToRaw } from '../utils/format.js';
+import { addCollectFeeToTx } from './protocolFee.js';
+const USDC_TYPE = SUPPORTED_ASSETS.USDC.type;
+const RATE_DECIMALS = 27;
+const LTV_DECIMALS = 27;
+const MIN_HEALTH_FACTOR = 1.5;
+function withdrawDustBuffer(decimals) {
+    return 1000 / 10 ** decimals;
+}
+const CLOCK = '0x06';
+const SUI_SYSTEM_STATE = '0x05';
+const NAVI_BALANCE_DECIMALS = 9;
+const CONFIG_API = 'https://open-api.naviprotocol.io/api/navi/config?env=prod';
+const POOLS_API = 'https://open-api.naviprotocol.io/api/navi/pools?env=prod';
+const PACKAGE_API = 'https://open-api.naviprotocol.io/api/package';
+let packageCache = null;
+function toBigInt(v) {
+    if (typeof v === 'bigint')
+        return v;
+    return BigInt(String(v));
+}
+// ---------------------------------------------------------------------------
+// BCS
+// ---------------------------------------------------------------------------
+const UserStateInfo = bcs.struct('UserStateInfo', {
+    asset_id: bcs.u8(),
+    borrow_balance: bcs.u256(),
+    supply_balance: bcs.u256(),
+});
+function decodeDevInspect(result, schema) {
+    const rv = result.results?.[0]?.returnValues?.[0];
+    if (result.error || !rv)
+        return undefined;
+    const bytes = Uint8Array.from(rv[0]);
+    return schema.parse(bytes);
+}
+// ---------------------------------------------------------------------------
+// Config + Pool cache
+// ---------------------------------------------------------------------------
+let configCache = null;
+let poolsCache = null;
+const CACHE_TTL = 5 * 60_000;
+async function fetchJson(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new T2000Error('PROTOCOL_UNAVAILABLE', `NAVI API error: ${res.status}`);
+    const json = (await res.json());
+    return (json.data ?? json);
+}
+async function getLatestPackageId() {
+    if (packageCache && Date.now() - packageCache.ts < CACHE_TTL)
+        return packageCache.id;
+    const res = await fetch(PACKAGE_API);
+    if (!res.ok)
+        throw new T2000Error('PROTOCOL_UNAVAILABLE', `NAVI package API error: ${res.status}`);
+    const json = (await res.json());
+    if (!json.packageId)
+        throw new T2000Error('PROTOCOL_UNAVAILABLE', 'NAVI package API returned no packageId');
+    packageCache = { id: json.packageId, ts: Date.now() };
+    return json.packageId;
+}
+async function getConfig(fresh = false) {
+    if (configCache && !fresh && Date.now() - configCache.ts < CACHE_TTL)
+        return configCache.data;
+    const [data, latestPkg] = await Promise.all([
+        fetchJson(CONFIG_API),
+        getLatestPackageId(),
+    ]);
+    data.package = latestPkg;
+    configCache = { data, ts: Date.now() };
+    return data;
+}
+async function getPools(fresh = false) {
+    if (poolsCache && !fresh && Date.now() - poolsCache.ts < CACHE_TTL)
+        return poolsCache.data;
+    const data = await fetchJson(POOLS_API);
+    poolsCache = { data, ts: Date.now() };
+    return data;
+}
+function matchesCoinType(poolType, targetType) {
+    const poolSuffix = poolType.split('::').slice(1).join('::').toLowerCase();
+    const targetSuffix = targetType.split('::').slice(1).join('::').toLowerCase();
+    return poolSuffix === targetSuffix;
+}
+function resolvePoolSymbol(pool) {
+    const coinType = pool.suiCoinType || pool.coinType || '';
+    for (const [key, info] of Object.entries(SUPPORTED_ASSETS)) {
+        if (matchesCoinType(coinType, info.type))
+            return key;
+    }
+    return pool.token?.symbol ?? 'UNKNOWN';
+}
+function resolveAssetInfo(asset) {
+    if (asset in SUPPORTED_ASSETS) {
+        const info = SUPPORTED_ASSETS[asset];
+        return { type: info.type, decimals: info.decimals, displayName: info.displayName };
+    }
+    throw new T2000Error('ASSET_NOT_SUPPORTED', `Unknown asset: ${asset}`);
+}
+async function getPool(asset = 'USDC') {
+    const pools = await getPools();
+    const { type: targetType, displayName } = resolveAssetInfo(asset);
+    const pool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || '', targetType));
+    if (!pool) {
+        throw new T2000Error('ASSET_NOT_SUPPORTED', `${displayName} pool not found on NAVI`);
+    }
+    return pool;
+}
+async function getUsdcPool() {
+    return getPool('USDC');
+}
+// ---------------------------------------------------------------------------
+// Oracle price update (required before withdraw/borrow)
+// ---------------------------------------------------------------------------
+function addOracleUpdate(tx, config, pool) {
+    const feed = config.oracle.feeds?.find((f) => f.assetId === pool.id);
+    if (!feed) {
+        throw new T2000Error('PROTOCOL_UNAVAILABLE', `Oracle feed not found for asset ${pool.token?.symbol ?? pool.id}`);
+    }
+    tx.moveCall({
+        target: `${config.oracle.packageId}::oracle_pro::update_single_price_v2`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.oracle.oracleConfig),
+            tx.object(config.oracle.priceOracle),
+            tx.object(config.oracle.supraOracleHolder),
+            tx.object(feed.pythPriceInfoObject),
+            tx.object(config.oracle.switchboardAggregator),
+            tx.pure.address(feed.feedId),
+        ],
+    });
+}
+/**
+ * Updates NAVI oracles for all supported assets that have active positions.
+ * Adds on-chain oracle refresh commands to the PTB so NAVI reads fresh
+ * price data maintained by keeper bots.
+ *
+ * For stablecoin-only operations, pass `assetFilter` to limit to stables.
+ * For investment assets (SUI/ETH), the full set is refreshed.
+ */
+function refreshOracles(tx, config, pools, opts) {
+    const assetsToRefresh = opts?.assetsToRefresh ?? NAVI_SUPPORTED_ASSETS;
+    const targetTypes = assetsToRefresh.map((a) => SUPPORTED_ASSETS[a].type);
+    const matchedPools = pools.filter((p) => {
+        const ct = p.suiCoinType || p.coinType || '';
+        return targetTypes.some((t) => matchesCoinType(ct, t));
+    });
+    for (const pool of matchedPools) {
+        addOracleUpdate(tx, config, pool);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function extractGasCost(effects) {
+    if (!effects?.gasUsed)
+        return 0;
+    return Math.abs((Number(effects.gasUsed.computationCost) +
+        Number(effects.gasUsed.storageCost) -
+        Number(effects.gasUsed.storageRebate)) / 1e9);
+}
+function rateToApy(rawRate) {
+    if (!rawRate || rawRate === '0')
+        return 0;
+    return Number(BigInt(rawRate)) / 10 ** RATE_DECIMALS * 100;
+}
+function poolSaveApy(pool) {
+    const incentive = parseFloat(pool.supplyIncentiveApyInfo?.apy ?? '0');
+    if (incentive > 0)
+        return incentive;
+    return rateToApy(pool.currentSupplyRate);
+}
+function poolBorrowApy(pool) {
+    const incentive = parseFloat(pool.borrowIncentiveApyInfo?.apy ?? '0');
+    if (incentive > 0)
+        return incentive;
+    return rateToApy(pool.currentBorrowRate);
+}
+function parseLtv(rawLtv) {
+    if (!rawLtv || rawLtv === '0')
+        return 0.75;
+    return Number(BigInt(rawLtv)) / 10 ** LTV_DECIMALS;
+}
+function parseLiqThreshold(val) {
+    if (typeof val === 'number')
+        return val;
+    const n = Number(val);
+    if (n > 1)
+        return Number(BigInt(val)) / 10 ** LTV_DECIMALS;
+    return n;
+}
+function normalizeHealthFactor(raw) {
+    const v = raw / 10 ** RATE_DECIMALS;
+    return v > 1e5 ? Infinity : v;
+}
+function naviStorageDecimals(poolId, tokenDecimals) {
+    // Original NAVI pools (id 0-10) normalize all balances to 9 decimals.
+    // Newer pools (id >= 11, e.g. suiETH, suiUSDT) use native token decimals.
+    if (poolId <= 10)
+        return NAVI_BALANCE_DECIMALS;
+    return tokenDecimals;
+}
+function compoundBalance(rawBalance, currentIndex, pool) {
+    if (!rawBalance || !currentIndex || currentIndex === '0')
+        return 0;
+    const scale = BigInt('1' + '0'.repeat(RATE_DECIMALS));
+    const half = scale / 2n;
+    const result = (rawBalance * BigInt(currentIndex) + half) / scale;
+    const decimals = pool ? naviStorageDecimals(pool.id, pool.token.decimals) : NAVI_BALANCE_DECIMALS;
+    return Number(result) / 10 ** decimals;
+}
+// ---------------------------------------------------------------------------
+// On-chain reads
+// ---------------------------------------------------------------------------
+async function getUserState(client, address) {
+    const config = await getConfig();
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${config.uiGetter}::getter_unchecked::get_user_state`,
+        arguments: [tx.object(config.storage), tx.pure.address(address)],
+    });
+    const result = await client.devInspectTransactionBlock({
+        transactionBlock: tx,
+        sender: address,
+    });
+    const decoded = decodeDevInspect(result, bcs.vector(UserStateInfo));
+    if (!decoded)
+        return [];
+    const mapped = decoded
+        .map((s) => ({
+        assetId: s.asset_id,
+        supplyBalance: toBigInt(s.supply_balance),
+        borrowBalance: toBigInt(s.borrow_balance),
+    }));
+    return mapped.filter((s) => s.supplyBalance !== 0n || s.borrowBalance !== 0n);
+}
+async function fetchCoins(client, owner, coinType) {
+    const all = [];
+    let cursor;
+    let hasNext = true;
+    while (hasNext) {
+        const page = await client.getCoins({ owner, coinType, cursor: cursor ?? undefined });
+        all.push(...page.data.map((c) => ({ coinObjectId: c.coinObjectId, balance: c.balance })));
+        cursor = page.nextCursor;
+        hasNext = page.hasNextPage;
+    }
+    return all;
+}
+function mergeCoins(tx, coins) {
+    if (coins.length === 0)
+        throw new T2000Error('INSUFFICIENT_BALANCE', 'No coins to merge');
+    const primary = tx.object(coins[0].coinObjectId);
+    if (coins.length > 1) {
+        tx.mergeCoins(primary, coins.slice(1).map((c) => tx.object(c.coinObjectId)));
+    }
+    return primary;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export async function buildSaveTx(client, address, amount, options = {}) {
+    if (!amount || amount <= 0 || !Number.isFinite(amount)) {
+        throw new T2000Error('INVALID_AMOUNT', 'Save amount must be a positive number');
+    }
+    const asset = options.asset ?? 'USDC';
+    const assetInfo = resolveAssetInfo(asset);
+    const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+    const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+    const coins = await fetchCoins(client, address, assetInfo.type);
+    if (coins.length === 0)
+        throw new T2000Error('INSUFFICIENT_BALANCE', `No ${assetInfo.displayName} coins found`);
+    const tx = new Transaction();
+    tx.setSender(address);
+    const coinObj = mergeCoins(tx, coins);
+    if (options.collectFee) {
+        addCollectFeeToTx(tx, coinObj, 'save');
+    }
+    tx.moveCall({
+        target: `${config.package}::incentive_v3::entry_deposit`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.storage),
+            tx.object(pool.contract.pool),
+            tx.pure.u8(pool.id),
+            coinObj,
+            tx.pure.u64(rawAmount),
+            tx.object(config.incentiveV2),
+            tx.object(config.incentiveV3),
+        ],
+        typeArguments: [pool.suiCoinType],
+    });
+    return tx;
+}
+export async function save(client, keypair, amount) {
+    const address = keypair.getPublicKey().toSuiAddress();
+    const tx = await buildSaveTx(client, address, amount);
+    const result = await client.signAndExecuteTransaction({
+        signer: keypair,
+        transaction: tx,
+        options: { showEffects: true },
+    });
+    await client.waitForTransaction({ digest: result.digest });
+    const rates = await getRates(client);
+    return {
+        success: true,
+        tx: result.digest,
+        amount,
+        apy: rates.USDC.saveApy,
+        fee: 0,
+        gasCost: extractGasCost(result.effects),
+        gasMethod: 'self-funded',
+        savingsBalance: amount,
+    };
+}
+export async function buildWithdrawTx(client, address, amount, options = {}) {
+    const asset = options.asset ?? 'USDC';
+    const assetInfo = resolveAssetInfo(asset);
+    const [config, pool, pools, states] = await Promise.all([
+        getConfig(),
+        getPool(asset),
+        getPools(),
+        getUserState(client, address),
+    ]);
+    const assetState = states.find((s) => s.assetId === pool.id);
+    const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex, pool) : 0;
+    const effectiveAmount = Math.min(amount, Math.max(0, deposited - withdrawDustBuffer(assetInfo.decimals)));
+    if (effectiveAmount <= 0)
+        throw new T2000Error('NO_COLLATERAL', `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
+    const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
+    if (rawAmount <= 0) {
+        throw new T2000Error('INVALID_AMOUNT', `Withdrawal amount rounds to zero — balance is dust`);
+    }
+    const tx = new Transaction();
+    tx.setSender(address);
+    refreshOracles(tx, config, pools);
+    const [balance] = tx.moveCall({
+        target: `${config.package}::incentive_v3::withdraw_v2`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.oracle.priceOracle),
+            tx.object(config.storage),
+            tx.object(pool.contract.pool),
+            tx.pure.u8(pool.id),
+            tx.pure.u64(rawAmount),
+            tx.object(config.incentiveV2),
+            tx.object(config.incentiveV3),
+            tx.object(SUI_SYSTEM_STATE),
+        ],
+        typeArguments: [pool.suiCoinType],
+    });
+    const [coin] = tx.moveCall({
+        target: '0x2::coin::from_balance',
+        arguments: [balance],
+        typeArguments: [pool.suiCoinType],
+    });
+    tx.transferObjects([coin], address);
+    return { tx, effectiveAmount };
+}
+/**
+ * Composable variant: adds withdraw commands to an existing PTB and
+ * returns the coin object for chaining (no transferObjects).
+ */
+export async function addWithdrawToTx(tx, client, address, amount, options = {}) {
+    const asset = options.asset ?? 'USDC';
+    const assetInfo = resolveAssetInfo(asset);
+    const [config, pool, pools, states] = await Promise.all([
+        getConfig(),
+        getPool(asset),
+        getPools(),
+        getUserState(client, address),
+    ]);
+    const assetState = states.find((s) => s.assetId === pool.id);
+    const deposited = assetState ? compoundBalance(assetState.supplyBalance, pool.currentSupplyIndex, pool) : 0;
+    const effectiveAmount = Math.min(amount, Math.max(0, deposited - withdrawDustBuffer(assetInfo.decimals)));
+    if (effectiveAmount <= 0)
+        throw new T2000Error('NO_COLLATERAL', `Nothing to withdraw for ${assetInfo.displayName} on NAVI`);
+    const rawAmount = Number(stableToRaw(effectiveAmount, assetInfo.decimals));
+    if (rawAmount <= 0) {
+        // Dust position — create a zero-value coin instead of calling on-chain withdraw
+        const [coin] = tx.moveCall({
+            target: '0x2::coin::zero',
+            typeArguments: [pool.suiCoinType],
+        });
+        return { coin, effectiveAmount: 0 };
+    }
+    refreshOracles(tx, config, pools);
+    const [balance] = tx.moveCall({
+        target: `${config.package}::incentive_v3::withdraw_v2`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.oracle.priceOracle),
+            tx.object(config.storage),
+            tx.object(pool.contract.pool),
+            tx.pure.u8(pool.id),
+            tx.pure.u64(rawAmount),
+            tx.object(config.incentiveV2),
+            tx.object(config.incentiveV3),
+            tx.object(SUI_SYSTEM_STATE),
+        ],
+        typeArguments: [pool.suiCoinType],
+    });
+    const [coin] = tx.moveCall({
+        target: '0x2::coin::from_balance',
+        arguments: [balance],
+        typeArguments: [pool.suiCoinType],
+    });
+    return { coin, effectiveAmount };
+}
+/**
+ * Composable variant: adds deposit commands to an existing PTB
+ * using a coin object from a prior step (withdraw/swap).
+ */
+export async function addSaveToTx(tx, _client, _address, coin, options = {}) {
+    const asset = options.asset ?? 'USDC';
+    const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+    if (options.collectFee) {
+        addCollectFeeToTx(tx, coin, 'save');
+    }
+    const [coinValue] = tx.moveCall({
+        target: '0x2::coin::value',
+        typeArguments: [pool.suiCoinType],
+        arguments: [coin],
+    });
+    tx.moveCall({
+        target: `${config.package}::incentive_v3::entry_deposit`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.storage),
+            tx.object(pool.contract.pool),
+            tx.pure.u8(pool.id),
+            coin,
+            coinValue,
+            tx.object(config.incentiveV2),
+            tx.object(config.incentiveV3),
+        ],
+        typeArguments: [pool.suiCoinType],
+    });
+}
+/**
+ * Composable variant: adds repay commands to an existing PTB
+ * using a coin object from a prior step (swap).
+ */
+export async function addRepayToTx(tx, _client, _address, coin, options = {}) {
+    const asset = options.asset ?? 'USDC';
+    const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+    addOracleUpdate(tx, config, pool);
+    const [coinValue] = tx.moveCall({
+        target: '0x2::coin::value',
+        typeArguments: [pool.suiCoinType],
+        arguments: [coin],
+    });
+    tx.moveCall({
+        target: `${config.package}::incentive_v3::entry_repay`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.oracle.priceOracle),
+            tx.object(config.storage),
+            tx.object(pool.contract.pool),
+            tx.pure.u8(pool.id),
+            coin,
+            coinValue,
+            tx.object(config.incentiveV2),
+            tx.object(config.incentiveV3),
+        ],
+        typeArguments: [pool.suiCoinType],
+    });
+}
+export async function withdraw(client, keypair, amount) {
+    const address = keypair.getPublicKey().toSuiAddress();
+    const { tx, effectiveAmount } = await buildWithdrawTx(client, address, amount);
+    const result = await client.signAndExecuteTransaction({
+        signer: keypair,
+        transaction: tx,
+        options: { showEffects: true },
+    });
+    await client.waitForTransaction({ digest: result.digest });
+    return {
+        success: true,
+        tx: result.digest,
+        amount: effectiveAmount,
+        gasCost: extractGasCost(result.effects),
+        gasMethod: 'self-funded',
+    };
+}
+export async function buildBorrowTx(client, address, amount, options = {}) {
+    if (!amount || amount <= 0 || !Number.isFinite(amount)) {
+        throw new T2000Error('INVALID_AMOUNT', 'Borrow amount must be a positive number');
+    }
+    const asset = options.asset ?? 'USDC';
+    const assetInfo = resolveAssetInfo(asset);
+    const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+    const [config, pool, pools] = await Promise.all([
+        getConfig(), getPool(asset), getPools(),
+    ]);
+    const tx = new Transaction();
+    tx.setSender(address);
+    refreshOracles(tx, config, pools);
+    const [balance] = tx.moveCall({
+        target: `${config.package}::incentive_v3::borrow_v2`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.oracle.priceOracle),
+            tx.object(config.storage),
+            tx.object(pool.contract.pool),
+            tx.pure.u8(pool.id),
+            tx.pure.u64(rawAmount),
+            tx.object(config.incentiveV2),
+            tx.object(config.incentiveV3),
+            tx.object(SUI_SYSTEM_STATE),
+        ],
+        typeArguments: [pool.suiCoinType],
+    });
+    const [borrowedCoin] = tx.moveCall({
+        target: '0x2::coin::from_balance',
+        arguments: [balance],
+        typeArguments: [pool.suiCoinType],
+    });
+    if (options.collectFee) {
+        addCollectFeeToTx(tx, borrowedCoin, 'borrow');
+    }
+    tx.transferObjects([borrowedCoin], address);
+    return tx;
+}
+export async function borrow(client, keypair, amount) {
+    const address = keypair.getPublicKey().toSuiAddress();
+    const tx = await buildBorrowTx(client, address, amount);
+    const result = await client.signAndExecuteTransaction({
+        signer: keypair,
+        transaction: tx,
+        options: { showEffects: true },
+    });
+    await client.waitForTransaction({ digest: result.digest });
+    const hfResult = await getHealthFactor(client, address);
+    return {
+        success: true,
+        tx: result.digest,
+        amount,
+        fee: 0,
+        healthFactor: hfResult.healthFactor,
+        gasCost: extractGasCost(result.effects),
+        gasMethod: 'self-funded',
+    };
+}
+export async function buildRepayTx(client, address, amount, options = {}) {
+    if (!amount || amount <= 0 || !Number.isFinite(amount)) {
+        throw new T2000Error('INVALID_AMOUNT', 'Repay amount must be a positive number');
+    }
+    const asset = options.asset ?? 'USDC';
+    const assetInfo = resolveAssetInfo(asset);
+    const rawAmount = Number(stableToRaw(amount, assetInfo.decimals));
+    const [config, pool] = await Promise.all([getConfig(), getPool(asset)]);
+    const coins = await fetchCoins(client, address, assetInfo.type);
+    if (coins.length === 0)
+        throw new T2000Error('INSUFFICIENT_BALANCE', `No ${assetInfo.displayName} coins to repay with`);
+    const tx = new Transaction();
+    tx.setSender(address);
+    addOracleUpdate(tx, config, pool);
+    const coinObj = mergeCoins(tx, coins);
+    tx.moveCall({
+        target: `${config.package}::incentive_v3::entry_repay`,
+        arguments: [
+            tx.object(CLOCK),
+            tx.object(config.oracle.priceOracle),
+            tx.object(config.storage),
+            tx.object(pool.contract.pool),
+            tx.pure.u8(pool.id),
+            coinObj,
+            tx.pure.u64(rawAmount),
+            tx.object(config.incentiveV2),
+            tx.object(config.incentiveV3),
+        ],
+        typeArguments: [pool.suiCoinType],
+    });
+    return tx;
+}
+export async function repay(client, keypair, amount) {
+    const address = keypair.getPublicKey().toSuiAddress();
+    const tx = await buildRepayTx(client, address, amount);
+    const result = await client.signAndExecuteTransaction({
+        signer: keypair,
+        transaction: tx,
+        options: { showEffects: true },
+    });
+    await client.waitForTransaction({ digest: result.digest });
+    const states = await getUserState(client, address);
+    const pools = await getPools();
+    let remainingDebt = 0;
+    for (const state of states) {
+        const pool = pools.find((p) => p.id === state.assetId);
+        if (!pool)
+            continue;
+        remainingDebt += compoundBalance(state.borrowBalance, pool.currentBorrowIndex, pool);
+    }
+    return {
+        success: true,
+        tx: result.digest,
+        amount,
+        remainingDebt,
+        gasCost: extractGasCost(result.effects),
+        gasMethod: 'self-funded',
+    };
+}
+export async function getHealthFactor(client, addressOrKeypair) {
+    const address = typeof addressOrKeypair === 'string'
+        ? addressOrKeypair
+        : addressOrKeypair.getPublicKey().toSuiAddress();
+    const [config, pools, states] = await Promise.all([
+        getConfig(),
+        getPools(),
+        getUserState(client, address),
+    ]);
+    let supplied = 0;
+    let borrowed = 0;
+    let weightedLtv = 0;
+    let weightedLiqThreshold = 0;
+    for (const state of states) {
+        const pool = pools.find((p) => p.id === state.assetId);
+        if (!pool)
+            continue;
+        const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex, pool);
+        const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex, pool);
+        const price = pool.token?.price ?? 1;
+        supplied += supplyBal * price;
+        borrowed += borrowBal * price;
+        if (supplyBal > 0) {
+            weightedLtv += supplyBal * price * parseLtv(pool.ltv);
+            weightedLiqThreshold += supplyBal * price * parseLiqThreshold(pool.liquidationFactor.threshold);
+        }
+    }
+    const ltv = supplied > 0 ? weightedLtv / supplied : 0.75;
+    const liqThreshold = supplied > 0 ? weightedLiqThreshold / supplied : 0.75;
+    const maxBorrowVal = Math.max(0, supplied * ltv - borrowed);
+    const usdcPool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || '', SUPPORTED_ASSETS.USDC.type));
+    let healthFactor;
+    if (borrowed <= 0) {
+        healthFactor = Infinity;
+    }
+    else if (usdcPool) {
+        try {
+            const tx = new Transaction();
+            tx.moveCall({
+                target: `${config.uiGetter}::calculator_unchecked::dynamic_health_factor`,
+                arguments: [
+                    tx.object(CLOCK),
+                    tx.object(config.storage),
+                    tx.object(config.oracle.priceOracle),
+                    tx.pure.u8(usdcPool.id),
+                    tx.pure.address(address),
+                    tx.pure.u8(usdcPool.id),
+                    tx.pure.u64(0),
+                    tx.pure.u64(0),
+                    tx.pure.bool(false),
+                ],
+                typeArguments: [usdcPool.suiCoinType],
+            });
+            const result = await client.devInspectTransactionBlock({
+                transactionBlock: tx,
+                sender: address,
+            });
+            const decoded = decodeDevInspect(result, bcs.u256());
+            if (decoded !== undefined) {
+                healthFactor = normalizeHealthFactor(Number(decoded));
+            }
+            else {
+                healthFactor = (supplied * liqThreshold) / borrowed;
+            }
+        }
+        catch {
+            healthFactor = (supplied * liqThreshold) / borrowed;
+        }
+    }
+    else {
+        healthFactor = (supplied * liqThreshold) / borrowed;
+    }
+    return {
+        healthFactor,
+        supplied,
+        borrowed,
+        maxBorrow: maxBorrowVal,
+        liquidationThreshold: liqThreshold,
+    };
+}
+const NAVI_SUPPORTED_ASSETS = [...STABLE_ASSETS, 'SUI', 'ETH', 'GOLD'];
+export async function getRates(client) {
+    try {
+        const pools = await getPools();
+        const result = {};
+        for (const asset of NAVI_SUPPORTED_ASSETS) {
+            const targetType = SUPPORTED_ASSETS[asset].type;
+            const pool = pools.find((p) => matchesCoinType(p.suiCoinType || p.coinType || '', targetType));
+            if (!pool)
+                continue;
+            let saveApy = poolSaveApy(pool);
+            let borrowApy = poolBorrowApy(pool);
+            if (saveApy <= 0 || saveApy > 200)
+                saveApy = 0;
+            if (borrowApy <= 0 || borrowApy > 200)
+                borrowApy = 0;
+            result[asset] = { saveApy, borrowApy };
+        }
+        if (!result.USDC)
+            result.USDC = { saveApy: 4.0, borrowApy: 6.0 };
+        return result;
+    }
+    catch {
+        return { USDC: { saveApy: 4.0, borrowApy: 6.0 } };
+    }
+}
+export async function getPositions(client, addressOrKeypair) {
+    const address = typeof addressOrKeypair === 'string'
+        ? addressOrKeypair
+        : addressOrKeypair.getPublicKey().toSuiAddress();
+    const [states, pools] = await Promise.all([getUserState(client, address), getPools()]);
+    const positions = [];
+    for (const state of states) {
+        const pool = pools.find((p) => p.id === state.assetId);
+        if (!pool)
+            continue;
+        const symbol = resolvePoolSymbol(pool);
+        const supplyBal = compoundBalance(state.supplyBalance, pool.currentSupplyIndex, pool);
+        const borrowBal = compoundBalance(state.borrowBalance, pool.currentBorrowIndex, pool);
+        if (supplyBal > 0.0001) {
+            positions.push({
+                protocol: 'navi',
+                asset: symbol,
+                type: 'save',
+                amount: supplyBal,
+                apy: poolSaveApy(pool),
+            });
+        }
+        if (borrowBal > 0.0001) {
+            positions.push({
+                protocol: 'navi',
+                asset: symbol,
+                type: 'borrow',
+                amount: borrowBal,
+                apy: poolBorrowApy(pool),
+            });
+        }
+    }
+    return { positions };
+}
+export 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) {
+        maxAmount = hf.supplied;
+    }
+    else {
+        maxAmount = Math.max(0, hf.supplied - (hf.borrowed * MIN_HEALTH_FACTOR / ltv));
+    }
+    const remainingSupply = hf.supplied - maxAmount;
+    const hfAfter = hf.borrowed > 0 ? (remainingSupply * ltv) / hf.borrowed : Infinity;
+    return { maxAmount, healthFactorAfter: hfAfter, currentHF: hf.healthFactor };
+}
+export 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 { maxAmount, healthFactorAfter: MIN_HEALTH_FACTOR, currentHF: hf.healthFactor };
+}
+// ---------------------------------------------------------------------------
+// Claim Rewards
+// ---------------------------------------------------------------------------
+const CERT_TYPE = '0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::cert::CERT';
+const DEEP_TYPE = '0xdeeb7a4662eec9f2f3def03fb937a663dddaa2e215b8078a284d026b7946c270::deep::DEEP';
+const REWARD_FUNDS = {
+    [CERT_TYPE]: '0x7093cf7549d5e5b35bfde2177223d1050f71655c7f676a5e610ee70eb4d93b5c',
+    [DEEP_TYPE]: '0xc889d78b634f954979e80e622a2ae0fece824c0f6d9590044378a2563035f32f',
+};
+const REWARD_SYMBOLS = {
+    [CERT_TYPE]: 'vSUI',
+    [DEEP_TYPE]: 'DEEP',
+};
+const REWARD_DECIMALS = {
+    [CERT_TYPE]: 9,
+    [DEEP_TYPE]: 6,
+};
+let incentiveRulesCache = null;
+async function getIncentiveRules(client) {
+    if (incentiveRulesCache && Date.now() - incentiveRulesCache.ts < CACHE_TTL) {
+        return incentiveRulesCache.data;
+    }
+    const [pools, obj] = await Promise.all([
+        getPools(),
+        client.getObject({
+            id: '0x62982dad27fb10bb314b3384d5de8d2ac2d72ab2dbeae5d801dbdb9efa816c80',
+            options: { showContent: true },
+        }),
+    ]);
+    const rewardCoinMap = new Map();
+    for (const pool of pools) {
+        const ct = (pool.suiCoinType || pool.coinType || '').toLowerCase();
+        const suffix = ct.split('::').slice(1).join('::');
+        const coins = pool.supplyIncentiveApyInfo?.rewardCoin;
+        if (Array.isArray(coins) && coins.length > 0) {
+            rewardCoinMap.set(suffix, coins[0]);
+        }
+    }
+    const result = new Map();
+    if (obj.data?.content?.dataType !== 'moveObject') {
+        incentiveRulesCache = { data: result, ts: Date.now() };
+        return result;
+    }
+    const fields = obj.data.content.fields;
+    const poolsObj = fields.pools;
+    const entries = poolsObj?.fields?.contents;
+    if (!Array.isArray(entries)) {
+        incentiveRulesCache = { data: result, ts: Date.now() };
+        return result;
+    }
+    for (const entry of entries) {
+        const ef = entry?.fields;
+        if (!ef)
+            continue;
+        const key = String(ef.key ?? '');
+        const value = ef.value;
+        const rules = value?.fields?.rules;
+        const ruleEntries = rules?.fields?.contents;
+        if (!Array.isArray(ruleEntries))
+            continue;
+        const ruleIds = ruleEntries.map((re) => {
+            const rf = re?.fields;
+            return String(rf?.key ?? '');
+        }).filter(Boolean);
+        const suffix = key.split('::').slice(1).join('::').toLowerCase();
+        const full = key.toLowerCase();
+        const rewardCoin = rewardCoinMap.get(suffix) ?? rewardCoinMap.get(full) ?? null;
+        result.set(key, { ruleIds, rewardCoinType: rewardCoin });
+    }
+    incentiveRulesCache = { data: result, ts: Date.now() };
+    return result;
+}
+function stripPrefix(coinType) {
+    return coinType.replace(/^0x0*/, '');
+}
+export async function getPendingRewards(client, address) {
+    const [pools, states] = await Promise.all([
+        getPools(),
+        getUserState(client, address),
+    ]);
+    const rewards = [];
+    const deposited = states.filter((s) => s.supplyBalance > 0n);
+    if (deposited.length === 0)
+        return rewards;
+    for (const state of deposited) {
+        const pool = pools.find((p) => p.id === state.assetId);
+        if (!pool)
+            continue;
+        const boostedApr = parseFloat(pool.supplyIncentiveApyInfo?.boostedApr ?? '0');
+        if (boostedApr <= 0)
+            continue;
+        const rewardCoins = pool.supplyIncentiveApyInfo?.rewardCoin;
+        if (!Array.isArray(rewardCoins) || rewardCoins.length === 0)
+            continue;
+        const rewardType = rewardCoins[0];
+        const assetSymbol = resolvePoolSymbol(pool);
+        rewards.push({
+            protocol: 'navi',
+            asset: assetSymbol,
+            coinType: rewardType,
+            symbol: REWARD_SYMBOLS[rewardType] ?? rewardType.split('::').pop() ?? 'UNKNOWN',
+            amount: 0,
+            estimatedValueUsd: 0,
+        });
+    }
+    return rewards;
+}
+export async function addClaimRewardsToTx(tx, client, address) {
+    const [config, pools, states, rules] = await Promise.all([
+        getConfig(),
+        getPools(),
+        getUserState(client, address),
+        getIncentiveRules(client),
+    ]);
+    const deposited = states.filter((s) => s.supplyBalance > 0n);
+    if (deposited.length === 0)
+        return [];
+    const claimGroups = new Map();
+    for (const state of deposited) {
+        const pool = pools.find((p) => p.id === state.assetId);
+        if (!pool)
+            continue;
+        const boostedApr = parseFloat(pool.supplyIncentiveApyInfo?.boostedApr ?? '0');
+        if (boostedApr <= 0)
+            continue;
+        const rewardCoins = pool.supplyIncentiveApyInfo?.rewardCoin;
+        if (!Array.isArray(rewardCoins) || rewardCoins.length === 0)
+            continue;
+        const rewardType = rewardCoins[0];
+        const fundId = REWARD_FUNDS[rewardType];
+        if (!fundId)
+            continue;
+        const coinType = pool.suiCoinType || pool.coinType || '';
+        const strippedType = stripPrefix(coinType);
+        const ruleData = Array.from(rules.entries()).find(([key]) => stripPrefix(key) === strippedType ||
+            key.split('::').slice(1).join('::').toLowerCase() ===
+                coinType.split('::').slice(1).join('::').toLowerCase());
+        if (!ruleData || ruleData[1].ruleIds.length === 0)
+            continue;
+        const group = claimGroups.get(rewardType) ?? { assets: [], ruleIds: [] };
+        for (const ruleId of ruleData[1].ruleIds) {
+            group.assets.push(strippedType);
+            group.ruleIds.push(ruleId);
+        }
+        claimGroups.set(rewardType, group);
+    }
+    const claimed = [];
+    for (const [rewardType, { assets, ruleIds }] of claimGroups) {
+        const fundId = REWARD_FUNDS[rewardType];
+        const [balance] = tx.moveCall({
+            target: `${config.package}::incentive_v3::claim_reward`,
+            typeArguments: [rewardType],
+            arguments: [
+                tx.object(CLOCK),
+                tx.object(config.incentiveV3),
+                tx.object(config.storage),
+                tx.object(fundId),
+                tx.pure(bcs.vector(bcs.string()).serialize(assets)),
+                tx.pure(bcs.vector(bcs.Address).serialize(ruleIds)),
+            ],
+        });
+        const [coin] = tx.moveCall({
+            target: '0x2::coin::from_balance',
+            typeArguments: [rewardType],
+            arguments: [balance],
+        });
+        tx.transferObjects([coin], address);
+        claimed.push({
+            protocol: 'navi',
+            asset: assets.join(', '),
+            coinType: rewardType,
+            symbol: REWARD_SYMBOLS[rewardType] ?? 'UNKNOWN',
+            amount: 0,
+            estimatedValueUsd: 0,
+        });
+    }
+    return claimed;
+}
+//# sourceMappingURL=navi.js.map