@affluent-org/sdk 0.0.4 → 0.0.6

package/dist/services/share-vault/query.js

@@ -38,6 +38,7 @@ exports.getVaultData = getVaultData;
 exports.getVaultWalletAddress = getVaultWalletAddress;
 exports.getVaultWallet = getVaultWallet;
 exports.getPoolInfoForShareVault = getPoolInfoForShareVault;
+exports.getPoolDataForShareVault = getPoolDataForShareVault;
 exports.getValuationContext = getValuationContext;
 exports.getEXR = getEXR;
 const core_1 = require("@ton/core");
@@ -45,7 +46,7 @@ const utils_1 = require("../../contracts/common/utils");
 const share_vault_1 = require("../../contracts/vault/share-vault");
 const pool_1 = require("../../contracts/core/pool");
 const jetton_wallet_1 = require("../../contracts/jetton/jetton-wallet");
-const computation_1 = require("./computation");
+const transform_1 = require("../../common/transform");
 /**
  * Get ShareVault contract instance
  */
@@ -109,23 +110,35 @@ async function getPoolInfoForShareVault(ctx, vaultData) {
     }
     return poolInfo;
 }
-async function getValuationContext(ctx, vaultAddress) {
+async function getPoolDataForShareVault(ctx, vaultAddress) {
     const vault = getVault(ctx, vaultAddress);
     const vaultData = await vault.getVaultData();
-    const poolInfo = await getPoolInfoForShareVault(ctx, vaultData);
-    const exrInfo = (0, computation_1.getExchangeRate)(vaultData, poolInfo);
+    const poolAddresses = Object.keys(vaultData.whitelistedPools);
+    const poolDataEntriesPromises = poolAddresses.map(async (poolAddress) => {
+        const pool = ctx.getByContract(pool_1.Pool, core_1.Address.parse(poolAddress));
+        return [poolAddress, await pool.getPoolData()];
+    });
+    const poolDataEntries = await Promise.all(poolDataEntriesPromises);
+    return Object.fromEntries(poolDataEntries);
+}
+async function getValuationContext(ctx, vaultAddress) {
+    const vault = ctx.getByContract(share_vault_1.ShareVault, (0, utils_1.toAddress)(vaultAddress));
+    const vaultData = await vault.getVaultData();
+    const poolPositions = await getPoolDataForShareVault(ctx, vaultAddress);
+    const poolContexts = {};
+    Object.entries(poolPositions).forEach(([poolAddress, poolState]) => poolContexts[poolAddress] = transform_1.PoolContext.fromPoolState(poolState));
+    const vaultStateContext = transform_1.VaultStateContext.fromShareVaultState(vaultData);
+    const amountContext = vaultStateContext.toAmountContext(poolContexts);
+    const netAmount = amountContext.decompose()[vaultData.asset.toString()].net();
     return {
-        storage: vaultData,
-        totalSupply: vaultData.totalSupply,
-        asset: vaultData.asset,
-        reserve: vaultData.cash,
-        poolPositions: poolInfo,
-        netAmount: exrInfo.netAmount,
-        exr: exrInfo.exr,
+        vaultStateContext,
+        amountContext,
+        netAmount,
+        exr: Number(netAmount) / Number(vaultData.totalSupply),
     };
 }
 async function getEXR(ctx, vaultAddress) {
-    return getValuationContext(ctx, vaultAddress).then((vaultCtx) => {
+    return getValuationContext(ctx, (0, utils_1.toAddress)(vaultAddress)).then((vaultCtx) => {
         return vaultCtx.exr;
     });
 }

package/dist/services/share-vault/user/trace.d.ts

@@ -0,0 +1,54 @@
+import { Address, Cell } from "@ton/core";
+import { TracerBase } from "../../../common/trace-action";
+import { MessageHash } from "../../../utils/external-message-hash";
+import { TonClient } from "@ton/ton";
+import { AffluentContext } from "../../../context";
+import { ToncenterV3Client } from "../../../utils/pending-tracker/v3-client";
+export type ShareVaultAddresses = {
+    actor: Address;
+    actorAssetWallet: Address;
+    actorVaultWallet: Address;
+    vault: Address;
+    vaultAssetWallet: Address;
+};
+export declare function getShareVaultAddresses(client: TonClient, params: {
+    actor: Address;
+    asset: Address;
+    vault: Address;
+}): Promise<ShareVaultAddresses>;
+export type ShareVaultSupplyTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class ShareVaultSupplyTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: ShareVaultSupplyTracerParams): Promise<ShareVaultSupplyTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: ShareVaultAddresses;
+    });
+}
+export type ShareVaultWithdrawTracerParams = {
+    ctx: AffluentContext;
+    msgBody: Cell;
+    extHash: MessageHash;
+    actor: Address;
+    asset: Address;
+    vault: Address;
+    isWTON: boolean;
+};
+export declare class ShareVaultWithdrawTracer extends TracerBase<"jetton" | "wton"> {
+    static create(params: ShareVaultWithdrawTracerParams): Promise<ShareVaultWithdrawTracer>;
+    constructor(toncenterClient: ToncenterV3Client, params: {
+        isWTON: boolean;
+        queryId: bigint;
+        extHash: MessageHash;
+        addresses: ShareVaultAddresses;
+    });
+}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShareVaultWithdrawTracer = exports.ShareVaultSupplyTracer = void 0;
+exports.getShareVaultAddresses = getShareVaultAddresses;
+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 share_vault_1 = require("../../../contracts/vault/share-vault");
+async function getShareVaultAddresses(client, params) {
+    const { actor, asset, vault } = params;
+    const _asset = client.open(jetton_minter_1.JettonMinter.createFromAddress(asset));
+    const _vault = client.open(share_vault_1.ShareVault.createFromAddress(vault));
+    return {
+        actor,
+        actorAssetWallet: await _asset.getWalletAddress(actor),
+        actorVaultWallet: await _vault.getWalletAddress(actor),
+        vault,
+        vaultAssetWallet: await _asset.getWalletAddress(vault),
+    };
+}
+class ShareVaultSupplyTracer 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 getShareVaultAddresses(ctx.client, { actor, asset, vault });
+        return new ShareVaultSupplyTracer(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.ShareVaultSupplyTracer = ShareVaultSupplyTracer;
+class ShareVaultWithdrawTracer 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 getShareVaultAddresses(ctx.client, { actor, asset, vault });
+        return new ShareVaultWithdrawTracer(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.vaultAssetWallet,
+                actorWallet: addresses.actorAssetWallet,
+                actor: addresses.actor,
+                description: "Receiving Asset",
+            }),
+        ];
+        super(toncenterClient, extHash, type, queryId, steps);
+    }
+}
+exports.ShareVaultWithdrawTracer = ShareVaultWithdrawTracer;