@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/farm.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FarmV1 = void 0;
+const ton_1 = require("@ton/ton");
+const contracts_1 = require("./constants/contracts");
+const pool_1 = require("./contracts/core/pool");
+const tracker_1 = require("./utils/tracker");
+const parser_1 = require("./utils/parser");
+const query_id_generactor_1 = require("./utils/tracker/query-id-generactor");
+const Receipt_compiled_json_1 = __importDefault(require("./build/Receipt.compiled.json"));
+const receipt_1 = require("./contracts/farm/receipt");
+const distributor_1 = require("./contracts/farm/distributor");
+const generateRandomQueryId = (senderAddress) => {
+    const randomCell = (0, ton_1.beginCell)().storeCoins(Date.now()).storeCoins(Math.floor(Math.random() * 1000000000000)).endCell();
+    const queryId = (0, query_id_generactor_1.generateQueryId)(toAddress(senderAddress), randomCell);
+    return queryId;
+};
+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 FarmV1 {
+    network;
+    client;
+    contracts;
+    // user -> asset -> wallet
+    walletAddresses = {};
+    // user -> pool -> account
+    accountAddresses = {};
+    constructor(client, network, custom_contracts) {
+        this.client = client;
+        this.network = network;
+        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 getAccountAddress(owner, pool) {
+        this.accountAddresses[owner] ||= {};
+        if (!this.accountAddresses[owner][pool]) {
+            const poolContract = this.client.open(pool_1.Pool.createFromAddress(toAddress(pool)));
+            this.accountAddresses[owner][pool] = await poolContract.getAccountAddress(toAddress(owner));
+        }
+        return this.accountAddresses[owner][pool];
+    }
+    async findAndCallback(target, step, createdLt, callbackFn) {
+        const matchedTx = await (0, tracker_1.findTx)(this.client, 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;
+    }
+    async claimFactorialRewardAndWaitTx(sender, params, callbackFn) {
+        let receipt = this.client.open(receipt_1.Receipt.createFromConfig({
+            distributor: toAddress(params.distributorAddress),
+            owner: toAddress(params.senderAddress),
+        }, ton_1.Cell.fromHex(Receipt_compiled_json_1.default.hex)));
+        let gas = (0, ton_1.toNano)(0.25);
+        if (await this.client.isContractDeployed(receipt.address)) {
+            receipt = this.client.open(receipt_1.Receipt.createFromAddress(receipt.address));
+            gas += (0, ton_1.toNano)(0.05);
+        }
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await receipt.sendClaim(sender, params.gas || gas, {
+            queryId,
+            rewardProofCell: params.proofCell,
+            response: toAddress(params.responseAddress),
+            receipient: toAddress(params.receipientAddress),
+        });
+        const steps = [];
+        steps.push({
+            queryId,
+            description: "Sending the tx",
+            from: toAddress(params.senderAddress),
+            to: receipt.address,
+            opcode: receipt_1.Receipt.Op.Claim,
+        });
+        steps.push({
+            queryId,
+            description: "Check claimed amount",
+            from: receipt.address,
+            to: toAddress(params.distributorAddress),
+            opcode: receipt_1.Receipt.Op.Claim,
+        });
+        steps.push({
+            queryId,
+            description: "Transfer claim reward",
+            from: toAddress(params.distributorAddress),
+            to: toAddress(params.senderAddress),
+            opcode: distributor_1.Distributor.Op.TransferReward,
+        });
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(toAddress(params.distributorAddress), steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(toAddress(params.senderAddress), steps[2], matchedTx1.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "distributor-claim",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async findTx(action, callbackFn) {
+        if (action.type == "distributor-claim") {
+            return this.findFactorialClaimTx(BigInt(action.queryId), action.params, callbackFn);
+        }
+    }
+    async findFactorialClaimTx(queryId, params, callbackFn) {
+        let receipt = this.client.open(receipt_1.Receipt.createFromConfig({
+            distributor: toAddress(params.distributorAddress),
+            owner: toAddress(params.senderAddress),
+        }, ton_1.Cell.fromHex(Receipt_compiled_json_1.default.hex)));
+        if (await this.client.isContractDeployed(receipt.address)) {
+            receipt = this.client.open(receipt_1.Receipt.createFromAddress(receipt.address));
+        }
+        const steps = [];
+        steps.push({
+            queryId,
+            description: "Sending the tx",
+            from: toAddress(params.senderAddress),
+            to: receipt.address,
+            opcode: receipt_1.Receipt.Op.Claim,
+        });
+        steps.push({
+            queryId,
+            description: "Check claimed amount",
+            from: receipt.address,
+            to: toAddress(params.distributorAddress),
+            opcode: receipt_1.Receipt.Op.Claim,
+        });
+        steps.push({
+            queryId,
+            description: "Transfer claim reward",
+            from: toAddress(params.distributorAddress),
+            to: toAddress(params.senderAddress),
+            opcode: distributor_1.Distributor.Op.TransferReward,
+        });
+        (async () => {
+            const matchedTx0 = await this.findAndCallback(toAddress(params.senderAddress), steps[0], "0", callbackFn);
+            const matchedTx1 = await this.findAndCallback(toAddress(params.distributorAddress), steps[1], matchedTx0.lt.toString(), callbackFn);
+            const matchedTx2 = await this.findAndCallback(toAddress(params.senderAddress), steps[2], matchedTx1.lt.toString(), callbackFn);
+        })();
+        return {
+            action: {
+                type: "distributor-claim",
+                params,
+                queryId,
+            },
+            steps,
+        };
+    }
+    async getDistributorData(distributorAddress) {
+        const distributor = this.client.open(distributor_1.Distributor.createFromAddress(toAddress(distributorAddress)));
+        return await distributor.getDistributorData();
+    }
+    async getReceiptData(distributorAddress, userAddress) {
+        let receipt = this.client.open(receipt_1.Receipt.createFromConfig({
+            distributor: toAddress(distributorAddress),
+            owner: toAddress(userAddress),
+        }, ton_1.Cell.fromHex(Receipt_compiled_json_1.default.hex)));
+        if (await this.client.isContractDeployed(receipt.address)) {
+            return {
+                deployed: true,
+                ...(await receipt.getReceiptData())
+            };
+        }
+        else {
+            return {
+                deployed: false,
+                owner: userAddress,
+                distributor: distributorAddress,
+                claimed: 0n,
+            };
+        }
+    }
+    async setDistributorRootHash(sender, params) {
+        const distributor = this.client.open(distributor_1.Distributor.createFromAddress(toAddress(params.distributorAddress)));
+        const queryId = generateRandomQueryId(params.senderAddress);
+        await distributor.sendSetRewardRootHash(sender, params.gas || (0, ton_1.toNano)(0.02), {
+            queryId,
+            newHash: params.newRootHash,
+        });
+    }
+}
+exports.FarmV1 = FarmV1;

package/dist/monitor.d.ts

@@ -0,0 +1,57 @@
+import { Address, TonClient } from "@ton/ton";
+import { RiskResult } from "./types/pool";
+import { PoolState } from "./contracts/core/pool/type";
+import { OnchainDataInfo } from "./contracts/oracle/redstone-onchain-oracle/type";
+import { TxCallBackFn, TxStep } from "./utils/tracker/type";
+import { AssetPriceInfo } from "./contracts/oracle/redstone-onchain-oracle/type";
+import { AccountAssetState, AccountState } from "./contracts/core/account/type";
+export declare class MonitorV1 {
+    network: "testnet" | "mainnet" | "custom";
+    client: TonClient;
+    contracts: Record<string, string>;
+    private walletAddresses;
+    private accountAddresses;
+    constructor(client: TonClient, network: "testnet" | "mainnet" | "custom", custom_contracts?: Record<string, string>);
+    private getJettonWalletAddress;
+    getAccountAddress(owner: string, pool: string): Promise<Address>;
+    findAndCallback(target: Address, step: TxStep, createdLt: string | bigint, callbackFn?: TxCallBackFn): Promise<import("./utils/tracker/type").MatchedTxResult>;
+    updateOnchainData(onchainDataInfo: OnchainDataInfo): Promise<OnchainDataInfo>;
+    getRedstonePrices(assets: string[], poolData: any): Promise<{
+        redstonePrices: AssetPriceInfo;
+        onchainData: any;
+    }>;
+    getRedstonePricesNew(assets: string[], oracleConfig: any): Promise<{
+        redstonePrices: AssetPriceInfo;
+        onchainData: any;
+    }>;
+    calculatePrices(_prices: AssetPriceInfo, oracleData: any): AssetPriceInfo;
+    decomposeAccountStatus(accountStatus: Record<string, AccountAssetState>, prices: AssetPriceInfo, onchainData: OnchainDataInfo): Record<string, Omit<AccountAssetState, "address">>;
+    calculateRisk(decomposedAccountStatus: Record<string, Omit<AccountAssetState, "address">>, prices: AssetPriceInfo, poolData: PoolState): {
+        result: boolean;
+        healthy: boolean;
+        unhealthy: boolean;
+        collateral: bigint;
+        debt: bigint;
+        risk: bigint;
+        riskRatio: bigint;
+        leverageRatio: bigint;
+    };
+    getOracleRequestParams(assets: string[], oracleConfig: any): Promise<{
+        feedIds: bigint[];
+        redstoneAssetNames: any[];
+        requestAssets: Address[];
+        redstoneAssets: Address[];
+    }>;
+    isHealthy(poolAddress: Address | string, ownerAddress: Address | string): Promise<RiskResult>;
+    getPricesNew(assets: string[], oracleConfig: any): Promise<AssetPriceInfo>;
+    getAssetPricesInPool(poolAddress: Address | string): Promise<AssetPriceInfo>;
+    getAssetPricesInVault(vaultAddress: Address | string): Promise<AssetPriceInfo>;
+    getPrices(poolAddress: Address | string): Promise<AssetPriceInfo>;
+    getPricesAndOnchainData(poolData: any): Promise<{
+        prices: AssetPriceInfo;
+        onchainData: any;
+    }>;
+    getPoolData(poolAddress: Address | string): Promise<PoolState>;
+    getAccountData(address: Address | string): Promise<AccountState>;
+    calculateHealth(_poolData: PoolState, _accountData: AccountState, prices: any, onchainData: any): RiskResult;
+}