@tonappchain/sdk 0.7.2-scaled-ui-support-2 → 0.7.2

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

@@ -0,0 +1,38 @@
+import { Address, Contract, OpenedContract, Transaction } from '@ton/ton';
+import { ILogger } from '../interfaces';
+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 readonly singleEngines;
+    private isClosing;
+    private isClosed;
+    private constructor();
+    static create(options: {
+        liteservers: LiteServer[];
+    } | {
+        network: Network;
+    }, logger?: ILogger): Promise<LiteClientOpener>;
+    open<T extends Contract>(contract: T): OpenedContract<T>;
+    private disableReconnect;
+    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;
+}, logger?: ILogger): Promise<LiteClientOpener>;
+export {};

package/dist/src/adapters/LiteClientOpener.js

@@ -0,0 +1,141 @@
+"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, logger, singleEngines = []) {
+        super(logger);
+        this.client = client;
+        this.engine = engine;
+        this.isClosing = false;
+        this.isClosed = false;
+        this.singleEngines = singleEngines;
+    }
+    static async create(options, logger) {
+        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, logger, engines);
+    }
+    open(contract) {
+        return this.client.open(contract);
+    }
+    disableReconnect(singleEngine) {
+        const engine = singleEngine;
+        engine.connect = async () => undefined;
+        engine.onClosed = () => undefined;
+    }
+    closeConnections() {
+        if (this.isClosing || this.isClosed) {
+            return;
+        }
+        this.isClosing = true;
+        try {
+            for (const singleEngine of this.singleEngines) {
+                this.disableReconnect(singleEngine);
+                singleEngine.close();
+            }
+            this.engine.close();
+            this.isClosed = true;
+        }
+        finally {
+            this.isClosing = false;
+        }
+    }
+    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);
+        const lastHashHex = state.lastTx ? state.lastTx.hash.toString(16).padStart(64, '0') : '';
+        const lastHashB64 = lastHashHex ? Buffer.from(lastHashHex, 'hex').toString('base64') : '';
+        return {
+            lastTransaction: {
+                lt: state.lastTx?.lt.toString() ?? '',
+                hash: lastHashB64,
+            },
+        };
+    }
+    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, logger) {
+    return LiteClientOpener.create(options, logger);
+}

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,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHttpEndpointWithRetry = getHttpEndpointWithRetry;
+exports.getHttpV4EndpointWithRetry = getHttpV4EndpointWithRetry;
+const ton_access_1 = require("@orbs-network/ton-access");
+const Consts_1 = require("../sdk/Consts");
+const Utils_1 = require("../sdk/Utils");
+const Struct_1 = require("../structs/Struct");
+async function getHttpEndpointWithRetry(network, maxRetries = Consts_1.DEFAULT_RETRY_MAX_COUNT, delay = Consts_1.DEFAULT_RETRY_DELAY_MS) {
+    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 = Consts_1.DEFAULT_RETRY_MAX_COUNT, delay = Consts_1.DEFAULT_RETRY_DELAY_MS) {
+    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,40 @@
+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);
+    setLogger(logger: ILogger): void;
+    private applyLoggerToOpeners;
+    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 trySingleAttempt;
+    private tryWithRetries;
+    private isContractExecutionError;
+    private isTransportError;
+    private createRetryableContract;
+    private callMethodAcrossOpeners;
+}
+export declare function createDefaultRetryableOpener(tonRpcEndpoint: string, networkType: Network, maxRetries?: number, retryDelay?: number, logger?: ILogger): Promise<RetryableContractOpener>;

package/dist/src/adapters/RetryableContractOpener.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryableContractOpener = void 0;
+exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
+const ton_1 = require("@ton/ton");
+const errors_1 = require("../errors");
+const instances_1 = require("../errors/instances");
+const Consts_1 = require("../sdk/Consts");
+const Struct_1 = require("../structs/Struct");
+const TonClient4Opener_1 = require("./TonClient4Opener");
+const TonClientOpener_1 = require("./TonClientOpener");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+class RetryableContractOpener {
+    constructor(openerConfigs, logger) {
+        if (openerConfigs.length === 0) {
+            throw new Error('No ContractOpener instances available');
+        }
+        this.openerConfigs = openerConfigs;
+        this.logger = logger;
+        if (logger) {
+            this.applyLoggerToOpeners(logger);
+        }
+    }
+    setLogger(logger) {
+        if (!this.logger) {
+            this.logger = logger;
+        }
+        this.applyLoggerToOpeners(logger);
+    }
+    applyLoggerToOpeners(logger) {
+        for (const config of this.openerConfigs) {
+            config.opener.setLogger(logger);
+        }
+    }
+    async getTransactions(address, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactions(address, opts), {
+            operationName: 'getTransactions',
+        });
+        if (result.success && result.data !== undefined) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transactions');
+    }
+    async getTransactionByHash(address, hash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByHash(address, hash, opts), { operationName: 'getTransactionByHash' });
+        if (result.success) {
+            return result.data ?? null;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by hash');
+    }
+    async getAdjacentTransactions(address, hash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getAdjacentTransactions(address, hash, opts), { operationName: 'getAdjacentTransactions' });
+        if (result.success && result.data !== undefined) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get adjacent transactions');
+    }
+    open(src) {
+        const firstConfig = this.openerConfigs[0];
+        const contract = firstConfig.opener.open(src);
+        return this.createRetryableContract(contract, src);
+    }
+    async getContractState(address) {
+        const result = await this.executeWithFallback((config) => config.opener.getContractState(address), {
+            operationName: 'getContractState',
+        });
+        if (result.success && result.data !== undefined) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get contract state');
+    }
+    async getAddressInformation(address) {
+        const result = await this.executeWithFallback((config) => config.opener.getAddressInformation(address), {
+            operationName: 'getAddressInformation',
+        });
+        if (result.success && result.data !== undefined) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get address information');
+    }
+    async getConfig() {
+        const result = await this.executeWithFallback((config) => config.opener.getConfig(), {
+            operationName: 'getConfig',
+        });
+        if (result.success && result.data !== undefined) {
+            return result.data;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get blockchain config');
+    }
+    async getTransactionByTxHash(address, txHash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByTxHash(address, txHash, opts), { operationName: 'getTransactionByTxHash' });
+        if (result.success) {
+            return result.data ?? null;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by transaction hash');
+    }
+    async getTransactionByInMsgHash(address, msgHash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByInMsgHash(address, msgHash, opts), { operationName: 'getTransactionByInMsgHash' });
+        if (result.success) {
+            return result.data ?? null;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by message hash');
+    }
+    async getTransactionByOutMsgHash(address, msgHash, opts) {
+        const result = await this.executeWithFallback((config) => config.opener.getTransactionByOutMsgHash(address, msgHash, opts), { operationName: 'getTransactionByOutMsgHash' });
+        if (result.success) {
+            return result.data ?? null;
+        }
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get transaction by outgoing message hash');
+    }
+    closeConnections() {
+        for (const config of this.openerConfigs) {
+            config.opener.closeConnections?.();
+        }
+    }
+    async trackTransactionTree(address, hash, params) {
+        const result = await this.executeWithFallback(async (config) => config.opener.trackTransactionTree(address, hash, params), {
+            shouldFallbackOnError: (error) => this.isTransportError(error),
+            operationName: 'trackTransactionTree',
+        });
+        if (!result.success) {
+            if (result.lastError instanceof errors_1.TransactionError) {
+                throw result.lastError;
+            }
+            throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to track transaction tree');
+        }
+    }
+    async trackTransactionTreeWithResult(address, hash, params) {
+        const result = await this.executeWithFallback(async (config) => config.opener.trackTransactionTreeWithResult(address, hash, params), {
+            shouldFallbackOnError: (error) => this.isTransportError(error),
+            operationName: 'trackTransactionTreeWithResult',
+        });
+        if (!result.success) {
+            if (result.lastError instanceof errors_1.TransactionError) {
+                throw result.lastError;
+            }
+            throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to track transaction tree with result');
+        }
+        return result.data;
+    }
+    async executeWithFallback(operation, options = {}) {
+        const { useRetries = true, shouldFallbackOnError, operationName = 'operation' } = options;
+        let lastError;
+        for (let index = 0; index < this.openerConfigs.length; index++) {
+            const config = this.openerConfigs[index];
+            const openerLabel = `opener ${index + 1}/${this.openerConfigs.length}`;
+            this.logger?.debug(`[RetryableContractOpener] ${operationName}: trying ${openerLabel}`);
+            const result = useRetries
+                ? await this.tryWithRetries(() => operation(config), config, `${operationName} ${openerLabel}`)
+                : await this.trySingleAttempt(() => operation(config));
+            if (result.success) {
+                return { success: true, data: result.data };
+            }
+            lastError = result.lastError;
+            const isTransactionError = lastError instanceof errors_1.TransactionError;
+            const isContractExecutionError = !!lastError && this.isContractExecutionError(lastError);
+            const shouldStopOnNonTransportError = !!lastError && !!shouldFallbackOnError && !shouldFallbackOnError(lastError);
+            if (lastError) {
+                const stopReason = isTransactionError
+                    ? 'TransactionError'
+                    : isContractExecutionError
+                        ? 'contract execution error'
+                        : shouldStopOnNonTransportError
+                            ? 'non-transport error'
+                            : undefined;
+                this.logger?.debug(`[RetryableContractOpener] ${operationName}: ${openerLabel} failed${stopReason ? ` (stopping fallback because of ${stopReason})` : ''}: ${lastError.message}`);
+            }
+            if (isTransactionError) {
+                return { success: false, lastError };
+            }
+            if (isContractExecutionError) {
+                return { success: false, lastError };
+            }
+            if (shouldStopOnNonTransportError) {
+                return { success: false, lastError };
+            }
+        }
+        return { success: false, lastError };
+    }
+    async trySingleAttempt(operation) {
+        try {
+            const data = await operation();
+            return { success: true, data };
+        }
+        catch (error) {
+            return { success: false, lastError: error };
+        }
+    }
+    async tryWithRetries(operation, config, operationContext = 'operation') {
+        let lastError;
+        for (let attempt = 0; attempt <= config.retries; attempt++) {
+            try {
+                const data = await operation();
+                return { success: true, data };
+            }
+            catch (error) {
+                lastError = error;
+                if (lastError instanceof errors_1.TransactionError || this.isContractExecutionError(lastError)) {
+                    return { success: false, lastError };
+                }
+                if (attempt < config.retries) {
+                    this.logger?.debug(`[RetryableContractOpener] ${operationContext}: attempt ${attempt + 1}/${config.retries + 1} failed (${lastError.message}), retrying in ${config.retryDelay}ms`);
+                    await sleep(config.retryDelay);
+                }
+            }
+        }
+        return { success: false, lastError };
+    }
+    isContractExecutionError(error) {
+        const errorWithExit = error;
+        if (typeof errorWithExit.exitCode === 'number' ||
+            typeof errorWithExit.vmExitCode === 'number' ||
+            typeof errorWithExit.exit_code === 'number') {
+            return true;
+        }
+        const message = String(error.message ?? error);
+        return (/unable to execute get method/i.test(message) ||
+            /exit[_\s-]*code\s*:\s*\d+/i.test(message) ||
+            /vm exit code\s*:\s*\d+/i.test(message));
+    }
+    isTransportError(error) {
+        if (error instanceof errors_1.TransactionError) {
+            return false;
+        }
+        const errorWithResponse = error;
+        const status = errorWithResponse.response?.status ?? errorWithResponse.response?.statusCode;
+        if (typeof status === 'number') {
+            return status === 429 || status >= 500;
+        }
+        const code = errorWithResponse.code ?? '';
+        if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN'].includes(code)) {
+            return true;
+        }
+        const message = String(error.message ?? error);
+        return /too many requests|timeout|timed out|network|connection/i.test(message);
+    }
+    createRetryableContract(contract, src) {
+        return new Proxy(contract, {
+            get: (target, prop) => {
+                const value = Reflect.get(target, prop);
+                if (typeof value !== 'function')
+                    return value;
+                return async (...args) => {
+                    return this.callMethodAcrossOpeners(prop, args, src);
+                };
+            },
+        });
+    }
+    async callMethodAcrossOpeners(methodName, args, src) {
+        const addressLabel = src.address ? src.address.toString() : 'unknown';
+        const result = await this.executeWithFallback((config) => {
+            const contract = config.opener.open(src);
+            const method = Reflect.get(contract, methodName);
+            if (typeof method !== 'function') {
+                throw new Error(`Method ${String(methodName)} is not a function`);
+            }
+            return method.call(contract, ...args);
+        }, { operationName: `${String(methodName)} (address=${addressLabel})` });
+        if (result.success)
+            return result.data;
+        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('failed to call method in contract');
+    }
+}
+exports.RetryableContractOpener = RetryableContractOpener;
+async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = Consts_1.DEFAULT_RETRY_MAX_COUNT, retryDelay = Consts_1.DEFAULT_RETRY_DELAY_MS, logger) {
+    const openers = [];
+    const tonClient = new ton_1.TonClient({
+        endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString(),
+        timeout: Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS,
+    });
+    const opener = (0, TonClientOpener_1.tonClientOpener)(tonClient, logger);
+    openers.push({ opener, retries: maxRetries, retryDelay });
+    if (networkType !== Struct_1.Network.DEV) {
+        try {
+            const opener = await (0, TonClientOpener_1.orbsOpener)(networkType, logger);
+            openers.push({ opener: opener, retries: maxRetries, retryDelay });
+        }
+        catch {
+            // skip opener in case of failure
+        }
+        try {
+            const opener4 = await (0, TonClient4Opener_1.orbsOpener4)(networkType, Consts_1.DEFAULT_HTTP_CLIENT_TIMEOUT_MS, logger);
+            openers.push({ opener: opener4, retries: maxRetries, retryDelay });
+        }
+        catch {
+            // skip opener in case of failure
+        }
+    }
+    return new RetryableContractOpener(openers, logger);
+}

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

@@ -0,0 +1,15 @@
+import { Blockchain, SandboxContract } from '@ton/sandbox';
+import { Address, Contract, Transaction } from '@ton/ton';
+import { ContractOpener } from '../interfaces';
+import { AddressInformation, ContractState } from '../structs/Struct';
+import { BaseContractOpener } from './BaseContractOpener';
+export declare class SandboxOpener extends BaseContractOpener {
+    private readonly blockchain;
+    constructor(blockchain: Blockchain);
+    open<T extends Contract>(contract: T): SandboxContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    getTransactions(): Promise<Transaction[]>;
+    getAddressInformation(): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+}
+export declare function sandboxOpener(blockchain: Blockchain): ContractOpener;

package/dist/src/adapters/SandboxOpener.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxOpener = void 0;
+exports.sandboxOpener = sandboxOpener;
+const BaseContractOpener_1 = require("./BaseContractOpener");
+class SandboxOpener extends BaseContractOpener_1.BaseContractOpener {
+    constructor(blockchain) {
+        super();
+        this.blockchain = blockchain;
+    }
+    open(contract) {
+        return this.blockchain.openContract(contract);
+    }
+    async getContractState(address) {
+        const state = await this.blockchain.provider(address).getState();
+        return {
+            balance: state.balance,
+            code: 'code' in state.state ? (state.state.code ?? null) : null,
+            state: state.state.type === 'uninit' ? 'uninitialized' : state.state.type,
+        };
+    }
+    async getTransactions() {
+        throw new Error('getTransactions not implemented for sandboxOpener');
+    }
+    async getAddressInformation() {
+        throw new Error('getAddressInformation not implemented for sandboxOpener');
+    }
+    async getConfig() {
+        return this.blockchain.config.toBoc().toString('base64');
+    }
+}
+exports.SandboxOpener = SandboxOpener;
+function sandboxOpener(blockchain) {
+    return new SandboxOpener(blockchain);
+}

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

@@ -0,0 +1,24 @@
+import { Address, Contract, OpenedContract, TonClient4, Transaction } from '@ton/ton';
+import { ILogger } from '../interfaces';
+import { AddressInformation, ContractState, GetTransactionsOptions, Network } from '../structs/Struct';
+import { BaseContractOpener } from './BaseContractOpener';
+export declare class TonClient4Opener extends BaseContractOpener {
+    private readonly client4;
+    constructor(client4: TonClient4, logger?: ILogger);
+    static create(endpoint: string, timeout?: number, logger?: ILogger): TonClient4Opener;
+    open<T extends Contract>(contract: T): OpenedContract<T>;
+    getContractState(address: Address): Promise<ContractState>;
+    getTransactions(address: Address, opts: GetTransactionsOptions): Promise<Transaction[]>;
+    getAddressInformation(addr: Address): Promise<AddressInformation>;
+    getConfig(): Promise<string>;
+}
+/**
+ * Creates a TonClient4Opener instance using TonHub public API
+ * @param network Network to connect to (mainnet or testnet)
+ * @param timeout Request timeout in milliseconds
+ * @param logger
+ */
+export declare function tonHubApi4Opener(network: Network, timeout?: number, logger?: ILogger): TonClient4Opener;
+export declare function tonClient4Opener(client: TonClient4, logger?: ILogger): TonClient4Opener;
+export declare function orbsOpener4(network: Network, timeout?: number, logger?: ILogger): Promise<TonClient4Opener>;
+export declare function getOrbsOpener4WithRetry(network: Network, timeout?: number, logger?: ILogger, maxRetries?: number, delay?: number): Promise<TonClient4Opener>;