@affluent-org/sdk 0.0.1

package/dist/services/strategy-vault/user/index.d.ts

@@ -0,0 +1,89 @@
+import { Address, Cell } from "@ton/core";
+import { AffluentContext } from "../../../context";
+import { AddressSender } from "../../../types/sender";
+import { DepositAssetParams, BurnVaultAssetParams, CreateDepositQueueParams, CreateWithdrawQueueParams, CancelQueueParams } from "./types";
+export * from "./types";
+export declare function createDepositAssetMsg(ctx: AffluentContext, sender: AddressSender, params: DepositAssetParams, value?: bigint): Promise<{
+    opts: {
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: Cell;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createBurnVaultAssetMsg(ctx: AffluentContext, sender: AddressSender, params: BurnVaultAssetParams, value?: bigint): Promise<{
+    opts: {
+        amount: bigint;
+        response: Address;
+        forwardPayload: Cell;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createDepositQueueMsg(ctx: AffluentContext, sender: AddressSender, params: CreateDepositQueueParams): Promise<{
+    opts: {
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: Cell;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createWithdrawQueueMsg(ctx: AffluentContext, sender: AddressSender, params: CreateWithdrawQueueParams): Promise<{
+    opts: {
+        amount: bigint;
+        response: Address;
+        forwardPayload: Cell;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createCancelDepositQueueMsg(ctx: AffluentContext, params: CancelQueueParams): Promise<{
+    opts: {
+        to: Address;
+        value: bigint;
+        assetAddress: Address;
+        userAddress: Address;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;
+export declare function createCancelWithdrawQueueMsg(ctx: AffluentContext, params: CancelQueueParams): Promise<{
+    opts: {
+        to: Address;
+        value: bigint;
+        assetAddress: Address;
+        userAddress: Address;
+        queryId: bigint;
+    };
+    input: {
+        to: Address;
+        value: bigint;
+        body: Cell;
+    };
+}>;

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

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDepositAssetMsg = createDepositAssetMsg;
+exports.createBurnVaultAssetMsg = createBurnVaultAssetMsg;
+exports.createDepositQueueMsg = createDepositQueueMsg;
+exports.createWithdrawQueueMsg = createWithdrawQueueMsg;
+exports.createCancelDepositQueueMsg = createCancelDepositQueueMsg;
+exports.createCancelWithdrawQueueMsg = createCancelWithdrawQueueMsg;
+const core_1 = require("@ton/core");
+const utils_1 = require("../../../contracts/common/utils");
+const jetton_minter_1 = require("../../../contracts/jetton/jetton-minter");
+const jetton_wallet_1 = require("../../../contracts/jetton/jetton-wallet");
+const strategy_vault_1 = require("../../../contracts/vault/strategy-vault");
+const computation_1 = require("../../../contracts/vault/strategy-vault/computation");
+const jetton_minter_2 = require("../../../contracts/wton/jetton-minter");
+const jetton_wallet_2 = require("../../../contracts/wton/jetton-wallet");
+const oracle_1 = require("../oracle");
+const query_1 = require("../query");
+__exportStar(require("./types"), exports);
+// ============================================================
+// Shared Helpers
+// ============================================================
+async function createJettonTransferMsg(ctx, senderAddress, assetAddress, transferOpts, sendValue) {
+    if (ctx.isWTON(assetAddress)) {
+        const wtonMaster = ctx.getByContract(jetton_minter_2.WTONMinter, assetAddress);
+        const wtonWallet = ctx.getByContract(jetton_wallet_2.WTONWallet, (0, utils_1.toAddress)(await wtonMaster.getWalletAddress(transferOpts.recipient)));
+        return {
+            to: wtonWallet.address,
+            value: transferOpts.amount + transferOpts.forwardTonAmount + sendValue,
+            body: wtonWallet.createExternalTransferBody(transferOpts),
+        };
+    }
+    else {
+        const jettonMaster = ctx.getByContract(jetton_minter_1.JettonMinter, assetAddress);
+        const jettonWalletAddress = await jettonMaster.getWalletAddress(senderAddress);
+        const jettonWallet = ctx.getByContract(jetton_wallet_1.JettonWallet, jettonWalletAddress);
+        return {
+            to: jettonWallet.address,
+            value: sendValue,
+            body: jettonWallet.createTransferBody(transferOpts),
+        };
+    }
+}
+// ============================================================
+// Deposit Functions
+// ============================================================
+async function createDepositAssetMsg(ctx, sender, params, value) {
+    const vault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const vaultData = await vault.getVaultData();
+    const oracle = new oracle_1.OracleHelper(ctx);
+    const { oracleParams: oraclePayload } = await oracle.getOracleParamsForStrategyVaultV2(vaultData, [
+        params.assetAddress.toString(),
+        ...Object.keys(vaultData.assets),
+    ]);
+    const isWTON = ctx.isWTON(params.assetAddress);
+    const jettonResponseTonAmount = isWTON ? (0, core_1.toNano)(0.02) : 0n;
+    const jettonResponsePayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined;
+    const forwardPayload = strategy_vault_1.StrategyVault.createDepositPayload(sender.address, oraclePayload, jettonResponseTonAmount, jettonResponsePayload);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const fee = vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Deposit] +
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.DepositLogic] +
+        jettonResponseTonAmount;
+    const opts = {
+        recipient: vault.address,
+        amount: params.amount,
+        response: sender.address,
+        forwardTonAmount: fee,
+        forwardPayload,
+        queryId: params.queryId ?? (0, computation_1.createQueryId)({ ...params, forwardPayload }),
+    };
+    const sendValue = isWTON
+        ? (value ?? jetton_wallet_2.WTONWallet.Gas.ExternalTransfer)
+        : (value ?? fee + (0, core_1.toNano)(0.1));
+    const input = await createJettonTransferMsg(ctx, sender.address, assetAddress, opts, sendValue);
+    return { opts, input };
+}
+// ============================================================
+// Withdraw Functions
+// ============================================================
+async function createBurnVaultAssetMsg(ctx, sender, params, value) {
+    const vault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const vaultData = await vault.getVaultData();
+    const vaultAssetWalllet = await (0, query_1.getVaultWallet)(ctx, params.strategyVaultAddress, sender.address);
+    const oracle = new oracle_1.OracleHelper(ctx);
+    const { oracleParams: oraclePayload } = await oracle.getOracleParamsForStrategyVaultV2(vaultData, [
+        params.withdrawAssetAddress.toString(),
+        ...Object.keys(vaultData.assets),
+    ]);
+    const withdrawAssetAddress = (0, utils_1.toAddress)(params.withdrawAssetAddress);
+    const isWTON = ctx.isWTON(withdrawAssetAddress);
+    const jettonResponseTonAmount = isWTON ? (0, core_1.toNano)(0.02) : 0n;
+    const jettonResponsePayload = isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined;
+    const forwardPayload = strategy_vault_1.StrategyVault.createWithdrawPayload(withdrawAssetAddress, oraclePayload, jettonResponseTonAmount, jettonResponsePayload);
+    const fee = vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.Withdraw] +
+        vaultData.gasConfig[strategy_vault_1.StrategyVault.GasKey.WithdrawLogic] +
+        jettonResponseTonAmount +
+        (0, core_1.toNano)(0.1);
+    const opts = {
+        amount: params.vaultShareAmountForBurn,
+        response: sender.address,
+        forwardPayload: forwardPayload,
+        queryId: (0, computation_1.createQueryId)({ ...params, forwardPayload }),
+    };
+    return {
+        opts,
+        input: {
+            to: vaultAssetWalllet.address,
+            value: value ?? fee,
+            body: vaultAssetWalllet.createBurnBody(opts),
+        },
+    };
+}
+// ============================================================
+// Queue Create Functions
+// ============================================================
+async function createDepositQueueMsg(ctx, sender, params) {
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const isWTON = ctx.isWTON(assetAddress);
+    const vault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const jettonForwardParams = params.jettonForwardParams ?? {};
+    const queueItemParams = params.queueItemParams ?? {};
+    queueItemParams.jettonForwardTonAmount ??= isWTON ? jetton_minter_2.WTON_UNWRAP_GAS : 0n;
+    queueItemParams.jettonForwardPayload ??= isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined;
+    queueItemParams.actionForwardTonAmount ??= 0n;
+    const vaultData = await vault.getVaultData();
+    jettonForwardParams.forwardPayload ??= strategy_vault_1.StrategyVault.createDepositQueuePayload(params.responseAddress ?? sender.address, queueItemParams.jettonForwardTonAmount, queueItemParams.jettonForwardPayload);
+    const isFirst = !vaultData.depositQueueManager.pendingAssetQueue[assetAddress.toString()]?.dict[sender.address.toString()];
+    jettonForwardParams.forwardTonAmount ??=
+        strategy_vault_1.StrategyVault.calcQueueResistGas(vaultData, queueItemParams, isFirst) + (0, core_1.toNano)(0.03);
+    const sendValue = params.value ?? jettonForwardParams.forwardTonAmount + (0, core_1.toNano)(0.1);
+    const opts = {
+        recipient: vault.address,
+        amount: params.amount,
+        response: sender.address,
+        forwardTonAmount: jettonForwardParams.forwardTonAmount,
+        forwardPayload: jettonForwardParams.forwardPayload,
+        queryId: params.queryId ?? (0, computation_1.createQueryId)(params),
+    };
+    const input = await createJettonTransferMsg(ctx, sender.address, assetAddress, opts, sendValue);
+    return { opts, input };
+}
+async function createWithdrawQueueMsg(ctx, sender, params) {
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const isWTON = ctx.isWTON(assetAddress);
+    const vault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const jettonForwardParams = params.jettonForwardParams ?? {};
+    const queueItemParams = params.queueItemParams ?? {};
+    queueItemParams.jettonForwardTonAmount ??= isWTON ? jetton_minter_2.WTON_UNWRAP_GAS : 0n;
+    queueItemParams.jettonForwardPayload ??= isWTON ? jetton_minter_2.WTON_UNWRAP_CELL : undefined;
+    queueItemParams.actionForwardTonAmount ??= 0n;
+    const vaultData = await vault.getVaultData();
+    jettonForwardParams.forwardPayload ??= strategy_vault_1.StrategyVault.createWithdrawQueuePayload(assetAddress, queueItemParams.jettonForwardTonAmount, queueItemParams.jettonForwardPayload, queueItemParams.actionForwardTonAmount, queueItemParams.actionForwardPayload);
+    const isFirst = !vaultData.withdrawQueueManager.pendingAssetQueue[assetAddress.toString()]?.dict[sender.address.toString()];
+    jettonForwardParams.forwardTonAmount ??=
+        strategy_vault_1.StrategyVault.calcQueueResistGas(vaultData, queueItemParams, isFirst) + (0, core_1.toNano)(0.03);
+    const sendValue = params.value ?? jettonForwardParams.forwardTonAmount + (0, core_1.toNano)(0.1);
+    const opts = {
+        amount: params.shareAmount,
+        response: sender.address,
+        forwardPayload: jettonForwardParams.forwardPayload,
+        queryId: params.queryId ?? (0, computation_1.createQueryId)(params),
+    };
+    const vaultWalllet = await (0, query_1.getVaultWallet)(ctx, params.strategyVaultAddress, sender.address);
+    return {
+        opts,
+        input: {
+            to: vaultWalllet.address,
+            value: sendValue,
+            body: vaultWalllet.createBurnBody(opts),
+        },
+    };
+}
+// ============================================================
+// Queue Cancel Functions
+// ============================================================
+async function createCancelDepositQueueMsg(ctx, params) {
+    const vault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const userAddress = (0, utils_1.toAddress)(params.userAddress);
+    const queryId = params.queryId ?? (0, computation_1.createQueryId)(params);
+    const value = params.value ?? (0, core_1.toNano)(0.1);
+    return {
+        opts: { to: vault.address, value, assetAddress, userAddress, queryId },
+        input: {
+            to: vault.address,
+            value,
+            body: strategy_vault_1.StrategyVault.createCancelDepositQueueBody({ assetAddress, userAddress, queryId }),
+        },
+    };
+}
+async function createCancelWithdrawQueueMsg(ctx, params) {
+    const vault = (0, query_1.getVault)(ctx, params.strategyVaultAddress);
+    const assetAddress = (0, utils_1.toAddress)(params.assetAddress);
+    const userAddress = (0, utils_1.toAddress)(params.userAddress);
+    const queryId = params.queryId ?? (0, computation_1.createQueryId)(params);
+    const value = params.value ?? (0, core_1.toNano)(0.1);
+    return {
+        opts: { to: vault.address, value, assetAddress, userAddress, queryId },
+        input: {
+            to: vault.address,
+            value,
+            body: strategy_vault_1.StrategyVault.createCancelWithdrawQueueBody({ assetAddress, userAddress, queryId }),
+        },
+    };
+}

package/dist/services/strategy-vault/user/types.d.ts

@@ -0,0 +1,46 @@
+import { Address, Cell } from "@ton/core";
+import { AddressInput, AddressLike } from "../../../contracts/common/type";
+import { VaultResponseOptions } from "../../../contracts/vault/strategy-vault";
+export type DepositAssetParams = {
+    strategyVaultAddress: AddressInput;
+    assetAddress: AddressLike;
+    amount: bigint;
+    queryId?: bigint;
+};
+export type BurnVaultAssetParams = {
+    strategyVaultAddress: AddressInput;
+    withdrawAssetAddress: AddressLike;
+    vaultShareAmountForBurn: bigint;
+    queryID?: bigint;
+};
+export type JettonForwardParams = {
+    forwardTonAmount?: bigint;
+    forwardPayload?: Cell;
+};
+export type CreateDepositQueueParams = {
+    strategyVaultAddress: AddressInput;
+    assetAddress: AddressLike;
+    amount: bigint;
+    responseAddress?: Address;
+    jettonForwardParams?: JettonForwardParams;
+    queueItemParams?: VaultResponseOptions;
+    queryId?: bigint;
+    value?: bigint;
+};
+export type CreateWithdrawQueueParams = {
+    strategyVaultAddress: AddressInput;
+    shareAmount: bigint;
+    assetAddress: AddressLike;
+    responseAddress?: Address;
+    jettonForwardParams?: JettonForwardParams;
+    queueItemParams?: VaultResponseOptions;
+    queryId?: bigint;
+    value?: bigint;
+};
+export type CancelQueueParams = {
+    strategyVaultAddress: AddressInput;
+    assetAddress: AddressLike;
+    userAddress: AddressLike;
+    queryId?: bigint;
+    value?: bigint;
+};

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

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

package/dist/types/sender.d.ts

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

package/dist/types/sender.js

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

package/dist/utils/action-parser.d.ts

@@ -0,0 +1,7 @@
+import { Cell } from "@ton/core";
+export declare function parseAction(cell: Cell): {
+    contractType: string;
+    opCode: number;
+    opName: string;
+    data: import("..").SuccessActionNotificationMsgBody | import("..").SuccessRepayActionNotificationMsgBody | import("..").SuccessLiquidateActionNotificationMsgBody | import("..").FailTransferInActionNotificationMsgBody | import("..").FailLiquidateActionNotificationMsgBody | import("..").FailTransferOutActionNotificationMsgBody;
+} | null;

package/dist/utils/action-parser.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAction = parseAction;
+const pool_1 = require("../contracts/core/pool");
+const parser_1 = require("./parser");
+function parseAction(cell) {
+    try {
+        const notification = (0, parser_1.parseActionNotification)(cell);
+        if (notification) {
+            return {
+                contractType: "Pool",
+                opCode: pool_1.Pool.Op.ActionNotification,
+                opName: "ActionNotification",
+                data: notification,
+            };
+        }
+    }
+    catch (e) { }
+    return null;
+}

package/dist/utils/external-message-hash.d.ts

@@ -0,0 +1,45 @@
+import { Address, Cell } from "@ton/core";
+/**
+ * Compute the hash of an external message for tracking via toncenter API.
+ *
+ * TEP-467 normalization is applied for consistent hashing:
+ * - src: undefined
+ * - importFee: 0n
+ * - init: null
+ * - body: stored as reference (forceRef: true)
+ *
+ * @param walletAddress - The wallet contract address (where external message is sent)
+ * @param signedBody - The signed wallet transfer body (from wallet.createTransfer())
+ * @returns Hash in multiple formats
+ *
+ * @example
+ * ```typescript
+ * import { WalletContractV4 } from "@ton/ton";
+ *
+ * const wallet = WalletContractV4.create({ workchain: 0, publicKey });
+ * const seqno = await wallet.getSeqno(provider);
+ *
+ * // Create the signed transfer
+ * const transfer = wallet.createTransfer({
+ *   seqno,
+ *   secretKey,
+ *   messages: [internal({ to: strategyVault, value: toNano(1), body: msgBody })],
+ * });
+ *
+ * // Compute the external message hash BEFORE sending
+ * const { hashHex } = computeExternalMessageHash(wallet.address, transfer);
+ *
+ * // Send the transaction
+ * await wallet.send(provider, transfer);
+ *
+ * // Track via toncenter API
+ * const response = await fetch(
+ *   `https://toncenter.com/api/v3/pendingTraces?ext_msg_hash=${hashHex}`
+ * );
+ * ```
+ */
+export declare function computeExternalMessageHash(walletAddress: Address, signedBody: Cell): {
+    hash: Buffer;
+    hashHex: string;
+    hashBase64: string;
+};

package/dist/utils/external-message-hash.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeExternalMessageHash = computeExternalMessageHash;
+const core_1 = require("@ton/core");
+/**
+ * Compute the hash of an external message for tracking via toncenter API.
+ *
+ * TEP-467 normalization is applied for consistent hashing:
+ * - src: undefined
+ * - importFee: 0n
+ * - init: null
+ * - body: stored as reference (forceRef: true)
+ *
+ * @param walletAddress - The wallet contract address (where external message is sent)
+ * @param signedBody - The signed wallet transfer body (from wallet.createTransfer())
+ * @returns Hash in multiple formats
+ *
+ * @example
+ * ```typescript
+ * import { WalletContractV4 } from "@ton/ton";
+ *
+ * const wallet = WalletContractV4.create({ workchain: 0, publicKey });
+ * const seqno = await wallet.getSeqno(provider);
+ *
+ * // Create the signed transfer
+ * const transfer = wallet.createTransfer({
+ *   seqno,
+ *   secretKey,
+ *   messages: [internal({ to: strategyVault, value: toNano(1), body: msgBody })],
+ * });
+ *
+ * // Compute the external message hash BEFORE sending
+ * const { hashHex } = computeExternalMessageHash(wallet.address, transfer);
+ *
+ * // Send the transaction
+ * await wallet.send(provider, transfer);
+ *
+ * // Track via toncenter API
+ * const response = await fetch(
+ *   `https://toncenter.com/api/v3/pendingTraces?ext_msg_hash=${hashHex}`
+ * );
+ * ```
+ */
+function computeExternalMessageHash(walletAddress, signedBody) {
+    // TEP-467 normalized external-in message
+    const normalizedMessage = {
+        info: {
+            type: "external-in",
+            dest: walletAddress,
+            src: undefined,
+            importFee: 0n,
+        },
+        init: null,
+        body: signedBody,
+    };
+    const hash = (0, core_1.beginCell)()
+        .store((0, core_1.storeMessage)(normalizedMessage, { forceRef: true }))
+        .endCell()
+        .hash();
+    return {
+        hash,
+        hashHex: hash.toString("hex"),
+        hashBase64: hash.toString("base64"),
+    };
+}

package/dist/utils/oracle/redstone/readonlyCachedRedstone.d.ts

@@ -0,0 +1,3 @@
+export declare class ReadonlyCachedRedstone {
+    static getPrices(assets: string[]): Promise<any>;
+}

package/dist/utils/oracle/redstone/readonlyCachedRedstone.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyCachedRedstone = void 0;
+const query_cache_1 = require("../../../lib/query-cache");
+const redstoneHelper_1 = require("./redstoneHelper");
+const cachedRedstoneClient = (0, query_cache_1.withQueryCache)((0, redstoneHelper_1.createRedstoneHelper)("prod"));
+class ReadonlyCachedRedstone {
+    static getPrices(assets) {
+        const whitelistedAssets = [
+            "TON",
+            "USDT",
+            "stTON_FUNDAMENTAL",
+            "tsTON_FUNDAMENTAL",
+            "XAU",
+            "USDe",
+            "tsUSDe_FUNDAMENTAL",
+        ];
+        const isWhitelistedAssetsRequest = assets.every((item) => whitelistedAssets.includes(item));
+        if (isWhitelistedAssetsRequest) {
+            assets = whitelistedAssets;
+        }
+        return cachedRedstoneClient.getPrices(assets);
+    }
+}
+exports.ReadonlyCachedRedstone = ReadonlyCachedRedstone;

package/dist/utils/oracle/redstone/redstoneHelper.d.ts

@@ -0,0 +1,21 @@
+export declare function parseDataPackageHex(dataPackageHex: string): {
+    timestamp: bigint;
+    price: bigint;
+    feedId: bigint;
+};
+export declare function createPayload(assets: string[]): Promise<import("@ton/core").Cell>;
+export declare function getHexlifiedFeedIds(assets: string[]): string[];
+export declare function getDataFeedIdTuples(assets: string[]): import("@ton/core").Cell;
+export declare function createRedstoneHelper(type: "demo" | "prod"): {
+    createPayload: (assets: string[]) => Promise<import("@ton/core").Cell>;
+    getHexlifiedFeedIds: (assets: string[]) => string[];
+    getDataFeedIdTuples: (assets: string[]) => import("@ton/core").Cell;
+    getPrices: (assets: string[]) => Promise<any>;
+};
+declare const _default: {
+    getDataFeedIdTuples: typeof getDataFeedIdTuples;
+    getHexlifiedFeedIds: typeof getHexlifiedFeedIds;
+    createPayload: typeof createPayload;
+    createRedstoneHelper: typeof createRedstoneHelper;
+};
+export default _default;