@affluent-org/sdk 0.0.5 → 0.0.6

package/dist/lib/send-msg.d.ts

@@ -1,11 +1,25 @@
 import { Address, Cell } from "@ton/core";
 import { AddressSender } from "../types/sender";
+import { AffluentContext } from "../context";
+import { SimpleTracer } from "../common/trace-action";
 export type InternalMessageInput = {
     to: Address;
     value: bigint;
     body: Cell;
 };
-export declare function sendMsg<T>(sender: AddressSender, msg: Promise<{
+export declare function sendMsg<T>(sender: AddressSender, msg: {
     opts: T;
     input: InternalMessageInput;
-}>): Promise<T>;
+}): Promise<T & {
+    seqno: number;
+}>;
+export declare function sendMsgAndWaitTx<T>(ctx: AffluentContext, sender: AddressSender, msg: {
+    opts: T;
+    input: InternalMessageInput;
+}): Promise<T & {
+    getExternalHash: () => Promise<import("../utils/external-message-hash").MessageHash>;
+    seqno: number;
+}>;
+export declare function sendMsgAndWaitTxSimple(ctx: AffluentContext, sender: AddressSender, msg: {
+    input: InternalMessageInput;
+}): Promise<SimpleTracer>;

package/dist/lib/send-msg.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendMsg = sendMsg;
+exports.sendMsgAndWaitTx = sendMsgAndWaitTx;
+exports.sendMsgAndWaitTxSimple = sendMsgAndWaitTxSimple;
 const core_1 = require("@ton/core");
+const trackable_sender_1 = require("../utils/pending-tracker/trackable-sender");
+const trace_action_1 = require("../common/trace-action");
 async function sendMsg(sender, msg) {
-    const { opts, input } = await msg;
+    const seqno = await sender.getSeqno();
+    const { opts, input } = msg;
     await sender.send({ ...input, sendMode: core_1.SendMode.PAY_GAS_SEPARATELY });
-    return opts;
+    return { ...opts, seqno };
+}
+async function sendMsgAndWaitTx(ctx, sender, msg) {
+    const result = await sendMsg(sender, msg);
+    const getExternalHash = () => (0, trackable_sender_1.pollExternalTransfer)(ctx.client, sender.address, result.seqno);
+    return { ...result, getExternalHash };
+}
+async function sendMsgAndWaitTxSimple(ctx, sender, msg) {
+    const result = await sendMsgAndWaitTx(ctx, sender, msg);
+    const { op, queryId } = (0, trace_action_1.getOpAndQueryId)(msg.input.body);
+    return new trace_action_1.SimpleTracer(ctx.toncenterClient, {
+        extHash: await result.getExternalHash(),
+        queryId,
+        actor: sender.address,
+        target: msg.input.to,
+        op,
+    });
 }

package/dist/monitor.js

@@ -428,6 +428,7 @@ class MonitorV1 {
         const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
         const onchainData2 = await this.updateOnchainData(poolData.oracleConfig.assetOnchainDataInfo);
         const onchainData = { ...od, ...onchainData2 };
+        // this.updateOnchainInternalData(redstonePrices, onchainData);
         Object.keys(onchainData).forEach((key) => {
             if (!result.requestAssets.map((item) => item.toString()).includes(key) &&
                 !result.redstoneAssets.map((item) => item.toString()).includes(key)) {
@@ -442,6 +443,7 @@ class MonitorV1 {
         const { redstonePrices, onchainData: od } = await this.getRedstonePricesNew(assets, oracleConfig);
         const _onchainData = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
         const onchainData = { ...od, ..._onchainData };
+        // this.updateOnchainInternalData(redstonePrices, onchainData);
         const prices = this.calculatePrices(redstonePrices, onchainData);
         return prices;
     }

package/dist/monitorCacheV1.js

@@ -170,8 +170,7 @@ class MonitorCacheV1 extends service_1.ServiceBaseV1 {
                     };
                 }
             }
-            catch (e) {
-            }
+            catch (e) { }
         });
         return { redstonePrices: prices, onchainData };
     }
@@ -405,6 +404,7 @@ class MonitorCacheV1 extends service_1.ServiceBaseV1 {
         const { redstonePrices, onchainData: od } = await this.getRedstonePrices(assets, poolData);
         const onchainData2 = await this.updateOnchainData(poolData.oracleConfig.assetOnchainDataInfo);
         const onchainData = { ...od, ...onchainData2 };
+        this.updateOnchainInternalData(redstonePrices, onchainData);
         Object.keys(onchainData).forEach((key) => {
             if (!result.requestAssets.map((item) => item.toString()).includes(key) &&
                 !result.redstoneAssets.map((item) => item.toString()).includes(key)) {
@@ -419,6 +419,7 @@ class MonitorCacheV1 extends service_1.ServiceBaseV1 {
         const { redstonePrices, onchainData: od } = await this.getRedstonePricesNew(assets, oracleConfig);
         const _onchainData = await this.updateOnchainData(oracleConfig.assetOnchainDataInfo);
         const onchainData = { ...od, ..._onchainData };
+        this.updateOnchainInternalData(redstonePrices, onchainData);
         const prices = this.calculatePrices(redstonePrices, onchainData);
         return prices;
     }

package/dist/oracle/oracle.d.ts

@@ -2,7 +2,7 @@ import { Address, Cell, OpenedContract } from "@ton/core";
 import { ServiceBaseV1 } from "../common/service";
 import { ShareVault } from "../contracts/vault/share-vault";
 import { StrategyVault } from "../contracts/vault/strategy-vault";
-import { ShareVaultState } from "../contracts/vault/share-vault/type";
+import { ShareVaultState } from "../contracts/vault/share-vault";
 import { RFQAuction } from "../contracts/rfq/rfq_auction";
 import { Pool } from "../contracts/core/pool";
 import { PoolState } from "../contracts/core/pool/type";
@@ -88,7 +88,7 @@ export declare class OracleLibs extends ServiceBaseV1 {
         oracleParams: Cell;
         bucket: AddressBucket;
     }>;
-    getOracleParamsForStrategyVaultRFQAuction(rfqAuctionData: ReturnType<typeof RFQAuction.parseRfqStorage>, bucket?: AddressBucket): Promise<Cell>;
+    getOracleParamsForStrategyVaultRFQAuction(rfqAuctionData: ReturnType<typeof RFQAuction.parseRFQStorage>, bucket?: AddressBucket): Promise<Cell>;
     getOracleParamsForRFQBatch(rfqBatchData: ReturnType<typeof RFQBatch.parseRFQBatchStorage>, bucket?: AddressBucket): Promise<{
         oracleParams: Cell;
         bucket: AddressBucket;
@@ -103,5 +103,6 @@ export declare class OracleLibs extends ServiceBaseV1 {
         strategyVaults: Record<string, StrategyVaultValueStatus>;
         shareVaults: Record<string, ShareVaultValueStatus>;
     }>;
+    makeAddressBucket(asset: Address, bucket?: AddressBucket): Promise<AddressBucket>;
 }
 export {};

package/dist/oracle/oracle.js

@@ -202,10 +202,10 @@ class AddressBucket {
     }
     updateVaultPoolPositions(vaultPoolPositions) {
         for (const [poolAddress, poolPosition] of Object.entries(vaultPoolPositions)) {
-            for (const [_, position] of Object.entries(poolPosition)) {
+            for (const [assetAddress, position] of Object.entries(poolPosition)) {
                 if (position.supply > 0 || position.borrow > 0) {
+                    this.assets.add(assetAddress);
                     this.pools.add(poolAddress);
-                    break;
                 }
             }
         }
@@ -388,5 +388,28 @@ class OracleLibs extends service_1.ServiceBaseV1 {
         }));
         return { strategyVaults, shareVaults };
     }
+    async makeAddressBucket(asset, bucket = new AddressBucket()) {
+        const assetAddress = asset.toString();
+        const assetType = await this.getAssetType(assetAddress);
+        if (assetType.type === "underlying-asset") {
+            bucket.assets.add(assetAddress.toString());
+        }
+        else if (assetType.type === "share-vault") {
+            bucket.vaults.add(assetAddress.toString());
+            Object.keys(assetType.data.whitelistedPools).forEach((poolAddress) => {
+                bucket.pools.add(poolAddress);
+            });
+        }
+        else if (assetType.type === "strategy-vault") {
+            bucket.vaults.add(assetAddress.toString());
+            Object.keys(assetType.data.factorialPools).forEach((poolAddress) => {
+                bucket.pools.add(poolAddress);
+            });
+            await Promise.all(Object.keys(assetType.data.assets).map(async (assetAddress) => {
+                this.makeAddressBucket(core_1.Address.parse(assetAddress), bucket);
+            }));
+        }
+        return bucket;
+    }
 }
 exports.OracleLibs = OracleLibs;

package/dist/pool.d.ts

@@ -1,5 +1,6 @@
 import { Address, Cell, Sender } from "@ton/ton";
 import { PoolState } from "./contracts/core/pool/type";
+import { Pool } from "./contracts/core/pool";
 import { OnchainDataInfo } from "./contracts/oracle/redstone-onchain-oracle/type";
 import { LiquidateActionParams, TransferInActionParams, TansferOutActionParams } from "./types/action";
 import { TxCallBackFn, TxStep } from "./utils/tracker/type";
@@ -47,6 +48,26 @@ export declare class PoolV1 extends ServiceBaseV1 {
         };
         steps: TxStep[];
     }>;
+    _withdrawMessage(params: TansferOutActionParams): Promise<{
+        pool: import("@ton/ton").OpenedContract<Pool>;
+        poolData: any;
+        oracleParams: Cell | null;
+        gas: bigint;
+        opts: {
+            queryId: bigint;
+            asset: Address;
+            isShare: boolean;
+            amount: bigint;
+            recipient: Address;
+            response: Address;
+            jettonForwardTonAmount: bigint;
+            jettonForwardPayload: Cell | null;
+            oracleParams: Cell | null;
+        };
+        senderAccountAddress: Address;
+        poolJettonWalletAddress: Address;
+        recipeintJettonWalletAddress: Address;
+    }>;
     findWithdrawTx(queryId: bigint, params: TansferOutActionParams, callbackFn?: TxCallBackFn): Promise<{
         action: {
             type: string;
@@ -64,6 +85,26 @@ export declare class PoolV1 extends ServiceBaseV1 {
         };
         steps: TxStep[];
     }>;
+    _borrowMessage(params: TansferOutActionParams): Promise<{
+        pool: import("@ton/ton").OpenedContract<Pool>;
+        poolData: any;
+        oracleParams: Cell;
+        gas: bigint;
+        opts: {
+            queryId: bigint;
+            asset: Address;
+            isShare: boolean;
+            amount: bigint;
+            recipient: Address;
+            response: Address;
+            jettonForwardTonAmount: bigint;
+            jettonForwardPayload: Cell | null;
+            oracleParams: Cell;
+        };
+        senderAccountAddress: Address;
+        poolJettonWalletAddress: Address;
+        recipeintJettonWalletAddress: Address;
+    }>;
     findBorrowTx(queryId: bigint, params: TansferOutActionParams, callbackFn?: TxCallBackFn): Promise<{
         action: {
             type: string;