@affluent-org/sdk 0.0.5 → 0.0.6

package/dist/services/strategy-vault/user/trace.js

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyVaultCancelWithdrawQueueTracer = exports.StrategyVaultCancelDepositQueueTracer = exports.StrategyVaultWithdrawQueueTracer = exports.StrategyVaultDepositQueueTracer = exports.StrategyVaultWithdrawTracer = exports.StrategyVaultDepositTracer = void 0;
+exports.getDepositAddresses = getDepositAddresses;
+exports.getWithdrawAddresses = getWithdrawAddresses;
+exports.getCancelDepositQueueAddresses = getCancelDepositQueueAddresses;
+exports.getCancelWithdrawQueueAddresses = getCancelWithdrawQueueAddresses;
+const trace_action_1 = require("../../../common/trace-action");
+const jetton_wallet_1 = require("../../../contracts/jetton/jetton-wallet");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+const strategy_vault_1 = require("../../../contracts/vault/strategy-vault");
+async function getDepositAddresses(client, params) {
+    const { actor, asset, vault } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    const _vault = client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        vault,
+        vaultAssetWallet: await _asset.getWalletAddress(vault),
+    };
+}
+async function getWithdrawAddresses(client, params) {
+    const { actor, withdrawAsset, vault } = params;
+    const _withdrawAsset = client.open(jetton_minter_1.JettonMinter.createFromAddress(withdrawAsset));
+    const _vault = client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+    return {
+        actor,
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        actorWithdrawAssetWallet: await _withdrawAsset.getWalletAddress(actor),
+        vault,
+        vaultWithdrawAssetWallet: await _withdrawAsset.getWalletAddress(vault),
+    };
+}
+class StrategyVaultDepositTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, vault, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getDepositAddresses(ctx.client, { actor, asset, vault });
+        return new StrategyVaultDepositTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const type = isWTON ? "wton" : "jetton";
+        const steps = [
+            ...(0, trace_action_1.createJettonSendSteps)({
+                isWTON,
+                actor: addresses.actor,
+                actorWallet: addresses.actorAssetWallet,
+                targetWallet: addresses.vaultAssetWallet,
+                target: addresses.vault,
+                description: "Transferring Tokens",
+            }),
+            ...(0, trace_action_1.createMintSteps)({
+                minter: addresses.vault,
+                actorWallet: addresses.actorVaultWallet,
+                description: "Receiving Vault Tokens",
+            }),
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            from: addresses.vaultAssetWallet,
+            to: addresses.actorAssetWallet,
+            description: "Refunding Tokens",
+        };
+        super(toncenterClient, extHash, type, queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultDepositTracer = StrategyVaultDepositTracer;
+class StrategyVaultWithdrawTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, withdrawAsset, vault, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getWithdrawAddresses(ctx.client, { actor, withdrawAsset, vault });
+        return new StrategyVaultWithdrawTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const type = isWTON ? "wton" : "jetton";
+        const steps = [
+            ...(0, trace_action_1.createBurnSteps)({
+                actor: addresses.actor,
+                actorWallet: addresses.actorVaultWallet,
+                minter: addresses.vault,
+                description: "Burning Vault Tokens",
+            }),
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON,
+                sourceWallet: addresses.vaultWithdrawAssetWallet,
+                actorWallet: addresses.actorWithdrawAssetWallet,
+                actor: addresses.actor,
+                description: "Receiving Withdraw Asset",
+            }),
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            from: addresses.vaultWithdrawAssetWallet,
+            to: addresses.actorWithdrawAssetWallet,
+            description: "Refunding Withdraw Asset",
+        };
+        super(toncenterClient, extHash, type, queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultWithdrawTracer = StrategyVaultWithdrawTracer;
+class StrategyVaultDepositQueueTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, vault, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getDepositAddresses(ctx.client, { actor, asset, vault });
+        return new StrategyVaultDepositQueueTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const type = isWTON ? "wton" : "jetton";
+        const steps = [
+            ...(0, trace_action_1.createJettonSendSteps)({
+                isWTON,
+                actor: addresses.actor,
+                actorWallet: addresses.actorAssetWallet,
+                targetWallet: addresses.vaultAssetWallet,
+                target: addresses.vault,
+                description: "Transferring Tokens",
+            }),
+            {
+                op: strategy_vault_1.StrategyVault.Op.Excesses,
+                from: addresses.vault,
+                to: addresses.actor,
+                description: "Queue Registered Excesses",
+            },
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.Transfer,
+            from: addresses.vault,
+            to: addresses.vaultAssetWallet,
+            description: "Refunding Tokens",
+        };
+        super(toncenterClient, extHash, type, queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultDepositQueueTracer = StrategyVaultDepositQueueTracer;
+class StrategyVaultWithdrawQueueTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, vault } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const _vault = ctx.client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+        const actorVaultWallet = await _vault.getWalletAddress(actor);
+        return new StrategyVaultWithdrawQueueTracer(ctx.toncenterClient, {
+            queryId,
+            extHash,
+            addresses: { actor, actorVaultWallet, vault },
+        });
+    }
+    constructor(toncenterClient, params) {
+        const { queryId, extHash, addresses } = params;
+        const steps = [
+            ...(0, trace_action_1.createBurnSteps)({
+                actor: addresses.actor,
+                actorWallet: addresses.actorVaultWallet,
+                minter: addresses.vault,
+                description: "Burning Vault Tokens",
+            }),
+            {
+                op: strategy_vault_1.StrategyVault.Op.Excesses,
+                from: addresses.vault,
+                to: addresses.actor,
+                description: "Queue Registered Excesses",
+            },
+        ];
+        const failStep = {
+            op: jetton_wallet_1.JettonWallet.Op.InternalTransfer,
+            from: addresses.vault,
+            to: addresses.actorVaultWallet,
+            description: "Refunding Vault Tokens",
+        };
+        super(toncenterClient, extHash, "jetton", queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultWithdrawQueueTracer = StrategyVaultWithdrawQueueTracer;
+async function getCancelDepositQueueAddresses(client, params) {
+    const { actor, asset, vault } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        vault,
+        vaultAssetWallet: await _asset.getWalletAddress(vault),
+    };
+}
+class StrategyVaultCancelDepositQueueTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, asset, vault, isWTON } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getCancelDepositQueueAddresses(ctx.client, { actor, asset, vault });
+        return new StrategyVaultCancelDepositQueueTracer(ctx.toncenterClient, { isWTON, queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { isWTON, queryId, extHash, addresses } = params;
+        const steps = [
+            {
+                op: strategy_vault_1.StrategyVault.Op.CancelDepositQueue,
+                from: addresses.actor,
+                to: addresses.vault,
+                description: "Cancelling Deposit Queue",
+            },
+            ...(0, trace_action_1.createJettonReceiveSteps)({
+                isWTON,
+                sourceWallet: addresses.vaultAssetWallet,
+                actorWallet: addresses.actorAssetWallet,
+                actor: addresses.actor,
+                description: "Refunding Tokens",
+            }),
+        ];
+        const failStep = {
+            op: 0xffffffff,
+            from: addresses.vault,
+            to: addresses.actor,
+            description: "Bounced",
+        };
+        super(toncenterClient, extHash, "cancel", queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultCancelDepositQueueTracer = StrategyVaultCancelDepositQueueTracer;
+async function getCancelWithdrawQueueAddresses(client, params) {
+    const { actor, vault } = params;
+    const _vault = client.open(strategy_vault_1.StrategyVault.createFromAddress(vault));
+    return {
+        actor,
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        vault,
+    };
+}
+class StrategyVaultCancelWithdrawQueueTracer extends trace_action_1.TracerBase {
+    static async create(params) {
+        const { ctx, msgBody, extHash, actor, vault } = params;
+        const { queryId } = (0, trace_action_1.getOpAndQueryId)(msgBody);
+        const addresses = await getCancelWithdrawQueueAddresses(ctx.client, { actor, vault });
+        return new StrategyVaultCancelWithdrawQueueTracer(ctx.toncenterClient, { queryId, extHash, addresses });
+    }
+    constructor(toncenterClient, params) {
+        const { queryId, extHash, addresses } = params;
+        const steps = [
+            {
+                op: strategy_vault_1.StrategyVault.Op.CancelWithdrawQueue,
+                from: addresses.actor,
+                to: addresses.vault,
+                description: "Cancelling Withdraw Queue",
+            },
+            ...(0, trace_action_1.createMintSteps)({
+                minter: addresses.vault,
+                actorWallet: addresses.actorVaultWallet,
+                description: "Refunding Vault Tokens",
+            }),
+        ];
+        const failStep = {
+            op: 0xffffffff,
+            from: addresses.vault,
+            to: addresses.actor,
+            description: "Bounced",
+        };
+        super(toncenterClient, extHash, "cancel", queryId, steps, failStep);
+    }
+}
+exports.StrategyVaultCancelWithdrawQueueTracer = StrategyVaultCancelWithdrawQueueTracer;

package/dist/share-vault.d.ts

@@ -1,8 +1,8 @@
-import { Address, Sender } from "@ton/ton";
+import { Address, Cell, Sender } from "@ton/ton";
 import { ShareVaultManagerSetTargetWeightAction, ShareVaultManagerSupplyAction, ShareVaultManagerWithdrawAction, ShareVaultUserActionParams } from "./types/action";
 import { TxStep, TxCallBackFn } from "./utils/tracker/type";
+import { ShareVaultState, WhitelistedPoolData } from "./contracts/vault/share-vault";
 import { ServiceBaseV1 } from "./common/service";
-import { ShareVaultState, WhitelistedPool } from "./contracts/vault/share-vault/type";
 type PoolInfoForShareVault = {
     cash: bigint;
     totalSupplyAmount: bigint;
@@ -20,8 +20,38 @@ export declare class ShareVaultV1 extends ServiceBaseV1 {
         };
         steps: TxStep[];
     } | undefined>;
-    supply(sender: Sender, params: ShareVaultUserActionParams): Promise<void>;
-    supplyAndWaitTx(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
+    supply(sender: Sender, params: ShareVaultUserActionParams, vaultData?: ShareVaultState): Promise<{
+        opt: {
+            queryId: bigint;
+            recipient: Address;
+            response: Address;
+            amount: bigint;
+            forwardTonAmount: bigint;
+        };
+        queryId: bigint;
+        steps: TxStep[];
+        senderVaultWalletAddress: Address;
+    } | {
+        opt: {
+            queryId: bigint;
+            recipient: Address;
+            response: Address;
+            amount: bigint;
+            forwardTonAmount: bigint;
+            forwardPayload: Cell;
+        };
+        steps: TxStep[];
+        senderVaultWalletAddress: Address;
+    }>;
+    supplyAndWaitTx(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn, vaultData?: ShareVaultState): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    supplyAndWaitTxV1(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn, vaultData?: ShareVaultState): Promise<{
         action: {
             type: string;
             params: ShareVaultUserActionParams;
@@ -29,6 +59,47 @@ export declare class ShareVaultV1 extends ServiceBaseV1 {
         };
         steps: TxStep[];
     }>;
+    supplyAndWaitTxV2(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn, vaultData?: ShareVaultState): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    supplyV1(sender: Sender, params: ShareVaultUserActionParams, vaultData?: ShareVaultState): Promise<{
+        opt: {
+            queryId: bigint;
+            recipient: Address;
+            response: Address;
+            amount: bigint;
+            forwardTonAmount: bigint;
+        };
+        queryId: bigint;
+        steps: TxStep[];
+        senderVaultWalletAddress: Address;
+    }>;
+    supplyV2(sender: Sender, params: ShareVaultUserActionParams, vaultData?: ShareVaultState): Promise<{
+        opt: {
+            queryId: bigint;
+            recipient: Address;
+            response: Address;
+            amount: bigint;
+            forwardTonAmount: bigint;
+            forwardPayload: Cell;
+        };
+        steps: TxStep[];
+        senderVaultWalletAddress: Address;
+    }>;
+    buildSupplySteps(params: ShareVaultUserActionParams, queryId: bigint, senderVaultWalletAddress: Address, firstStep: TxStep): TxStep[];
+    waitSupplyTx(steps: TxStep[], params: ShareVaultUserActionParams, queryId: bigint, senderVaultWalletAddress: Address, callbackFn?: TxCallBackFn): {
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    };
     findSupplyTx(queryId: bigint, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
         action: {
             type: string;
@@ -37,8 +108,34 @@ export declare class ShareVaultV1 extends ServiceBaseV1 {
         };
         steps: TxStep[];
     }>;
-    withdraw(sender: Sender, params: ShareVaultUserActionParams): Promise<void>;
-    withdrawAndWaitTx(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
+    withdraw(sender: Sender, params: ShareVaultUserActionParams, vaultData?: ShareVaultState): Promise<{
+        opt: {
+            queryId: bigint;
+            response: Address;
+            amount: bigint;
+        };
+        steps: TxStep[];
+        senderVaultWalletAddress: Address;
+        asset: Address;
+        senderJettonWalletAddress: Address;
+    }>;
+    withdrawAndWaitTx(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn, vaultData?: ShareVaultState): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    withdrawAndWaitTxV1(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    }>;
+    withdrawAndWaitTxV2(sender: Sender, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
         action: {
             type: string;
             params: ShareVaultUserActionParams;
@@ -46,6 +143,38 @@ export declare class ShareVaultV1 extends ServiceBaseV1 {
         };
         steps: TxStep[];
     }>;
+    withdrawV1(sender: Sender, params: ShareVaultUserActionParams, vaultData?: ShareVaultState): Promise<{
+        opt: {
+            queryId: bigint;
+            response: Address;
+            amount: bigint;
+        };
+        steps: TxStep[];
+        senderVaultWalletAddress: Address;
+        asset: Address;
+        senderJettonWalletAddress: Address;
+    }>;
+    withdrawV2(sender: Sender, params: ShareVaultUserActionParams, vaultData?: ShareVaultState): Promise<{
+        opt: {
+            queryId: bigint;
+            response: Address;
+            amount: bigint;
+            forwardPayload: Cell;
+        };
+        steps: TxStep[];
+        senderVaultWalletAddress: Address;
+        asset: Address;
+        senderJettonWalletAddress: Address;
+    }>;
+    buildWithdrawSteps(params: ShareVaultUserActionParams, queryId: bigint, vaultJettonWalletAddress: Address, senderVaultWalletAddress: Address, senderJettonWalletAddress: Address): TxStep[];
+    waitWithdrawTx(steps: TxStep[], params: ShareVaultUserActionParams, queryId: bigint, senderVaultWalletAddress: Address, assetAddress: Address, senderJettonWalletAddress: Address, callbackFn?: TxCallBackFn): {
+        action: {
+            type: string;
+            params: ShareVaultUserActionParams;
+            queryId: bigint;
+        };
+        steps: TxStep[];
+    };
     findWithdrawTx(queryId: bigint, params: ShareVaultUserActionParams, callbackFn?: TxCallBackFn): Promise<{
         action: {
             type: string;
@@ -58,7 +187,34 @@ export declare class ShareVaultV1 extends ServiceBaseV1 {
     withdrawFromPool(sender: Sender, params: ShareVaultManagerWithdrawAction): Promise<void>;
     withdrawFromPoolSimulate(sender: Address, params: ShareVaultManagerWithdrawAction): Promise<void>;
     setTargetWeight(sender: Sender, params: ShareVaultManagerSetTargetWeightAction): Promise<void>;
-    getVaultData(vaultAddress: Address | string): Promise<ShareVaultState>;
+    getVaultData(vaultAddress: Address | string): Promise<{
+        totalSupply: bigint;
+        owner: Address | null;
+        manager: Address | null;
+        asset: Address;
+        balance: bigint;
+        cash: bigint;
+        totalTargetWeight: bigint;
+        nextAggregatorIndex: bigint;
+        isWtonVault: boolean;
+        assetWallet: Address | null;
+        whitelistedPools: Record<string, {
+            isWhitelisted: boolean;
+            targetWeight: bigint;
+            supply: bigint;
+        } & {
+            address: Address;
+        }>;
+        minimumGasFee: {
+            supply: bigint;
+            withdraw: bigint;
+            factorialSupply: bigint;
+            factorialWithdraw: bigint;
+            mintVaultShareTokens: bigint;
+        };
+        code: Cell;
+        address: Address;
+    }>;
     getPoolCashAmounts(vaultData: ShareVaultState): Promise<Record<string, bigint>>;
     getPoolInfoForShareVault(vaultData: ShareVaultState): Promise<Record<string, PoolInfoForShareVault>>;
     estimateWithdrawLiquidityFulfillmentPoolCount(vaultData: ShareVaultState, requst_vault_shares: bigint): Promise<{
@@ -70,7 +226,7 @@ export declare class ShareVaultV1 extends ServiceBaseV1 {
             pool: any;
         }[];
     }>;
-    getPoolTupleSortedByTargetWeight(whitelistedPools: Record<string, WhitelistedPool>, totalAssetAmount: bigint, totalTargetWeight: bigint, poolInfoForShareVault: Record<string, PoolInfoForShareVault>): {
+    getPoolTupleSortedByTargetWeight(whitelistedPools: Record<string, WhitelistedPoolData>, totalAssetAmount: bigint, totalTargetWeight: bigint, poolInfoForShareVault: Record<string, PoolInfoForShareVault>): {
         targetWeightRatio: number;
         poolAddress: string;
         availableAmount: bigint;