@cryptorubic/web3 0.0.35 → 0.0.37-alpha-1212.0

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,22 +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;
-    private _walletAddress;
-    set walletAddress(value: string | null);
-    get walletAddress(): string;
-    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,61 +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;
-    }
-    set walletAddress(value) {
-        this._walletAddress = value;
-    }
-    get walletAddress() {
-        if (!this._walletAddress) {
-            const msg = 'Trying to access undefined walletAddress';
-            this.logger?.customLog(msg);
-            throw new Error(msg);
-        }
-        return this._walletAddress;
-    }
-    constructor(blockchain, logger) {
-        this._public = null;
-        this._wallet = null;
-        this._walletAddress = 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,55 +0,0 @@
-import { Abi, MulticallResponse, MulticallParameters, PublicActions, PublicClient, WalletClient, WalletActions, BlockNumber, BlockTag, GetBlockReturnType } 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";
-import { GasPrice } from "./models/gas-price";
-export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter<EvmTransactionConfig> {
-    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<string>;
-    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>;
-    approve(fromAddress: string, tokenAddress: string, spenderAddress: string, amount?: string): Promise<string>;
-    /**
-     * Calculates EIP-1559 specific gas details.
-     * @see {@link https://github.com/ethers-io/ethers.js/blob/master/packages/abstract-provider/src.ts/index.ts#L235}
-     * @returns block baseFee, average maxPriorityFeePerGas, and maxFeePerGas.
-     */
-    getPriorityFeeGas(): Promise<GasPrice>;
-    /**
-     * Gets block by block id.
-     * @param [blockId] Block id: hash, number ... Default is 'latest'.
-     * @returns Block by blockId parameter.
-     */
-    getBlock(blockType?: BlockNumber | BlockTag): Promise<GetBlockReturnType>;
-    /**
-     * Estimates average maxPriorityFeePerGas for EIP-1559 transactions based on last 20 blocks.
-     * @see {@link https://docs.alchemy.com/docs/how-to-build-a-gas-fee-estimator-using-eip-1559}
-     * @returns Average maxPriorityFeePerGas in wei
-     */
-    getMaxPriorityFeePerGas(): Promise<number>;
-    getBaseFeePerGas(blockNumber: bigint): Promise<number>;
-}

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

@@ -1,326 +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) })
-            };
-            const gasLimitWei = await this.public.estimateGas(callParams);
-            return gasLimitWei.toString();
-        }
-        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);
-    }
-    ;
-    async approve(fromAddress, tokenAddress, spenderAddress, amount) {
-        const config = this.encodeApprove(tokenAddress, spenderAddress, amount);
-        return this.write(fromAddress, config.to, config.value, config.data);
-    }
-    ;
-    /**
-     * Calculates EIP-1559 specific gas details.
-     * @see {@link https://github.com/ethers-io/ethers.js/blob/master/packages/abstract-provider/src.ts/index.ts#L235}
-     * @returns block baseFee, average maxPriorityFeePerGas, and maxFeePerGas.
-     */
-    async getPriorityFeeGas() {
-        const block = await this.getBlock('latest');
-        let lastBaseFeePerGas = null;
-        let maxFeePerGas = null;
-        let maxPriorityFeePerGas = null;
-        if (block && block.baseFeePerGas) {
-            const baseFeePerGas = await this.getBaseFeePerGas(block.number);
-            try {
-                lastBaseFeePerGas = baseFeePerGas;
-                maxPriorityFeePerGas = await this.getMaxPriorityFeePerGas();
-                maxFeePerGas = baseFeePerGas * 2 + maxPriorityFeePerGas;
-            }
-            catch (err) {
-                console.debug(err);
-            }
-        }
-        return {
-            baseFee: lastBaseFeePerGas?.toFixed(),
-            maxFeePerGas: maxFeePerGas?.toFixed(),
-            maxPriorityFeePerGas: maxPriorityFeePerGas?.toFixed()
-        };
-    }
-    /**
-     * Gets block by block id.
-     * @param [blockId] Block id: hash, number ... Default is 'latest'.
-     * @returns Block by blockId parameter.
-     */
-    getBlock(blockType = 'latest') {
-        if (typeof blockType === 'string') {
-            // @TODO FIX TYPE
-            return this.public.getBlock({ blockTag: blockType });
-        }
-        return this.public.getBlock({ blockNumber: blockType });
-    }
-    /**
-     * Estimates average maxPriorityFeePerGas for EIP-1559 transactions based on last 20 blocks.
-     * @see {@link https://docs.alchemy.com/docs/how-to-build-a-gas-fee-estimator-using-eip-1559}
-     * @returns Average maxPriorityFeePerGas in wei
-     */
-    async getMaxPriorityFeePerGas() {
-        const HISTORICAL_BLOCKS = 20;
-        const feeHistory = await this.public.getFeeHistory({
-            blockCount: HISTORICAL_BLOCKS,
-            rewardPercentiles: [50],
-            blockTag: 'pending'
-        });
-        if (!feeHistory?.reward) {
-            throw new Error('No fee history found');
-        }
-        const blocks = feeHistory.reward.map(x => x.map(reward => Number(reward)));
-        const rewardSum = blocks
-            .map(x => x[0])
-            .reduce((acc, v) => acc + (v || 0), 0);
-        return Math.round(rewardSum / blocks.length);
-    }
-    async getBaseFeePerGas(blockNumber) {
-        const feeHistory = await this.public.getFeeHistory({
-            blockCount: 1,
-            rewardPercentiles: [50],
-            // blockTag: 'pending',
-            blockNumber: blockNumber
-        });
-        if (!feeHistory?.baseFeePerGas.length) {
-            throw new Error('No fee history found');
-        }
-        const feedSum = feeHistory.baseFeePerGas
-            .reduce((acc, v) => acc.plus(v.toString() || 0), new bignumber_js_1.default(0));
-        return feedSum.dividedBy(feeHistory.baseFeePerGas.length).toNumber();
-    }
-}
-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;
-}