@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/stonfi.d.ts

@@ -0,0 +1,18 @@
+import { Address, Cell, TonClient } from "@ton/ton";
+export declare class StonfiV1 {
+    client: TonClient;
+    contracts: Record<string, string>;
+    private walletAddresses;
+    constructor(client: TonClient, network: "testnet" | "mainnet" | "custom", custom_contracts?: Record<string, string>);
+    private getJettonWalletAddress;
+    getFarmingData(nftAddress: string | Address): Promise<{
+        address: string | Address;
+        status: number;
+        statusString: string;
+        itemIndex: bigint;
+        stakedTokens: bigint;
+        stakedDate: bigint;
+        claimedPerUnitDict: Cell;
+        ownerAddress: Address;
+    }>;
+}

package/dist/stonfi.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StonfiV1 = void 0;
+const ton_1 = require("@ton/ton");
+const contracts_1 = require("./constants/contracts");
+const jetton_minter_1 = require("./contracts/jetton/jetton-minter");
+const TIMEOUT_SEC = 2 * 60 * 1000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const toAddress = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value;
+    }
+    return ton_1.Address.parse(value);
+};
+const toString = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value.toString();
+    }
+    return value;
+};
+class StonfiV1 {
+    client;
+    contracts;
+    // user -> asset -> wallet
+    walletAddresses = {};
+    constructor(client, network, custom_contracts) {
+        this.client = client;
+        if (network === "custom" && !custom_contracts)
+            throw "should provide custom contracts";
+        this.contracts =
+            network === "mainnet"
+                ? contracts_1.MAINNET_CONTRACTS
+                : network === "testnet"
+                    ? contracts_1.TESTNET_CONTRACTS
+                    : custom_contracts;
+    }
+    async getJettonWalletAddress(owner, jetton) {
+        if (!this.walletAddresses[owner]) {
+            this.walletAddresses[owner] = {};
+        }
+        if (!this.walletAddresses[owner][jetton]) {
+            const jettonMinter = this.client.open(jetton_minter_1.JettonMinter.createFromAddress(toAddress(jetton)));
+            this.walletAddresses[owner][jetton] = await jettonMinter.getWalletAddress(toAddress(owner));
+        }
+        return this.walletAddresses[owner][jetton];
+    }
+    async getFarmingData(nftAddress) {
+        const result = await this.client
+            .provider(toAddress(nftAddress))
+            .get("get_farming_data", []);
+        const status = result.stack.readNumber();
+        const itemIndex = result.stack.readBigNumber();
+        const stakedTokens = result.stack.readBigNumber();
+        const stakedDate = result.stack.readBigNumber();
+        const claimedPerUnitDict = result.stack.readCell();
+        const ownerAddress = result.stack.readAddress();
+        const statusMap = {
+            0: "nft::status::uninitialized",
+            1: "nft::status::active",
+            2: "nft::status::unstaked",
+            3: "nft::status::claiming",
+            4: "nft::status::unstaked_pending",
+        };
+        return {
+            address: nftAddress,
+            status,
+            statusString: statusMap[status],
+            itemIndex,
+            stakedTokens,
+            stakedDate,
+            claimedPerUnitDict,
+            ownerAddress
+        };
+    }
+}
+exports.StonfiV1 = StonfiV1;

package/dist/strategy_vault/base.d.ts

@@ -0,0 +1,399 @@
+import { Address, Sender, OpenedContract, Cell } from "@ton/core";
+import { ServiceBaseV1 } from "../common/service";
+import { AddressInput, AddressLike } from "../contracts/common/type";
+import { StrategyVault } from "../contracts/vault/strategy-vault";
+import { JettonWallet } from "../contracts/jetton/jetton-wallet";
+import { RFQAuction } from "../contracts/rfq/rfq_auction";
+import { AssetPriceInfo, OnchainDataInfo } from "../contracts/oracle/redstone-onchain-oracle/type";
+import { PoolState, StrategyVaultState } from "..";
+export declare function createQueryId(data: any, timestamp?: number): bigint;
+type SlippageBound = {
+    min: number;
+    max: number;
+};
+type SippageBoundInput = number | SlippageBound;
+export declare class StrategyVaultBase extends ServiceBaseV1 {
+    getVaultData(strategyVaultAddress: AddressLike): Promise<{
+        owner: Address;
+        manager: Address;
+        assets: Record<string, import("../contracts/vault/strategy-vault").Asset>;
+        factorialPools: Record<string, import("../contracts/vault/strategy-vault").FactorialPool>;
+        aggregatorIndex: bigint;
+        content: Cell;
+        totalSupply: bigint;
+        oracleConfig: import("../contracts/oracle/redstone-oracle/type").RedstonOracleConfig | Cell | import("../contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | null;
+        rfqConfig: {
+            priceDerivationTolerance: number;
+            rfqEventEmitterAddress: string | null;
+        } | null;
+        gasConfig: Record<string, bigint> | null;
+        isPrivateVault: boolean;
+        depositCloseTimestamp: number;
+        withdrawOpenTimestamp: number;
+        whitelistedMinters: Address[];
+        lastCollectTime: number;
+        managementFeeRatePerYear: number;
+        protocolFeeRatePerYear: number;
+        collectedManagementFee: bigint;
+        collectedProtocolFee: bigint;
+        rfqCode: Cell;
+        walletCode: Cell;
+        dataAggregatorCode: Cell;
+        protocolFeeManagerAddress: Address;
+        rfqIndex: bigint;
+        isExecutingStrategy: boolean;
+        maxLeverageRatio: number;
+        assetWalletDict: Record<string, string>;
+        walletAssetDict: Record<string, string>;
+        managementFeeRecipientAddress: Address | null;
+        guardianAddress: Address | null;
+        timelock: bigint;
+        pendingOwnerActionIndex: bigint;
+        pendingOwnerActionCount: bigint;
+        pendingOwnerAction: Record<string, import("../contracts/vault/strategy-vault").PendingOwnerAction>;
+        address: Address;
+    }>;
+    getVault(strategyVaultAddress: AddressLike): OpenedContract<StrategyVault>;
+    getVaultWallet(strategyVaultAddress: AddressLike, accountAddress: AddressLike): Promise<OpenedContract<JettonWallet>>;
+    sendSetOwner(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        owner: AddressLike;
+        queryId?: number;
+    }): Promise<void>;
+    sendSetGuardianAddress(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        guardianAddress: AddressLike;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetManager(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        manager: AddressLike;
+        queryId?: number;
+    }): Promise<void>;
+    sendSetPrivateVault(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        isPrivateVault: boolean;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetWhitelistedMinters(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        whitelistedMinters: AddressLike[];
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetMaxLeverageRatio(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        maxLeverageRatio: number;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendExecuteOwnerAction(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        updateIndex: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendRevertOwnerAction(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        updateIndex: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetTimelock(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        timelock: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetManagementFeeRecipientAddress(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        managementFeeRecipientAddress: AddressLike;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetProtocolFeeRatePerYear(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        protocolFeeRatePerYear: number;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetProtocolFeeManagerAddress(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        protocolFeeManagerAddress: AddressLike;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetFactorialPoolConfig(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        configs: {
+            poolAddress: AddressLike;
+            assetAddress: AddressLike;
+            isSupplyable: boolean;
+            isBorrowable: boolean;
+        }[];
+    }): Promise<void>;
+    sendSetAssetConfig(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        isWhitelisted: boolean;
+        isDepositable: boolean;
+        isWithdrawable: boolean;
+        exposureCap: number;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetRFQConfig(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        priceDeviationTolerance: bigint;
+        rfqEmitterAddress: AddressLike;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    getOracleParamsV2(vaultAddress: AddressLike, vaultData?: StrategyVaultState, extraAssets?: {
+        assets: string[];
+        vaultAssets: string[];
+    }): Promise<Cell>;
+    getOracleParams(vaultAddress: AddressLike, additionalAssets?: AddressLike[], allFactorialVaults?: AddressLike[], vaultData?: StrategyVaultState): Promise<Cell>;
+    sendDepositAsset(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        amount: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<{
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: Cell;
+        queryId: bigint;
+    }>;
+    sendBurnVaultAsset(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        withdrawAssetAddress: AddressLike;
+        vaultShareAmountForBurn: bigint;
+        queryID?: bigint;
+    }, value?: bigint): Promise<{
+        amount: bigint;
+        response: Address;
+        forwardPayload: Cell;
+        queryId: bigint;
+    }>;
+    createInternalDepositAsset(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        amount: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<{
+        to: Address | string;
+        value: bigint | string;
+        extracurrency?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").ExtraCurrency>;
+        bounce?: import("@ton/core/dist/utils/maybe").Maybe<boolean>;
+        init?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").StateInit>;
+        body?: import("@ton/core/dist/utils/maybe").Maybe<Cell | string>;
+    }>;
+    createInternalBurnVaultAsset(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        withdrawAssetAddress: AddressLike;
+        vaultShareAmountForBurn: bigint;
+        queryID?: bigint;
+    }, value?: bigint): Promise<{
+        to: Address | string;
+        value: bigint | string;
+        extracurrency?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").ExtraCurrency>;
+        bounce?: import("@ton/core/dist/utils/maybe").Maybe<boolean>;
+        init?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/core").StateInit>;
+        body?: import("@ton/core/dist/utils/maybe").Maybe<Cell | string>;
+    }>;
+    getRFQAuctionAddress(strategyVaultAddress: AddressInput, index: bigint): Promise<Address>;
+    getRFQAuction(strategyVaultAddress: AddressInput, index: bigint): Promise<OpenedContract<RFQAuction>>;
+    sendCreateAmountRFQ(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        sellAssetAddress: AddressLike;
+        buyAssetAddress: AddressLike;
+        sellAssetAmount: bigint;
+        minBuyAssetAmount: bigint;
+        maxBuyAssetAmount: bigint;
+        period: number;
+        allowSellerCancel: boolean;
+        allowBidderCancel: boolean;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendUnwrapWTON(sender: Sender, params: {
+        senderAddress: AddressLike;
+        wtonAddress: AddressLike;
+        amount: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendCreateSlippageRFQ(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        sellAssetAddress: AddressLike;
+        buyAssetAddress: AddressLike;
+        sellAssetAmount: bigint;
+        slippageBound: SippageBoundInput;
+        period: number;
+        allowSellerCancel: boolean;
+        allowBidderCancel: boolean;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendCancelRFQ(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        rfqIndex: bigint;
+        queryID?: number;
+    }, value?: bigint): Promise<void>;
+    sendSupplyToFactorial(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        poolAddress: AddressLike;
+        assetAddress: AddressLike;
+        assetAmount: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendBorrowFromFactorial(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        poolAddress: AddressLike;
+        assetAddress: AddressLike;
+        assetAmount: bigint;
+        isShare: boolean;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendRepayToFactorial(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        poolAddress: AddressLike;
+        assetAddress: AddressLike;
+        assetAmount: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendWithdrawFromFactorial(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        poolAddress: AddressLike;
+        assetAddress: AddressLike;
+        assetAmount: bigint;
+        isShare: boolean;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendLiquidateToFactorial(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        poolAddress: AddressLike;
+        borrowerAddress: AddressLike;
+        repayAssetAddress: AddressLike;
+        seizeAssetAddress: AddressLike;
+        repayAmount: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    splitPureAndVaultAsset(addresses: AddressInput[]): Promise<{
+        vaultAssetAddresses: string[];
+        pureAssetAddresses: string[];
+    }>;
+    isVaultAsset(address: AddressInput): Promise<boolean>;
+    getAssetPrices(strategyVaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<AssetPriceInfo>;
+    getPrice(strategyVaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<bigint>;
+    getPriceV2(strategyVaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<{
+        price: bigint;
+        type: number;
+        additionalData: {
+            decomposed: Record<string, {
+                supply: bigint;
+                borrow: bigint;
+            }>;
+            totalSupply: bigint;
+        };
+    }>;
+    getAssetPricesV2(vaultAddress: Address | string): Promise<{
+        [x: string]: import("../contracts/oracle/redstone-onchain-oracle/type").AssetPrice | {
+            price: bigint;
+            type: number;
+            additionalData: {
+                decomposed: Record<string, {
+                    supply: bigint;
+                    borrow: bigint;
+                }>;
+                totalSupply: bigint;
+            };
+        };
+    }>;
+    calculateVaultPrices(price: AssetPriceInfo, poolInfos: Record<string, PoolState>, vaults: Record<string, VaultPosition>): Promise<Record<string, {
+        price: bigint;
+        type: number;
+        additionalData: {
+            decomposed: Record<string, {
+                supply: bigint;
+                borrow: bigint;
+            }>;
+            totalSupply: bigint;
+        };
+    }>>;
+    getParsedVaults(vaultAddresses: (Address | string)[]): Promise<Record<string, VaultPosition>>;
+    getExposures(vaults: Record<string, VaultPosition>): Promise<{
+        pools: string[];
+        assets: string[];
+    }>;
+    calculatePrices(_prices: AssetPriceInfo, oracleData: any): AssetPriceInfo;
+    updateOnchainData(onchainDataInfo: OnchainDataInfo): Promise<OnchainDataInfo>;
+    getRedstonePrices(assets: string[], oracleConfig: any): Promise<{
+        redstonePrices: AssetPriceInfo;
+        onchainData: any;
+    }>;
+    separateAssets(_assets: string[], oracleConfig: any): Promise<{
+        assets: string[];
+        vaultAssets: string[];
+    }>;
+    sendCollectProtocolFee(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendClaimManagementFee(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        receiverAddress: AddressLike;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetManagementFeeRatePerYear(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        managementFeeRatePerYear: number;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetDepositCloseTimestamp(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        depositCloseTimestamp: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetWithdrawOpenTimestamp(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        withdrawOpenTimestamp: bigint;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetGasConfig(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        gasConfig: Cell | null;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetOracleConfig(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        oracleConfig: Cell | null;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetWalletCode(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        walletCode: Cell;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetDataAggregatorCode(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        dataAggregatorCode: Cell;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetRFQCode(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        rfqCode: Cell;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSetContent(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        content: Cell;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendUpgradeCode(sender: Sender, params: {
+        strategyVaultAddress: AddressLike;
+        newCode: Cell;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    getTotalValue(strategyVaultAddress: AddressLike, vaultData?: StrategyVaultState): Promise<bigint>;
+}
+type VaultPosition = {
+    assets: Record<string, bigint>;
+    poolPositions: Record<string, Record<string, {
+        supply: bigint;
+        borrow: bigint;
+    }>>;
+    totalSupply: bigint;
+};
+export {};