@affluent-org/sdk 0.0.5 → 0.0.6

package/dist/strategy_vault/steps.d.ts

@@ -1,9 +1,10 @@
-import { Address, Sender } from "@ton/core";
+import { Address, Cell } from "@ton/core";
 import { AddressLike } from "../contracts/common/type";
 import { StrategyVaultBase } from "./base";
 import { TxCallBackFn, TxStep } from "../utils/tracker/type";
+import { AddressSender } from "../types/sender";
 export declare class StrategyVaultSteps extends StrategyVaultBase {
-    sendDepositAssetAndWait(sender: Sender, params: {
+    sendDepositAssetAndWait(sender: AddressSender, params: {
         strategyVaultAddress: AddressLike;
         assetAddress: AddressLike;
         amount: bigint;
@@ -21,7 +22,7 @@ export declare class StrategyVaultSteps extends StrategyVaultBase {
         };
         steps: TxStep[];
     }>;
-    sendBurnVaultAssetAndWait(sender: Sender, params: {
+    sendBurnVaultAssetAndWait(sender: AddressSender, params: {
         strategyVaultAddress: AddressLike;
         withdrawAssetAddress: AddressLike;
         vaultShareAmountForBurn: bigint;
@@ -39,6 +40,122 @@ export declare class StrategyVaultSteps extends StrategyVaultBase {
         };
         steps: TxStep[];
     }>;
+    sendDepositQueueAndWait(sender: AddressSender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        amount: bigint;
+        forwardParams?: {
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queueItemParams?: {
+            actionForwardTonAmount?: bigint;
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queryId?: bigint;
+        value?: bigint;
+    }, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: {
+                strategyVaultAddress: AddressLike;
+                assetAddress: AddressLike;
+                amount: bigint;
+                forwardParams?: {
+                    forwardTonAmount?: bigint;
+                    forwardPayload?: Cell;
+                };
+                queueItemParams?: {
+                    actionForwardTonAmount?: bigint;
+                    forwardTonAmount?: bigint;
+                    forwardPayload?: Cell;
+                };
+                queryId?: bigint;
+                value?: bigint;
+            };
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    sendWithdrawQueueAndWait(sender: AddressSender, params: {
+        strategyVaultAddress: AddressLike;
+        shareAmount: bigint;
+        assetAddress: AddressLike;
+        forwardParams?: {
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queueItemParams?: {
+            actionForwardTonAmount?: bigint;
+            forwardTonAmount?: bigint;
+            forwardPayload?: Cell;
+        };
+        queryId?: bigint;
+        value?: bigint;
+    }, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: {
+                strategyVaultAddress: AddressLike;
+                shareAmount: bigint;
+                assetAddress: AddressLike;
+                forwardParams?: {
+                    forwardTonAmount?: bigint;
+                    forwardPayload?: Cell;
+                };
+                queueItemParams?: {
+                    actionForwardTonAmount?: bigint;
+                    forwardTonAmount?: bigint;
+                    forwardPayload?: Cell;
+                };
+                queryId?: bigint;
+                value?: bigint;
+            };
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    sendCancelDepositQueueAndWait(sender: AddressSender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        userAddress: AddressLike;
+        queryId?: bigint;
+        value?: bigint;
+    }, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: {
+                strategyVaultAddress: AddressLike;
+                assetAddress: AddressLike;
+                userAddress: AddressLike;
+                queryId?: bigint;
+                value?: bigint;
+            };
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    sendCancelWithdrawQueueAndWait(sender: AddressSender, params: {
+        strategyVaultAddress: AddressLike;
+        assetAddress: AddressLike;
+        userAddress: AddressLike;
+        queryId?: bigint;
+        value?: bigint;
+    }, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: {
+                strategyVaultAddress: AddressLike;
+                assetAddress: AddressLike;
+                userAddress: AddressLike;
+                queryId?: bigint;
+                value?: 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: ({

package/dist/strategy_vault/steps.js

@@ -3,6 +3,7 @@ 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 strategy_vault_1 = require("../contracts/vault/strategy-vault");
 const base_1 = require("./base");
 const jetton_wallet_1 = require("../contracts/jetton/jetton-wallet");
 const parser_1 = require("../utils/parser");
@@ -123,6 +124,166 @@ class StrategyVaultSteps extends base_1.StrategyVaultBase {
             steps: fullSteps,
         };
     }
+    async sendDepositQueueAndWait(sender, params, callbackFn) {
+        const requesterAddress = sender.address;
+        const vault = this.getVault(params.strategyVaultAddress);
+        const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+        const isWTONDeposit = this.isWTON(assetAddress);
+        ////////////////////////// tx //////////////////////////
+        const opts = await this.sendDepositQueue(sender, params);
+        const stepInfo = [];
+        if (isWTONDeposit) {
+            const wtonMaster = this.getByContract(jetton_minter_2.WTONMinter, assetAddress);
+            stepInfo.push({
+                description: "Send deposit queue wton",
+                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: "Send deposit queue jetton",
+                to: await asset.getWalletAddress(sender.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            }, {
+                description: "Transfer deposit queue jetton to the StrategyVault",
+                to: await asset.getWalletAddress(vault.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            });
+        }
+        ////////////////////////// steps //////////////////////////
+        stepInfo.push({
+            description: "Send deposit queue",
+            to: vault.address,
+            opcode: jetton_wallet_1.JettonWallet.Op.TransferNotification,
+        }, {
+            description: "Excesses deposit queue",
+            to: requesterAddress,
+            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-deposit_queue",
+                params,
+                queryId: opts.queryId,
+            },
+            steps: fullSteps,
+        };
+    }
+    async sendWithdrawQueueAndWait(sender, params, callbackFn) {
+        const opts = await this.sendWithdrawQueue(sender, params);
+        const requesterAddress = sender.address;
+        const vault = this.getVault(params.strategyVaultAddress);
+        const stepInfo = [];
+        stepInfo.push({
+            description: "Sending the withdraw queue tx",
+            to: await vault.getWalletAddress(sender.address),
+            opcode: jetton_wallet_1.JettonWallet.Op.Burn,
+        }, {
+            description: "Send withdraw queue",
+            to: vault.address,
+            opcode: jetton_wallet_1.JettonWallet.Op.BurnNotification,
+        }, {
+            description: "Excesses withdraw queue",
+            to: requesterAddress,
+            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_queue",
+                params,
+                queryId: opts.queryId,
+            },
+            steps: fullSteps,
+        };
+    }
+    async sendCancelDepositQueueAndWait(sender, params, callbackFn) {
+        const opts = await this.sendCancelDepositQueue(sender, params);
+        const requesterAddress = sender.address;
+        const vault = this.getVault(params.strategyVaultAddress);
+        const isWTON = this.isWTON(params.assetAddress);
+        const stepInfo = [];
+        stepInfo.push({
+            description: "Sending the Deposit Queue Cancel tx",
+            to: vault.address,
+            opcode: strategy_vault_1.StrategyVault.Op.CancelDepositQueue,
+        });
+        if (isWTON) {
+            const wton = this.getByContract(jetton_minter_2.WTONMinter, params.assetAddress);
+            stepInfo.push({
+                description: "Refund WTON",
+                to: await wton.getWalletAddress(vault.address),
+                opcode: jetton_wallet_2.WTONWallet.Op.Transfer,
+            }, {
+                description: "Refund transfer WTON",
+                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.assetAddress);
+            stepInfo.push({
+                description: "Refund Jetton",
+                to: await asset.getWalletAddress(vault.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.Transfer,
+            }, {
+                description: "Refund transfer Jetton",
+                to: await asset.getWalletAddress(sender.address),
+                opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            }, {
+                description: "Excesses jetton transfer",
+                to: requesterAddress,
+                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-deposit_queue_cancel",
+                params,
+                queryId: opts.queryId,
+            },
+            steps: fullSteps,
+        };
+    }
+    async sendCancelWithdrawQueueAndWait(sender, params, callbackFn) {
+        const opts = await this.sendCancelWithdrawQueue(sender, params);
+        const vault = this.getVault(params.strategyVaultAddress);
+        const stepInfo = [];
+        stepInfo.push({
+            description: "Sending the withdraw queue cancel tx",
+            to: vault.address,
+            opcode: strategy_vault_1.StrategyVault.Op.CancelWithdrawQueue,
+        }, {
+            description: "Refund StrategyVault Token",
+            to: await vault.getWalletAddress(sender.address),
+            opcode: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+        }, {
+            description: "Excesses StrategyVault mint",
+            to: sender.address,
+            opcode: jetton_wallet_1.JettonWallet.Op.Excesses,
+        });
+        const fullSteps = this.buildFullSteps(sender.address, params.queryId, stepInfo);
+        this.processingSteps(sender.address, opts.queryId, fullSteps, callbackFn);
+        return {
+            action: {
+                type: "strategy_vault-withdraw_queue_cancel",
+                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;

package/dist/types/sender.d.ts

@@ -1,6 +1,7 @@
 import { Address, Sender, SenderArguments } from "@ton/core";
 export interface AddressSender extends Sender {
     readonly address: Address;
+    getSeqno(): Promise<number>;
 }
 export interface MultiSender extends AddressSender {
     multiSend(args: SenderArguments[]): Promise<void>;

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

@@ -1,4 +1,4 @@
-import { Address, Builder, Cell, Contract, ContractProvider, Dictionary, Sender, Slice } from '@ton/core';
+import { Address, Builder, Cell, Contract, ContractProvider, Dictionary, Sender, Slice } from "@ton/core";
 export type StrategyVaultConfig = {
     ownerAddress: Address;
     assets: Cell | null;
@@ -61,12 +61,12 @@ export declare class StrategyVault implements Contract {
         SetWhitelistedMinters: number;
         SetManagementFeeRatePerYear: number;
         SetMaxLeverageRatio: number;
-        SetRfqConfig: number;
+        SetRFQConfig: number;
         SetGasConfig: number;
         SetOracleConfig: number;
         SetWalletCode: number;
         SetDataAggregatorCode: number;
-        SetRfqCode: number;
+        SetRFQCode: number;
         SetContent: number;
         UpgradeCode: number;
         SetGuardianAddress: number;
@@ -89,10 +89,10 @@ export declare class StrategyVault implements Contract {
         LiquidateToFactorial: number;
         Deposit: number;
         Withdraw: number;
-        CreateRfq: number;
+        CreateRFQ: number;
         ExecuteStrategy: number;
         TakeAggregatedData: number;
-        CancelRfq: number;
+        CancelRFQ: number;
         Excesses: number;
     };
     static Error: {
@@ -122,7 +122,7 @@ export declare class StrategyVault implements Contract {
         NotEnoughGas: number;
         InvalidOp: number;
         ExceededExposureCap: number;
-        InvalidRfqPeriod: number;
+        InvalidRFQPeriod: number;
         InvalidConfig: number;
         InvalidPendingOwnerActionIndex: number;
         NotYetExecutable: number;
@@ -134,7 +134,7 @@ export declare class StrategyVault implements Contract {
         IncreaseBalance: number;
         FactorialTransferIn: number;
         FactorialTransferOut: number;
-        CreateRfq: number;
+        CreateRFQ: number;
         FactorialLiquidate: number;
         RFQInitialize: number;
         RFQNotification: number;
@@ -240,7 +240,7 @@ export declare class StrategyVault implements Contract {
     }): Promise<void>;
     getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
     getWalletAddress(provider: ContractProvider, address: Address): Promise<Address>;
-    getRfqAddress(provider: ContractProvider, index: bigint): Promise<Address>;
+    getRFQAddress(provider: ContractProvider, index: bigint): Promise<Address>;
     static createFactorialPoolConfig(params: [Address, Address, boolean, boolean][]): Dictionary<Address, FactorialPool>;
     static createFactorialPoolUpdateConfig(params: [Address, Address, boolean, boolean][]): Dictionary<Address, any>;
     static createAssetConfig(params: [Address, boolean, boolean, boolean, number][]): Dictionary<Address, Asset>;
@@ -429,7 +429,7 @@ export declare class StrategyVault implements Contract {
     static getOpName(opCode: number): string;
     static getErrorName(errorCode: number): string;
     static getGasKeyName(gasKey: number): string;
-    static getAvailableActionsOriginal(): readonly ["SetOwnerAddress", "SetAssetConfig", "SetFactorialPoolConfig", "SetManagerAddress", "SetPrivateVault", "SetDepositCloseTimestamp", "SetWithdrawOpenTimestamp", "SetWhitelistedMinters", "SetManagementFeeRatePerYear", "SetMaxLeverageRatio", "SetRfqConfig", "SetGasConfig", "SetOracleConfig", "SetWalletCode", "SetDataAggregatorCode", "SetRfqCode", "SetContent", "UpgradeCode", "SetGuardianAddress", "SetTimelock", "SetManagementFeeRecipientAddress", "ClaimProtocolFee", "SetProtocolFeeRatePerYear", "SetProtocolFeeManagerAddress", "ClaimManagementFee", "ExecuteOwnerAction", "RevertOwnerAction", "Initialize", "SupplyToFactorial", "WithdrawFromFactorial", "BorrowFromFactorial", "RepayToFactorial", "LiquidateToFactorial", "CreateRfq", "CancelRfq", "TakeAggregatedData", "Excesses"];
+    static getAvailableActionsOriginal(): readonly ["SetOwnerAddress", "SetAssetConfig", "SetFactorialPoolConfig", "SetManagerAddress", "SetPrivateVault", "SetDepositCloseTimestamp", "SetWithdrawOpenTimestamp", "SetWhitelistedMinters", "SetManagementFeeRatePerYear", "SetMaxLeverageRatio", "SetRFQConfig", "SetGasConfig", "SetOracleConfig", "SetWalletCode", "SetDataAggregatorCode", "SetRFQCode", "SetContent", "UpgradeCode", "SetGuardianAddress", "SetTimelock", "SetManagementFeeRecipientAddress", "ClaimProtocolFee", "SetProtocolFeeRatePerYear", "SetProtocolFeeManagerAddress", "ClaimManagementFee", "ExecuteOwnerAction", "RevertOwnerAction", "Initialize", "SupplyToFactorial", "WithdrawFromFactorial", "BorrowFromFactorial", "RepayToFactorial", "LiquidateToFactorial", "CreateRFQ", "CancelRFQ", "TakeAggregatedData", "Excesses"];
     static createInitializeMsgBody(queryID?: number): Cell;
     static createExecuteStrategyMsgBody(body: Builder, queryID?: number): Cell;
     static createLiquidateToFactorialMsgBody(oracleParams: Cell, pool: Address, borrower: Address, repayAsset: Address, seizeAsset: Address, repayAmount: bigint, response: Address, queryID?: number): Cell;