@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/strategy_vault/index.d.ts

@@ -0,0 +1,3 @@
+import { StrategyVaultSteps } from "./steps";
+export declare class StrategyVaultV1 extends StrategyVaultSteps {
+}

package/dist/strategy_vault/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyVaultV1 = void 0;
+const steps_1 = require("./steps");
+class StrategyVaultV1 extends steps_1.StrategyVaultSteps {
+}
+exports.StrategyVaultV1 = StrategyVaultV1;

package/dist/strategy_vault/steps.d.ts

@@ -0,0 +1,49 @@
+import { Address, Sender } from "@ton/core";
+import { AddressLike } from "../contracts/common/type";
+import { StrategyVaultBase } from "./base";
+import { TxCallBackFn, TxStep } from "../utils/tracker/type";
+export declare class StrategyVaultSteps extends StrategyVaultBase {
+    sendDepositAssetAndWait(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        amount: bigint;
+        queryID?: bigint;
+    }, callbackFn?: TxCallBackFn, value?: bigint): Promise<{
+        action: {
+            type: string;
+            params: {
+                strategyVaultAddress: AddressLike;
+                assetAddress: AddressLike;
+                amount: bigint;
+                queryID?: bigint;
+            };
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    sendBurnVaultAssetAndWait(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        withdrawAssetAddress: AddressLike;
+        vaultShareAmountForBurn: bigint;
+        queryID?: bigint;
+    }, callbackFn?: TxCallBackFn, value?: bigint): Promise<{
+        action: {
+            type: string;
+            params: {
+                strategyVaultAddress: AddressLike;
+                withdrawAssetAddress: AddressLike;
+                vaultShareAmountForBurn: bigint;
+                queryID?: bigint;
+            };
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    findAndCallback(target: Address, step: TxStep, createdLt: string | bigint, callbackFn?: TxCallBackFn): Promise<import("../utils/tracker/type").MatchedTxResult>;
+    buildFullSteps(startAddress: Address, queryId: bigint, steps: TxStep[]): TxStep[];
+    processingSteps(startAddress: Address, queryId: bigint, steps: ({
+        description: string;
+        opcode: number;
+        to: Address;
+    } | TxStep)[], callbackFn?: TxCallBackFn): Promise<void>;
+}

package/dist/strategy_vault/steps.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyVaultSteps = void 0;
+const utils_1 = require("../contracts/common/utils");
+const jetton_minter_1 = require("../contracts/jetton/jetton-minter");
+const base_1 = require("./base");
+const jetton_wallet_1 = require("../contracts/jetton/jetton-wallet");
+const parser_1 = require("../utils/parser");
+const tracker_1 = require("../utils/tracker");
+const jetton_minter_2 = require("../contracts/wton/jetton-minter");
+const jetton_wallet_2 = require("../contracts/wton/jetton-wallet");
+class StrategyVaultSteps extends base_1.StrategyVaultBase {
+    async sendDepositAssetAndWait(sender, params, callbackFn, value) {
+        const requesterAddress = sender.address;
+        const vault = this.getVault(params.strategyVaultAddress);
+        const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+        const isWTONDeposit = assetAddress.toString() === (0, utils_1.toAddress)(this.contracts.WTON).toString();
+        ////////////////////////// tx //////////////////////////
+        const opts = await this.sendDepositAsset(sender, params, value);
+        const stepInfo = [];
+        if (isWTONDeposit) {
+            const wtonMaster = this.getByContract(jetton_minter_2.WTONMinter, assetAddress);
+            stepInfo.push({
+                description: "Supplying Ton to the StrategyVault",
+                to: await wtonMaster.getWalletAddress(vault.address),
+                opcode: jetton_wallet_2.WTONWallet.Op.ExternalTransfer,
+            });
+        }
+        else {
+            const asset = this.getByContract(jetton_minter_1.JettonMinter, assetAddress);
+            stepInfo.push({
+                description: "Sending the tx",
+                to: await asset.getWalletAddress(sender.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            }, {
+                description: "Supplying jetton to the StrategyVault",
+                to: await asset.getWalletAddress(vault.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            });
+        }
+        ////////////////////////// steps //////////////////////////
+        stepInfo.push({
+            description: "StrategyVault action notification",
+            to: vault.address,
+            opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+        }, {
+            description: "Mint StrategyVault jetton",
+            to: await vault.getWalletAddress(sender.address),
+            opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+        }, {
+            description: "Excesses StrategyVault jetton mint",
+            to: opts.response,
+            opcode: jetton_wallet_1.JettonWallet.Op.Excesses,
+        });
+        const fullSteps = this.buildFullSteps(requesterAddress, opts.queryId, stepInfo);
+        this.processingSteps(requesterAddress, opts.queryId, fullSteps, callbackFn);
+        return {
+            action: {
+                type: "strategy_vault-supply",
+                params,
+                queryId: opts.queryId,
+            },
+            steps: fullSteps,
+        };
+    }
+    async sendBurnVaultAssetAndWait(sender, params, callbackFn, value) {
+        const opts = await this.sendBurnVaultAsset(sender, params, value);
+        const requesterAddress = sender.address;
+        const vault = this.getVault(params.strategyVaultAddress);
+        const isWTON = params.withdrawAssetAddress.toString() === this.contracts.WTON
+            ? true
+            : false;
+        const stepInfo = [];
+        stepInfo.push({
+            description: "Sending the Burn tx",
+            to: await vault.getWalletAddress(sender.address),
+            opcode: jetton_wallet_1.JettonWallet.Op.Burn,
+        }, {
+            description: "Notify StrategyVault Token Burn",
+            to: vault.address,
+            opcode: jetton_wallet_1.JettonWallet.Op.BurnNotification,
+        });
+        if (isWTON) {
+            const wton = this.getByContract(jetton_minter_2.WTONMinter, params.withdrawAssetAddress);
+            stepInfo.push({
+                description: "Withdraw WTON",
+                to: await wton.getWalletAddress(vault.address),
+                opcode: jetton_wallet_2.WTONWallet.Op.Transfer,
+            }, {
+                description: "Transfer WTON Asset",
+                to: await wton.getWalletAddress(sender.address),
+                opcode: jetton_wallet_2.WTONWallet.Op.InternalTransfer,
+            }, {
+                description: "Unwrap WTON",
+                to: sender.address,
+                opcode: jetton_wallet_2.WTONWallet.Op.UnwrapNotification,
+            });
+        }
+        else {
+            const asset = this.getByContract(jetton_minter_1.JettonMinter, params.withdrawAssetAddress);
+            stepInfo.push({
+                description: "Withdraw Asset",
+                to: await asset.getWalletAddress(vault.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            }, {
+                description: "Transfer Withdraw Asset",
+                to: await asset.getWalletAddress(sender.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            }, {
+                description: "Excesses StrategyVault withdraw",
+                to: opts.response,
+                opcode: jetton_wallet_1.JettonWallet.Op.Excesses,
+            });
+        }
+        const fullSteps = this.buildFullSteps(requesterAddress, opts.queryId, stepInfo);
+        this.processingSteps(requesterAddress, opts.queryId, fullSteps, callbackFn);
+        return {
+            action: {
+                type: "strategy_vault-withdraw",
+                params,
+                queryId: opts.queryId,
+            },
+            steps: fullSteps,
+        };
+    }
+    async findAndCallback(target, step, createdLt, callbackFn) {
+        const matchedTx = await (0, tracker_1.findTx)(this.client, (0, utils_1.toAddress)(target), createdLt.toString(), step);
+        step.matchedTx = matchedTx;
+        if (matchedTx.inMessage?.body) {
+            const parsed = (0, parser_1.parseActionNotification)(matchedTx.inMessage.body);
+            if (parsed) {
+                step.actionNotificationResult = parsed;
+            }
+        }
+        if (callbackFn)
+            callbackFn(step);
+        return matchedTx;
+    }
+    buildFullSteps(startAddress, queryId, steps) {
+        const result = [];
+        let currentFrom = startAddress;
+        for (const step of steps) {
+            const fullStep = {
+                queryId,
+                description: step.description,
+                opcode: step.opcode,
+                from: currentFrom,
+                to: step.to,
+            };
+            result.push(fullStep);
+            currentFrom = step.to;
+        }
+        return result;
+    }
+    async processingSteps(startAddress, queryId, steps, callbackFn) {
+        let prevLt = "0";
+        let currentAddress = startAddress;
+        for (const step of steps) {
+            const enrichedStep = {
+                ...step,
+                queryId,
+                from: currentAddress,
+            };
+            const matchedTx = await this.findAndCallback(currentAddress, enrichedStep, prevLt, callbackFn);
+            currentAddress = step.to;
+            prevLt = matchedTx.lt.toString();
+        }
+    }
+}
+exports.StrategyVaultSteps = StrategyVaultSteps;

package/dist/types/action.d.ts

@@ -0,0 +1,55 @@
+import { Address } from "@ton/ton";
+export type TransferInActionParams = {
+    sender: Address | string;
+    pool: Address | string;
+    asset: Address | string;
+    amount: bigint;
+    recipient: Address | string;
+    response: Address | string;
+};
+export type TansferOutActionParams = {
+    sender: Address | string;
+    pool: Address | string;
+    asset: Address | string;
+    isShare: boolean;
+    amount: bigint;
+    recipient: Address | string;
+    response: Address | string;
+};
+export type LiquidateActionParams = {
+    sender: Address | string;
+    pool: Address | string;
+    repayAsset: Address | string;
+    seizeAsset: Address | string;
+    borrower: Address | string;
+    amount: bigint;
+    response: Address | string;
+};
+export type HealthCheckParams = {
+    pool: Address | string;
+    borrower: Address | string;
+};
+export type ShareVaultUserActionParams = {
+    sender: Address | string;
+    vault: Address | string;
+    amount: bigint;
+    response: Address | string;
+};
+export type ShareVaultManagerSupplyAction = {
+    sender: Address | string;
+    vault: Address | string;
+    pool: Address | string;
+    amount: bigint;
+};
+export type ShareVaultManagerWithdrawAction = {
+    sender: Address | string;
+    vault: Address | string;
+    pool: Address | string;
+    amount: bigint;
+    isShare: boolean;
+};
+export type ShareVaultManagerSetTargetWeightAction = {
+    vault: Address | string;
+    pool: Address | string;
+    targetWeight: number;
+};

package/dist/types/action.js

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

package/dist/types/messages.d.ts

@@ -0,0 +1,7 @@
+import { Address, Cell, internal } from "@ton/core";
+export type InternalInput = Promise<Parameters<typeof internal>[0]>;
+export type InternalMessageInput = {
+    to: Address;
+    value: bigint;
+    body: Cell;
+};

package/dist/types/messages.js

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

package/dist/types/params.d.ts

@@ -0,0 +1,19 @@
+import { Address } from "@ton/core";
+export type Hex = `0x${string}`;
+export type UnderlyingAssetOracleConfig = {
+    type: "underlying";
+    assetAddress: Address;
+    decimal: bigint;
+};
+export type SynthAssetOracleConfig = {
+    type: "synth";
+    assetAddress: Address;
+    underlyingAddress: Address;
+    decimal: bigint;
+};
+export type AssetOracleConfigParams = Record<string, UnderlyingAssetOracleConfig | SynthAssetOracleConfig>;
+export type OracleConfigParams = {
+    assetConfig: AssetOracleConfigParams;
+    signerThreshold: bigint;
+    signers: Hex[];
+};

package/dist/types/params.js

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

package/dist/types/pool.d.ts

@@ -0,0 +1,83 @@
+import { Address, BitString, Cell, Dictionary } from "@ton/ton";
+export type Maybe<T> = T | null | undefined;
+export type PoolConfig = {
+    feeConfigurer: Address;
+    owner: Address;
+    router: Address;
+    oracle: Address;
+    plugins: Dictionary<Address, Boolean>;
+    assets: Dictionary<Address, BitString>;
+    accountCode: Cell;
+};
+export type AssetConfig = {
+    wallet?: Address;
+    irm?: Address;
+    irmData: Cell;
+    ltv: number;
+    lltv: number;
+    lir: number;
+    isBorrowable: number;
+};
+export type ActionGasFee = {
+    supply: bigint;
+    withdraw: bigint;
+    borrow: bigint;
+    repay: bigint;
+    liquidate: bigint;
+};
+export type ActionParams = {
+    pool: Address;
+    queryId?: number;
+    deadline?: number;
+};
+export type SupplyParams = ActionParams & {
+    asset: Address;
+    amount: bigint;
+    recipient?: Address;
+};
+export type WithdrawParams = ActionParams & {
+    asset: Address;
+    amount: bigint;
+    isShare: boolean;
+    useOracle: boolean;
+    recipient?: Address;
+};
+export type BorrowParams = ActionParams & {
+    asset: Address;
+    amount: bigint;
+    isShare: boolean;
+    recipient?: Address;
+};
+export type RepayParams = ActionParams & {
+    asset: Address;
+    amount: bigint;
+    recipient?: Address;
+};
+export type LiquidateParams = ActionParams & {
+    repayAsset: Address;
+    seizeAsset: Address;
+    borrower: Address;
+    oracleParams: Cell;
+};
+export type RiskResult = {
+    result: boolean;
+    healthy: boolean;
+    unhealthy: boolean;
+    collateral: bigint;
+    debt: bigint;
+    risk: bigint;
+    riskRatio: bigint;
+    leverageRatio: bigint;
+};
+export type MaxBorrowableResult = {
+    amount: bigint;
+    reason: "RISK_RATIO_CONSTRAINT" | "LEVERAGE_CONSTRAINT" | "POOL_CASH_CONSTRAINT";
+    beforeAccountHealth: RiskResult;
+    afterAccountHealth: RiskResult;
+};
+export type MaxWithdrawableResult = {
+    amount: bigint;
+    reason: "RISK_RATIO_CONSTRAINT" | "LEVERAGE_CONSTRAINT" | "POOL_CASH_CONSTRAINT" | "USER_SUPPLY_CONSTRAINT";
+    beforeAccountHealth?: RiskResult;
+    afterAccountHealth?: RiskResult;
+};

package/dist/types/pool.js

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

package/dist/types/transaction.d.ts

@@ -0,0 +1,40 @@
+import { Address } from "@ton/ton";
+export type ActionSuccessTransaciton = {
+    op: number;
+    queryId: number;
+    sender: Address;
+    opType: "supply" | "withdraw" | "borrow" | "repay" | "liquidate";
+};
+export type SupplySuccessTransaction = ActionSuccessTransaciton & {
+    opType: "supply";
+    asset: Address;
+    supplyAmount: bigint;
+    supplyShare: bigint;
+};
+export type WithdrawSuccessTransaction = ActionSuccessTransaciton & {
+    opType: "withdraw";
+    asset: Address;
+    withdrawAmount: bigint;
+    withdrawShare: bigint;
+};
+export type BorrowSuccessTransaction = ActionSuccessTransaciton & {
+    opType: "borrow";
+    asset: Address;
+    borrowAmount: bigint;
+    borrowShare: bigint;
+};
+export type RepaySuccessTransaction = ActionSuccessTransaciton & {
+    opType: "repay";
+    asset: Address;
+    repayAmount: bigint;
+    repayShare: bigint;
+    overRepaidAmount: bigint;
+};
+export type LiquidateSuccessTransaction = ActionSuccessTransaciton & {
+    opType: "liquidate";
+    repayAsset: Address;
+    seizeAsset: Address;
+    repayAmount: bigint;
+    repayShare: bigint;
+    seizeShare: bigint;
+};

package/dist/types/transaction.js

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

package/dist/utils/_parse_temp/JumpIRM.d.ts

@@ -0,0 +1,37 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/core';
+export type JumpIRMConfig = {
+    owner: Address;
+};
+export type JumpIRMParams = {
+    baseRate: bigint;
+    kinkLow: number;
+    kinkHigh: number;
+    slopeLow: bigint;
+    slopeMedium: bigint;
+    slopeHigh: bigint;
+};
+export declare function jumpIRMConfigToCell(config: JumpIRMConfig): Cell;
+export declare class JumpIRM implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): JumpIRM;
+    static createFromConfig(config: JumpIRMConfig, code: Cell, workchain?: number): JumpIRM;
+    static createJumpIRMConfig(params: JumpIRMParams): Cell;
+    static parseJumpIRMConfig(cell: Cell): {
+        baseRate: bigint;
+        kinkLow: number;
+        kinkHigh: number;
+        slopeLow: bigint;
+        slopeMedium: bigint;
+        slopeHigh: bigint;
+    };
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    getInterestRate(provider: ContractProvider, supply: bigint, borrow: bigint, cell: Cell): Promise<bigint>;
+}

package/dist/utils/_parse_temp/JumpIRM.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JumpIRM = void 0;
+exports.jumpIRMConfigToCell = jumpIRMConfigToCell;
+const core_1 = require("@ton/core");
+function jumpIRMConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(config.owner)
+        .endCell();
+}
+class JumpIRM {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JumpIRM(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = jumpIRMConfigToCell(config);
+        const init = { code, data };
+        return new JumpIRM((0, core_1.contractAddress)(workchain, init), init);
+    }
+    static createJumpIRMConfig(params) {
+        return (0, core_1.beginCell)()
+            .storeCoins(params.baseRate)
+            .storeUint(params.kinkLow, 14)
+            .storeUint(params.kinkHigh, 14)
+            .storeCoins(params.slopeLow)
+            .storeCoins(params.slopeMedium)
+            .storeCoins(params.slopeHigh)
+            .endCell();
+    }
+    static parseJumpIRMConfig(cell) {
+        const result = cell.beginParse();
+        const baseRate = result.loadCoins();
+        const kinkLow = result.loadUint(14);
+        const kinkHigh = result.loadUint(14);
+        const slopeLow = result.loadCoins();
+        const slopeMedium = result.loadCoins();
+        const slopeHigh = result.loadCoins();
+        return {
+            baseRate,
+            kinkLow,
+            kinkHigh,
+            slopeLow,
+            slopeMedium,
+            slopeHigh,
+        };
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    async getInterestRate(provider, supply, borrow, cell) {
+        const _supply = { type: 'int', value: supply };
+        const _borrow = { type: 'int', value: borrow };
+        const tic = {
+            type: 'cell',
+            cell: cell,
+        };
+        const result = await provider.get('get_interest_rate', [_supply, _borrow, tic]);
+        return result.stack.readBigNumber();
+    }
+}
+exports.JumpIRM = JumpIRM;