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

package/dist/src/adapters/contractOpener.js

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.liteClientOpener = liteClientOpener;
-exports.sandboxOpener = sandboxOpener;
-exports.orbsOpener = orbsOpener;
-exports.orbsOpener4 = orbsOpener4;
-const ton_access_1 = require("@orbs-network/ton-access");
-const ton_1 = require("@ton/ton");
-const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
-const artifacts_1 = require("../../artifacts");
-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) {
-                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) {
-                await (0, Utils_1.sleep)(delay);
-            }
-        }
-    }
-    throw lastError || new Error('Failed to get HTTP V4 endpoint after retries');
-}
-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;
-}
-async function liteClientOpener(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 });
-    const closeConnections = () => {
-        engine.close();
-    };
-    return {
-        getContractState: async (addr) => {
-            const block = await client.getMasterchainInfo();
-            const state = await 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,
-            };
-        },
-        open: (contract) => client.open(contract),
-        closeConnections,
-    };
-}
-function sandboxOpener(blockchain) {
-    return {
-        open: (contract) => blockchain.openContract(contract),
-        getContractState: async (address) => {
-            const state = await 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 function orbsOpener(network) {
-    const endpoint = await getHttpEndpointWithRetry(network);
-    return new ton_1.TonClient({ endpoint });
-}
-async function orbsOpener4(network, timeout = 10000) {
-    const endpoint = await getHttpV4EndpointWithRetry(network);
-    const client4 = new ton_1.TonClient4({ endpoint, timeout });
-    return {
-        open: (contract) => client4.open(contract),
-        getContractState: async (address) => {
-            const latestBlock = await client4.getLastBlock();
-            const latestBlockNumber = latestBlock.last.seqno;
-            const state = await client4.getAccount(latestBlockNumber, address);
-            return {
-                balance: BigInt(state.account.balance.coins),
-                code: 'code' in state.account.state && state.account.state.code !== null
-                    ? Buffer.from(state.account.state.code, 'base64')
-                    : null,
-                state: state.account.state.type === 'uninit' ? 'uninitialized' : state.account.state.type,
-            };
-        },
-    };
-}

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

@@ -1,24 +0,0 @@
-import { SandboxContract } from '@ton/sandbox';
-import { Address, Contract, OpenedContract } from '@ton/ton';
-import { ContractOpener } from '../interfaces';
-import { ContractState, Network } 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;
-    constructor(openerConfigs: OpenerConfig[]);
-    open<T extends Contract>(src: T): OpenedContract<T> | SandboxContract<T>;
-    getContractState(address: Address): Promise<ContractState>;
-    closeConnections(): void;
-    private executeWithFallback;
-    private tryWithRetries;
-    private createRetryableContract;
-    private callMethodAcrossOpeners;
-}
-export declare function createDefaultRetryableOpener(tonRpcEndpoint: string, networkType: Network, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;

package/dist/src/adapters/retryableContractOpener.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetryableContractOpener = void 0;
-exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
-const ton_1 = require("@ton/ton");
-const instances_1 = require("../errors/instances");
-const Struct_1 = require("../structs/Struct");
-const contractOpener_1 = require("./contractOpener");
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-class RetryableContractOpener {
-    constructor(openerConfigs) {
-        if (openerConfigs.length === 0) {
-            throw new Error('No ContractOpener instances available');
-        }
-        this.openerConfigs = openerConfigs;
-    }
-    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));
-        if (result.success && result.data) {
-            return result.data;
-        }
-        throw result.lastError || (0, instances_1.allContractOpenerFailedError)('Failed to get contract state');
-    }
-    closeConnections() {
-        for (const config of this.openerConfigs) {
-            config.opener.closeConnections?.();
-        }
-    }
-    async executeWithFallback(operation) {
-        let lastError;
-        for (const config of this.openerConfigs) {
-            const result = await this.tryWithRetries(() => operation(config), config);
-            if (result.success) {
-                return { success: true, data: result.data };
-            }
-            lastError = result.lastError;
-        }
-        return { success: false, lastError };
-    }
-    async tryWithRetries(operation, config) {
-        let lastError;
-        for (let attempt = 0; attempt <= config.retries; attempt++) {
-            try {
-                const data = await operation();
-                return { success: true, data };
-            }
-            catch (error) {
-                lastError = error;
-                if (attempt < config.retries) {
-                    await sleep(config.retryDelay);
-                }
-            }
-        }
-        return { success: false, lastError };
-    }
-    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 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);
-        });
-        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 = 5, retryDelay = 1000) {
-    const openers = [];
-    const tonClient = new ton_1.TonClient({
-        endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString(),
-    });
-    openers.push({ opener: tonClient, retries: maxRetries, retryDelay });
-    if (networkType !== Struct_1.Network.DEV) {
-        try {
-            const opener4 = await (0, contractOpener_1.orbsOpener4)(networkType);
-            openers.push({ opener: opener4, retries: maxRetries, retryDelay });
-        }
-        catch {
-            // skip opener in case of failure
-        }
-        try {
-            const opener = await (0, contractOpener_1.orbsOpener)(networkType);
-            openers.push({ opener: opener, retries: maxRetries, retryDelay });
-        }
-        catch {
-            // skip opener in case of failure
-        }
-    }
-    return new RetryableContractOpener(openers);
-}