@tonappchain/sdk 0.7.2-alpha-11 → 0.7.2-alpha-13

package/dist/artifacts/dev/ton/internal/build/CrossChainLayer.compiled.json

@@ -1 +1 @@
-{ "hash": "b7a220facd930fbfbf4b50baa2d2663dd81177c9e2de3f75973e40ddcac945a4", "hashBase64": "t6Ig+s2TD7+/S1C6otJmPdgRd8ni3j91lz5A3crJRaQ=", "hex": "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" }
+{ "hash": "85de6d2e111cbc56b64af4ac6e0c705806e37d984440d197ff4b6fb39439b672", "hashBase64": "hd5tLhEcvFa2SvSsbgxwWAbjfZhEQNGX/0tvs5Q5tnI=", "hex": "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" }

package/dist/src/adapters/BaseContractOpener.d.ts

@@ -0,0 +1,71 @@
+import { SandboxContract } from '@ton/sandbox';
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { ContractOpener, ILogger } from '../interfaces';
+import { AddressInformation, GetTransactionsOptions } from '../structs/Struct';
+import { ContractState, TrackTransactionTreeParams, TrackTransactionTreeResult } from '../structs/Struct';
+/**
+ * Base class for ContractOpener implementations with common functionality
+ */
+export declare abstract class BaseContractOpener implements ContractOpener {
+    protected logger?: ILogger;
+    protected constructor(logger?: ILogger);
+    abstract open<T extends Contract>(contract: T): OpenedContract<T> | SandboxContract<T>;
+    abstract getContractState(address: Address): Promise<ContractState>;
+    abstract getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    abstract getAddressInformation(address: Address): Promise<AddressInformation>;
+    abstract getConfig(): Promise<string>;
+    closeConnections?(): void;
+    /**
+     * Common pagination logic for scanning transaction history
+     * @param addr Account address
+     * @param opts Search options
+     * @param predicate Function to check if transaction matches search criteria
+     * @returns Found transaction or null
+     */
+    private scanTransactionHistory;
+    /**
+     * Find transaction by hash with pagination through account history
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    getTransactionByHash(addr: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its transaction hash only.
+     * More efficient than getTransactionByHash when you know it's a transaction hash.
+     */
+    getTransactionByTxHash(addr: Address, txHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its incoming message hash.
+     * Useful for finding the transaction that processed a specific message.
+     */
+    getTransactionByInMsgHash(addr: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Find transaction by its outgoing message hash.
+     * Useful for finding the parent transaction that sent a specific message.
+     */
+    getTransactionByOutMsgHash(addr: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    /**
+     * Get adjacent transactions (children and parent)
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    getAdjacentTransactions(addr: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
+    /**
+     * Validate transaction phases and return error details
+     */
+    private validateTransactionWithResult;
+    /**
+     * Find transaction by hash type
+     */
+    private findTransactionByHashType;
+    /**
+     * Track transaction tree and validate all transactions
+     */
+    trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
+    /**
+     * Track transaction tree and validate all transactions (returns result instead of throwing)
+     */
+    trackTransactionTreeWithResult(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<TrackTransactionTreeResult>;
+}

package/dist/src/adapters/BaseContractOpener.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContractOpener = void 0;
+const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
+const Consts_1 = require("../sdk/Consts");
+const Utils_1 = require("../sdk/Utils");
+/**
+ * Base class for ContractOpener implementations with common functionality
+ */
+class BaseContractOpener {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    /**
+     * Common pagination logic for scanning transaction history
+     * @param addr Account address
+     * @param opts Search options
+     * @param predicate Function to check if transaction matches search criteria
+     * @returns Found transaction or null
+     */
+    async scanTransactionHistory(addr, opts, predicate) {
+        const limit = opts?.limit ?? Consts_1.DEFAULT_FIND_TX_LIMIT;
+        let currentLt = opts?.lt;
+        let currentHash = opts?.hash;
+        while (true) {
+            const batch = await this.getTransactions(addr, {
+                limit,
+                lt: currentLt,
+                hash: currentHash,
+                archival: opts?.archival ?? Consts_1.DEFAULT_FIND_TX_ARCHIVAL,
+            });
+            if (batch.length === 0)
+                break;
+            for (const tx of batch) {
+                if (predicate(tx)) {
+                    return tx;
+                }
+            }
+            const oldestTx = batch[batch.length - 1];
+            if (oldestTx.prevTransactionLt === 0n)
+                break;
+            currentLt = oldestTx.prevTransactionLt.toString();
+            const hashHex = oldestTx.prevTransactionHash.toString(16).padStart(64, '0');
+            currentHash = Buffer.from(hashHex, 'hex').toString('base64');
+        }
+        return null;
+    }
+    /**
+     * Find transaction by hash with pagination through account history
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    async getTransactionByHash(addr, hash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(hash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            // 1. check tx itself
+            if (tx.hash().toString('base64') === targetHashB64) {
+                return true;
+            }
+            // 2. check incoming message(external-in)
+            if (tx.inMessage && tx.inMessage.info.type === 'external-in') {
+                const msgHash = (0, Utils_1.getNormalizedExtMessageHash)(tx.inMessage);
+                if (msgHash === targetHashB64) {
+                    return true;
+                }
+            }
+            // 3. check incoming message(internal)
+            if (tx.inMessage && tx.inMessage.info.type === 'internal') {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell();
+                const msgHash = messageCell.hash();
+                if (msgHash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Find transaction by its transaction hash only.
+     * More efficient than getTransactionByHash when you know it's a transaction hash.
+     */
+    async getTransactionByTxHash(addr, txHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(txHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            return tx.hash().toString('base64') === targetHashB64;
+        });
+    }
+    /**
+     * Find transaction by its incoming message hash.
+     * Useful for finding the transaction that processed a specific message.
+     */
+    async getTransactionByInMsgHash(addr, msgHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(msgHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            // Check incoming message(external-in) - uses normalized hash
+            if (tx.inMessage && tx.inMessage.info.type === 'external-in') {
+                const hash = (0, Utils_1.getNormalizedExtMessageHash)(tx.inMessage);
+                if (hash === targetHashB64) {
+                    return true;
+                }
+            }
+            // Check incoming message(internal) - uses full message cell hash
+            if (tx.inMessage && tx.inMessage.info.type === 'internal') {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Find transaction by its outgoing message hash.
+     * Useful for finding the parent transaction that sent a specific message.
+     */
+    async getTransactionByOutMsgHash(addr, msgHash, opts) {
+        const targetHashB64 = (0, Utils_1.normalizeHashToBase64)(msgHash);
+        return this.scanTransactionHistory(addr, opts, (tx) => {
+            for (const outMsg of tx.outMessages.values()) {
+                const messageCell = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(outMsg)).endCell();
+                const hash = messageCell.hash();
+                if (hash.toString('base64') === targetHashB64) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    /**
+     * Get adjacent transactions (children and parent)
+     * @param addr Account address
+     * @param hash Transaction hash in any format (base64, hex)
+     * @param opts Search options
+     */
+    async getAdjacentTransactions(addr, hash, opts) {
+        // 1. Find the root transaction (hash will be normalized inside getTransactionByHash)
+        const rootTx = await this.getTransactionByHash(addr, hash, opts);
+        if (!rootTx)
+            return [];
+        const adjacent = [];
+        // 2. Follow every outgoing message to find child transactions
+        for (const msg of rootTx.outMessages.values()) {
+            const dst = msg.info.dest;
+            if (!dst || dst instanceof ton_1.ExternalAddress)
+                continue;
+            const msgHashB64 = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(msg)).endCell().hash().toString('base64');
+            // The outgoing message becomes an incoming message at the destination
+            const tx = await this.getTransactionByInMsgHash(dst, msgHashB64, opts);
+            if (tx)
+                adjacent.push(tx);
+        }
+        // 3. Optional: follow the incoming message to find parent transaction
+        if (rootTx.inMessage?.info.type === 'internal') {
+            const msgHashB64 = (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(rootTx.inMessage)).endCell().hash().toString('base64');
+            // The incoming message was an outgoing message at the source
+            const tx = await this.getTransactionByOutMsgHash(rootTx.inMessage.info.src, msgHashB64, opts);
+            if (tx)
+                adjacent.push(tx);
+        }
+        return adjacent;
+    }
+    /**
+     * Validate transaction phases and return error details
+     */
+    validateTransactionWithResult(tx, ignoreOpcodeList) {
+        if (tx.description.type !== 'generic' || !tx.inMessage)
+            return null;
+        // Skip validation for 1 nano messages
+        if (tx.inMessage.info.type === 'internal' && tx.inMessage.info.value.coins === Consts_1.IGNORE_MSG_VALUE_1_NANO) {
+            return null;
+        }
+        const bodySlice = tx.inMessage.body.beginParse();
+        if (bodySlice.remainingBits < 32)
+            return null;
+        const opcode = bodySlice.loadUint(32);
+        if (ignoreOpcodeList.includes(opcode)) {
+            this.logger?.debug(`Skipping validation for tx: ${tx.hash().toString('base64')} (opcode in ignore list)`);
+            return null;
+        }
+        const { aborted, computePhase, actionPhase } = tx.description;
+        const txHash = tx.hash().toString('base64');
+        const exitCode = computePhase && computePhase.type !== 'skipped' ? computePhase.exitCode : 'N/A';
+        const resultCode = actionPhase ? actionPhase.resultCode : 'N/A';
+        if (aborted) {
+            if (!computePhase || computePhase.type === 'skipped') {
+                return { txHash, exitCode, resultCode, reason: 'compute_phase_missing' };
+            }
+            if (!computePhase.success || computePhase.exitCode !== 0) {
+                return { txHash, exitCode, resultCode, reason: 'compute_phase_failed' };
+            }
+            if (actionPhase && (!actionPhase.success || actionPhase.resultCode !== 0)) {
+                return { txHash, exitCode, resultCode, reason: 'action_phase_failed' };
+            }
+            return { txHash, exitCode, resultCode, reason: 'aborted' };
+        }
+        return null;
+    }
+    /**
+     * Find transaction by hash type
+     */
+    async findTransactionByHashType(address, hash, hashType, limit) {
+        const opts = { limit, archival: true };
+        if (hashType === 'in') {
+            return this.getTransactionByInMsgHash(address, hash, opts);
+        }
+        else if (hashType === 'out') {
+            return this.getTransactionByOutMsgHash(address, hash, opts);
+        }
+        else {
+            return this.getTransactionByHash(address, hash, opts);
+        }
+    }
+    /**
+     * Track transaction tree and validate all transactions
+     */
+    async trackTransactionTree(address, hash, params = {
+        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+        ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
+        limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
+        direction: 'both',
+    }) {
+        const result = await this.trackTransactionTreeWithResult(address, hash, params);
+        if (!result.success && result.error) {
+            const { txHash, exitCode, resultCode, reason } = result.error;
+            throw (0, errors_1.txFinalizationError)(`${txHash}: reason= ${reason} (exitCode=${exitCode}, resultCode=${resultCode})`);
+        }
+    }
+    /**
+     * Track transaction tree and validate all transactions (returns result instead of throwing)
+     */
+    async trackTransactionTreeWithResult(address, hash, params = {
+        maxDepth: Consts_1.DEFAULT_FIND_TX_MAX_DEPTH,
+        ignoreOpcodeList: Consts_1.IGNORE_OPCODE,
+        limit: Consts_1.DEFAULT_FIND_TX_LIMIT,
+        direction: 'both',
+    }) {
+        const { maxDepth = Consts_1.DEFAULT_FIND_TX_MAX_DEPTH, ignoreOpcodeList = Consts_1.IGNORE_OPCODE, limit = Consts_1.DEFAULT_FIND_TX_LIMIT, direction = 'both', } = params;
+        const parsedAddress = ton_1.Address.parse(address);
+        const visitedHashes = new Set();
+        const queue = [{ address: parsedAddress, hash, depth: 0, hashType: 'unknown' }];
+        while (queue.length > 0) {
+            const { hash: currentHash, depth: currentDepth, address: currentAddress, hashType } = queue.shift();
+            if (visitedHashes.has(currentHash))
+                continue;
+            visitedHashes.add(currentHash);
+            this.logger?.debug(`Checking hash (depth ${currentDepth}): ${currentHash}`);
+            const tx = await this.findTransactionByHashType(currentAddress, currentHash, hashType, limit);
+            if (!tx) {
+                this.logger?.debug(`Transaction not found for hash: ${currentHash}`);
+                continue;
+            }
+            // Validate transaction and return error if found
+            const validationError = this.validateTransactionWithResult(tx, ignoreOpcodeList);
+            if (validationError) {
+                return { success: false, error: validationError };
+            }
+            // Add adjacent transactions to queue
+            if (currentDepth + 1 < maxDepth) {
+                if ((direction === 'forward' || direction === 'both') && tx.outMessages.size > 0) {
+                    for (const msg of tx.outMessages.values()) {
+                        const dst = msg.info.dest;
+                        if (!dst || dst instanceof ton_1.ExternalAddress)
+                            continue;
+                        queue.push({
+                            hash: (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(msg)).endCell().hash().toString('base64'),
+                            address: dst,
+                            depth: currentDepth + 1,
+                            hashType: 'in',
+                        });
+                    }
+                }
+                // Backward: add parent (incoming message source)
+                if ((direction === 'backward' || direction === 'both') && tx.inMessage?.info.type === 'internal') {
+                    queue.push({
+                        hash: (0, ton_1.beginCell)().store((0, ton_1.storeMessage)(tx.inMessage)).endCell().hash().toString('base64'),
+                        address: tx.inMessage.info.src,
+                        depth: currentDepth + 1,
+                        hashType: 'out',
+                    });
+                }
+            }
+            this.logger?.debug(`Finished checking hash (depth ${currentDepth}): ${currentHash}`);
+        }
+        return { success: true };
+    }
+}
+exports.BaseContractOpener = BaseContractOpener;

package/dist/src/adapters/LiteClientOpener.d.ts

@@ -0,0 +1,33 @@
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { AddressInformation, ContractState, GetTransactionsOptions, Network } from '../structs/Struct';
+import { BaseContractOpener } from './BaseContractOpener';
+type LiteServer = {
+    ip: number;
+    port: number;
+    id: {
+        '@type': string;
+        key: string;
+    };
+};
+export declare class LiteClientOpener extends BaseContractOpener {
+    private readonly client;
+    private readonly engine;
+    private constructor();
+    static create(options: {
+        liteservers: LiteServer[];
+    } | {
+        network: Network;
+    }): Promise<LiteClientOpener>;
+    open<T extends Contract>(contract: T): OpenedContract<T>;
+    closeConnections(): void;
+    getContractState(addr: Address): Promise<ContractState>;
+    getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    getAddressInformation(addr: Address): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+}
+export declare function liteClientOpener(options: {
+    liteservers: LiteServer[];
+} | {
+    network: Network;
+}): Promise<LiteClientOpener>;
+export {};

package/dist/src/adapters/LiteClientOpener.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteClientOpener = void 0;
+exports.liteClientOpener = liteClientOpener;
+const ton_1 = require("@ton/ton");
+const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
+const artifacts_1 = require("../../artifacts");
+const Consts_1 = require("../sdk/Consts");
+const Struct_1 = require("../structs/Struct");
+const BaseContractOpener_1 = require("./BaseContractOpener");
+function intToIP(int) {
+    const part1 = int & 255;
+    const part2 = (int >> 8) & 255;
+    const part3 = (int >> 16) & 255;
+    const part4 = (int >> 24) & 255;
+    return part4 + '.' + part3 + '.' + part2 + '.' + part1;
+}
+async function getDefaultLiteServers(network) {
+    const url = network === Struct_1.Network.TESTNET || network === Struct_1.Network.DEV
+        ? artifacts_1.testnet.DEFAULT_LITESERVERS
+        : artifacts_1.mainnet.DEFAULT_LITESERVERS;
+    const resp = await fetch(url);
+    const liteClients = await resp.json();
+    return liteClients.liteservers;
+}
+class LiteClientOpener extends BaseContractOpener_1.BaseContractOpener {
+    constructor(client, engine) {
+        super();
+        this.client = client;
+        this.engine = engine;
+    }
+    static async create(options) {
+        const liteservers = 'liteservers' in options ? options.liteservers : await getDefaultLiteServers(options.network);
+        const engines = [];
+        for (const server of liteservers) {
+            const engine = await ton_lite_client_1.LiteSingleEngine.create({
+                host: `tcp://${intToIP(server.ip)}:${server.port}`,
+                publicKey: Buffer.from(server.id.key, 'base64'),
+            });
+            engines.push(engine);
+        }
+        const engine = new ton_lite_client_1.LiteRoundRobinEngine(engines);
+        const client = new ton_lite_client_1.LiteClient({ engine });
+        return new LiteClientOpener(client, engine);
+    }
+    open(contract) {
+        return this.client.open(contract);
+    }
+    closeConnections() {
+        this.engine.close();
+    }
+    async getContractState(addr) {
+        const block = await this.client.getMasterchainInfo();
+        const state = await this.client.getAccountState(addr, block.last);
+        const accountState = state.state?.storage?.state;
+        const code = accountState?.type === 'active' ? accountState?.state?.code?.toBoc() : null;
+        return {
+            balance: state.balance.coins,
+            state: state.state.storage.state.type === 'uninit' ? 'uninitialized' : state.state.storage.state.type,
+            code: code ?? null,
+        };
+    }
+    async getTransactions(address, opts) {
+        // LiteClient requires valid lt and hash to fetch transactions
+        // If not provided, fetch from the latest transaction
+        let lt;
+        let hash;
+        if (opts.lt && opts.hash) {
+            lt = opts.lt;
+            hash = Buffer.from(opts.hash, 'base64');
+        }
+        else {
+            // Get latest transaction info first
+            const block = await this.client.getMasterchainInfo();
+            const state = await this.client.getAccountState(address, block.last);
+            if (!state.lastTx) {
+                // No transactions for this account
+                return [];
+            }
+            lt = state.lastTx.lt.toString();
+            hash = Buffer.from(state.lastTx.hash.toString(16).padStart(64, '0'), 'hex');
+        }
+        const txsBuffered = await this.client
+            .getAccountTransactions(address, lt, hash, opts.limit ?? Consts_1.DEFAULT_FIND_TX_LIMIT)
+            .then((r) => r.transactions);
+        const cell = ton_1.Cell.fromBoc(txsBuffered);
+        let txs = cell.map((c) => (0, ton_1.loadTransaction)(c.beginParse()));
+        // Apply to_lt filter if specified
+        if (opts.to_lt) {
+            const toLt = BigInt(opts.to_lt);
+            txs = txs.filter((tx) => {
+                const comparison = tx.lt > toLt;
+                return opts.inclusive ? tx.lt >= toLt : comparison;
+            });
+        }
+        return txs;
+    }
+    async getAddressInformation(addr) {
+        const block = await this.client.getMasterchainInfo();
+        const state = await this.client.getAccountState(addr, block.last);
+        return {
+            lastTransaction: {
+                lt: state.lastTx?.lt.toString() ?? '',
+                hash: Buffer.from(state.lastTx?.hash.toString(16) ?? '', 'hex').toString('base64'),
+            },
+        };
+    }
+    async getConfig() {
+        const block = await this.client.getMasterchainInfo();
+        const { config } = await this.client.getConfig(block.last);
+        return (0, ton_1.beginCell)().storeDictDirect(config).endCell().toBoc().toString('base64');
+    }
+}
+exports.LiteClientOpener = LiteClientOpener;
+async function liteClientOpener(options) {
+    return LiteClientOpener.create(options);
+}

package/dist/src/adapters/OpenerUtils.d.ts

@@ -0,0 +1,3 @@
+import { Network } from '../structs/Struct';
+export declare function getHttpEndpointWithRetry(network: Network, maxRetries?: number, delay?: number): Promise<string>;
+export declare function getHttpV4EndpointWithRetry(network: Network, maxRetries?: number, delay?: number): Promise<string>;

package/dist/src/adapters/OpenerUtils.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHttpEndpointWithRetry = getHttpEndpointWithRetry;
+exports.getHttpV4EndpointWithRetry = getHttpV4EndpointWithRetry;
+const ton_access_1 = require("@orbs-network/ton-access");
+const Utils_1 = require("../sdk/Utils");
+const Struct_1 = require("../structs/Struct");
+async function getHttpEndpointWithRetry(network, maxRetries = 5, delay = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
+            return await (0, ton_access_1.getHttpEndpoint)({ network: tonNetwork });
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxRetries - 1) {
+                await (0, Utils_1.sleep)(delay);
+            }
+        }
+    }
+    throw lastError || new Error('Failed to get HTTP endpoint after retries');
+}
+async function getHttpV4EndpointWithRetry(network, maxRetries = 5, delay = 1000) {
+    let lastError;
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
+            return await (0, ton_access_1.getHttpV4Endpoint)({ network: tonNetwork });
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxRetries - 1) {
+                await (0, Utils_1.sleep)(delay);
+            }
+        }
+    }
+    throw lastError || new Error('Failed to get HTTP V4 endpoint after retries');
+}

package/dist/src/adapters/RetryableContractOpener.d.ts

@@ -0,0 +1,35 @@
+import { SandboxContract } from '@ton/sandbox';
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { ContractOpener, ILogger } from '../interfaces';
+import { AddressInformation, ContractState, GetTransactionsOptions, Network, TrackTransactionTreeParams, TrackTransactionTreeResult } from '../structs/Struct';
+export interface OpenerConfig {
+    /** Underlying opener implementation to use for this slot. */
+    opener: ContractOpener;
+    /** Number of retry attempts before falling back to the next opener. */
+    retries: number;
+    /** Delay in milliseconds between retries for this opener. */
+    retryDelay: number;
+}
+export declare class RetryableContractOpener implements ContractOpener {
+    private readonly openerConfigs;
+    private logger?;
+    constructor(openerConfigs: OpenerConfig[], logger?: ILogger);
+    getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    getTransactionByHash(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    getAdjacentTransactions(address: Address, hash: string, opts?: GetTransactionsOptions): Promise<Transaction[]>;
+    open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    getAddressInformation(address: Address): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+    getTransactionByTxHash(address: Address, txHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    getTransactionByInMsgHash(address: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    getTransactionByOutMsgHash(address: Address, msgHash: string, opts?: GetTransactionsOptions): Promise<Transaction | null>;
+    closeConnections(): void;
+    trackTransactionTree(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<void>;
+    trackTransactionTreeWithResult(address: string, hash: string, params?: TrackTransactionTreeParams): Promise<TrackTransactionTreeResult>;
+    private executeWithFallback;
+    private tryWithRetries;
+    private createRetryableContract;
+    private callMethodAcrossOpeners;
+}
+export declare function createDefaultRetryableOpener(tonRpcEndpoint: string, networkType: Network, maxRetries?: number, retryDelay?: number, logger?: ILogger): Promise<RetryableContractOpener>;