@affluent-org/sdk 0.0.5 → 0.0.6

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

@@ -1,4 +1,37 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,6 +41,7 @@ exports.createPayload = createPayload;
 exports.getHexlifiedFeedIds = getHexlifiedFeedIds;
 exports.getDataFeedIdTuples = getDataFeedIdTuples;
 exports.createRedstoneHelper = createRedstoneHelper;
+exports.createRedstoneCustomHelper = createRedstoneCustomHelper;
 const core_1 = require("@ton/core");
 const sdk_1 = require("@redstone-finance/sdk");
 const protocol_1 = require("@redstone-finance/protocol");
@@ -211,13 +245,81 @@ function createRedstoneHelper(type) {
         getPrices,
     };
 }
+function createRedstoneCustomHelper(baseUrl) {
+    const SIGNER_COUNT_THRESHOLD = 5;
+    async function fetchPayloadHex(assets) {
+        const { default: axios } = await Promise.resolve(`${"axios"}`).then(s => __importStar(require(s)));
+        const response = await axios.get(`${baseUrl}/prices/latest`, {
+            timeout: 10000,
+            params: {
+                dataFeedIds: assets,
+                minimalSignersCount: SIGNER_COUNT_THRESHOLD,
+            },
+            paramsSerializer: { indexes: null },
+        });
+        const { SignedDataPackage, RedstonePayload } = await Promise.resolve(`${"@redstone-finance/protocol"}`).then(s => __importStar(require(s)));
+        const prices = response.data.prices;
+        const flatPackages = assets.flatMap((asset) => prices[asset] || []);
+        const signedDataPackages = flatPackages.map((obj) => SignedDataPackage.fromObj(obj));
+        const payload = new RedstonePayload(signedDataPackages, "");
+        return payload.toBytesHexWithout0xPrefix();
+    }
+    async function createPayload(assets) {
+        if (assets.length === 0)
+            return (0, core_1.beginCell)().storeUint(0, 2).endCell();
+        const payloadHex = await fetchPayloadHex(assets);
+        const { dataPackageChunks, metadata } = splitPayloadHex(payloadHex);
+        const payloadCell = (0, core_1.beginCell)();
+        const cells = new Map();
+        for (let i = 0; i < dataPackageChunks.length; i++) {
+            cells.set(BigInt(i), dataPackageChunks[i]);
+        }
+        const dataPackagesDict = (0, core_1.beginCell)();
+        const BASE_KEY_LEN = 16;
+        (0, serializeDict_1.serializeDict)(cells, BASE_KEY_LEN, storeSignatureAndData, dataPackagesDict);
+        payloadCell.storeRef(dataPackagesDict);
+        storeMetadata(metadata, payloadCell);
+        return payloadCell.endCell();
+    }
+    async function getPrices(assets) {
+        const payloadHex = await fetchPayloadHex(assets);
+        const { dataPackageChunks } = splitPayloadHex(payloadHex);
+        const result = [];
+        for (let i = 0; i < dataPackageChunks.length; i++) {
+            result.push({
+                name: assets[i],
+                ...parseDataPackageHex(dataPackageChunks[i]),
+            });
+        }
+        return result;
+    }
+    function getHexlifiedFeedIds(assets) {
+        const paramsProvider = new sdk_1.ContractParamsProvider({
+            dataServiceId: "redstone-primary-prod",
+            uniqueSignersCount: SIGNER_COUNT_THRESHOLD,
+            dataPackagesIds: assets,
+        });
+        return paramsProvider.getHexlifiedFeedIds();
+    }
+    function getDataFeedIdTuples(assets) {
+        const dataFeedIdsTupleBuilder = new core_1.TupleBuilder();
+        getHexlifiedFeedIds(assets).forEach((item) => dataFeedIdsTupleBuilder.writeNumber(BigInt(item)));
+        return (0, core_1.serializeTuple)(dataFeedIdsTupleBuilder.build());
+    }
+    return {
+        createPayload,
+        getHexlifiedFeedIds,
+        getDataFeedIdTuples,
+        getPrices,
+    };
+}
 exports.default = {
     getDataFeedIdTuples,
     getHexlifiedFeedIds,
     createPayload,
     createRedstoneHelper,
+    createRedstoneCustomHelper,
 };
-const encoder = new TextEncoder();
 function stringToBytes(value) {
     const hexArray = value
         .slice(2)

package/dist/utils/pending-tracker/trackable-sender.d.ts

@@ -1,16 +1,49 @@
+import { SenderArguments, OpenedContract, Address, Cell } from "@ton/core";
 import { TonClient, WalletContractV5R1 } from "@ton/ton";
 import { KeyPair } from "@ton/crypto";
-import { TrackableSender } from "./type";
+import { MessageHash } from "../external-message-hash";
+export declare const sleep: (ms?: number) => Promise<unknown>;
 export interface TrackableSenderConfig {
     client: TonClient;
-    wallet: WalletContractV5R1;
+    wallet: OpenedContract<WalletContractV5R1>;
     keyPair: KeyPair;
 }
+export declare function parseExternalMessage(body: Cell): {
+    op: number;
+    walletId: number;
+    timeout: number;
+    seqno: number;
+    actions: any[];
+    signature: Buffer<ArrayBufferLike>;
+};
+export declare function pollExternalTransfer(client: TonClient, address: Address, seqno: number): Promise<MessageHash>;
 /**
  * Create a TrackableSender from wallet contract and key pair
  */
-export declare function createTrackableSender(config: TrackableSenderConfig): TrackableSender;
+export declare function createTrackableSender(config: TrackableSenderConfig): {
+    address: Address;
+    getSeqno(): Promise<number>;
+    send(args: SenderArguments): Promise<{
+        signedBody: Cell;
+        extMsgHash: {
+            ext: MessageHash;
+            norm: MessageHash;
+        };
+        seqno: number;
+    }>;
+};
 /**
  * Create a TrackableSender from mnemonic
  */
-export declare function createTrackableSenderFromMnemonic(client: TonClient, mnemonic: string[], workchain?: number): Promise<TrackableSender>;
+export declare function createTrackableSenderFromMnemonic(client: TonClient, mnemonic: string[], workchain?: number): Promise<{
+    address: Address;
+    getSeqno(): Promise<number>;
+    send(args: SenderArguments): Promise<{
+        signedBody: Cell;
+        extMsgHash: {
+            ext: MessageHash;
+            norm: MessageHash;
+        };
+        seqno: number;
+    }>;
+}>;

package/dist/utils/pending-tracker/trackable-sender.js

@@ -33,22 +33,60 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+exports.parseExternalMessage = parseExternalMessage;
+exports.pollExternalTransfer = pollExternalTransfer;
 exports.createTrackableSender = createTrackableSender;
 exports.createTrackableSenderFromMnemonic = createTrackableSenderFromMnemonic;
 const core_1 = require("@ton/core");
 const ton_1 = require("@ton/ton");
 const external_message_hash_1 = require("../external-message-hash");
+const WalletContractV5R1_1 = require("@ton/ton/dist/wallets/WalletContractV5R1");
+const sleep = (ms = 1000) => new Promise(r => setTimeout(r, ms));
+exports.sleep = sleep;
+function parseExternalMessage(body) {
+    const slice = body.beginParse();
+    const op = Number(slice.loadUint(32));
+    const walletId = Number(slice.loadUint(32));
+    const timeout = Number(slice.loadUint(32));
+    const seqno = Number(slice.loadUint(32));
+    const actions = [];
+    const outList = slice.loadMaybeRef();
+    if (outList)
+        actions.push(...(0, core_1.loadOutList)(outList.beginParse()));
+    if (slice.loadBit())
+        actions.push((0, WalletContractV5R1_1.loadOutActionExtendedV5R1)(slice));
+    while (slice.remainingRefs > 0) {
+        actions.push((0, WalletContractV5R1_1.loadOutActionExtendedV5R1)(slice.loadRef().beginParse()));
+    }
+    const signature = slice.loadBuffer(64);
+    return { op, walletId, timeout, seqno, actions, signature };
+}
+async function pollExternalTransfer(client, address, seqno) {
+    while (true) {
+        const txs = await client.getTransactions(address, {
+            limit: 100
+        });
+        const tx = txs
+            .filter(tx => tx.inMessage?.info.type === "external-in")
+            .find(tx => parseExternalMessage(tx.inMessage?.body).seqno === seqno);
+        if (tx) {
+            const result = (0, external_message_hash_1.computeExternalMessageHash)(address, tx.inMessage?.body);
+            return result.ext;
+        }
+        await (0, exports.sleep)();
+    }
+}
 /**
  * Create a TrackableSender from wallet contract and key pair
  */
 function createTrackableSender(config) {
     const { client, wallet, keyPair } = config;
-    const openedWallet = client.open(wallet);
     return {
         address: wallet.address,
         async getSeqno() {
             try {
-                return await openedWallet.getSeqno();
+                return await wallet.getSeqno();
             }
             catch {
                 return 0;
@@ -61,18 +99,19 @@ function createTrackableSender(config) {
                 value: args.value,
                 body: args.body,
                 bounce: args.bounce ?? true,
-                init: args.init,
+                // init: args.init,
             });
             const sendMode = args.sendMode ?? core_1.SendMode.PAY_GAS_SEPARATELY;
-            const signedBody = openedWallet.createTransfer({
+            wallet.send;
+            const signedBody = wallet.createTransfer({
                 seqno,
                 secretKey: keyPair.secretKey,
                 sendMode,
                 messages: [internalMessage],
             });
-            const { hashHex } = (0, external_message_hash_1.computeExternalMessageHash)(wallet.address, signedBody);
-            await openedWallet.send(signedBody);
-            return { extMsgHash: hashHex, seqno };
+            const extMsgHash = (0, external_message_hash_1.computeExternalMessageHash)(wallet.address, signedBody);
+            await wallet.send(signedBody);
+            return { signedBody, extMsgHash, seqno };
         },
     };
 }
@@ -82,6 +121,6 @@ function createTrackableSender(config) {
 async function createTrackableSenderFromMnemonic(client, mnemonic, workchain = 0) {
     const { mnemonicToWalletKey } = await Promise.resolve().then(() => __importStar(require("@ton/crypto")));
     const keyPair = await mnemonicToWalletKey(mnemonic);
-    const wallet = ton_1.WalletContractV5R1.create({ publicKey: keyPair.publicKey, workchain });
+    const wallet = client.open(ton_1.WalletContractV5R1.create({ publicKey: keyPair.publicKey, workchain }));
     return createTrackableSender({ client, wallet, keyPair });
 }

package/dist/utils/pending-tracker/v3-client.d.ts

@@ -1,4 +1,5 @@
 import { PendingTraceResponse, TraceResult, WaitOptions } from "./type";
+import { ToncenterPendingTracesResponseRaw, ToncenterTraceRaw } from "../toncenter/type";
 /**
  * Toncenter v3 API endpoints
  */
@@ -19,6 +20,21 @@ export declare class ToncenterV3Client {
      * Get pending traces by external message hash
      */
     getPendingTraces(extMsgHash: string): Promise<PendingTraceResponse>;
+    /**
+     * Get detailed pending traces (includes transaction details for step tracking)
+     */
+    getDetailedPendingTraces(extMsgHash: string): Promise<ToncenterPendingTracesResponseRaw>;
+    /**
+     * Get confirmed traces by message hash
+     */
+    getTraces(msgHash: string): Promise<ToncenterPendingTracesResponseRaw>;
+    /**
+     * Poll for detailed trace (for TracerBase compatibility)
+     */
+    pollDetailedTrace(extMsgHash: string, options?: {
+        pollInterval?: number;
+        maxRetries?: number;
+    }): Promise<ToncenterTraceRaw>;
     /**
      * Convert raw trace to simplified TraceResult
      */

package/dist/utils/pending-tracker/v3-client.js

@@ -3,6 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ToncenterV3Client = void 0;
 const core_1 = require("@ton/core");
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class ToncenterApiError extends Error {
+    status;
+    statusText;
+    payload;
+    constructor(status, statusText, payload) {
+        super(`Toncenter v3 API error: ${status} ${statusText}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.payload = payload;
+        this.name = "ToncenterApiError";
+    }
+}
 /**
  * Toncenter v3 API endpoints
  */
@@ -30,7 +42,14 @@ class ToncenterV3Client {
         }
         const response = await fetch(url, { headers });
         if (!response.ok) {
-            throw new Error(`Toncenter v3 API error: ${response.status} ${response.statusText}`);
+            let payload;
+            try {
+                payload = await response.json();
+            }
+            catch {
+                payload = await response.text();
+            }
+            throw new ToncenterApiError(response.status, response.statusText, payload);
         }
         return response.json();
     }
@@ -38,7 +57,66 @@ class ToncenterV3Client {
      * Get pending traces by external message hash
      */
     async getPendingTraces(extMsgHash) {
-        return this.fetch(`/pendingTraces?ext_msg_hash=${extMsgHash}`);
+        const param = encodeURIComponent(extMsgHash);
+        try {
+            return await this.fetch(`/pendingTraces?ext_msg_hash=${param}`);
+        }
+        catch (error) {
+            if (error instanceof ToncenterApiError && error.status === 422) {
+                return { traces: [] };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get detailed pending traces (includes transaction details for step tracking)
+     */
+    async getDetailedPendingTraces(extMsgHash) {
+        const param = encodeURIComponent(extMsgHash);
+        try {
+            return await this.fetch(`/pendingTraces?ext_msg_hash=${param}`);
+        }
+        catch (error) {
+            if (error instanceof ToncenterApiError && error.status === 422) {
+                return { traces: null, address_book: {}, metadata: {} };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get confirmed traces by message hash
+     */
+    async getTraces(msgHash) {
+        const param = encodeURIComponent(msgHash);
+        try {
+            return await this.fetch(`/traces?msg_hash=${param}`);
+        }
+        catch (error) {
+            if (error instanceof ToncenterApiError && error.status === 422) {
+                return { traces: null, address_book: {}, metadata: {} };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Poll for detailed trace (for TracerBase compatibility)
+     */
+    async pollDetailedTrace(extMsgHash, options = {}) {
+        const { pollInterval = 3000, maxRetries = 30 } = options;
+        let count = 0;
+        while (count < maxRetries) {
+            count++;
+            const pending = await this.getDetailedPendingTraces(extMsgHash);
+            const pendingTrace = pending.traces?.find(t => t.trace.in_msg_hash === extMsgHash);
+            if (pendingTrace)
+                return pendingTrace;
+            const confirmed = await this.getTraces(extMsgHash);
+            const confirmedTrace = confirmed.traces?.find(t => t.trace.in_msg_hash === extMsgHash);
+            if (confirmedTrace)
+                return confirmedTrace;
+            await sleep(pollInterval);
+        }
+        throw new Error(`Max retries exceeded for trace: ${extMsgHash}`);
     }
     /**
      * Convert raw trace to simplified TraceResult

package/dist/utils/toncenter/index.d.ts

@@ -0,0 +1 @@
+export * from "./type";

package/dist/utils/toncenter/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./type"), exports);

package/dist/utils/toncenter/transform.d.ts

@@ -0,0 +1,11 @@
+import { ToncenterPendingTracesResponse, ToncenterPendingTracesResponseRaw } from "./type";
+/**
+ * Convert Toncenter raw JSON responses into objects where numeric strings become bigint.
+ */
+export declare class ToncenterResponseTransformer {
+    static normalize(response: ToncenterPendingTracesResponseRaw): ToncenterPendingTracesResponse;
+    static normalize(response: Promise<ToncenterPendingTracesResponseRaw>): Promise<ToncenterPendingTracesResponse>;
+    private static deepNormalize;
+    private static isNumericString;
+    private static isPromise;
+}

package/dist/utils/toncenter/transform.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToncenterResponseTransformer = void 0;
+/**
+ * Convert Toncenter raw JSON responses into objects where numeric strings become bigint.
+ */
+class ToncenterResponseTransformer {
+    static normalize(response) {
+        if (ToncenterResponseTransformer.isPromise(response)) {
+            return response.then((value) => ToncenterResponseTransformer.deepNormalize(value));
+        }
+        return ToncenterResponseTransformer.deepNormalize(response);
+    }
+    static deepNormalize(value) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        if (typeof value === "string" && ToncenterResponseTransformer.isNumericString(value)) {
+            return BigInt(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.deepNormalize(item));
+        }
+        if (typeof value === "object") {
+            const result = {};
+            for (const [key, entry] of Object.entries(value)) {
+                result[key] = this.deepNormalize(entry);
+            }
+            return result;
+        }
+        return value;
+    }
+    static isNumericString(value) {
+        return /^-?\d+$/.test(value);
+    }
+    static isPromise(value) {
+        return typeof value.then === "function";
+    }
+}
+exports.ToncenterResponseTransformer = ToncenterResponseTransformer;