@affluent-org/sdk 0.0.2 → 0.0.3

package/dist/rfq-auction.d.ts

@@ -0,0 +1,75 @@
+import { Address, Cell, Sender } from "@ton/ton";
+import { AddressInput, AddressLike } from "./contracts/common/type";
+import { StrategyVaultState } from "./contracts/vault/strategy-vault/type";
+import { ServiceBaseV1 } from "./common/service";
+export declare class RFQAuctionV1 extends ServiceBaseV1 {
+    sendAmountBid(sender: Sender, params: {
+        rfqAuctionAddress: AddressInput;
+        bidAsset: AddressInput;
+        intendedBidAmount: bigint;
+        forwardTonAmount?: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<void>;
+    sendSlippageBid(sender: Sender, params: {
+        rfqAuctionAddress: AddressInput;
+        bidAsset: AddressInput;
+        slippage: number;
+        intendedBidAmount: bigint;
+        forwardfee?: bigint;
+        queryId?: bigint;
+    }, value?: bigint): Promise<void>;
+    sendCancelBid(sender: Sender, params: {
+        rfqAuctionAddress: AddressInput;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendSettle(sender: Sender, params: {
+        rfqAuctionAddress: AddressInput;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    sendClearBids(sender: Sender, params: {
+        rfqAuctionAddress: AddressInput;
+        clear_counts: number;
+        queryId?: number;
+    }, value?: bigint): Promise<void>;
+    getRfqData(rfqAuctionAddress: AddressInput): Promise<{
+        initialized: boolean;
+        index: bigint;
+        state: number;
+        sellerAddress: Address;
+        verifiedSellWallet: boolean;
+        verifiedBuyWallet: boolean;
+        depositedSellAsset: boolean;
+        bids: Record<string, {
+            bidValue: bigint;
+            escrowAmount: bigint;
+            lt: bigint;
+            responseAddress: Address;
+            forwardTonAmount: bigint;
+            forwardPayload: string | null;
+        }>;
+        sellAssetAddress: Address;
+        buyAssetAddress: Address;
+        sellAssetAmount: bigint;
+        config: {
+            auctionMode: number;
+            bidCloseTimestamp: number;
+            minBuyAssetValue: bigint;
+            maxBuyAssetValue: bigint;
+            allowSellerCancel: boolean;
+            allowBidderCancel: boolean;
+            priceDeviationTolerance: bigint;
+        };
+        sellAssetWalletAddress: Address | null;
+        buyAssetWalletAddress: Address | null;
+        rfqEventEmitterAddress: Address | null;
+        dataAggregatorCodeHash: string | null;
+        dataAggregatorIndex: bigint;
+        oracleConfig: import("./contracts/oracle/redstone-oracle/type").RedstonOracleConfig | Cell | import("./contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | null;
+        jettonForwardTonAmount: bigint;
+        jettonForwardPayloadHash: string | null;
+        responseAddress: Address;
+        rfqNotiForwardTonAmount: bigint;
+        rfqNotiForwardPayloadHash: string | null;
+    }>;
+    getOracleParams(vaultAddress: AddressLike, additionalAssets?: AddressLike[], allFactorialVaults?: AddressLike[], vaultData?: StrategyVaultState): Promise<Cell>;
+}

package/dist/rfq-auction.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFQAuctionV1 = void 0;
+const ton_1 = require("@ton/ton");
+const redstone_onchain_oracle_1 = require("./contracts/oracle/redstone-onchain-oracle");
+const redstoneHelper_1 = require("./utils/oracle/redstone/redstoneHelper");
+const utils_1 = require("./contracts/common/utils");
+const service_1 = require("./common/service");
+const rfq_auction_1 = require("./contracts/rfq/rfq_auction");
+const jetton_minter_1 = require("./contracts/jetton/jetton-minter");
+const jetton_wallet_1 = require("./contracts/jetton/jetton-wallet");
+const strategy_vault_1 = require("./contracts/vault/strategy-vault");
+const jetton_minter_2 = require("./contracts/wton/jetton-minter");
+const jetton_wallet_2 = require("./contracts/wton/jetton-wallet");
+const WTONWallet_compiled_json_1 = __importDefault(require("./build/WTONWallet.compiled.json"));
+const strategy_vault_2 = require("./strategy_vault");
+const oracle_1 = require("./oracle/oracle");
+const toString = (value) => {
+    if (value instanceof ton_1.Address) {
+        return value.toString();
+    }
+    return value;
+};
+class RFQAuctionV1 extends service_1.ServiceBaseV1 {
+    async sendAmountBid(sender, params, value) {
+        const rfqAuction = this.getByContract(rfq_auction_1.RFQAuction, (0, utils_1.toAddress)(params.rfqAuctionAddress));
+        const rfqData = await rfqAuction.getRfqData();
+        if (rfqData.config.auctionMode !== rfq_auction_1.RFQAuction.AuctionMode.AmountBid)
+            throw new Error("Auction mode must be AmountBid.");
+        const existingBid = rfqData.bids[sender.address.toString()];
+        const maxEscrow = rfqData.config.maxBuyAssetValue;
+        const existingEscrow = existingBid?.escrowAmount ?? 0n;
+        const intendedBidAmount = params.intendedBidAmount > maxEscrow
+            ? maxEscrow
+            : params.intendedBidAmount;
+        const transferBidAmount = intendedBidAmount > existingEscrow
+            ? intendedBidAmount - existingEscrow
+            : 0n;
+        const rfqAddress = (0, utils_1.toAddress)(params.rfqAuctionAddress);
+        const bidAssetAddress = (0, utils_1.toAddress)(params.bidAsset);
+        const sellAsset = (0, utils_1.toAddress)(rfqData.sellAssetAddress);
+        const wtonAddress = (0, utils_1.toAddress)(this.contracts.WTON);
+        const jettonForwardTonAmount = sellAsset.toString() === wtonAddress.toString() ||
+            bidAssetAddress.toString() === wtonAddress.toString()
+            ? (0, ton_1.toNano)(0.02)
+            : 0n;
+        const jettonForwardPayload = sellAsset.toString() === wtonAddress.toString() ||
+            bidAssetAddress.toString() === wtonAddress.toString()
+            ? jetton_minter_2.WTON_UNWRAP_CELL
+            : null;
+        if (bidAssetAddress.toString() === wtonAddress.toString()) {
+            // send to rfqContract wton wallet
+            const wtonMaster = this.getByContract(jetton_minter_2.WTONMinter, bidAssetAddress);
+            let wtonWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromConfig({
+                jettonMinter: wtonMaster.address,
+                owner: rfqAddress,
+                walletCode: ton_1.Cell.fromHex(WTONWallet_compiled_json_1.default.hex),
+            }, ton_1.Cell.fromHex(WTONWallet_compiled_json_1.default.hex)));
+            let gas = jetton_wallet_2.WTONWallet.Gas.ExternalTransfer + (0, ton_1.toNano)(0.1);
+            if (await this.client.isContractDeployed(wtonWallet.address)) {
+                wtonWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromAddress(wtonWallet.address));
+                gas += (0, ton_1.toNano)(0.05);
+            }
+            await wtonWallet.sendExternalTransfer(sender, value ?? gas, {
+                recipient: rfqAddress,
+                amount: transferBidAmount,
+                response: sender.address,
+                forwardTonAmount: params.forwardTonAmount ?? (0, ton_1.toNano)(0.2) + jettonForwardTonAmount, // RFQAuction.Constants.BID_FEE ??
+                forwardPayload: rfq_auction_1.RFQAuction.createBidMsg(intendedBidAmount, sender.address, jettonForwardTonAmount, jettonForwardPayload),
+                queryId: params.queryId,
+            });
+        }
+        else {
+            const bidWalletAddress = await this.getByContract(jetton_minter_1.JettonMinter, params.bidAsset).getWalletAddress(sender.address);
+            const bidWallet = this.getByContract(jetton_wallet_1.JettonWallet, bidWalletAddress);
+            await bidWallet.sendTransfer(sender, value ?? (0, ton_1.toNano)(0.3), {
+                recipient: (0, utils_1.toAddress)(params.rfqAuctionAddress),
+                response: sender.address,
+                amount: transferBidAmount,
+                forwardTonAmount: params.forwardTonAmount ?? (0, ton_1.toNano)(0.2) + jettonForwardTonAmount,
+                forwardPayload: rfq_auction_1.RFQAuction.createBidMsg(intendedBidAmount, sender.address, jettonForwardTonAmount, jettonForwardPayload),
+            });
+        }
+    }
+    async sendSlippageBid(sender, params, value) {
+        const rfqAuction = this.getByContract(rfq_auction_1.RFQAuction, (0, utils_1.toAddress)(params.rfqAuctionAddress));
+        const rfqData = await rfqAuction.getRfqData();
+        if (rfqData.config.auctionMode !== rfq_auction_1.RFQAuction.AuctionMode.SlippageBid)
+            throw new Error("Auction mode must be SlippageBid.");
+        if (params.slippage < 0)
+            throw new Error("Slippage must not be negative in SlippageBid mode.");
+        const existingBid = rfqData.bids[sender.address.toString()];
+        const existingEscrow = existingBid?.escrowAmount ?? 0n;
+        const intendedBidAmount = params.intendedBidAmount > existingEscrow
+            ? params.intendedBidAmount - existingEscrow
+            : 0n;
+        const slippage = (0, ton_1.toNano)(params.slippage);
+        const rfqAddress = (0, utils_1.toAddress)(params.rfqAuctionAddress);
+        const bidAssetAddress = (0, utils_1.toAddress)(params.bidAsset);
+        const sellAsset = (0, utils_1.toAddress)(rfqData.sellAssetAddress);
+        const wtonAddress = (0, utils_1.toAddress)(this.contracts.WTON);
+        const jettonForwardTonAmount = sellAsset.toString() === wtonAddress.toString() ||
+            bidAssetAddress.toString() === wtonAddress.toString()
+            ? (0, ton_1.toNano)(0.02)
+            : 0n;
+        const jettonForwardPayload = sellAsset.toString() === wtonAddress.toString() ||
+            bidAssetAddress.toString() === wtonAddress.toString()
+            ? jetton_minter_2.WTON_UNWRAP_CELL
+            : null;
+        if (bidAssetAddress.toString() === (0, utils_1.toAddress)(this.contracts.WTON).toString()) {
+            // send to rfqContract wton wallet
+            const wtonMaster = this.getByContract(jetton_minter_2.WTONMinter, bidAssetAddress);
+            let wtonWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromConfig({
+                jettonMinter: wtonMaster.address,
+                owner: rfqAddress,
+                walletCode: ton_1.Cell.fromHex(WTONWallet_compiled_json_1.default.hex),
+            }, ton_1.Cell.fromHex(WTONWallet_compiled_json_1.default.hex)));
+            let gas = jetton_wallet_2.WTONWallet.Gas.ExternalTransfer + (0, ton_1.toNano)(0.1);
+            if (await this.client.isContractDeployed(wtonWallet.address)) {
+                wtonWallet = this.client.open(jetton_wallet_2.WTONWallet.createFromAddress(wtonWallet.address));
+                gas += (0, ton_1.toNano)(0.05);
+            }
+            await wtonWallet.sendExternalTransfer(sender, value ?? gas, {
+                recipient: rfqAddress,
+                amount: intendedBidAmount,
+                response: sender.address,
+                forwardTonAmount: params.forwardfee ?? (0, ton_1.toNano)(0.2) + jettonForwardTonAmount, // RFQAuction.Constants.BID_FEE ??
+                forwardPayload: rfq_auction_1.RFQAuction.createBidMsg(slippage, sender.address, jettonForwardTonAmount, jettonForwardPayload),
+                queryId: params.queryId,
+            });
+        }
+        else {
+            // send to sender jetton wallet
+            const bidWalletAddress = await this.getByContract(jetton_minter_1.JettonMinter, bidAssetAddress).getWalletAddress(sender.address);
+            const bidWallet = this.getByContract(jetton_wallet_1.JettonWallet, bidWalletAddress);
+            await bidWallet.sendTransfer(sender, value ?? (0, ton_1.toNano)(0.3), {
+                recipient: rfqAddress,
+                response: sender.address,
+                amount: intendedBidAmount,
+                forwardTonAmount: params.forwardfee ?? (0, ton_1.toNano)(0.2) + jettonForwardTonAmount, // RFQAuction.Constants.BID_FEE ??
+                forwardPayload: rfq_auction_1.RFQAuction.createBidMsg(slippage, sender.address, jettonForwardTonAmount, jettonForwardPayload),
+                queryId: params.queryId,
+            });
+        }
+    }
+    async sendCancelBid(sender, params, value) {
+        const rfqAuction = this.getByContract(rfq_auction_1.RFQAuction, (0, utils_1.toAddress)(params.rfqAuctionAddress));
+        await rfqAuction.sendCancelBid(sender, value ?? (0, ton_1.toNano)(0.1));
+    }
+    async sendSettle(sender, params, value) {
+        const rfqAuction = this.getByContract(rfq_auction_1.RFQAuction, (0, utils_1.toAddress)(params.rfqAuctionAddress));
+        const oracleLibs = new oracle_1.OracleLibs(this.client, this.network);
+        const oracleParams = await oracleLibs.getOracleParamsForStrategyVaultRFQAuction(await rfqAuction.getRfqData());
+        await rfqAuction.sendSettle(sender, value ?? (0, ton_1.toNano)(1), { oracleParams });
+    }
+    async sendClearBids(sender, params, value) {
+        const rfqAuction = this.getByContract(rfq_auction_1.RFQAuction, (0, utils_1.toAddress)(params.rfqAuctionAddress));
+        const fee = value ?? (0, ton_1.toNano)(0.005 * params.clear_counts) + (0, ton_1.toNano)(0.1);
+        await rfqAuction.sendClearBids(sender, fee, params.clear_counts);
+    }
+    async getRfqData(rfqAuctionAddress) {
+        const rfqAuction = this.getByContract(rfq_auction_1.RFQAuction, (0, utils_1.toAddress)(rfqAuctionAddress));
+        return await rfqAuction.getRfqData();
+    }
+    async getOracleParams(vaultAddress, additionalAssets = [], allFactorialVaults = [], vaultData) {
+        const sv = new strategy_vault_2.StrategyVaultV1(this.client, this.network);
+        const vault = this.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+        vaultData = vaultData ?? (await vault.getVaultData());
+        const allAssetAddresses = new Set();
+        additionalAssets.map((item) => allAssetAddresses.add(item.toString()));
+        Object.keys(vaultData.assets).forEach((assetAddress) => {
+            const asset = vaultData.assets[assetAddress];
+            if (asset.cash > 0) {
+                allAssetAddresses.add(assetAddress);
+            }
+        });
+        const pools = [];
+        for (const poolAddress of Object.keys(vaultData.factorialPools)) {
+            const assets = vaultData.factorialPools[poolAddress];
+            for (const assetAddress of Object.keys(assets)) {
+                if (assets[assetAddress].supply > 0 ||
+                    assets[assetAddress].borrow > 0) {
+                    pools.push(poolAddress);
+                    break;
+                }
+            }
+        }
+        const { vaultAssetAddresses, pureAssetAddresses } = await sv.splitPureAndVaultAsset([...allAssetAddresses]);
+        const result = redstone_onchain_oracle_1.RedstoneOnchainOracle.getOracleRequestParams(pureAssetAddresses, 
+        // @ts-ignore
+        vaultData.oracleConfig);
+        const helper = (0, redstoneHelper_1.createRedstoneHelper)("prod");
+        const payload = await helper.createPayload(result.redstoneAssetNames);
+        const requestAssetCell = redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(result.requestAssets);
+        const dataFeedIdsTupleBuilder = new ton_1.TupleBuilder();
+        result.feedIds.forEach((item) => dataFeedIdsTupleBuilder.writeNumber(item));
+        const feedIdCell = (0, ton_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+        let requestFactorialPoolsCell = pools.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(pools.map((item) => ton_1.Address.parse(item)))
+            : null;
+        let requestFactorialVaultsCell = vaultAssetAddresses.length > 0
+            ? redstone_onchain_oracle_1.RedstoneOnchainOracle.createAddressToTupleCell(vaultAssetAddresses.map((item) => ton_1.Address.parse(item)))
+            : null;
+        let requestFactorialCell = (0, ton_1.beginCell)()
+            .storeMaybeRef(requestFactorialPoolsCell)
+            .storeMaybeRef(requestFactorialVaultsCell)
+            .endCell();
+        const oracleParams = (0, ton_1.beginCell)()
+            .storeRef(feedIdCell)
+            .storeRef(payload)
+            .storeRef(requestAssetCell)
+            .storeRef(requestFactorialCell)
+            .endCell();
+        return oracleParams;
+    }
+}
+exports.RFQAuctionV1 = RFQAuctionV1;

package/dist/rfq-batch.d.ts

@@ -0,0 +1,112 @@
+import { Address, Cell, internal, Sender } from "@ton/ton";
+import { AddressInput } from "./contracts/common/type";
+import { ServiceBaseV1 } from "./common/service";
+export declare class RFQBatchV1 extends ServiceBaseV1 {
+    sendAddOrder(sender: Sender, params: {
+        senderAddress: AddressInput;
+        rfqBatchAddress: AddressInput;
+        assetAddress: AddressInput;
+        amount: bigint;
+        forwardTonAmount?: bigint;
+        forwardPayload?: Cell | null;
+        queryId?: bigint;
+    }, value?: bigint): Promise<void>;
+    sendSettle(sender: Sender, params: {
+        senderAddress: AddressInput;
+        rfqBatchAddress: AddressInput;
+        assetAddress: AddressInput;
+        amount: bigint;
+        forwardTonAmount?: bigint;
+        forwardPayload?: Cell | null;
+        queryId?: bigint;
+    }, value?: bigint): Promise<void>;
+    separateAssets(_assets: string[], oracleConfig: any): Promise<{
+        assets: string[];
+        vaultAssets: string[];
+    }>;
+    getParsedVaults(vaultAddresses: (Address | string)[]): Promise<Record<string, VaultPosition>>;
+    getExposures(vaults: Record<string, VaultPosition>): Promise<{
+        pools: string[];
+        assets: string[];
+    }>;
+    getOracleParams(rfqBatchAddress: AddressInput): Promise<Cell>;
+    sendLock(sender: Sender, params: {
+        rfqBatchAddress: AddressInput;
+    }, value?: bigint): Promise<void>;
+    sendCancelOrder(sender: Sender, params: {
+        rfqBatchAddress: AddressInput;
+        assetAddress: AddressInput;
+    }, value?: bigint): Promise<void>;
+    sendPayout(sender: Sender, params: {
+        rfqBatchAddress: AddressInput;
+        assetAddress: AddressInput;
+        count: number;
+    }, value?: bigint): Promise<void>;
+    sendReopen(sender: Sender, params: {
+        rfqBatchAddress: AddressInput;
+    }, value?: bigint): Promise<void>;
+    sendCollectFee(sender: Sender, params: {
+        rfqBatchAddress: AddressInput;
+    }, value?: bigint): Promise<void>;
+    getRfqBatchData(rfqBatchAddress: AddressInput): Promise<{
+        index: bigint;
+        asset0Address: Address;
+        asset1Address: Address;
+        asset0TotalAmount: bigint;
+        asset1TotalAmount: bigint;
+        asset0Orders: Record<string, import("./contracts/rfq/rfq_batch").Order>;
+        asset1Orders: Record<string, import("./contracts/rfq/rfq_batch").Order>;
+        status: number;
+        lockedTimestamp: number;
+        lockOwner: Address | null;
+        asset0WalletAddress: Address | null;
+        asset1WalletAddress: Address | null;
+        aggregatorIndex: bigint;
+        feeRate: bigint;
+        feeManager: Address | null;
+        whitelistedSettlers: Record<string, boolean>;
+        lockPeriod: number;
+        lockCooldown: number;
+        asset0CollectedFee: bigint;
+        asset1CollectedFee: bigint;
+        orderCount: bigint;
+        orderLimit: bigint;
+        asset0MinAmount: bigint;
+        asset1MinAmount: bigint;
+        asset0MaxAmount: bigint;
+        asset1MaxAmount: bigint;
+        guardianAddress: Address | null;
+        asset0Price: bigint;
+        asset1Price: bigint;
+        oracleConfig: import("./contracts/oracle/redstone-oracle/type").RedstonOracleConfig | Cell | import("./contracts/oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | null;
+    }>;
+    createInternalAddOrder(sender: Sender, params: {
+        senderAddress: AddressInput;
+        rfqBatchAddress: AddressInput;
+        assetAddress: AddressInput;
+        amount: bigint;
+        forwardTonAmount?: bigint;
+        forwardPayload?: Cell | null;
+        queryId?: bigint;
+    }, value?: bigint): Promise<{
+        to: Address | string;
+        value: bigint | string;
+        extracurrency?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/ton").ExtraCurrency>;
+        bounce?: import("@ton/core/dist/utils/maybe").Maybe<boolean>;
+        init?: import("@ton/core/dist/utils/maybe").Maybe<import("@ton/ton").StateInit>;
+        body?: import("@ton/core/dist/utils/maybe").Maybe<Cell | string>;
+    }>;
+    createInternalCancelOrder(params: {
+        rfqBatchAddress: AddressInput;
+        assetAddress: AddressInput;
+    }, value?: bigint): Promise<Parameters<typeof internal>[0]>;
+}
+type VaultPosition = {
+    assets: Record<string, bigint>;
+    poolPositions: Record<string, Record<string, {
+        supply: bigint;
+        borrow: bigint;
+    }>>;
+    totalSupply: bigint;
+};
+export {};