@affluent-org/sdk 0.0.1

package/dist/contracts/wton/jetton-wallet.d.ts

@@ -0,0 +1,90 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from "@ton/ton";
+import { WalletState } from "./type";
+export declare function wtonWalletConfigToCell(config: {
+    jettonMinter: Address;
+    owner: Address;
+    walletCode: Cell;
+}): Cell;
+export type WTONWalletConfig = {
+    jettonMinter: Address;
+    owner: Address;
+    walletCode: Cell;
+};
+export declare class WTONWallet implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        TransferNotification: number;
+        InternalTransfer: number;
+        ExternalTransfer: number;
+        Transfer: number;
+        Burn: number;
+        Excesses: number;
+        BurnNotification: number;
+        UnwrapNotification: number;
+    };
+    static createFromAddress(address: Address): WTONWallet;
+    static createFromConfig(config: WTONWalletConfig, code: Cell, workchain?: number): WTONWallet;
+    static Gas: {
+        ExternalTransfer: bigint;
+    };
+    sendTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: bigint;
+        recipient: Address;
+        response: Address;
+        amount: bigint;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+    }): Promise<Cell>;
+    sendExternalTransfer(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        queryId?: bigint;
+        recipient: Address;
+        response: Address;
+        amount: bigint;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+    }): Promise<Cell>;
+    static createExternalTransferBody(opts: {
+        queryId?: bigint;
+        recipient: Address;
+        response: Address;
+        amount: bigint;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+    }): Cell;
+    static createTransferBody(opts: {
+        queryId?: bigint;
+        recipient: Address;
+        response: Address;
+        amount: bigint;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+    }): Cell;
+    static getBurnMsgBody(opts: {
+        amount: bigint;
+        response: Address;
+    }): Cell;
+    sendBurn(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        amount: bigint;
+        response: Address;
+        queryId?: bigint;
+    }): Promise<Cell>;
+    sendMint(provider: ContractProvider, via: Sender, value: bigint): Promise<Cell>;
+    getState(provider: ContractProvider): Promise<import("@ton/ton").ContractState>;
+    getWalletData(provider: ContractProvider): Promise<WalletState>;
+    createExternalTransferBody(opts: {
+        queryId?: bigint;
+        recipient: Address;
+        response: Address;
+        amount: bigint;
+        forwardTonAmount: bigint;
+        forwardPayload?: Cell;
+    }): Cell;
+}

package/dist/contracts/wton/jetton-wallet.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WTONWallet = void 0;
+exports.wtonWalletConfigToCell = wtonWalletConfigToCell;
+const ton_1 = require("@ton/ton");
+function wtonWalletConfigToCell(config) {
+    return (0, ton_1.beginCell)().storeAddress(config.owner).storeAddress(config.jettonMinter).storeRef(config.walletCode).endCell();
+}
+class WTONWallet {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static Op = {
+        TransferNotification: 0x7362d09c,
+        InternalTransfer: 0x178d4519,
+        ExternalTransfer: 0x05db0ab7,
+        Transfer: 0xf8a7ea5,
+        Burn: 0x595f07bc,
+        Excesses: 0xd53276db,
+        BurnNotification: 0x7bdd97de,
+        UnwrapNotification: 0x90d0a42f,
+    };
+    static createFromAddress(address) {
+        return new WTONWallet(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = wtonWalletConfigToCell(config);
+        const init = { code, data };
+        return new WTONWallet((0, ton_1.contractAddress)(workchain, init), init);
+    }
+    static Gas = {
+        ExternalTransfer: (0, ton_1.toNano)(0.06),
+    };
+    async sendTransfer(provider, via, value, opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(WTONWallet.Op.Transfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.recipient)
+            .storeAddress(opts.response)
+            .storeDict(null)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        await provider.internal(via, {
+            value: value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+        return body;
+    }
+    async sendExternalTransfer(provider, via, value, opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(WTONWallet.Op.ExternalTransfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        const value2 = opts.amount + opts.forwardTonAmount + value;
+        await provider.internal(via, {
+            value: value2,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+        return body;
+    }
+    static createExternalTransferBody(opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(WTONWallet.Op.ExternalTransfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        return body;
+    }
+    static createTransferBody(opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(WTONWallet.Op.Transfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.recipient)
+            .storeAddress(opts.response)
+            .storeDict(null)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+        return body;
+    }
+    static getBurnMsgBody(opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(WTONWallet.Op.Burn, 32)
+            .storeUint(0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .endCell();
+        return body;
+    }
+    async sendBurn(provider, via, value, opts) {
+        const body = (0, ton_1.beginCell)()
+            .storeUint(WTONWallet.Op.Burn, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .endCell();
+        await provider.internal(via, {
+            value: value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: body,
+        });
+        return body;
+    }
+    async sendMint(provider, via, value) {
+        await provider.internal(via, {
+            value: value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().endCell(),
+        });
+        return (0, ton_1.beginCell)().endCell();
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async getWalletData(provider) {
+        const _result = await provider.get("get_wallet_data", []);
+        const balance = _result.stack.readBigNumber();
+        const owner = _result.stack.readAddress();
+        const jetton = _result.stack.readAddress();
+        return {
+            address: this.address,
+            balance,
+            owner,
+            jetton,
+        };
+    }
+    createExternalTransferBody(opts) {
+        return (0, ton_1.beginCell)()
+            .storeUint(WTONWallet.Op.ExternalTransfer, 32)
+            .storeUint(opts.queryId ?? 0, 64)
+            .storeCoins(opts.amount)
+            .storeAddress(opts.response)
+            .storeCoins(opts.forwardTonAmount)
+            .storeMaybeRef(opts.forwardPayload)
+            .endCell();
+    }
+}
+exports.WTONWallet = WTONWallet;

package/dist/contracts/wton/type.d.ts

@@ -0,0 +1,7 @@
+import { Address } from "@ton/core";
+export type WalletState = {
+    address: Address;
+    balance: bigint;
+    owner: Address;
+    jetton: Address;
+};

package/dist/contracts/wton/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { MAINNET_CONTRACTS, TESTNET_CONTRACTS } from "./constants/contracts";
+import { Maybe } from "@ton/ton/dist/utils/maybe";
+import { AccountState, AccountAssetState } from "./contracts/core/account/type";
+import { PoolState, LiquidatePayload, TransferInPayload, TransferOutMsgBody, LiquidateParams, TransferInParams, TransferOutMsgParams, AssetState, BaseActionNotificationMsgBody, SuccessActionNotificationMsgBody, SuccessRepayActionNotificationMsgBody, SuccessLiquidateActionNotificationMsgBody, FailTransferInActionNotificationMsgBody, FailLiquidateActionNotificationMsgBody, FailTransferOutActionNotificationMsgBody, ActionNotificationMsgBody } from "./contracts/core/pool/type";
+import { FactoryState } from "./contracts/factory/type";
+import { JumpIRMConfig } from "./contracts/irm/jump-irm/type";
+import { ShareVaultState, WhitelistedPoolData } from "./contracts/vault/share-vault";
+import { Factory } from "./contracts/factory/factory";
+import { Pool } from "./contracts/core/pool";
+import { Account } from "./contracts/core/account";
+import { RiskCalculator } from "./utils/risk_calculator/risk_calculator";
+import { JettonMinter } from "./contracts/jetton/jetton-minter";
+import { JettonWallet } from "./contracts/jetton/jetton-wallet";
+import { ShareVault } from "./contracts/vault/share-vault";
+import { StrategyVault, strategyVaultConfigToCell } from "./contracts/vault/strategy-vault/";
+import Affluent from "./affluent";
+import { RFQEventEmitter } from "./contracts/rfq/rfq_event_emitter";
+import { RFQAuction } from "./contracts/rfq/rfq_auction";
+import { RFQBatch } from "./contracts/rfq/rfq_batch";
+import { StrategyVaultState } from "./contracts/vault/strategy-vault/";
+import { ONE_PERCENT_IR_PER_SEC } from "./constants/constants";
+import { toPercentBigInt, toPercentNumber } from "./utils/utils";
+import { WTONWalletCompiled } from "./_compiled";
+import { WTON_UNWRAP_CELL, WTONMinter } from "./contracts/wton/jetton-minter";
+import { WTONWallet } from "./contracts/wton/jetton-wallet";
+import { parseAction } from "./utils/action-parser";
+import { CompositeOracleV1 } from "./services/composite-oracle";
+import { StrategyVaultV1 } from "./services/strategy-vault";
+import { PoolServiceV1 } from "./services/pool";
+import { ShareVaultServiceV1 } from "./services/share-vault";
+import { RFQBatchServiceV1 } from "./services/rfq-batch";
+import { RFQAuctionServiceV1 } from "./services/rfq-auction";
+import { sendMsgTracked, createTrackableSender, createTrackableSenderFromMnemonic, ToncenterV3Client, TrackableSender, TrackableSenderConfig, SendResult, TraceResult, WaitOptions } from "./utils/pending-tracker";
+export { Maybe, AccountState, AccountAssetState, strategyVaultConfigToCell, PoolState, LiquidatePayload, TransferInPayload, TransferOutMsgBody, LiquidateParams, TransferInParams, TransferOutMsgParams, AssetState, BaseActionNotificationMsgBody, SuccessActionNotificationMsgBody, SuccessRepayActionNotificationMsgBody, SuccessLiquidateActionNotificationMsgBody, FailTransferInActionNotificationMsgBody, FailLiquidateActionNotificationMsgBody, FailTransferOutActionNotificationMsgBody, ActionNotificationMsgBody, FactoryState, JumpIRMConfig, ShareVaultState, WhitelistedPoolData, StrategyVaultState, Affluent, Factory, Pool, Account, JettonMinter, JettonWallet, ShareVault, RiskCalculator, StrategyVault, RFQEventEmitter, RFQAuction, RFQBatch, MAINNET_CONTRACTS, TESTNET_CONTRACTS, ONE_PERCENT_IR_PER_SEC, toPercentBigInt, toPercentNumber, WTONWalletCompiled, WTONMinter, WTONWallet, WTON_UNWRAP_CELL, parseAction, CompositeOracleV1, StrategyVaultV1, PoolServiceV1, ShareVaultServiceV1, RFQBatchServiceV1, RFQAuctionServiceV1, sendMsgTracked, createTrackableSender, createTrackableSenderFromMnemonic, ToncenterV3Client, TrackableSender, TrackableSenderConfig, SendResult, TraceResult, WaitOptions, };

package/dist/index.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToncenterV3Client = exports.createTrackableSenderFromMnemonic = exports.createTrackableSender = exports.sendMsgTracked = exports.RFQAuctionServiceV1 = exports.RFQBatchServiceV1 = exports.ShareVaultServiceV1 = exports.PoolServiceV1 = exports.StrategyVaultV1 = exports.CompositeOracleV1 = exports.parseAction = exports.WTON_UNWRAP_CELL = exports.WTONWallet = exports.WTONMinter = exports.WTONWalletCompiled = exports.toPercentNumber = exports.toPercentBigInt = exports.ONE_PERCENT_IR_PER_SEC = exports.TESTNET_CONTRACTS = exports.MAINNET_CONTRACTS = exports.RFQBatch = exports.RFQAuction = exports.RFQEventEmitter = exports.StrategyVault = exports.RiskCalculator = exports.ShareVault = exports.JettonWallet = exports.JettonMinter = exports.Account = exports.Pool = exports.Factory = exports.Affluent = exports.strategyVaultConfigToCell = void 0;
+const contracts_1 = require("./constants/contracts");
+Object.defineProperty(exports, "MAINNET_CONTRACTS", { enumerable: true, get: function () { return contracts_1.MAINNET_CONTRACTS; } });
+Object.defineProperty(exports, "TESTNET_CONTRACTS", { enumerable: true, get: function () { return contracts_1.TESTNET_CONTRACTS; } });
+const factory_1 = require("./contracts/factory/factory");
+Object.defineProperty(exports, "Factory", { enumerable: true, get: function () { return factory_1.Factory; } });
+const pool_1 = require("./contracts/core/pool");
+Object.defineProperty(exports, "Pool", { enumerable: true, get: function () { return pool_1.Pool; } });
+const account_1 = require("./contracts/core/account");
+Object.defineProperty(exports, "Account", { enumerable: true, get: function () { return account_1.Account; } });
+const risk_calculator_1 = require("./utils/risk_calculator/risk_calculator");
+Object.defineProperty(exports, "RiskCalculator", { enumerable: true, get: function () { return risk_calculator_1.RiskCalculator; } });
+const jetton_minter_1 = require("./contracts/jetton/jetton-minter");
+Object.defineProperty(exports, "JettonMinter", { enumerable: true, get: function () { return jetton_minter_1.JettonMinter; } });
+const jetton_wallet_1 = require("./contracts/jetton/jetton-wallet");
+Object.defineProperty(exports, "JettonWallet", { enumerable: true, get: function () { return jetton_wallet_1.JettonWallet; } });
+const share_vault_1 = require("./contracts/vault/share-vault");
+Object.defineProperty(exports, "ShareVault", { enumerable: true, get: function () { return share_vault_1.ShareVault; } });
+const strategy_vault_1 = require("./contracts/vault/strategy-vault/");
+Object.defineProperty(exports, "StrategyVault", { enumerable: true, get: function () { return strategy_vault_1.StrategyVault; } });
+Object.defineProperty(exports, "strategyVaultConfigToCell", { enumerable: true, get: function () { return strategy_vault_1.strategyVaultConfigToCell; } });
+const affluent_1 = __importDefault(require("./affluent"));
+exports.Affluent = affluent_1.default;
+const rfq_event_emitter_1 = require("./contracts/rfq/rfq_event_emitter");
+Object.defineProperty(exports, "RFQEventEmitter", { enumerable: true, get: function () { return rfq_event_emitter_1.RFQEventEmitter; } });
+const rfq_auction_1 = require("./contracts/rfq/rfq_auction");
+Object.defineProperty(exports, "RFQAuction", { enumerable: true, get: function () { return rfq_auction_1.RFQAuction; } });
+const rfq_batch_1 = require("./contracts/rfq/rfq_batch");
+Object.defineProperty(exports, "RFQBatch", { enumerable: true, get: function () { return rfq_batch_1.RFQBatch; } });
+const constants_1 = require("./constants/constants");
+Object.defineProperty(exports, "ONE_PERCENT_IR_PER_SEC", { enumerable: true, get: function () { return constants_1.ONE_PERCENT_IR_PER_SEC; } });
+const utils_1 = require("./utils/utils");
+Object.defineProperty(exports, "toPercentBigInt", { enumerable: true, get: function () { return utils_1.toPercentBigInt; } });
+Object.defineProperty(exports, "toPercentNumber", { enumerable: true, get: function () { return utils_1.toPercentNumber; } });
+const _compiled_1 = require("./_compiled");
+Object.defineProperty(exports, "WTONWalletCompiled", { enumerable: true, get: function () { return _compiled_1.WTONWalletCompiled; } });
+const jetton_minter_2 = require("./contracts/wton/jetton-minter");
+Object.defineProperty(exports, "WTON_UNWRAP_CELL", { enumerable: true, get: function () { return jetton_minter_2.WTON_UNWRAP_CELL; } });
+Object.defineProperty(exports, "WTONMinter", { enumerable: true, get: function () { return jetton_minter_2.WTONMinter; } });
+const jetton_wallet_2 = require("./contracts/wton/jetton-wallet");
+Object.defineProperty(exports, "WTONWallet", { enumerable: true, get: function () { return jetton_wallet_2.WTONWallet; } });
+const action_parser_1 = require("./utils/action-parser");
+Object.defineProperty(exports, "parseAction", { enumerable: true, get: function () { return action_parser_1.parseAction; } });
+const composite_oracle_1 = require("./services/composite-oracle");
+Object.defineProperty(exports, "CompositeOracleV1", { enumerable: true, get: function () { return composite_oracle_1.CompositeOracleV1; } });
+const strategy_vault_2 = require("./services/strategy-vault");
+Object.defineProperty(exports, "StrategyVaultV1", { enumerable: true, get: function () { return strategy_vault_2.StrategyVaultV1; } });
+const pool_2 = require("./services/pool");
+Object.defineProperty(exports, "PoolServiceV1", { enumerable: true, get: function () { return pool_2.PoolServiceV1; } });
+const share_vault_2 = require("./services/share-vault");
+Object.defineProperty(exports, "ShareVaultServiceV1", { enumerable: true, get: function () { return share_vault_2.ShareVaultServiceV1; } });
+const rfq_batch_2 = require("./services/rfq-batch");
+Object.defineProperty(exports, "RFQBatchServiceV1", { enumerable: true, get: function () { return rfq_batch_2.RFQBatchServiceV1; } });
+const rfq_auction_2 = require("./services/rfq-auction");
+Object.defineProperty(exports, "RFQAuctionServiceV1", { enumerable: true, get: function () { return rfq_auction_2.RFQAuctionServiceV1; } });
+const pending_tracker_1 = require("./utils/pending-tracker");
+Object.defineProperty(exports, "sendMsgTracked", { enumerable: true, get: function () { return pending_tracker_1.sendMsgTracked; } });
+Object.defineProperty(exports, "createTrackableSender", { enumerable: true, get: function () { return pending_tracker_1.createTrackableSender; } });
+Object.defineProperty(exports, "createTrackableSenderFromMnemonic", { enumerable: true, get: function () { return pending_tracker_1.createTrackableSenderFromMnemonic; } });
+Object.defineProperty(exports, "ToncenterV3Client", { enumerable: true, get: function () { return pending_tracker_1.ToncenterV3Client; } });

package/dist/lib/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(condition: boolean, message?: string): asserts condition;

package/dist/lib/assert.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+// Browser-compatible assert function to replace Node.js assert module for webpack5 compatibility
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}

package/dist/lib/query-cache.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Wraps an object to cache results of get* method calls for TTL milliseconds.
+ * Prevents duplicate RPC calls when the same getter is called multiple times.
+ */
+export declare function withQueryCache<T extends object>(instance: T, ttl?: number): T;

package/dist/lib/query-cache.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withQueryCache = withQueryCache;
+const ton_1 = require("@ton/ton");
+/**
+ * Wraps an object to cache results of get* method calls for TTL milliseconds.
+ * Prevents duplicate RPC calls when the same getter is called multiple times.
+ */
+function withQueryCache(instance, ttl = 2500) {
+    const cache = new Map();
+    const inflightRequests = new Map();
+    return new Proxy(instance, {
+        get(target, prop) {
+            const value = target[prop];
+            // Return as-is if not a function
+            if (typeof value !== "function") {
+                return value;
+            }
+            const methodName = String(prop);
+            // Only cache methods that start with 'get'
+            if (!methodName.startsWith("get")) {
+                return value;
+            }
+            // Return cached function
+            return async function (...args) {
+                // Generate cache key (method name + arguments)
+                const params = JSON.stringify(args, (key, value) => typeof value === "bigint" || value instanceof ton_1.Cell || value instanceof ton_1.Address ? value.toString() : value);
+                const key = `${methodName}_${params}`;
+                const now = Date.now();
+                // 1. Check cache
+                const cached = cache.get(key);
+                if (cached && now < cached.expiry) {
+                    return cached.data;
+                }
+                // 2. Check if there's already an inflight request
+                const inflight = inflightRequests.get(key);
+                if (inflight) {
+                    return await inflight;
+                }
+                // 3. Start new request
+                const promise = Promise.resolve(value.apply(target, args))
+                    .then((data) => {
+                    // Store in cache on success
+                    cache.set(key, { data, expiry: now + ttl });
+                    return data;
+                })
+                    .finally(() => {
+                    // Remove from inflight requests after completion
+                    inflightRequests.delete(key);
+                });
+                // Register as inflight request
+                inflightRequests.set(key, promise);
+                return await promise;
+            };
+        },
+    });
+}

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

@@ -0,0 +1,11 @@
+import { Address, Cell } from "@ton/core";
+import { AddressSender } from "../types/sender";
+export type InternalMessageInput = {
+    to: Address;
+    value: bigint;
+    body: Cell;
+};
+export declare function sendMsg<T>(sender: AddressSender, msg: Promise<{
+    opts: T;
+    input: InternalMessageInput;
+}>): Promise<T>;

package/dist/lib/send-msg.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMsg = sendMsg;
+const core_1 = require("@ton/core");
+async function sendMsg(sender, msg) {
+    const { opts, input } = await msg;
+    await sender.send({ ...input, sendMode: core_1.SendMode.PAY_GAS_SEPARATELY });
+    return opts;
+}

package/dist/services/composite-oracle/computation.d.ts

@@ -0,0 +1,55 @@
+import { Cell } from "@ton/core";
+import { Prices, SyntheticCompositions, VaultPosition, VaultPositions, PoolInfos, VaultPrices, CompositeOracleResult, CompositeOracleInput } from "./types";
+import { AssetPriceInfo, OnchainDataInfo } from "../../contracts/oracle/redstone-onchain-oracle/type";
+export type OracleExposures = {
+    assets: Set<string>;
+    pools: Set<string>;
+    vaults: Set<string>;
+    totalSize(): number;
+};
+export declare function createOracleExposures(): OracleExposures;
+export declare function applyPrice(amount: bigint, price: bigint): bigint;
+export declare function calculateSyntheticPrices(rawPrices: Prices, syntheticCompositions: SyntheticCompositions): Prices;
+export declare function computePoolPositionsValue(poolPositions: VaultPosition["poolPositions"], poolInfos: PoolInfos, prices: Prices): {
+    totalValue: bigint;
+    decomposed: Record<string, {
+        supply: bigint;
+        borrow: bigint;
+    }>;
+    assetAmounts: Record<string, bigint>;
+};
+export declare function computeVaultValue(vault: VaultPosition, poolInfos: PoolInfos, prices: Prices): {
+    totalValue: bigint;
+    price: bigint;
+    decomposed: Record<string, {
+        supply: bigint;
+        borrow: bigint;
+    }>;
+};
+export declare function calculateVaultPrices(vaultPositions: VaultPositions, poolInfos: PoolInfos, assetPrices: Prices): VaultPrices;
+export declare function computeCompositePrices(input: CompositeOracleInput): CompositeOracleResult;
+export declare function getExposures(vaultPositions: VaultPositions): {
+    assets: string[];
+    pools: string[];
+};
+export declare function separateAssets(allAssets: string[], oracleConfig: {
+    redstoneAssetInfo?: Record<string, {
+        address: {
+            toString(): string;
+        };
+    }>;
+    assetOnchainDataInfo?: Record<string, any>;
+}): {
+    assets: string[];
+    vaultAssets: string[];
+};
+export declare function updateOnchainInternalData(prices: AssetPriceInfo, onchainData: OnchainDataInfo): AssetPriceInfo;
+/**
+ * Build oracle params Cell from pre-fetched Redstone payload
+ * Pure computation - no network calls
+ */
+export declare function buildOracleParamsCellFromPayload(assets: string[], oracleConfig: any, payload: Cell, pools: string[], vaults: string[]): Cell;
+/**
+ * Build oracle params Cell - fetches Redstone payload and builds Cell
+ */
+export declare function buildOracleParamsCell(assets: string[], oracleConfig: any, pools: string[], vaults: string[]): Promise<Cell>;