@kestrelfi/lyc-sdk 1.0.1

package/dist/sdks/long-yield-carry/src/metrics/protocolMetrics.js

@@ -0,0 +1,547 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_MANIFEST_PK = exports.MIN_MATERIAL_KAMINO_COLLATERAL_USD = void 0;
+exports.protocolMetricPartitionKey = protocolMetricPartitionKey;
+exports.buildProtocolManifestSnapshot = buildProtocolManifestSnapshot;
+exports.flattenProtocolMetricsSnapshot = flattenProtocolMetricsSnapshot;
+exports.toProtocolMetricDynamoItem = toProtocolMetricDynamoItem;
+exports.buildProtocolMetricDynamoItems = buildProtocolMetricDynamoItems;
+exports.buildProtocolMetricsSnapshot = buildProtocolMetricsSnapshot;
+exports.buildFeeWalletBalanceSnapshots = buildFeeWalletBalanceSnapshots;
+exports.buildTokenMetricSnapshot = buildTokenMetricSnapshot;
+exports.buildYieldingBankMetricSnapshot = buildYieldingBankMetricSnapshot;
+exports.buildTokenLendingPositionMetricSnapshots = buildTokenLendingPositionMetricSnapshots;
+exports.buildTokenLendingPositionMetricSnapshotsAsync = buildTokenLendingPositionMetricSnapshotsAsync;
+exports.serializeLendingPositionInspectMetrics = serializeLendingPositionInspectMetrics;
+exports.kaminoCollateralUsd = kaminoCollateralUsd;
+exports.shouldIncludeKaminoPositionRate = shouldIncludeKaminoPositionRate;
+exports.buildTokenCarryPositionMetricSnapshots = buildTokenCarryPositionMetricSnapshots;
+exports.buildYieldingBankAssetMetricSnapshots = buildYieldingBankAssetMetricSnapshots;
+exports.buildKaminoPositionRateSnapshotFromReserves = buildKaminoPositionRateSnapshotFromReserves;
+const web3_js_1 = require("@solana/web3.js");
+const token_1 = require("@solana-program/token");
+const token_2022_1 = require("@solana-program/token-2022");
+const common_1 = require("common");
+const general_1 = require("../constants/general");
+const feeDripMetrics_1 = require("../utils/feeDripMetrics");
+const general_2 = require("../utils/general");
+const tokenFeeMath_1 = require("../utils/tokenFeeMath");
+/** Skip dust Kamino slots when a material position exists on the same token. */
+exports.MIN_MATERIAL_KAMINO_COLLATERAL_USD = 1;
+exports.PROTOCOL_MANIFEST_PK = "protocol_manifest";
+function protocolMetricPartitionKey(metric) {
+    switch (metric.entityType) {
+        case "token":
+            return `token#${metric.mint}`;
+        case "yielding_bank":
+            return `yielding_bank#${metric.bank}`;
+        case "yielding_bank_asset":
+            return `yielding_bank_asset#${metric.bank}#${metric.mint}`;
+        case "kamino_position_rate":
+            return `kamino_position#${metric.mint}#${metric.lendingPositionIndex}`;
+        case "token_lending_position":
+            return `token_lending_position#${metric.mint}#${metric.lendingPositionIndex}`;
+        case "token_carry_position":
+            return `token_carry_position#${metric.mint}#${metric.carryPositionIndex}`;
+        case "fee_wallet_balance":
+            return `fee_wallet#${metric.wallet}#${metric.mint}`;
+        case "protocol_manifest":
+            return exports.PROTOCOL_MANIFEST_PK;
+    }
+}
+function buildProtocolManifestSnapshot(snapshot) {
+    return {
+        entityType: "protocol_manifest",
+        tokenMints: snapshot.tokens.map((token) => token.mint),
+        bankAddresses: snapshot.yieldingBanks.map((bank) => bank.bank),
+        kaminoPositions: snapshot.kaminoPositionRates.map((rate) => ({
+            mint: rate.mint,
+            lendingPositionIndex: rate.lendingPositionIndex,
+        })),
+        yieldingBankAssets: snapshot.yieldingBankAssets.map((asset) => ({
+            bank: asset.bank,
+            mint: asset.mint,
+        })),
+        tokenLendingPositions: snapshot.tokenLendingPositions.map((position) => ({
+            mint: position.mint,
+            lendingPositionIndex: position.lendingPositionIndex,
+        })),
+        tokenCarryPositions: snapshot.tokenCarryPositions.map((position) => ({
+            mint: position.mint,
+            carryPositionIndex: position.carryPositionIndex,
+        })),
+        feeWalletBalances: snapshot.feeWalletBalances.map((balance) => ({
+            wallet: balance.wallet,
+            mint: balance.mint,
+        })),
+        errors: snapshot.errors,
+    };
+}
+function flattenProtocolMetricsSnapshot(snapshot) {
+    return [
+        ...snapshot.tokens,
+        ...snapshot.yieldingBanks,
+        ...snapshot.yieldingBankAssets,
+        ...snapshot.kaminoPositionRates,
+        ...snapshot.tokenLendingPositions,
+        ...snapshot.tokenCarryPositions,
+        ...snapshot.feeWalletBalances,
+        buildProtocolManifestSnapshot(snapshot),
+    ];
+}
+function toProtocolMetricDynamoItem(metric, hourTimestamp, ttl) {
+    return {
+        pk: protocolMetricPartitionKey(metric),
+        timestamp: hourTimestamp,
+        entityType: metric.entityType,
+        metrics: metric,
+        ttl,
+    };
+}
+/** Builds on-chain snapshot rows and maps them to Dynamo put payloads. */
+async function buildProtocolMetricDynamoItems(client, opts) {
+    const snapshot = await buildProtocolMetricsSnapshot(client, {
+        ...opts,
+        timestamp: opts.hourTimestamp,
+    });
+    const items = flattenProtocolMetricsSnapshot(snapshot).map((row) => toProtocolMetricDynamoItem(row, opts.hourTimestamp, opts.ttl));
+    return { items, errors: snapshot.errors };
+}
+async function buildProtocolMetricsSnapshot(client, opts = {}) {
+    const timestamp = opts.timestamp ?? Math.floor(Date.now() / 1000);
+    const { tokens, yieldingBanks } = opts.tokens && opts.yieldingBanks
+        ? { tokens: opts.tokens, yieldingBanks: opts.yieldingBanks }
+        : await client.account.fetchAllTokensAndYieldingBanks();
+    const filteredTokens = opts.includeInactive ? tokens : tokens.filter((token) => token.isActive);
+    const filteredBanks = opts.includeInactive
+        ? yieldingBanks
+        : yieldingBanks.filter((bank) => bank.isActive);
+    const tokenSnapshots = filteredTokens.map((token) => buildTokenMetricSnapshot(token, filteredBanks, timestamp));
+    const bankSnapshots = filteredBanks.map(buildYieldingBankMetricSnapshot);
+    const assetSnapshots = filteredBanks.flatMap(buildYieldingBankAssetMetricSnapshots);
+    const lendingPositionResults = await Promise.all(filteredTokens.map((token) => buildTokenLendingPositionMetricSnapshotsAsync(client, token, filteredBanks)));
+    const lendingPositionSnapshots = lendingPositionResults.flatMap((result) => result.snapshots);
+    // Kamino rate rows use `usedLendingPositions` (collateral > 0) while lending position
+    // snapshots use `activeLendingPositions` (all configured slots). Zero-collateral slots
+    // can still appear in lending rows; Kamino rate rows and stale-slot alerts handle that.
+    const { rates, errors } = await buildKaminoPositionRateSnapshots(client, filteredTokens);
+    const carryPositionSnapshots = filteredTokens.flatMap((token) => buildTokenCarryPositionMetricSnapshots(token, filteredBanks));
+    const feeWalletBalances = await buildFeeWalletBalanceSnapshots(client, filteredTokens);
+    return {
+        timestamp,
+        tokens: tokenSnapshots,
+        yieldingBanks: bankSnapshots,
+        yieldingBankAssets: assetSnapshots,
+        kaminoPositionRates: rates,
+        tokenLendingPositions: lendingPositionSnapshots,
+        tokenCarryPositions: carryPositionSnapshots,
+        feeWalletBalances,
+        errors: [...errors, ...lendingPositionResults.flatMap((result) => result.errors)],
+    };
+}
+function resolveFeeWalletTokenProgram(tp) {
+    if (tp == null) {
+        return token_1.TOKEN_PROGRAM_ADDRESS;
+    }
+    return (0, common_1.resolveTokenProgram)(tp);
+}
+/** Read an SPL or Token-2022 ATA balance using the mint's token program. */
+async function fetchFeeWalletTokenAmountRaw(rpc, ata, tokenProgram) {
+    const account = tokenProgram === token_2022_1.TOKEN_2022_PROGRAM_ADDRESS
+        ? await (0, token_2022_1.fetchMaybeToken)(rpc, ata)
+        : await (0, token_1.fetchMaybeToken)(rpc, ata);
+    return account.exists ? account.data.amount : 0n;
+}
+async function buildFeeWalletBalanceSnapshots(client, tokens) {
+    const wallet = general_1.PROTOCOL_FEE_WALLET[client.environment];
+    const targets = new Map();
+    for (const token of tokens) {
+        const collateralPriceUsd = (0, common_1.toUiAmount)(token.data.collateral.price, token.data.collateral.decimals);
+        const collateralTokenProgram = resolveFeeWalletTokenProgram(token.data.collateral.tokenProgram);
+        if (!targets.has(token.collateralMint)) {
+            targets.set(token.collateralMint, {
+                kind: "collateral",
+                symbol: (0, common_1.mintSymbol)(token.collateralMint),
+                decimals: token.data.collateral.decimals,
+                priceUsd: collateralPriceUsd,
+                tokenProgram: collateralTokenProgram,
+            });
+        }
+        targets.set(token.mint, {
+            kind: "ytoken",
+            symbol: `y${(0, common_1.mintSymbol)(token.collateralMint)}`,
+            decimals: token.decimals,
+            priceUsd: token.price * collateralPriceUsd,
+            tokenProgram: resolveFeeWalletTokenProgram(token.data.config.tokenProgram),
+        });
+    }
+    const snapshots = await Promise.all([...targets.entries()].map(async ([mint, target]) => {
+        try {
+            const ata = await (0, common_1.getAtaAddress)(mint, wallet, target.tokenProgram);
+            const amountRaw = await fetchFeeWalletTokenAmountRaw(client.rpc, ata, target.tokenProgram);
+            const amountUi = (0, common_1.toUiAmount)(amountRaw, target.decimals);
+            return {
+                entityType: "fee_wallet_balance",
+                wallet,
+                mint,
+                symbol: target.symbol,
+                kind: target.kind,
+                decimals: target.decimals,
+                amountRaw: amountRaw.toString(),
+                amountUi,
+                priceUsd: target.priceUsd,
+                valueUsd: amountUi * target.priceUsd,
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return snapshots.filter((row) => row !== null);
+}
+function buildTokenMetricSnapshot(token, yieldingBanks = [], nowTs = Math.floor(Date.now() / 1000)) {
+    const carryTvlUsdRaw = token.data.debtCarry
+        .filter((carry) => !carry.yieldingBaseMint.equals(web3_js_1.PublicKey.default) && (0, common_1.toBigInt)(carry.shares) > BigInt(0))
+        .reduce((sum, carry) => sum + (0, common_1.toBigInt)(carry.tvlUsd), 0n);
+    const debtUsdRaw = token.activeLendingPositions.reduce((sum, { data }) => sum + (0, common_1.toBigInt)(data.accounting.debt.tvlUsd), 0n);
+    const netYieldUsdRaw = (0, tokenFeeMath_1.collectableNetYieldUsd)(carryTvlUsdRaw, debtUsdRaw);
+    const collateralPriceUsd = (0, common_1.toUiAmount)(token.data.collateral.price, token.data.collateral.decimals);
+    const feeDripMetrics = (0, feeDripMetrics_1.calculateFeeDripMetrics)({
+        currentPriceRaw: (0, common_1.toBigInt)(token.data.accounting.price),
+        apyReferencePriceRaw: (0, common_1.toBigInt)(token.data.feeDrip.apyReferencePrice),
+        apyReferenceTs: (0, common_1.toBigInt)(token.data.feeDrip.apyReferenceTs),
+        currentPriceTs: BigInt(token.data.accounting.lastRefreshedTs.toNumber()),
+        totalSupplyRaw: (0, common_1.toBigInt)(token.data.accounting.totalSupply),
+        tokenDecimals: token.decimals,
+        undrippedFeeCollateralRaw: (0, common_1.toBigInt)(token.data.feeDrip.undrippedFeeCollateral),
+        feeDripMaxApyBps: token.data.fees.feeDripMaxApyBps,
+        feeDripDurationSecs: (0, common_1.toBigInt)(token.data.fees.feeDripDurationSecs),
+        dripEndTs: (0, common_1.toBigInt)(token.data.feeDrip.dripEndTs),
+        nowTs: BigInt(nowTs),
+    });
+    return {
+        entityType: "token",
+        token: token.address,
+        mint: token.mint,
+        collateralMint: token.collateralMint,
+        isActive: token.isActive,
+        priceCollateral: token.price,
+        collateralPriceUsd,
+        priceUsd: token.price * collateralPriceUsd,
+        totalSupply: token.totalSupply,
+        tvlUsdRaw: (0, common_1.toBigInt)(token.data.accounting.tvlUsd).toString(),
+        tvlUsd: (0, common_1.toUiAmount)(token.data.accounting.tvlUsd, common_1.TVL_USD_DECIMAL_PLACES),
+        carryTvlUsdRaw: carryTvlUsdRaw.toString(),
+        carryTvlUsd: (0, common_1.toUiAmount)(carryTvlUsdRaw, common_1.TVL_USD_DECIMAL_PLACES),
+        debtUsdRaw: debtUsdRaw.toString(),
+        debtUsd: (0, common_1.toUiAmount)(debtUsdRaw, common_1.TVL_USD_DECIMAL_PLACES),
+        netYieldUsdRaw: netYieldUsdRaw.toString(),
+        netYieldUsd: (0, common_1.toUiAmount)(netYieldUsdRaw, common_1.TVL_USD_DECIMAL_PLACES),
+        pendingProtocolFeesRaw: (0, common_1.toBigInt)(token.data.accounting.pendingProtocolFees).toString(),
+        pendingProtocolFeesUi: (0, common_1.toUiAmount)(token.data.accounting.pendingProtocolFees, token.decimals),
+        pendingCuratorFeesRaw: (0, common_1.toBigInt)(token.data.accounting.pendingCuratorFees).toString(),
+        pendingCuratorFeesUi: (0, common_1.toUiAmount)(token.data.accounting.pendingCuratorFees, token.decimals),
+        performanceFeeBps: token.data.fees.performanceFeeBps,
+        mintingFeeBps: token.data.fees.mintingFeeBps,
+        burningFeeBps: token.data.fees.burningFeeBps,
+        protocolMintBurnPctBps: token.data.fees.protocolMintBurnPctBps,
+        curatorMintBurnPctBps: token.data.fees.curatorMintBurnPctBps,
+        curatorPerfPctBps: token.data.fees.curatorPerfPctBps,
+        feeDripMaxApyBps: token.data.fees.feeDripMaxApyBps,
+        feeDripCurrentApyBps: feeDripMetrics.currentApyBps,
+        undrippedFeeCollateralUi: (0, common_1.toUiAmount)(token.data.feeDrip.undrippedFeeCollateral, token.data.collateral.decimals),
+        feeDripAbsorptionEtaSeconds: feeDripMetrics.absorptionEtaSeconds,
+        feeDripAbsorptionStatus: feeDripMetrics.absorptionStatus,
+        firstMintTs: token.data.accounting.firstMintTs.toNumber(),
+        collateralOracle: (0, common_1.fromWeb3Pk)(token.data.collateral.oracle),
+        collateralLastRefreshedTs: token.data.collateral.lastRefreshedTs.toNumber(),
+        unlentCollateralUi: (0, common_1.toUiAmount)(token.data.collateral.unlentAmount, token.data.collateral.decimals),
+        lastRefreshedTs: token.data.accounting.lastRefreshedTs.toNumber(),
+    };
+}
+function buildYieldingBankMetricSnapshot(bank) {
+    const defaultRedemptionMint = bank.defaultRedemptionMint !== web3_js_1.PublicKey.default.toBase58()
+        ? bank.defaultRedemptionMint
+        : undefined;
+    const externalYieldingPositions = bank.externalYieldingPositions
+        .map((position) => ({
+        platform: (0, common_1.lendingPlatformToEnum)(position.lendingPlatform),
+        pool: (0, common_1.fromWeb3Pk)(position.pool),
+        tvlRaw: (0, common_1.toBigInt)(position.tvl),
+        tvlUsd: (0, common_1.toUiAmount)(position.tvl, common_1.TVL_USD_DECIMAL_PLACES),
+    }))
+        .filter((position) => position.platform !== common_1.LendingPlatform.None)
+        .map((position) => ({
+        platform: position.platform,
+        pool: position.pool,
+        tvlUsdRaw: position.tvlRaw.toString(),
+        tvlUsd: position.tvlUsd,
+    }));
+    return {
+        entityType: "yielding_bank",
+        bank: bank.address,
+        id: bank.id,
+        baseMint: bank.baseMint,
+        baseSymbol: (0, common_1.mintSymbol)(bank.baseMint),
+        curator: (0, common_1.fromWeb3Pk)(bank.data.roles.curator),
+        isActive: bank.isActive,
+        circuitBreaker: bank.circuitBreaker,
+        defaultRedemptionMint,
+        externalYieldingPositions,
+        sharePriceRaw: (0, common_1.toBigInt)(bank.data.accounting.sharePrice).toString(),
+        sharePriceUsd: bank.sharePrice,
+        totalSharesRaw: (0, common_1.toBigInt)(bank.data.accounting.totalShares).toString(),
+        totalShares: bank.totalShares,
+        tvlUsdRaw: (0, common_1.toBigInt)(bank.data.accounting.tvl).toString(),
+        tvlUsd: (0, common_1.toUiAmount)(bank.data.accounting.tvl, common_1.TVL_USD_DECIMAL_PLACES),
+        lastRefreshedTs: bank.data.accounting.lastRefreshedTs.toNumber(),
+        lastRebalancedTs: bank.data.accounting.lastRebalancedTs.toNumber(),
+    };
+}
+function buildTokenLendingPositionMetricSnapshots(token, yieldingBanks = []) {
+    const collateralSymbol = (0, common_1.mintSymbol)(token.collateralMint);
+    const collateralDecimals = token.data.collateral.decimals;
+    const collateralPriceUsd = (0, common_1.toUiAmount)(token.data.collateral.price, token.data.collateral.decimals);
+    return token.activeLendingPositions.map(({ index, data: position }) => {
+        const platform = (0, common_1.lendingPlatformToEnum)(position.platform);
+        const collateralAmountUi = (0, common_1.toUiAmount)(position.accounting.collateral, collateralDecimals);
+        const debtMint = (0, common_1.fromWeb3Pk)(position.accounting.debt.mint);
+        const debtTvlUsdRaw = (0, common_1.toBigInt)(position.accounting.debt.tvlUsd);
+        return {
+            entityType: "token_lending_position",
+            token: token.address,
+            mint: token.mint,
+            lendingPositionIndex: index,
+            platform,
+            withdrawPending: (0, general_2.podBoolToNumber)(position.withdrawPending) !== 0,
+            pool: (0, common_1.fromWeb3Pk)(position.pool),
+            userAccount: (0, common_1.fromWeb3Pk)(position.protocolUserAcc),
+            collateralAmountRaw: (0, common_1.toBigInt)(position.accounting.collateral).toString(),
+            collateralAmountUi,
+            collateralSymbol,
+            collateralUsd: collateralAmountUi * collateralPriceUsd,
+            debtAmountRaw: (0, common_1.toBigInt)(position.accounting.debt.amount).toString(),
+            debtAmountUi: (0, common_1.toUiAmount)(position.accounting.debt.amount, position.accounting.debt.decimals),
+            debtTvlUsdRaw: debtTvlUsdRaw.toString(),
+            debtTvlUsd: (0, common_1.toUiAmount)(debtTvlUsdRaw, common_1.TVL_USD_DECIMAL_PLACES),
+            debtMint,
+            debtSymbol: (0, common_1.mintSymbol)(debtMint),
+            debtPriceUsd: (0, common_1.toUiAmount)(position.accounting.debt.price, position.accounting.debt.decimals),
+            onChainUtilizationRateBps: position.accounting.ltvUtilizationRateBps,
+            targetUtilizationRateBps: position.config.targetUtilizationRateBps,
+            maxDeviationAboveTargetUtilBps: position.config.maxDeviationAboveTargetUtilBps,
+            maxDeviationBelowTargetUtilBps: position.config.maxDeviationBelowTargetUtilBps,
+        };
+    });
+}
+async function buildTokenLendingPositionMetricSnapshotsAsync(client, token, yieldingBanks = []) {
+    const baseSnapshots = buildTokenLendingPositionMetricSnapshots(token, yieldingBanks);
+    const kaminoData = client.getLendingPlatformClientByPlatform(common_1.LendingPlatform.Kamino).data;
+    const errors = [];
+    const snapshots = await Promise.all(baseSnapshots.map(async (snapshot) => {
+        if (snapshot.platform !== common_1.LendingPlatform.Kamino) {
+            return snapshot;
+        }
+        const position = token.activeLendingPositions.find((row) => row.index === snapshot.lendingPositionIndex)?.data;
+        if (!position) {
+            return snapshot;
+        }
+        try {
+            const { LycLendingPositionManager } = await Promise.resolve().then(() => __importStar(require("../services/carry")));
+            const manager = await LycLendingPositionManager.create(kaminoData, position);
+            const inspectMetrics = await manager.getInspectMetrics();
+            const inspect = serializeLendingPositionInspectMetrics(inspectMetrics);
+            return inspect ? { ...snapshot, inspect } : snapshot;
+        }
+        catch (err) {
+            // The base snapshot is still valid without inspect enrichment, but the
+            // failure must be recorded — silently missing Util RT/EMA cells have
+            // hidden real bugs (e.g. trigger-band math throwing on >100% bands).
+            errors.push({
+                scope: "lending_position_inspect",
+                token: token.address,
+                lendingPositionIndex: snapshot.lendingPositionIndex,
+                message: err instanceof Error ? err.message : String(err),
+            });
+            return snapshot;
+        }
+    }));
+    return { snapshots, errors };
+}
+function serializeLendingPositionInspectMetrics(metrics) {
+    if (!metrics) {
+        return undefined;
+    }
+    return {
+        utilizationRealtimeBps: metrics.utilizationRateBps.realtime,
+        utilizationEmaBps: metrics.utilizationRateBps.ema,
+        lowerTriggerPriceChangePct: metrics.triggerBand.lower?.priceChangePct,
+        upperTriggerPriceChangePct: metrics.triggerBand.upper?.priceChangePct,
+    };
+}
+function kaminoCollateralUsd(token, position) {
+    const collateralAmountUi = (0, common_1.toUiAmount)(position.accounting.collateral, token.data.collateral.decimals);
+    const collateralPriceUsd = (0, common_1.toUiAmount)(token.data.collateral.price, token.data.collateral.decimals);
+    return collateralAmountUi * collateralPriceUsd;
+}
+function shouldIncludeKaminoPositionRate(collateralUsd, maxCollateralUsdOnToken) {
+    if (maxCollateralUsdOnToken < exports.MIN_MATERIAL_KAMINO_COLLATERAL_USD) {
+        return true;
+    }
+    return collateralUsd >= exports.MIN_MATERIAL_KAMINO_COLLATERAL_USD;
+}
+function buildTokenCarryPositionMetricSnapshots(token, yieldingBanks) {
+    const snapshots = [];
+    token.data.debtCarry.forEach((carry, carryPositionIndex) => {
+        if (carry.yieldingBaseMint.equals(web3_js_1.PublicKey.default)) {
+            return;
+        }
+        const baseMint = (0, common_1.fromWeb3Pk)(carry.yieldingBaseMint);
+        const resolvedBank = yieldingBanks.find((bank) => bank.id === carry.yieldingBankId && bank.baseMint === baseMint);
+        snapshots.push({
+            entityType: "token_carry_position",
+            token: token.address,
+            mint: token.mint,
+            carryPositionIndex,
+            yieldingBankId: carry.yieldingBankId,
+            yieldingBankAddress: resolvedBank?.address,
+            baseMint,
+            baseSymbol: (0, common_1.mintSymbol)(baseMint),
+            sharesRaw: (0, common_1.toBigInt)(carry.shares).toString(),
+            sharesUi: resolvedBank ? (0, common_1.toUiAmount)(carry.shares, resolvedBank.decimals) : undefined,
+            tvlUsdRaw: (0, common_1.toBigInt)(carry.tvlUsd).toString(),
+            tvlUsd: (0, common_1.toUiAmount)(carry.tvlUsd, common_1.TVL_USD_DECIMAL_PLACES),
+        });
+    });
+    return snapshots;
+}
+function buildYieldingBankAssetMetricSnapshots(bank) {
+    const snapshots = [];
+    if (!bank.data.baseAsset.mint.equals(web3_js_1.PublicKey.default)) {
+        snapshots.push(buildYieldingBankAssetMetricSnapshot(bank, bank.data.baseAsset, 0, "base"));
+    }
+    bank.data.assets.forEach((asset, index) => {
+        if (asset.mint.equals(web3_js_1.PublicKey.default))
+            return;
+        snapshots.push(buildYieldingBankAssetMetricSnapshot(bank, asset, index + 1, "asset"));
+    });
+    return snapshots;
+}
+async function buildKaminoPositionRateSnapshots(client, tokens) {
+    const rates = [];
+    const errors = [];
+    const kaminoData = client.getLendingPlatformClientByPlatform(common_1.LendingPlatform.Kamino).data;
+    for (const token of tokens) {
+        const kaminoPositions = token.usedLendingPositions.filter(({ data: position }) => (0, common_1.lendingPlatformToEnum)(position.platform) === common_1.LendingPlatform.Kamino);
+        const maxCollateralUsd = Math.max(0, ...kaminoPositions.map(({ data: position }) => kaminoCollateralUsd(token, position)));
+        for (const { index, data: position } of kaminoPositions) {
+            const collateralUsd = kaminoCollateralUsd(token, position);
+            if (!shouldIncludeKaminoPositionRate(collateralUsd, maxCollateralUsd)) {
+                continue;
+            }
+            try {
+                const rate = await buildKaminoPositionRateSnapshot(token, index, position, kaminoData);
+                rates.push(rate);
+            }
+            catch (err) {
+                errors.push({
+                    scope: "kamino_position_rate",
+                    token: token.address,
+                    lendingPositionIndex: index,
+                    message: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    return { rates, errors };
+}
+async function buildKaminoPositionRateSnapshot(token, lendingPositionIndex, position, kaminoData) {
+    const pool = (0, common_1.fromWeb3Pk)(position.pool);
+    const [collateralReserve, debtReserve] = await Promise.all([
+        kaminoData.fetchReserve(pool, (0, common_1.fromWeb3Pk)(position.collateralReserve)),
+        kaminoData.fetchReserve(pool, (0, common_1.fromWeb3Pk)(position.debtReserve)),
+    ]);
+    if (!collateralReserve || !debtReserve) {
+        throw new Error("Failed to fetch Kamino reserves");
+    }
+    return buildKaminoPositionRateSnapshotFromReserves(token, lendingPositionIndex, position, collateralReserve, debtReserve);
+}
+function buildKaminoPositionRateSnapshotFromReserves(token, lendingPositionIndex, position, collateralReserve, debtReserve) {
+    const supplyEffectiveApy = collateralReserve.supplyAPY(debtReserve.address);
+    const borrowEffectiveApy = debtReserve.borrowAPY(collateralReserve.address);
+    return {
+        entityType: "kamino_position_rate",
+        token: token.address,
+        mint: token.mint,
+        lendingPositionIndex,
+        pool: (0, common_1.fromWeb3Pk)(position.pool),
+        userAccount: (0, common_1.fromWeb3Pk)(position.protocolUserAcc),
+        collateralReserve: (0, common_1.fromWeb3Pk)(position.collateralReserve),
+        debtReserve: (0, common_1.fromWeb3Pk)(position.debtReserve),
+        collateralMint: collateralReserve.mint.mint,
+        debtMint: debtReserve.mint.mint,
+        supplyBaseApy: collateralReserve.deposits.apy,
+        borrowBaseApy: debtReserve.borrows.apy,
+        supplyEffectiveApy,
+        borrowEffectiveApy,
+        netEffectiveApy: supplyEffectiveApy - borrowEffectiveApy,
+        collateralReserveUtilizationPct: collateralReserve.utilizationRatePct(),
+        debtReserveUtilizationPct: debtReserve.utilizationRatePct(),
+        onChainLtvUtilizationBps: position.accounting.ltvUtilizationRateBps,
+        targetUtilizationRateBps: position.config.targetUtilizationRateBps,
+        maxDeviationAboveTargetUtilBps: position.config.maxDeviationAboveTargetUtilBps,
+        maxDeviationBelowTargetUtilBps: position.config.maxDeviationBelowTargetUtilBps,
+    };
+}
+function buildYieldingBankAssetMetricSnapshot(bank, asset, assetIndex, assetKind) {
+    const amountRaw = (0, common_1.toBigInt)(asset.amount);
+    const priceRaw = (0, common_1.toBigInt)(asset.price);
+    const tvlUsdRaw = (0, common_1.calculateTvlUsd)(amountRaw, priceRaw, asset.decimals);
+    return {
+        entityType: "yielding_bank_asset",
+        bank: bank.address,
+        assetIndex,
+        assetKind,
+        mint: (0, common_1.fromWeb3Pk)(asset.mint),
+        amountRaw: amountRaw.toString(),
+        amountUi: (0, common_1.toUiAmount)(asset.amount, asset.decimals),
+        decimals: asset.decimals,
+        priceRaw: priceRaw.toString(),
+        priceUsd: (0, common_1.toUiAmount)(asset.price, asset.decimals),
+        tvlUsdRaw: tvlUsdRaw.toString(),
+        tvlUsd: (0, common_1.toUiAmount)(tvlUsdRaw, common_1.TVL_USD_DECIMAL_PLACES),
+    };
+}

package/dist/sdks/long-yield-carry/src/models/index.d.ts

@@ -0,0 +1,3 @@
+export { LYCToken } from "./lycToken";
+export type { TokenAccountData, TokenCarryPositionData, TokenLendingPositionData, IndexedCarryPosition, IndexedLendingPosition, } from "./lycToken";
+export { LYCYieldingBank } from "./yieldingBank";

package/dist/sdks/long-yield-carry/src/models/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LYCYieldingBank = exports.LYCToken = void 0;
+var lycToken_1 = require("./lycToken");
+Object.defineProperty(exports, "LYCToken", { enumerable: true, get: function () { return lycToken_1.LYCToken; } });
+var yieldingBank_1 = require("./yieldingBank");
+Object.defineProperty(exports, "LYCYieldingBank", { enumerable: true, get: function () { return yieldingBank_1.LYCYieldingBank; } });