@affluent-org/sdk 0.0.1

package/dist/utils/pending-tracker/trackable-sender.js

@@ -0,0 +1,87 @@
+"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.createTrackableSender = createTrackableSender;
+exports.createTrackableSenderFromMnemonic = createTrackableSenderFromMnemonic;
+const core_1 = require("@ton/core");
+const ton_1 = require("@ton/ton");
+const external_message_hash_1 = require("../external-message-hash");
+/**
+ * Create a TrackableSender from wallet contract and key pair
+ */
+function createTrackableSender(config) {
+    const { client, wallet, keyPair } = config;
+    const openedWallet = client.open(wallet);
+    return {
+        address: wallet.address,
+        async getSeqno() {
+            try {
+                return await openedWallet.getSeqno();
+            }
+            catch {
+                return 0;
+            }
+        },
+        async send(args) {
+            const seqno = await this.getSeqno();
+            const internalMessage = (0, core_1.internal)({
+                to: args.to,
+                value: args.value,
+                body: args.body,
+                bounce: args.bounce ?? true,
+                init: args.init,
+            });
+            const sendMode = args.sendMode ?? core_1.SendMode.PAY_GAS_SEPARATELY;
+            const signedBody = openedWallet.createTransfer({
+                seqno,
+                secretKey: keyPair.secretKey,
+                sendMode,
+                messages: [internalMessage],
+            });
+            const { hashHex } = (0, external_message_hash_1.computeExternalMessageHash)(wallet.address, signedBody);
+            await openedWallet.send(signedBody);
+            return { extMsgHash: hashHex, seqno };
+        },
+    };
+}
+/**
+ * Create a TrackableSender from mnemonic
+ */
+async function createTrackableSenderFromMnemonic(client, mnemonic, workchain = 0) {
+    const { mnemonicToWalletKey } = await Promise.resolve().then(() => __importStar(require("@ton/crypto")));
+    const keyPair = await mnemonicToWalletKey(mnemonic);
+    const wallet = ton_1.WalletContractV5R1.create({ publicKey: keyPair.publicKey, workchain });
+    return createTrackableSender({ client, wallet, keyPair });
+}

package/dist/utils/pending-tracker/type.d.ts

@@ -0,0 +1,78 @@
+import { Address, SenderArguments } from "@ton/core";
+/**
+ * Result from toncenter v3 pendingTraces API
+ */
+export interface PendingTraceResponse {
+    traces: PendingTrace[];
+}
+export interface PendingTrace {
+    id: string;
+    utime: number;
+    start_lt: string;
+    end_lt: string | null;
+    state: "pending" | "complete" | "failed";
+    transaction_count: number;
+    mc_seqno_start: number;
+    mc_seqno_end: number | null;
+    edges: TraceEdge[];
+    pending_edges: TraceEdge[];
+    nodes: TraceNode[];
+}
+export interface TraceEdge {
+    from_node: string;
+    to_node: string;
+    in_msg_hash: string;
+    out_msg_hash: string;
+}
+export interface TraceNode {
+    tx_hash: string;
+    account: string;
+    lt: string;
+    trace_id: string;
+}
+/**
+ * Simplified trace result for SDK consumers
+ */
+export interface TraceResult {
+    traceId: string;
+    state: "pending" | "complete" | "failed";
+    startLt: string;
+    endLt: string | null;
+    transactionCount: number;
+    transactions: TraceTransaction[];
+}
+export interface TraceTransaction {
+    txHash: string;
+    account: Address;
+    lt: string;
+}
+/**
+ * Options for waiting on pending traces
+ */
+export interface WaitOptions {
+    /** Maximum time to wait in milliseconds (default: 120000 = 2 minutes) */
+    timeout?: number;
+    /** Polling interval in milliseconds (default: 2000 = 2 seconds) */
+    pollInterval?: number;
+    /** Callback for each poll attempt */
+    onPoll?: (attempt: number, elapsed: number) => void;
+    /** Callback when trace state changes */
+    onStateChange?: (state: "pending" | "complete" | "failed") => void;
+}
+/**
+ * Send result with tracking info
+ */
+export interface SendResult {
+    /** External message hash for tracking */
+    extMsgHash: string;
+    /** Seqno used for the transaction */
+    seqno: number;
+}
+/**
+ * Trackable sender that exposes external message hash
+ */
+export interface TrackableSender {
+    readonly address: Address;
+    send(args: SenderArguments): Promise<SendResult>;
+    getSeqno(): Promise<number>;
+}

package/dist/utils/pending-tracker/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/pending-tracker/v3-client.d.ts

@@ -0,0 +1,31 @@
+import { PendingTraceResponse, TraceResult, WaitOptions } from "./type";
+/**
+ * Toncenter v3 API endpoints
+ */
+declare const ENDPOINTS: {
+    readonly mainnet: "https://toncenter.com/api/v3";
+    readonly testnet: "https://testnet.toncenter.com/api/v3";
+};
+export type Network = keyof typeof ENDPOINTS;
+/**
+ * Toncenter v3 API client for pending traces
+ */
+export declare class ToncenterV3Client {
+    private baseUrl;
+    private apiKey?;
+    constructor(network: Network | string, apiKey?: string);
+    private fetch;
+    /**
+     * Get pending traces by external message hash
+     */
+    getPendingTraces(extMsgHash: string): Promise<PendingTraceResponse>;
+    /**
+     * Convert raw trace to simplified TraceResult
+     */
+    private toTraceResult;
+    /**
+     * Wait for a pending trace to complete
+     */
+    waitForTrace(extMsgHash: string, options?: WaitOptions): Promise<TraceResult>;
+}
+export {};

package/dist/utils/pending-tracker/v3-client.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToncenterV3Client = void 0;
+const core_1 = require("@ton/core");
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * Toncenter v3 API endpoints
+ */
+const ENDPOINTS = {
+    mainnet: "https://toncenter.com/api/v3",
+    testnet: "https://testnet.toncenter.com/api/v3",
+};
+/**
+ * Toncenter v3 API client for pending traces
+ */
+class ToncenterV3Client {
+    baseUrl;
+    apiKey;
+    constructor(network, apiKey) {
+        this.baseUrl = network in ENDPOINTS ? ENDPOINTS[network] : network;
+        this.apiKey = apiKey;
+    }
+    async fetch(path) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            Accept: "application/json",
+        };
+        if (this.apiKey) {
+            headers["X-API-Key"] = this.apiKey;
+        }
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            throw new Error(`Toncenter v3 API error: ${response.status} ${response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Get pending traces by external message hash
+     */
+    async getPendingTraces(extMsgHash) {
+        return this.fetch(`/pendingTraces?ext_msg_hash=${extMsgHash}`);
+    }
+    /**
+     * Convert raw trace to simplified TraceResult
+     */
+    toTraceResult(trace) {
+        return {
+            traceId: trace.id,
+            state: trace.state,
+            startLt: trace.start_lt,
+            endLt: trace.end_lt,
+            transactionCount: trace.transaction_count,
+            transactions: trace.nodes.map((node) => ({
+                txHash: node.tx_hash,
+                account: core_1.Address.parse(node.account),
+                lt: node.lt,
+            })),
+        };
+    }
+    /**
+     * Wait for a pending trace to complete
+     */
+    async waitForTrace(extMsgHash, options = {}) {
+        const { timeout = 120000, pollInterval = 2000, onPoll, onStateChange } = options;
+        const startTime = Date.now();
+        let attempt = 0;
+        let lastState = null;
+        while (true) {
+            const elapsed = Date.now() - startTime;
+            if (elapsed > timeout) {
+                throw new Error(`Timeout waiting for trace: ${extMsgHash}`);
+            }
+            attempt++;
+            onPoll?.(attempt, elapsed);
+            try {
+                const response = await this.getPendingTraces(extMsgHash);
+                if (response.traces.length > 0) {
+                    const trace = response.traces[0];
+                    if (trace.state !== lastState) {
+                        lastState = trace.state;
+                        onStateChange?.(trace.state);
+                    }
+                    if (trace.state === "complete") {
+                        return this.toTraceResult(trace);
+                    }
+                    if (trace.state === "failed") {
+                        throw new Error(`Transaction failed: ${extMsgHash}`);
+                    }
+                }
+            }
+            catch (error) {
+                // Ignore fetch errors and retry
+                if (error instanceof Error && error.message.startsWith("Timeout")) {
+                    throw error;
+                }
+                if (error instanceof Error && error.message.startsWith("Transaction failed")) {
+                    throw error;
+                }
+            }
+            await sleep(pollInterval);
+        }
+    }
+}
+exports.ToncenterV3Client = ToncenterV3Client;

package/dist/utils/risk_calculator/risk_calculator.d.ts

@@ -0,0 +1,45 @@
+import { AccountAssetState, AccountAssetStateWithDelta } from "../../contracts/core/account/type";
+import { AssetPrice, AssetPriceInfo, OnchainDataInfo } from "../../contracts/oracle/redstone-onchain-oracle/type";
+import { PoolState } from "../../contracts/core/pool/type";
+export declare class RiskCalculator {
+    accountStatus: Record<string, AccountAssetState>;
+    prices: AssetPriceInfo;
+    onchainData: OnchainDataInfo;
+    poolData: PoolState;
+    PRICE_DECIMALS: number;
+    DELTA_DECIMALS: number;
+    RATIO_DECIMALS: number;
+    LEVERAGE_DECIMALS: number;
+    constructor(accountStatus: Record<string, AccountAssetState>, prices: AssetPriceInfo, onchainData: OnchainDataInfo, poolData: PoolState);
+    calculateDeltaForTargetRiskRatio(_targetRiskRatio: bigint, // ex : 6000n
+    targetAsset: string, dualAsset?: string): SolutionForTargetRatio[];
+    calculateDeltaForTargetLeverage(_targetLeverage: bigint, // ex : 6000n
+    targetAsset: string, action: "supply" | "borrow", dualAsset?: string): SolutionForTargetLeverage;
+    getAssetStatesWithDelta(decomposedStatus: Record<string, Omit<AccountAssetStateWithDelta, "address">>): AssetStateWithDelta[];
+    decomposeAccountStatusWithDelta(accountStatus: Record<string, AccountAssetState>, targetAsset: string, dualAsset?: string): Record<string, Omit<AccountAssetStateWithDelta, "address">>;
+    findDeltaSolutionsForTargetRatio(assetStates: AssetStateWithDelta[], targetRiskRatio: bigint): SolutionForTargetRatio[];
+    findDeltaSolutionForTargetLeverage(assetStates: AssetStateWithDelta[], targetLeverage: bigint, action: "supply" | "borrow"): SolutionForTargetLeverage;
+}
+export interface AssetStateWithDelta {
+    asset: string;
+    supply: bigint;
+    borrow: bigint;
+    deltaCoefficient: bigint;
+    threshold: bigint | null;
+    riskFactor: bigint;
+    price: AssetPrice;
+    isCollateral: boolean;
+}
+interface SolutionForTargetRatio {
+    delta: bigint;
+    interval: {
+        start: bigint;
+        end: bigint;
+    };
+    targetRiskRatio: bigint;
+}
+interface SolutionForTargetLeverage {
+    delta: bigint;
+    targetLeverage: bigint;
+}
+export {};

package/dist/utils/risk_calculator/risk_calculator.js

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RiskCalculator = void 0;
+const type_1 = require("../../contracts/oracle/redstone-onchain-oracle/type");
+const core_1 = require("@ton/core");
+class RiskCalculator {
+    accountStatus;
+    prices;
+    onchainData;
+    poolData;
+    PRICE_DECIMALS = 8;
+    DELTA_DECIMALS = 18;
+    RATIO_DECIMALS = 4;
+    LEVERAGE_DECIMALS = 4;
+    constructor(accountStatus, prices, onchainData, poolData) {
+        this.accountStatus = accountStatus;
+        this.prices = prices;
+        this.onchainData = onchainData;
+        this.poolData = poolData;
+        const assetAddresses = Object.keys(poolData.assets);
+        for (const assetAddress of assetAddresses) {
+            if (!this.accountStatus[assetAddress]) {
+                this.accountStatus[assetAddress] = {
+                    address: core_1.Address.parse(assetAddress),
+                    supply: 0n,
+                    borrow: 0n,
+                };
+                continue;
+            }
+        }
+    }
+    calculateDeltaForTargetRiskRatio(_targetRiskRatio, // ex : 6000n
+    targetAsset, dualAsset) {
+        const decomposedStatusWithDelta = this.decomposeAccountStatusWithDelta(this.accountStatus, targetAsset, dualAsset);
+        const assetStatesWithDelta = this.getAssetStatesWithDelta(decomposedStatusWithDelta);
+        const solutions = this.findDeltaSolutionsForTargetRatio(assetStatesWithDelta, _targetRiskRatio);
+        return solutions;
+    }
+    calculateDeltaForTargetLeverage(_targetLeverage, // ex : 6000n
+    targetAsset, action, dualAsset) {
+        const decomposedStatusWithDelta = this.decomposeAccountStatusWithDelta(this.accountStatus, targetAsset, dualAsset);
+        const assetStatesWithDelta = this.getAssetStatesWithDelta(decomposedStatusWithDelta);
+        const solution = this.findDeltaSolutionForTargetLeverage(assetStatesWithDelta, _targetLeverage, action);
+        return solution;
+    }
+    getAssetStatesWithDelta(decomposedStatus) {
+        const assetStatesWithDelta = Object.entries(decomposedStatus).map(([assetAddress, state]) => {
+            const assetPrice = this.prices[assetAddress];
+            let threshold = null;
+            if (state.deltaCoefficient !== 0n) {
+                threshold = ((state.borrow - state.supply) * 10n ** BigInt(this.DELTA_DECIMALS)) / state.deltaCoefficient;
+            }
+            else {
+                threshold = null;
+            }
+            const riskFactor = this.poolData.assets[assetAddress].riskFactor;
+            return {
+                asset: assetAddress,
+                supply: state.supply,
+                borrow: state.borrow,
+                deltaCoefficient: state.deltaCoefficient,
+                threshold: threshold,
+                riskFactor: riskFactor,
+                price: assetPrice,
+                isCollateral: this.poolData.assets[assetAddress].isCollateral,
+            };
+        });
+        return assetStatesWithDelta;
+    }
+    // 내부 헬퍼 메서드들
+    decomposeAccountStatusWithDelta(accountStatus, targetAsset, dualAsset) {
+        const accumStatus = {};
+        const assetAddresses = Object.keys(accountStatus);
+        let userAssets;
+        if (!assetAddresses.includes(targetAsset)) {
+            throw new Error("Target asset not found in account status");
+        }
+        if (dualAsset) {
+            const targetAssetPrice = this.prices[targetAsset].price;
+            const dualAssetPrice = this.prices[dualAsset].price;
+            if (!targetAssetPrice || !dualAssetPrice) {
+                throw new Error("Dual asset price not found");
+            }
+            // const dualDeltaCoefficient = targetAssetPrice / dualAssetPrice;
+            const dualDeltaCoefficient = (10n ** BigInt(this.DELTA_DECIMALS) * targetAssetPrice) / dualAssetPrice;
+            userAssets = Object.values(accountStatus).map((asset) => {
+                let initialDeltaCoefficient = 0n;
+                if (asset.address.toString() === dualAsset) {
+                    initialDeltaCoefficient = dualDeltaCoefficient;
+                }
+                if (asset.address.toString() === targetAsset) {
+                    initialDeltaCoefficient = 10n ** BigInt(this.DELTA_DECIMALS);
+                }
+                return {
+                    ...asset,
+                    deltaCoefficient: initialDeltaCoefficient,
+                };
+            });
+        }
+        else {
+            userAssets = Object.values(accountStatus).map((asset) => ({
+                ...asset,
+                deltaCoefficient: asset.address.toString() === targetAsset ? 10n ** BigInt(this.DELTA_DECIMALS) : 0n,
+            }));
+        }
+        while (userAssets.length !== 0) {
+            const restUserAssets = [];
+            for (let i = 0; i < userAssets.length; i++) {
+                const state = userAssets[i];
+                if (state.supply > 0n || state.borrow > 0n || state.deltaCoefficient > 0n) {
+                    if (!accumStatus[userAssets[i].address.toString()])
+                        accumStatus[userAssets[i].address.toString()] = {
+                            supply: 0n,
+                            borrow: 0n,
+                            deltaCoefficient: 0n,
+                        };
+                    if (state.supply > 0n) {
+                        accumStatus[userAssets[i].address.toString()].supply += state.supply;
+                    }
+                    if (state.borrow > 0n) {
+                        accumStatus[userAssets[i].address.toString()].borrow += state.borrow;
+                    }
+                    if (state.deltaCoefficient !== 0n) {
+                        accumStatus[userAssets[i].address.toString()].deltaCoefficient += state.deltaCoefficient;
+                    }
+                    const onchainDataInfo = this.onchainData[state.address.toString()];
+                    if (!onchainDataInfo && !this.prices[state.address.toString()])
+                        throw "not found onchain data info2";
+                    if (onchainDataInfo) {
+                        if (onchainDataInfo.assetType === type_1.AssetType.SingleAsset &&
+                            onchainDataInfo.underlyingReserve &&
+                            onchainDataInfo.totalSupply) {
+                            const underlyingSupply = (state.supply * onchainDataInfo.underlyingReserve) / onchainDataInfo.totalSupply;
+                            const underlyingBorrow = (state.borrow * onchainDataInfo.underlyingReserve) / onchainDataInfo.totalSupply;
+                            const underlyingDelta = (state.deltaCoefficient * onchainDataInfo.underlyingReserve) / onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlyingAddress,
+                                supply: underlyingSupply,
+                                borrow: underlyingBorrow,
+                                deltaCoefficient: underlyingDelta,
+                            });
+                        }
+                        else if (onchainDataInfo.assetType === type_1.AssetType.MultiAsset &&
+                            onchainDataInfo.underlying0Reserve &&
+                            onchainDataInfo.underlying1Reserve &&
+                            onchainDataInfo.totalSupply) {
+                            const underlying0Supply = (state.supply * onchainDataInfo.underlying0Reserve) / onchainDataInfo.totalSupply;
+                            const underlying0Borrow = (state.borrow * onchainDataInfo.underlying0Reserve) / onchainDataInfo.totalSupply;
+                            const underlying0Delta = (state.deltaCoefficient * onchainDataInfo.underlying0Reserve) / onchainDataInfo.totalSupply;
+                            const underlying1Supply = (state.supply * onchainDataInfo.underlying1Reserve) / onchainDataInfo.totalSupply;
+                            const underlying1Borrow = (state.borrow * onchainDataInfo.underlying1Reserve) / onchainDataInfo.totalSupply;
+                            const underlying1Delta = (state.deltaCoefficient * onchainDataInfo.underlying1Reserve) / onchainDataInfo.totalSupply;
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlying0Address,
+                                supply: underlying0Supply,
+                                borrow: underlying0Borrow,
+                                deltaCoefficient: underlying0Delta,
+                            });
+                            restUserAssets.push({
+                                address: onchainDataInfo.underlying1Address,
+                                supply: underlying1Supply,
+                                borrow: underlying1Borrow,
+                                deltaCoefficient: underlying1Delta,
+                            });
+                        }
+                    }
+                    else if (this.prices[state.address.toString()]?.type === type_1.AssetType.VaultAsset) {
+                        const priceData = this.prices[state.address.toString()];
+                        const decomposed = priceData.additionalData.decomposed;
+                        const totalSupply = priceData.additionalData.totalSupply;
+                        for (const asset of Object.keys(decomposed)) {
+                            const underlyingSupply = (state.supply * decomposed[asset].supply) / totalSupply +
+                                (state.borrow * decomposed[asset].borrow) / totalSupply;
+                            const underlyingBorrow = (state.supply * decomposed[asset].borrow) / totalSupply +
+                                (state.borrow * decomposed[asset].supply) / totalSupply;
+                            const underlyingSupplyDelta = (state.deltaCoefficient * decomposed[asset].supply) / totalSupply;
+                            const underlyingBorrowDelta = (state.deltaCoefficient * decomposed[asset].borrow) / totalSupply;
+                            const underlyingDelta = underlyingSupplyDelta - underlyingBorrowDelta;
+                            restUserAssets.push({
+                                address: core_1.Address.parse(asset),
+                                supply: underlyingSupply,
+                                borrow: underlyingBorrow,
+                                deltaCoefficient: underlyingDelta,
+                            });
+                        }
+                    }
+                }
+            }
+            userAssets = restUserAssets;
+        }
+        return accumStatus;
+    }
+    findDeltaSolutionsForTargetRatio(assetStates, targetRiskRatio) {
+        const sortedThresholds = [
+            ...new Set([...assetStates].map((state) => state.threshold).filter((t) => t !== null)),
+        ].sort((a, b) => Number(a - b));
+        const solutions = [];
+        for (let i = 0; i <= sortedThresholds.length; i++) {
+            const maxBigint = 1n << 255n;
+            const intervalStart = i === 0 ? -maxBigint : sortedThresholds[i - 1];
+            const intervalEnd = i === sortedThresholds.length ? maxBigint : sortedThresholds[i];
+            const nominatorConstant = assetStates.reduce((sum, state) => {
+                const netPosition = state.supply - state.borrow;
+                if (state.threshold === null) {
+                    const absoluteNetPosition = netPosition > 0n ? netPosition : -netPosition;
+                    return (sum +
+                        (absoluteNetPosition * state.price.price * state.riskFactor) /
+                            BigInt(10 ** (this.PRICE_DECIMALS + this.RATIO_DECIMALS)));
+                }
+                const sign = state.threshold === null || state.threshold <= intervalStart ? 1n : -1n;
+                return (sum +
+                    (sign * (netPosition * state.price.price * state.riskFactor)) /
+                        BigInt(10 ** (this.PRICE_DECIMALS + this.RATIO_DECIMALS)));
+            }, 0n);
+            const nominatorCoefficient = assetStates.reduce((sum, state) => {
+                const sign = state.threshold === null || state.threshold <= intervalStart ? 1n : -1n;
+                return (sum +
+                    (sign * (state.deltaCoefficient * state.riskFactor * state.price.price)) /
+                        BigInt(10 ** (this.PRICE_DECIMALS + this.RATIO_DECIMALS)));
+            }, 0n);
+            const denominatorConstant = assetStates.reduce((sum, state) => {
+                if (!state.isCollateral || state.price.type !== type_1.AssetType.Native)
+                    return sum;
+                const netPosition = state.supply - state.borrow;
+                return sum + (netPosition * state.price.price) / BigInt(10 ** this.PRICE_DECIMALS);
+            }, 0n);
+            const denominatorCoefficient = assetStates.reduce((sum, state) => {
+                if (!state.isCollateral || state.price.type !== type_1.AssetType.Native)
+                    return sum;
+                return sum + (state.deltaCoefficient * state.price.price) / BigInt(10 ** this.PRICE_DECIMALS);
+            }, 0n);
+            // 분자 0 Case
+            if (nominatorCoefficient === 0n && nominatorConstant === 0n) {
+                return [];
+            }
+            // 분모 0 Case
+            if (denominatorCoefficient === 0n && denominatorConstant === 0n) {
+                return [];
+            }
+            const nominator = BigInt(10 ** this.RATIO_DECIMALS) * nominatorConstant - targetRiskRatio * denominatorConstant;
+            const denominator = targetRiskRatio * denominatorCoefficient - nominatorCoefficient * BigInt(10 ** this.RATIO_DECIMALS);
+            if (denominator === 0n) {
+                throw new Error("Denominator cannot be zero");
+            }
+            const deltaSolution = (nominator * BigInt(10 ** this.DELTA_DECIMALS)) / denominator;
+            let currentRisk = 0n;
+            if (intervalStart === sortedThresholds[sortedThresholds.length - 1] &&
+                intervalEnd === maxBigint &&
+                denominatorConstant !== 0n) {
+                currentRisk = (nominatorConstant * BigInt(10 ** this.RATIO_DECIMALS)) / denominatorConstant;
+            }
+            if (currentRisk === targetRiskRatio) {
+                return [
+                    {
+                        delta: 0n,
+                        interval: {
+                            start: intervalStart,
+                            end: intervalEnd,
+                        },
+                        targetRiskRatio: targetRiskRatio,
+                    },
+                ];
+            }
+            // 구간 내에 있는 delta만 solutions에 추가
+            if (deltaSolution >= intervalStart && deltaSolution < intervalEnd) {
+                solutions.push({
+                    delta: deltaSolution,
+                    interval: {
+                        start: intervalStart,
+                        end: intervalEnd,
+                    },
+                    targetRiskRatio: targetRiskRatio,
+                });
+            }
+        }
+        return solutions;
+    }
+    findDeltaSolutionForTargetLeverage(assetStates, targetLeverage, action) {
+        const nominatorConstant = assetStates.reduce((sum, state) => {
+            if (!state.isCollateral || state.price.type !== type_1.AssetType.Native)
+                return sum;
+            return sum + (state.supply * state.price.price) / BigInt(10 ** this.PRICE_DECIMALS);
+        }, 0n);
+        const nominatorCoefficient = assetStates.reduce((sum, state) => {
+            if (!state.isCollateral || state.price.type !== type_1.AssetType.Native)
+                return sum;
+            if (action === "borrow")
+                return sum;
+            return sum + (state.deltaCoefficient * state.price.price) / BigInt(10 ** this.PRICE_DECIMALS);
+        }, 0n);
+        const denominatorConstant = assetStates.reduce((sum, state) => {
+            if (!state.isCollateral || state.price.type !== type_1.AssetType.Native)
+                return sum;
+            const netPosition = state.supply - state.borrow;
+            return sum + (netPosition * state.price.price) / BigInt(10 ** this.PRICE_DECIMALS);
+        }, 0n);
+        const denominatorCoefficient = assetStates.reduce((sum, state) => {
+            if (!state.isCollateral || state.price.type !== type_1.AssetType.Native)
+                return sum;
+            const sign = action === "supply" ? 1n : -1n;
+            return sum + (sign * state.deltaCoefficient * state.price.price) / BigInt(10 ** this.PRICE_DECIMALS);
+        }, 0n);
+        // 분자 0 Case
+        if (nominatorCoefficient === 0n && nominatorConstant === 0n) {
+            return {
+                delta: 0n,
+                targetLeverage: targetLeverage,
+            };
+        }
+        // 분모 0 Case
+        if (denominatorCoefficient === 0n && denominatorConstant === 0n) {
+            return {
+                delta: 0n,
+                targetLeverage: targetLeverage,
+            };
+        }
+        const nominator = BigInt(10 ** this.LEVERAGE_DECIMALS) * nominatorConstant - targetLeverage * denominatorConstant;
+        const denominator = targetLeverage * denominatorCoefficient - nominatorCoefficient * BigInt(10 ** this.LEVERAGE_DECIMALS);
+        if (denominator === 0n) {
+            throw new Error("Denominator cannot be zero");
+        }
+        // const currentLeverage =
+        //   (nominatorConstant * BigInt(10 ** this.LEVERAGE_DECIMALS)) /
+        //   denominatorConstant;
+        const deltaSolution = (nominator * BigInt(10 ** this.DELTA_DECIMALS)) / denominator;
+        return {
+            delta: deltaSolution,
+            targetLeverage: targetLeverage,
+        };
+    }
+}
+exports.RiskCalculator = RiskCalculator;