@affluent-org/sdk 0.0.1

package/dist/services/pool/query.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPool = getPool;
+exports.getPoolData = getPoolData;
+exports.getAccountAddress = getAccountAddress;
+exports.getAccount = getAccount;
+exports.getAccountData = getAccountData;
+exports.getPricesAndCompositions = getPricesAndCompositions;
+exports.getPrices = getPrices;
+exports.isHealthy = isHealthy;
+exports.calculateMaxBorrowableAmount = calculateMaxBorrowableAmount;
+exports.calculateMaxWithdrawableAmount = calculateMaxWithdrawableAmount;
+const core_1 = require("@ton/core");
+const utils_1 = require("../../contracts/common/utils");
+const pool_1 = require("../../contracts/core/pool");
+const account_1 = require("../../contracts/core/account");
+const query_1 = require("../composite-oracle/query");
+const computation_1 = require("../composite-oracle/computation");
+const risk_calculator_1 = require("../../utils/risk_calculator/risk_calculator");
+const utils_2 = require("../../utils/utils");
+const computation_2 = require("./computation");
+// ============================================================
+// Basic Queries (Data Fetching)
+// ============================================================
+/**
+ * Get Pool contract instance
+ */
+function getPool(ctx, poolAddress) {
+    return ctx.getByContract(pool_1.Pool, (0, utils_1.toAddress)(poolAddress));
+}
+/**
+ * Get Pool data
+ */
+async function getPoolData(ctx, poolAddress) {
+    const pool = getPool(ctx, poolAddress);
+    return pool.getPoolData();
+}
+/**
+ * Get Account address for a user in a pool
+ */
+async function getAccountAddress(ctx, poolAddress, userAddress) {
+    const pool = getPool(ctx, poolAddress);
+    return pool.getAccountAddress((0, utils_1.toAddress)(userAddress));
+}
+/**
+ * Get Account contract instance
+ */
+async function getAccount(ctx, poolAddress, userAddress) {
+    const accountAddress = await getAccountAddress(ctx, poolAddress, userAddress);
+    return ctx.getByContract(account_1.Account, accountAddress);
+}
+/**
+ * Get Account data for a user in a pool
+ */
+async function getAccountData(ctx, poolAddress, userAddress) {
+    const pool = getPool(ctx, poolAddress);
+    const poolData = await pool.getPoolData();
+    const assets = poolData.assets;
+    const accountAddress = await pool.getAccountAddress((0, utils_1.toAddress)(userAddress));
+    const account = ctx.getByContract(account_1.Account, accountAddress);
+    const emptyStatus = Object.keys(assets).reduce((acc, asset) => {
+        acc[asset] = {
+            address: core_1.Address.parse(asset),
+            supply: 0n,
+            borrow: 0n,
+        };
+        return acc;
+    }, {});
+    try {
+        const accountDataFromOnchain = await account.getAccountData();
+        return {
+            ...accountDataFromOnchain,
+            status: { ...emptyStatus, ...accountDataFromOnchain.status },
+        };
+    }
+    catch {
+        return {
+            address: (0, utils_1.toAddress)(userAddress),
+            pool: (0, utils_1.toAddress)(poolAddress),
+            owner: poolData.owner,
+            status: emptyStatus,
+        };
+    }
+}
+// ============================================================
+// Price Queries (Fetch + Compute)
+// ============================================================
+/**
+ * Get prices and vault compositions for all assets in a pool
+ */
+async function getPricesAndCompositions(ctx, poolAddress) {
+    const pool = getPool(ctx, poolAddress);
+    const poolData = await pool.getPoolData();
+    const oracleConfig = poolData.oracleConfig;
+    const allAssets = Object.keys(poolData.assets);
+    const { vaultAssets } = (0, computation_1.separateAssets)(allAssets, oracleConfig);
+    const fetcher = new query_1.CompositeOracleFetcher(ctx);
+    const [{ rawPrices, onchainData: redstoneSyntheticData }, additionalSyntheticData, vaultPositions, poolInfos] = await Promise.all([
+        fetcher.fetchRawPrices(allAssets, oracleConfig),
+        fetcher.fetchOnchainData(oracleConfig.assetOnchainDataInfo ?? {}),
+        fetcher.fetchVaultPositions(vaultAssets.map((v) => core_1.Address.parse(v))),
+        fetcher.fetchPoolInfos([]),
+    ]);
+    const result = (0, computation_1.computeCompositePrices)({
+        rawPrices,
+        syntheticCompositions: { ...redstoneSyntheticData, ...additionalSyntheticData },
+        vaultPositions,
+        poolInfos,
+    });
+    const vaultCompositions = Object.fromEntries(Object.entries(result.vaultPrices).map(([k, v]) => [k, v.additionalData]));
+    return { prices: result.allPrices, vaultCompositions };
+}
+/**
+ * Get prices for all assets in a pool
+ * @deprecated Use getPricesAndCompositions instead
+ */
+async function getPrices(ctx, poolAddress) {
+    const { prices } = await getPricesAndCompositions(ctx, poolAddress);
+    return prices;
+}
+// ============================================================
+// Health Queries (Fetch + Compute)
+// ============================================================
+/**
+ * Check if account is healthy
+ * Fetches pool data, account data, and prices, then calculates health
+ */
+async function isHealthy(ctx, poolAddress, ownerAddress, delta) {
+    const pool = getPool(ctx, poolAddress);
+    const poolData = (0, computation_2.simulateAccrueInterest)(await pool.getPoolData());
+    const accountAddress = await pool.getAccountAddress((0, utils_1.toAddress)(ownerAddress));
+    const account = ctx.getByContract(account_1.Account, accountAddress);
+    let accountData;
+    try {
+        accountData = (0, computation_2.convertShareToAmount)(await account.getAccountData(), poolData);
+        if (delta) {
+            accountData = (0, computation_2.applyDelta)(accountData, delta);
+        }
+    }
+    catch {
+        return {
+            result: true,
+            healthy: true,
+            unhealthy: false,
+            collateral: 0n,
+            debt: 0n,
+            risk: 0n,
+            riskRatio: 0n,
+            leverageRatio: 0n,
+        };
+    }
+    const assets = (0, computation_2.haveAssets)(accountData);
+    if (assets.length === 0) {
+        return {
+            result: true,
+            healthy: true,
+            unhealthy: false,
+            collateral: 0n,
+            debt: 0n,
+            risk: 0n,
+            riskRatio: 0n,
+            leverageRatio: 0n,
+        };
+    }
+    const { prices, vaultCompositions } = await getPricesAndCompositions(ctx, poolAddress);
+    const oracleConfig = poolData.oracleConfig;
+    return (0, computation_2.isHealthyFromData)(poolData, accountData.status, prices, oracleConfig.assetOnchainDataInfo ?? {}, vaultCompositions);
+}
+/**
+ * Calculate maximum borrowable amount for an asset
+ */
+async function calculateMaxBorrowableAmount(ctx, params) {
+    const { borrowerAddress, poolAddress, tokenAddress, BUFFER = 100n } = params;
+    const pool = getPool(ctx, poolAddress);
+    const poolData = (0, computation_2.simulateAccrueInterest)(await pool.getPoolData());
+    const accountAddress = await pool.getAccountAddress(borrowerAddress);
+    const account = ctx.getByContract(account_1.Account, accountAddress);
+    const accountState = (0, computation_2.convertShareToAmount)(await account.getAccountData(), poolData);
+    const cash = poolData.assets[tokenAddress].cash;
+    const { prices, vaultCompositions } = await getPricesAndCompositions(ctx, poolAddress);
+    const oracleConfig = poolData.oracleConfig;
+    const syntheticCompositions = oracleConfig.assetOnchainDataInfo ?? {};
+    const beforeHealth = (0, computation_2.isHealthyFromData)(poolData, accountState.status, prices, syntheticCompositions, vaultCompositions);
+    const riskCalculator = new risk_calculator_1.RiskCalculator(accountState.status, prices, syntheticCompositions, poolData);
+    const deltaSolutionsForTargetRatio = riskCalculator.calculateDeltaForTargetRiskRatio(poolData.maxLoanVarRatio - BUFFER, tokenAddress);
+    const deltaSolutionForLeverage = riskCalculator.calculateDeltaForTargetLeverage(poolData.maxLoanLeverageRatio - BUFFER, tokenAddress, "borrow");
+    const solutionsForTargetRatio = deltaSolutionsForTargetRatio.map((solution) => (0, utils_2.bigIntMin)([solution.delta, 0n]) * -1n);
+    const hasAnswer = solutionsForTargetRatio.length > 0;
+    const solutionForTargetRatio = hasAnswer ? (0, utils_2.bigIntMin)(solutionsForTargetRatio) : utils_2.MAX256;
+    const solutionForLeverage = deltaSolutionForLeverage.delta >= 0n ? deltaSolutionForLeverage.delta : 0n;
+    const maxBorrowableAmount = (0, utils_2.bigIntMin)([solutionForTargetRatio, solutionForLeverage, cash]);
+    let reason;
+    if (maxBorrowableAmount === solutionForTargetRatio) {
+        reason = "RISK_RATIO_CONSTRAINT";
+    }
+    else if (maxBorrowableAmount === solutionForLeverage) {
+        reason = "LEVERAGE_CONSTRAINT";
+    }
+    else {
+        reason = "POOL_CASH_CONSTRAINT";
+    }
+    const accountState2 = (0, computation_2.applyDelta)(accountState, {
+        [tokenAddress]: {
+            address: core_1.Address.parse(tokenAddress),
+            supply: 0n,
+            borrow: maxBorrowableAmount,
+        },
+    });
+    const afterHealth = (0, computation_2.isHealthyFromData)(poolData, accountState2.status, prices, syntheticCompositions, vaultCompositions);
+    return {
+        amount: maxBorrowableAmount,
+        reason,
+        beforeAccountHealth: beforeHealth,
+        afterAccountHealth: afterHealth,
+    };
+}
+/**
+ * Calculate maximum withdrawable amount for an asset
+ */
+async function calculateMaxWithdrawableAmount(ctx, params) {
+    const { withdrawerAddress, poolAddress, tokenAddress, BUFFER = 100n } = params;
+    const pool = getPool(ctx, poolAddress);
+    const poolData = (0, computation_2.simulateAccrueInterest)(await pool.getPoolData());
+    const accountAddress = await pool.getAccountAddress(withdrawerAddress);
+    const account = ctx.getByContract(account_1.Account, accountAddress);
+    const accountState = (0, computation_2.convertShareToAmount)(await account.getAccountData(), poolData);
+    const cash = poolData.assets[tokenAddress]?.cash ?? 0n;
+    const hasNoPosition = Object.values(accountState.status).every((value) => value.borrow === 0n && value.supply === 0n);
+    if (hasNoPosition) {
+        return { amount: 0n, reason: "USER_SUPPLY_CONSTRAINT" };
+    }
+    const hasNoBorrowedAmount = Object.values(accountState.status).every((value) => value.borrow === 0n);
+    if (hasNoBorrowedAmount) {
+        const supplyAmount = accountState.status[tokenAddress]?.supply ?? 0n;
+        if (supplyAmount > cash) {
+            return { amount: cash, reason: "POOL_CASH_CONSTRAINT" };
+        }
+        else {
+            return { amount: supplyAmount, reason: "USER_SUPPLY_CONSTRAINT" };
+        }
+    }
+    const { prices, vaultCompositions } = await getPricesAndCompositions(ctx, poolAddress);
+    const oracleConfig = poolData.oracleConfig;
+    const syntheticCompositions = oracleConfig.assetOnchainDataInfo ?? {};
+    const beforeHealth = (0, computation_2.isHealthyFromData)(poolData, accountState.status, prices, syntheticCompositions, vaultCompositions);
+    const riskCalculator = new risk_calculator_1.RiskCalculator(accountState.status, prices, syntheticCompositions, poolData);
+    const deltaSolutionsForTargetRatio = riskCalculator.calculateDeltaForTargetRiskRatio(poolData.maxLoanVarRatio - BUFFER, tokenAddress);
+    const deltaSolutionForLeverage = riskCalculator.calculateDeltaForTargetLeverage(poolData.maxLoanLeverageRatio - BUFFER, tokenAddress, "supply");
+    const solutionsForTargetRatio = deltaSolutionsForTargetRatio.map((solution) => (0, utils_2.bigIntMin)([solution.delta, 0n]) * -1n);
+    const hasTargetRatioAnswer = solutionsForTargetRatio.length > 0;
+    const solutionForTargetRatio = hasTargetRatioAnswer ? (0, utils_2.bigIntMin)(solutionsForTargetRatio) : utils_2.MAX256;
+    const solutionForLeverage = (0, utils_2.bigIntMin)([deltaSolutionForLeverage.delta, 0n]) * -1n;
+    const userSupplyAmount = accountState.status[tokenAddress]?.supply ?? 0n;
+    const maxWithdrawableAmount = (0, utils_2.bigIntMin)([userSupplyAmount, solutionForTargetRatio, solutionForLeverage, cash]);
+    let reason;
+    if (maxWithdrawableAmount === solutionForTargetRatio) {
+        reason = "RISK_RATIO_CONSTRAINT";
+    }
+    else if (maxWithdrawableAmount === solutionForLeverage) {
+        reason = "LEVERAGE_CONSTRAINT";
+    }
+    else if (maxWithdrawableAmount === cash) {
+        reason = "POOL_CASH_CONSTRAINT";
+    }
+    else {
+        reason = "USER_SUPPLY_CONSTRAINT";
+    }
+    const accountState2 = (0, computation_2.applyDelta)(accountState, {
+        [tokenAddress]: {
+            address: core_1.Address.parse(tokenAddress),
+            supply: -maxWithdrawableAmount,
+            borrow: 0n,
+        },
+    });
+    const afterHealth = (0, computation_2.isHealthyFromData)(poolData, accountState2.status, prices, syntheticCompositions, vaultCompositions);
+    return {
+        amount: maxWithdrawableAmount,
+        reason,
+        beforeAccountHealth: beforeHealth,
+        afterAccountHealth: afterHealth,
+    };
+}

package/dist/services/pool/user/index.d.ts

@@ -0,0 +1,86 @@
+import { Address, Cell } from "@ton/core";
+import { AffluentContext } from "../../../context";
+import { AddressSender } from "../../../types/sender";
+import { SupplyParams, WithdrawParams, BorrowParams, RepayParams, LiquidateParams } from "./types";
+export * from "./types";
+export declare function createSupplyMsg(ctx: AffluentContext, sender: AddressSender, params: SupplyParams, value?: bigint): Promise<{
+    opts: {
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: Cell;
+        queryId: bigint | undefined;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createWithdrawMsg(ctx: AffluentContext, sender: AddressSender, params: WithdrawParams, value?: bigint): Promise<{
+    opts: {
+        asset: Address;
+        isShare: boolean;
+        amount: bigint;
+        recipient: Address;
+        response: Address;
+        jettonForwardTonAmount: bigint;
+        jettonForwardPayload: Cell | null;
+        oracleParams: Cell | null;
+        queryId: bigint | undefined;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createBorrowMsg(ctx: AffluentContext, sender: AddressSender, params: BorrowParams, value?: bigint): Promise<{
+    opts: {
+        asset: Address;
+        isShare: boolean;
+        amount: bigint;
+        recipient: Address;
+        response: Address;
+        jettonForwardTonAmount: bigint;
+        jettonForwardPayload: Cell | null;
+        oracleParams: Cell | null;
+        queryId: bigint | undefined;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createRepayMsg(ctx: AffluentContext, sender: AddressSender, params: RepayParams, value?: bigint): Promise<{
+    opts: {
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: Cell;
+        queryId: bigint | undefined;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createLiquidateMsg(ctx: AffluentContext, sender: AddressSender, params: LiquidateParams, value?: bigint): Promise<{
+    opts: {
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: Cell;
+        queryId: bigint | undefined;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;

package/dist/services/pool/user/index.js

@@ -0,0 +1,285 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSupplyMsg = createSupplyMsg;
+exports.createWithdrawMsg = createWithdrawMsg;
+exports.createBorrowMsg = createBorrowMsg;
+exports.createRepayMsg = createRepayMsg;
+exports.createLiquidateMsg = createLiquidateMsg;
+const core_1 = require("@ton/core");
+const utils_1 = require("../../../contracts/common/utils");
+const pool_1 = require("../../../contracts/core/pool");
+const account_1 = require("../../../contracts/core/account");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+const jetton_wallet_1 = require("../../../contracts/jetton/jetton-wallet");
+const jetton_wallet_2 = require("../../../contracts/wton/jetton-wallet");
+const jetton_minter_2 = require("../../../contracts/wton/jetton-minter");
+const oracle_1 = require("../oracle");
+__exportStar(require("./types"), exports);
+// ============================================================
+// Shared Helpers
+// ============================================================
+async function getJettonWalletAddress(ctx, ownerAddress, assetAddress) {
+    if (ctx.isWTON(assetAddress)) {
+        const poolWalletAddress = await ctx.getByContract(jetton_minter_1.JettonMinter, assetAddress).getWalletAddress(ownerAddress);
+        return poolWalletAddress;
+    }
+    const jettonMinter = ctx.getByContract(jetton_minter_1.JettonMinter, assetAddress);
+    return jettonMinter.getWalletAddress(ownerAddress);
+}
+function getWTONParams(ctx, assetAddress) {
+    const isWTON = ctx.isWTON(assetAddress);
+    return {
+        isWTON,
+        jettonForwardTonAmount: isWTON ? (0, core_1.toNano)(0.02) : 0n,
+        jettonForwardPayload: isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : null,
+    };
+}
+// ============================================================
+// Supply
+// ============================================================
+async function createSupplyMsg(ctx, sender, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const recipientAddress = params.recipientAddress ? (0, utils_1.toAddress)(params.recipientAddress) : sender.address;
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const poolData = await pool.getPoolData();
+    const { isWTON, jettonForwardTonAmount, jettonForwardPayload } = getWTONParams(ctx, assetAddress);
+    const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Supply, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+    const forwardPayload = pool_1.Pool.createSupplyPayload({
+        asset: assetAddress,
+        recipient: recipientAddress,
+        response: sender.address,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+    });
+    const opts = {
+        recipient: poolAddress,
+        amount: params.amount,
+        response: sender.address,
+        forwardTonAmount: gas,
+        forwardPayload,
+        queryId: params.queryId,
+    };
+    if (isWTON) {
+        const poolWalletAddress = await getJettonWalletAddress(ctx, poolAddress, assetAddress);
+        const poolWTONWallet = ctx.getByContract(jetton_wallet_2.WTONWallet, poolWalletAddress);
+        return {
+            opts,
+            input: {
+                to: poolWTONWallet.address,
+                value: value ?? jetton_wallet_2.WTONWallet.Gas.ExternalTransfer,
+                body: poolWTONWallet.createExternalTransferBody(opts),
+            },
+        };
+    }
+    else {
+        const senderWalletAddress = await getJettonWalletAddress(ctx, sender.address, assetAddress);
+        const senderWallet = ctx.getByContract(jetton_wallet_1.JettonWallet, senderWalletAddress);
+        return {
+            opts,
+            input: {
+                to: senderWallet.address,
+                value: value ?? gas + jetton_wallet_1.JettonWallet.Gas.Transfer,
+                body: senderWallet.createTransferBody(opts),
+            },
+        };
+    }
+}
+// ============================================================
+// Withdraw
+// ============================================================
+async function createWithdrawMsg(ctx, sender, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const recipientAddress = params.recipientAddress ? (0, utils_1.toAddress)(params.recipientAddress) : sender.address;
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const poolData = await pool.getPoolData();
+    const accountAddress = await pool.getAccountAddress(sender.address);
+    const account = ctx.getByContract(account_1.Account, accountAddress);
+    const { isWTON, jettonForwardTonAmount, jettonForwardPayload } = getWTONParams(ctx, assetAddress);
+    let oracleParams = null;
+    try {
+        const accountData = await account.getAccountData();
+        if (account_1.Account.haveBorrow(accountData)) {
+            oracleParams = await (0, oracle_1.getOracleParams)(ctx, poolAddress, sender.address, assetAddress);
+        }
+    }
+    catch {
+        // Account not deployed, no borrow
+    }
+    const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Withdraw, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, !!oracleParams, poolData.minimumGasFee);
+    const opts = {
+        asset: assetAddress,
+        isShare: params.isShare ?? false,
+        amount: params.amount,
+        recipient: recipientAddress,
+        response: sender.address,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+        oracleParams,
+        queryId: params.queryId,
+    };
+    return {
+        opts,
+        input: {
+            to: pool.address,
+            value: value ?? gas + (0, core_1.toNano)(0.4),
+            body: pool_1.Pool.createWithdrawMsgBody(opts),
+        },
+    };
+}
+// ============================================================
+// Borrow
+// ============================================================
+async function createBorrowMsg(ctx, sender, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const recipientAddress = params.recipientAddress ? (0, utils_1.toAddress)(params.recipientAddress) : sender.address;
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const poolData = await pool.getPoolData();
+    const { isWTON, jettonForwardTonAmount, jettonForwardPayload } = getWTONParams(ctx, assetAddress);
+    const oracleParams = await (0, oracle_1.getOracleParams)(ctx, poolAddress, sender.address, assetAddress);
+    const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Borrow, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, true, poolData.minimumGasFee);
+    const opts = {
+        asset: assetAddress,
+        isShare: params.isShare ?? false,
+        amount: params.amount,
+        recipient: recipientAddress,
+        response: sender.address,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+        oracleParams,
+        queryId: params.queryId,
+    };
+    return {
+        opts,
+        input: {
+            to: pool.address,
+            value: value ?? gas,
+            body: pool_1.Pool.createBorrowMsgBody(opts),
+        },
+    };
+}
+// ============================================================
+// Repay
+// ============================================================
+async function createRepayMsg(ctx, sender, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const recipientAddress = params.recipientAddress ? (0, utils_1.toAddress)(params.recipientAddress) : sender.address;
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const poolData = await pool.getPoolData();
+    const { isWTON, jettonForwardTonAmount, jettonForwardPayload } = getWTONParams(ctx, assetAddress);
+    const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Repay, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+    const forwardPayload = pool_1.Pool.createRepayPayload({
+        asset: assetAddress,
+        recipient: recipientAddress,
+        response: sender.address,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+    });
+    const opts = {
+        recipient: poolAddress,
+        amount: params.amount,
+        response: sender.address,
+        forwardTonAmount: gas,
+        forwardPayload,
+        queryId: params.queryId,
+    };
+    if (isWTON) {
+        const poolWalletAddress = await getJettonWalletAddress(ctx, poolAddress, assetAddress);
+        const poolWTONWallet = ctx.getByContract(jetton_wallet_2.WTONWallet, poolWalletAddress);
+        return {
+            opts,
+            input: {
+                to: poolWTONWallet.address,
+                value: value ?? jetton_wallet_2.WTONWallet.Gas.ExternalTransfer,
+                body: poolWTONWallet.createExternalTransferBody(opts),
+            },
+        };
+    }
+    else {
+        const senderWalletAddress = await getJettonWalletAddress(ctx, sender.address, assetAddress);
+        const senderWallet = ctx.getByContract(jetton_wallet_1.JettonWallet, senderWalletAddress);
+        return {
+            opts,
+            input: {
+                to: senderWallet.address,
+                value: value ?? gas + jetton_wallet_1.JettonWallet.Gas.Transfer,
+                body: senderWallet.createTransferBody(opts),
+            },
+        };
+    }
+}
+// ============================================================
+// Liquidate
+// ============================================================
+async function createLiquidateMsg(ctx, sender, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const repayAssetAddress = (0, utils_1.toAddress)(params.repayAssetAddress);
+    const seizeAssetAddress = (0, utils_1.toAddress)(params.seizeAssetAddress);
+    const borrowerAddress = (0, utils_1.toAddress)(params.borrowerAddress);
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const poolData = await pool.getPoolData();
+    const { isWTON, jettonForwardTonAmount, jettonForwardPayload } = getWTONParams(ctx, repayAssetAddress);
+    const oracleParams = await (0, oracle_1.getOracleParams)(ctx, poolAddress, borrowerAddress, repayAssetAddress);
+    if (!oracleParams) {
+        throw new Error("Failed to get oracle params for liquidation - borrower has no positions");
+    }
+    const gas = pool_1.Pool.calculateGasFee(pool_1.Pool.Op.Liquidate, pool_1.Pool.Gas.baseFee, pool_1.Pool.Gas.forwardFee, jettonForwardTonAmount, !poolData.oracle, false, poolData.minimumGasFee);
+    const forwardPayload = pool_1.Pool.createLiquidatePayload({
+        repayAsset: repayAssetAddress,
+        seizeAsset: seizeAssetAddress,
+        borrower: borrowerAddress,
+        response: sender.address,
+        jettonForwardTonAmount,
+        jettonForwardPayload,
+        oracleParams,
+    });
+    const opts = {
+        recipient: poolAddress,
+        amount: params.amount,
+        response: sender.address,
+        forwardTonAmount: gas,
+        forwardPayload,
+        queryId: params.queryId,
+    };
+    if (isWTON) {
+        const poolWalletAddress = await getJettonWalletAddress(ctx, poolAddress, repayAssetAddress);
+        const poolWTONWallet = ctx.getByContract(jetton_wallet_2.WTONWallet, poolWalletAddress);
+        return {
+            opts,
+            input: {
+                to: poolWTONWallet.address,
+                value: value ?? jetton_wallet_2.WTONWallet.Gas.ExternalTransfer,
+                body: poolWTONWallet.createExternalTransferBody(opts),
+            },
+        };
+    }
+    else {
+        const senderWalletAddress = await getJettonWalletAddress(ctx, sender.address, repayAssetAddress);
+        const senderWallet = ctx.getByContract(jetton_wallet_1.JettonWallet, senderWalletAddress);
+        return {
+            opts,
+            input: {
+                to: senderWallet.address,
+                value: value ?? gas + jetton_wallet_1.JettonWallet.Gas.Transfer,
+                body: senderWallet.createTransferBody(opts),
+            },
+        };
+    }
+}