@cryptorubic/web3 0.0.34 → 0.0.37-alpha-1212.0

package/src/lib/utils/web3-types/tron-web3-pure.js

@@ -25,7 +25,7 @@ class TronWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
      * @returns An ABI encoded function call. Means function signature + parameters.
      */
     static encodeFunctionCall(contractAbi, methodName, methodArguments) {
-        const methodSignature = contractAbi.find(abiItem => abiItem.name === methodName);
+        const methodSignature = contractAbi.find((abiItem) => abiItem.name === methodName);
         if (methodSignature === undefined) {
             throw Error('No such method in abi');
         }
@@ -50,7 +50,7 @@ class TronWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         return this.flattenParameterToPrimitive(decodedParam);
     }
     static flattenTypesToString(abiInputs) {
-        return (abiInputs?.map(abiInput => {
+        return (abiInputs?.map((abiInput) => {
             if (abiInput.type === 'tuple') {
                 const flattenedComponents = this.flattenTypesToString(abiInput.components);
                 return `(${flattenedComponents.join(',')})`;
@@ -59,7 +59,7 @@ class TronWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         }) || []);
     }
     static flattenTypesToArray(abiInputs) {
-        return (abiInputs?.map(abiInput => {
+        return (abiInputs?.map((abiInput) => {
             if (abiInput.type === 'tuple') {
                 return this.flattenTypesToArray(abiInput.components);
             }
@@ -69,7 +69,7 @@ class TronWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
     static flattenParameters(parameters) {
         const types = [];
         const values = [];
-        parameters.forEach(parameter => {
+        parameters.forEach((parameter) => {
             if (parameter.type === 'tuple') {
                 const [tupleTypes, tupleValues] = this.flattenParameters(parameter.value);
                 types.push(tupleTypes);
@@ -97,5 +97,19 @@ class TronWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
             };
         }, {});
     }
+    static encodeMethodCall(contractAddress, contractAbi, methodName, methodArguments, callValue, feeLimit) {
+        const methodAbi = contractAbi.find((abiItem) => abiItem.name === methodName);
+        if (!methodAbi) {
+            throw new Error('Encode fail. No method in ABI');
+        }
+        const signature = `${methodAbi.name}(${this.flattenTypesToString(methodAbi.inputs).join(',')})`;
+        return {
+            to: contractAddress,
+            arguments: methodArguments,
+            signature,
+            ...(callValue && { callValue }),
+            ...(feeLimit && { feeLimit })
+        };
+    }
 }
 exports.TronWeb3Pure = TronWeb3Pure;

package/src/lib/utils/web3-types/zcash-web3-pure.d.ts

@@ -0,0 +1,5 @@
+import { CommonWeb3Pure } from './common-web3-pure';
+export declare class ZcashWeb3Pure extends CommonWeb3Pure {
+    constructor();
+    isAddressCorrect(address: string): Promise<boolean>;
+}

package/src/lib/utils/web3-types/zcash-web3-pure.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZcashWeb3Pure = void 0;
+const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchain");
+const common_web3_pure_1 = require("./common-web3-pure");
+class ZcashWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    constructor() {
+        super({
+            cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.ZCASH,
+            regex: /^(t1[a-zA-Z0-9]{33}|zs[a-zA-Z0-9]{76,}|u1[a-z0-9]{76,})$/
+        });
+    }
+    async isAddressCorrect(address) {
+        return /^(t1[a-zA-Z0-9]{33}|zs[a-zA-Z0-9]{76,}|u1[a-z0-9]{76,})$/.test(address);
+    }
+}
+exports.ZcashWeb3Pure = ZcashWeb3Pure;

package/src/lib/adapter/adapters/abstract-adapter.d.ts

@@ -1,19 +0,0 @@
-import BigNumber from "bignumber.js";
-import { ICustomLogger, Token, TokenAmount, BlockchainName } from "@cryptorubic/core";
-export declare abstract class AbstractAdapter<P, W, B extends BlockchainName> {
-    protected readonly logger?: ICustomLogger;
-    protected readonly blockchain: B;
-    private _public;
-    protected set public(value: P | null);
-    get public(): P;
-    private _wallet;
-    set wallet(value: W | null);
-    get wallet(): W;
-    protected constructor(blockchain: B, logger?: ICustomLogger);
-    abstract callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string | BigNumber): Promise<boolean>;
-    handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
-    abstract read<T>(...args: unknown[]): Promise<T>;
-    abstract write(...args: unknown[]): Promise<string>;
-    static getRandomBytes(bytes: number): string;
-}

package/src/lib/adapter/adapters/abstract-adapter.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractAdapter = void 0;
-const viem_1 = require("viem");
-class AbstractAdapter {
-    set public(value) {
-        this._public = value;
-    }
-    get public() {
-        if (!this._public) {
-            const msg = 'Trying to access undefined client';
-            this.logger?.customLog(msg);
-            throw new Error(msg);
-        }
-        return this._public;
-    }
-    set wallet(value) {
-        this._wallet = value;
-    }
-    get wallet() {
-        if (!this._wallet) {
-            const msg = 'Trying to access undefined client';
-            this.logger?.customLog(msg);
-            throw new Error(msg);
-        }
-        return this._wallet;
-    }
-    constructor(blockchain, logger) {
-        this._public = null;
-        this._wallet = null;
-        this.blockchain = blockchain;
-        if (logger) {
-            this.logger = logger;
-        }
-    }
-    needPreswapAction(token, contractAddress, walletAddress, amount) {
-        return Promise.resolve(false);
-    }
-    ;
-    handlePreswap(contractAddress, walletAddress, tokenAmount) {
-        return Promise.resolve();
-    }
-    ;
-    static getRandomBytes(bytes) {
-        const randomBytes = crypto.getRandomValues(new Uint8Array(bytes));
-        return (0, viem_1.bytesToHex)(randomBytes);
-    }
-}
-exports.AbstractAdapter = AbstractAdapter;

package/src/lib/adapter/adapters/evm-adapter.d.ts

@@ -1,34 +0,0 @@
-import { Abi, MulticallResponse, MulticallParameters, PublicActions, PublicClient, WalletClient, WalletActions } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
-import { EvmBlockchainName, ICustomLogger, Token, TokenAmount, PriceTokenAmount } from '@cryptorubic/core';
-import BigNumber from "bignumber.js";
-import { EvmAdapterOptions } from "./models/evm-adapter-options";
-import { EvmTransactionConfig } from "../../utils/models/evm-transaction-config";
-import { ApproveAdapter } from "./models/approve-adapter";
-import { AllowanceInfo } from "./models/common-types";
-export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter {
-    needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-    handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
-    constructor(adapterOptions: EvmAdapterOptions, logger?: ICustomLogger);
-    protected createPublicClient(rpcList: string[]): PublicActions & PublicClient | null;
-    read<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[]): Promise<T>;
-    writeContract(address: string, abi: Abi, method: string, value?: string, methodArgs?: unknown[]): Promise<string>;
-    write(address: string, to: string, value: string, data: string): Promise<string>;
-    multicallByContract<T>(contracts: MulticallParameters, allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    multicallByAddress<T>(address: string, abi: Abi, method: string, methodArgs?: unknown[][], allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    static encodeMethodCall(contractAddress: string, contractAbi: Abi, method: string, parameters?: unknown[], value?: string): EvmTransactionConfig;
-    simulateTransaction(config: EvmTransactionConfig, from: string): Promise<void>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<EvmBlockchainName>[]>;
-    getGasPrice(): Promise<string>;
-    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string, amount?: BigNumber): Promise<boolean>;
-    /**
-     * @param walletAddress
-     * @param tokenAddress
-     * @returns wei amount
-     */
-    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
-    getTransactionCount(walletAddress: string): Promise<number>;
-    getAllowance(fromTokenAddress: string, walletAddress: string, spenderAddress: string): Promise<AllowanceInfo>;
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
-    needApprove(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
-}

package/src/lib/adapter/adapters/evm-adapter.js

@@ -1,247 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EvmAdapter = void 0;
-const viem_1 = require("viem");
-const viem_blockchain_mapping_1 = require("../constants/viem-blockchain-mapping");
-const erc20_token_abi_1 = require("./constants/erc20-token-abi");
-const abstract_adapter_1 = require("./abstract-adapter");
-const core_1 = require("@cryptorubic/core");
-const bignumber_js_1 = require("bignumber.js");
-const web3_pure_1 = require("../../utils/web3-pure");
-class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
-    async needPreswapAction(token, contractAddress, walletAddress, amount) {
-        return this.needApprove(token, contractAddress, walletAddress, amount);
-    }
-    async handlePreswap(contractAddress, walletAddress, tokenAmount) {
-        const approveAmount = this.blockchain === core_1.BLOCKCHAIN_NAME.GNOSIS ||
-            this.blockchain === core_1.BLOCKCHAIN_NAME.CRONOS
-            ? tokenAmount.stringWeiAmount
-            : tokenAmount.stringTokenAmount;
-        const isNative = web3_pure_1.Web3Pure.isNativeAddress(this.blockchain, tokenAmount.address);
-        const fromTokenAddress = isNative && tokenAmount.blockchain === core_1.BLOCKCHAIN_NAME.METIS
-            ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000'
-            : tokenAmount.blockchain;
-        await this.writeContract(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', '0', [approveAmount]);
-    }
-    constructor(adapterOptions, logger) {
-        super(adapterOptions.blockchain, logger);
-        this.public = this.createPublicClient(adapterOptions.rpcList);
-        if (adapterOptions?.walletAddress) {
-        }
-    }
-    createPublicClient(rpcList) {
-        if (!rpcList?.[0]) {
-            this.logger?.customError('RPC list is empty');
-            return null;
-        }
-        const transports = rpcList.map((rpc) => (0, viem_1.http)(rpc, {
-            batch: { batchSize: 2000, wait: 16 },
-            onFetchResponse: (response) => {
-                if ('error' in response) {
-                    this.logger?.customError('Rpc fetch error', response.error);
-                }
-            },
-            retryCount: 5,
-            retryDelay: 100,
-            timeout: 5000
-        }));
-        const chain = viem_blockchain_mapping_1.viemBlockchainMapping[this.blockchain];
-        return (0, viem_1.createPublicClient)({
-            // @ts-ignore
-            chain,
-            transport: (0, viem_1.fallback)(transports, {
-                rank: true
-            })
-        });
-    }
-    async read(address, abi, method, methodArgs = []) {
-        const result = await this.public.readContract({
-            abi,
-            address: address,
-            args: methodArgs,
-            functionName: method
-        });
-        return result;
-    }
-    async writeContract(address, abi, method, value = '0', methodArgs = []) {
-        const result = await this.wallet.writeContract({
-            abi,
-            address: address,
-            account: address,
-            args: methodArgs,
-            functionName: method,
-            chain: this.public.chain,
-            value: (0, viem_1.parseEther)(value)
-        });
-        return result;
-    }
-    async write(address, to, value, data) {
-        const result = await this.wallet.sendTransaction({
-            account: address,
-            to: to,
-            value: (0, viem_1.parseEther)(value),
-            data: data,
-            chain: this.public.chain
-        });
-        return result;
-    }
-    async multicallByContract(contracts, allowErrors = true) {
-        const results = await this.public.multicall(contracts);
-        const rpcRequestFail = results.every((result) => result?.status === 'failure');
-        if (rpcRequestFail) {
-            // @ts-ignore
-            if (rpcRequestFail?.[0]?.stats === 'failure') {
-                // @ts-ignore
-                throw new Error(rpcRequestFail?.[0]?.error);
-            }
-        }
-        const hasErrors = results.find((result) => {
-            if (result?.error || result.status !== 'success') {
-                this.logger?.customWarn('Multicall error', result?.error?.data || result?.error?.message || result?.error);
-                return true;
-            }
-            return false;
-        });
-        if (hasErrors && !allowErrors) {
-            throw new Error('Multicall error');
-        }
-        return results;
-    }
-    async multicallByAddress(address, abi, method, methodArgs = [], allowErrors = true) {
-        const contract = { abi, address: address, functionName: method };
-        const contracts = methodArgs.map((multicallArguments) => ({
-            ...contract,
-            args: multicallArguments
-        }));
-        return this.multicallByContract({ contracts }, allowErrors);
-    }
-    static encodeMethodCall(contractAddress, contractAbi, method, parameters = [], value) {
-        try {
-            const data = (0, viem_1.encodeFunctionData)({ abi: contractAbi, args: parameters, functionName: method });
-            return {
-                data: data,
-                to: contractAddress,
-                value: value || '0'
-            };
-        }
-        catch (err) {
-            throw err;
-        }
-    }
-    async simulateTransaction(config, from) {
-        try {
-            const callParams = {
-                account: from,
-                data: config.data,
-                to: config.to,
-                ...(config.value && { value: BigInt(config.value) })
-            };
-            // @ts-ignore
-            await this.core.call(callParams);
-        }
-        catch (err) {
-            this.logger?.customError('Error while simulating transaction', err);
-            throw err;
-        }
-    }
-    async callForTokensInfo(tokenAddresses) {
-        const nativeTokenIndex = tokenAddresses.findIndex((address) => (0, core_1.compareAddresses)(address, '0x0000000000000000000000000000000000000000'));
-        const filteredTokenAddresses = tokenAddresses.filter((_, index) => index !== nativeTokenIndex);
-        const contracts = filteredTokenAddresses.flatMap((contractAddress) => {
-            const contract = {
-                abi: erc20_token_abi_1.erc20TokenAbi,
-                address: contractAddress
-            };
-            return ['decimals', 'symbol', 'name'].map((method) => ({ ...contract, functionName: method }));
-        });
-        const results = contracts.length ? (await this.multicallByContract({ contracts })) : [];
-        const tokens = [];
-        for (let i = 0; i < results.length; i += 3) {
-            try {
-                const decimals = Number(results[i].result);
-                const symbol = results[i + 1].result;
-                const name = results[i + 2].result;
-                const token = new core_1.Token({
-                    address: filteredTokenAddresses[i / 3],
-                    blockchain: this.blockchain,
-                    decimals,
-                    name,
-                    symbol
-                });
-                tokens.push(token);
-            }
-            catch (err) {
-                this.logger?.customError('Error while loading token', err);
-                tokens.push(null);
-            }
-        }
-        if (nativeTokenIndex === -1) {
-            return tokens.filter(Boolean);
-        }
-        const blockchainNativeToken = core_1.nativeTokensList[this.blockchain];
-        tokens.splice(nativeTokenIndex, 0, blockchainNativeToken);
-        return tokens.filter(Boolean);
-    }
-    async getGasPrice() {
-        const bigIntGas = await this.public.getGasPrice();
-        return String(bigIntGas);
-    }
-    async checkEnoughBalance(token, walletAddress, amount = token.tokenAmount) {
-        const weiBalance = await this.getBalance(walletAddress, token.isNative ? undefined : token.address);
-        const balance = core_1.Token.fromWei(weiBalance, token.decimals);
-        return balance.gte(amount);
-    }
-    /**
-     * @param walletAddress
-     * @param tokenAddress
-     * @returns wei amount
-     */
-    async getBalance(walletAddress, tokenAddress) {
-        if (!tokenAddress) {
-            const nativeBalance = await this.public.getBalance({
-                address: walletAddress
-            });
-            return new bignumber_js_1.default(nativeBalance.toString());
-        }
-        const tokenBalance = await this.read(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'balanceOf', [walletAddress]);
-        return new bignumber_js_1.default(tokenBalance);
-    }
-    async getTransactionCount(walletAddress) {
-        const transactionCount = await this.public?.getTransactionCount({
-            address: walletAddress
-        });
-        return transactionCount ?? 0;
-    }
-    async getAllowance(fromTokenAddress, walletAddress, spenderAddress) {
-        const [decimals, allowance] = await Promise.all([
-            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'decimals'),
-            this.read(fromTokenAddress, erc20_token_abi_1.erc20TokenAbi, 'allowance', [walletAddress, spenderAddress])
-        ]);
-        const allowanceWeiBN = new bignumber_js_1.default(allowance);
-        const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
-        return { allowanceNonWei, allowanceWei: allowanceWeiBN };
-    }
-    ;
-    encodeApprove(tokenAddress, spenderAddress, amount) {
-        const amountWei = amount ?? new bignumber_js_1.default(2).pow(256).minus(1).toFixed();
-        const tx = EvmAdapter.encodeMethodCall(tokenAddress, erc20_token_abi_1.erc20TokenAbi, 'approve', [spenderAddress, amountWei]);
-        return {
-            data: tx.data,
-            to: tx.to,
-            value: tx.value
-        };
-    }
-    ;
-    async needApprove(token, contractAddress, walletAddress, amount) {
-        // Native coin in METIS can be Token required approve
-        if (token.isNative && token.blockchain !== core_1.BLOCKCHAIN_NAME.METIS) {
-            return false;
-        }
-        // Special native address for METIS native coin
-        const fromTokenAddress = token.isNative && token.blockchain === core_1.BLOCKCHAIN_NAME.METIS ? '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000' : token.address;
-        const { allowanceWei } = await this.getAllowance(fromTokenAddress, walletAddress, contractAddress);
-        return allowanceWei.lt(token.weiAmount);
-    }
-    ;
-}
-exports.EvmAdapter = EvmAdapter;

package/src/lib/adapter/adapters/solana-adapter.d.ts

@@ -1,15 +0,0 @@
-import { Abi, MulticallResponse, MulticallParameters } from 'viem';
-import { AbstractAdapter } from './abstract-adapter';
-import { Connection } from "@solana/web3.js";
-import { ICustomLogger, SolanaBlockchainName, Token } from "@cryptorubic/core";
-import { EvmTransactionConfig } from "../../utils/models/evm-transaction-config";
-export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
-    constructor(rpcList: string[], logger?: ICustomLogger);
-    private createPublicClient;
-    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
-    multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
-    simulateTransaction(_config: EvmTransactionConfig, _from: string): Promise<void>;
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SolanaBlockchainName>[]>;
-}

package/src/lib/adapter/adapters/solana-adapter.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapter = void 0;
-const abstract_adapter_1 = require("./abstract-adapter");
-const web3_js_1 = require("@solana/web3.js");
-const utl_sdk_1 = require("@solflare-wallet/utl-sdk");
-const core_1 = require("@cryptorubic/core");
-const web3_pure_1 = require("../../utils/web3-pure");
-class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, logger) {
-        super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
-        this.public = this.createPublicClient(rpcList);
-    }
-    createPublicClient(rpcList) {
-        if (!rpcList?.[0]) {
-            this.logger?.customError('RPC list is empty');
-            return null;
-        }
-        else {
-            return new web3_js_1.Connection(rpcList[0], 'confirmed');
-        }
-    }
-    async read(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
-    }
-    async write(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
-    }
-    async multicallByContract(_contracts, _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
-    }
-    async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
-    }
-    async simulateTransaction(_config, _from) { }
-    async callForTokensInfo(tokenAddresses) {
-        const nativeTokenIndex = tokenAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.SOLANA, address));
-        const filteredTokenAddresses = tokenAddresses.filter((_, index) => index !== nativeTokenIndex);
-        const mints = filteredTokenAddresses.map((address) => new web3_js_1.PublicKey(address));
-        const tokenSdk = new utl_sdk_1.Client();
-        const tokensMint = await tokenSdk.fetchMints(mints);
-        const tokens = tokensMint.map((token) => {
-            return new core_1.Token({
-                address: token.address.toString(),
-                blockchain: core_1.BLOCKCHAIN_NAME.SOLANA,
-                decimals: token.decimals,
-                name: token.name,
-                symbol: token.symbol
-            });
-        });
-        if (nativeTokenIndex === -1) {
-            return tokens;
-        }
-        const blockchainNativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.SOLANA];
-        tokens.splice(nativeTokenIndex, 0, blockchainNativeToken);
-        return tokens;
-    }
-}
-exports.SolanaAdapter = SolanaAdapter;

package/src/lib/adapter/adapters/ton-adapter.d.ts

@@ -1,22 +0,0 @@
-import { BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, Token, TokenAmount, TonBlockchainName } from '@cryptorubic/core';
-import { Address, TonClient } from "@ton/ton";
-import { TonApiParseAddressResp } from "./models/tonapi-models";
-import { TonAdapterConfig } from "./models/ton-adapter-config";
-import BigNumber from "bignumber.js";
-import { TonTransactionConfig } from "../../utils/models/ton-transaction-config";
-import { AbstractAdapter } from "./abstract-adapter";
-export declare class TonAdapter extends AbstractAdapter<TonClient, TonClient, TonBlockchainName> {
-    private readonly tonApi;
-    readonly tonClient: TonClient;
-    constructor(httpClient: HttpClient, config: TonAdapterConfig, logger?: ICustomLogger);
-    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
-    read<T>(args: unknown): Promise<T>;
-    write(args: unknown): Promise<string>;
-    getAllFormatsOfAddress(walletAddress: string): Promise<TonApiParseAddressResp>;
-    getWalletAddress(address: Address, contractAddress: Address): Promise<Address>;
-    checkEnoughTokenBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string, amount?: BigNumber): Promise<boolean>;
-    getBalance(walletAddress: string, tokenAddress?: string): Promise<BigNumber>;
-    getTransferEncodedConfig(tokenAddress: string, walletAddress: string, receiver: string, amount: string): Promise<TonTransactionConfig>;
-    private getTransferNativeConfig;
-    private getTransferJettonConfig;
-}

package/src/lib/adapter/adapters/ton-adapter.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TonAdapter = void 0;
-const core_1 = require("@cryptorubic/core");
-const ton_api_service_1 = require("./utils/ton-api.service");
-const ton_1 = require("@ton/ton");
-const bignumber_js_1 = require("bignumber.js");
-const abstract_adapter_1 = require("./abstract-adapter");
-const web3_pure_1 = require("../../utils/web3-pure");
-class TonAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(httpClient, config, logger) {
-        super(core_1.BLOCKCHAIN_NAME.TON, logger);
-        this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig);
-        this.tonClient = new ton_1.TonClient(config.tonClientConfig);
-    }
-    async callForTokensInfo(tokenAddresses) {
-        const info = await Promise.all(tokenAddresses.map((address) => {
-            if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, address)) {
-                const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.TON];
-                return nativeToken;
-            }
-            return this.tonApi.fetchTokenInfo(address);
-        }));
-        if (!info.length)
-            return [];
-        const necessaryInfo = info.map(({ decimals, name, symbol, address }) => new core_1.Token({
-            address,
-            blockchain: core_1.BLOCKCHAIN_NAME.TON,
-            decimals: Number(decimals),
-            name,
-            symbol
-        }));
-        return necessaryInfo;
-    }
-    read(args) {
-        throw new Error('Not implemented');
-    }
-    write(args) {
-        throw new Error('Not implemented');
-    }
-    async getAllFormatsOfAddress(walletAddress) {
-        return this.tonApi.getAllFormatsOfAddress(walletAddress);
-    }
-    async getWalletAddress(address, contractAddress) {
-        const addressResult = await this.tonClient.runMethod(contractAddress, 'get_wallet_address', [
-            { cell: (0, ton_1.beginCell)().storeAddress(address).endCell(), type: 'slice' }
-        ]);
-        return addressResult.stack.readAddress();
-    }
-    async checkEnoughTokenBalance(token, walletAddress, amount = token.tokenAmount) {
-        const weiBalance = await this.getBalance(walletAddress, token.isNative ? undefined : token.address);
-        const balance = core_1.Token.fromWei(weiBalance, token.decimals);
-        return balance.gte(amount);
-    }
-    async getBalance(walletAddress, tokenAddress) {
-        const isNative = !tokenAddress || web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.TON, tokenAddress);
-        const tokenBalance = isNative
-            ? (await this.tonApi.fetchAccountInfo(walletAddress)).balance
-            : (await this.tonApi.fetchTokenInfoForWallet(walletAddress, tokenAddress)).balance;
-        return new bignumber_js_1.default(tokenBalance || 0);
-    }
-    getTransferEncodedConfig(tokenAddress, walletAddress, receiver, amount) {
-        if ((0, core_1.compareAddresses)(core_1.nativeTokensList.TON.address, tokenAddress)) {
-            return this.getTransferNativeConfig(receiver, amount);
-        }
-        return this.getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount);
-    }
-    async getTransferNativeConfig(receiver, amount) {
-        const transferAmount = BigInt(amount);
-        const encodeConfig = {
-            address: receiver,
-            amount: transferAmount.toString()
-        };
-        return encodeConfig;
-    }
-    async getTransferJettonConfig(tokenAddress, walletAddress, receiver, amount) {
-        const fromAddress = ton_1.Address.parse(walletAddress);
-        const contractAddress = ton_1.Address.parse(tokenAddress);
-        const transferAmount = BigInt(amount);
-        const receiverAddress = ton_1.Address.parse(receiver);
-        const jettonWalletAddress = await this.getWalletAddress(fromAddress, contractAddress);
-        const body = (0, ton_1.beginCell)()
-            .storeUint(0xf8a7ea5, 32)
-            .storeUint(0, 64)
-            .storeCoins(transferAmount)
-            .storeAddress(receiverAddress)
-            .storeAddress(receiverAddress)
-            .storeBit(0)
-            .storeCoins((0, ton_1.toNano)('0.02'))
-            .storeBit(0)
-            .endCell();
-        const encodeConfig = {
-            address: jettonWalletAddress.toRawString(),
-            amount: (0, ton_1.toNano)('0.05').toString(),
-            payload: body.toBoc().toString('base64')
-        };
-        return encodeConfig;
-    }
-}
-exports.TonAdapter = TonAdapter;