@cryptorubic/web3 0.14.0-alpha.near.6 → 0.14.0-alpha.solana-gas.12

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.14.0-alpha.near.6",
+    "version": "0.14.0-alpha.solana-gas.12",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",

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

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractAdapter = void 0;
 const viem_1 = require("viem");
 class AbstractAdapter {
+    logger;
+    blockchain;
+    _public = null;
     set public(value) {
         this._public = value;
     }
@@ -14,6 +17,7 @@ class AbstractAdapter {
         }
         return this._public;
     }
+    _wallet = null;
     set wallet(value) {
         this._wallet = value;
     }
@@ -25,6 +29,7 @@ class AbstractAdapter {
         }
         return this._wallet;
     }
+    _walletAddress = null;
     set walletAddress(value) {
         this._walletAddress = value;
     }
@@ -37,9 +42,6 @@ class AbstractAdapter {
         return this._walletAddress;
     }
     constructor(blockchain, logger) {
-        this._public = null;
-        this._wallet = null;
-        this._walletAddress = null;
         this.blockchain = blockchain;
         if (logger) {
             this.logger = logger;

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

@@ -5,6 +5,7 @@ const core_1 = require("@cryptorubic/core");
 const bignumber_js_1 = require("bignumber.js");
 const abstract_adapter_1 = require("./abstract-adapter");
 class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
+    httpClient;
     constructor(httpClient, logger) {
         super(core_1.BLOCKCHAIN_NAME.BITCOIN, logger);
         this.httpClient = httpClient;

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

@@ -34,21 +34,22 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             return null;
         }
         const transports = rpcList.map((rpc) => (0, viem_1.http)(rpc, {
-            batch: { batchSize: 2000, wait: 16 },
+            batch: { batchSize: 2_000, wait: 16 },
             onFetchResponse: (response) => {
                 this.handlePossibleError(response);
             },
             retryCount: 2,
             retryDelay: 100,
-            timeout: 5000
+            timeout: 5_000
         }));
         const chain = viem_blockchain_mapping_1.viemBlockchainMapping[this.blockchain];
+        // @ts-ignore
         return (0, viem_1.createPublicClient)({
             // @ts-ignore
             chain,
             transport: (0, viem_1.fallback)(transports, {
                 rank: {
-                    interval: 1800000
+                    interval: 1_800_000
                 }
             })
         });
@@ -135,7 +136,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             throw err;
         }
     }
-    async simulateTransaction(config, from, timeout = 15000) {
+    async simulateTransaction(config, from, timeout = 15_000) {
         try {
             const callParams = {
                 account: from,
@@ -278,7 +279,7 @@ class EvmAdapter extends abstract_adapter_1.AbstractAdapter {
             to: tx.to
         };
     }
-    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1000000), amount) {
+    async approveOnPermit2(fromAddress, tokenAddress, permit2Address, spenderAddress, deadline = new bignumber_js_1.default(1_000_000), amount) {
         const approveAmount = amount ? amount : new bignumber_js_1.default(2).pow(256).minus(1);
         const expiration = new bignumber_js_1.default(Date.now()).plus(deadline).toFixed();
         const tx = this.encodePermit2Approve(tokenAddress, spenderAddress, permit2Address, expiration, approveAmount.toFixed());

package/src/lib/adapter/adapters/models/adapter-factory-params.d.ts

@@ -0,0 +1,7 @@
+import { HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { TonAdapterConfig } from './ton-adapter-config';
+export interface AdaptersFactoryParams {
+    tonParams: TonAdapterConfig;
+    httpClient?: HttpClient;
+    createLogger?: (label: string) => ICustomLogger;
+}

package/src/lib/adapter/adapters/models/adapter-factory-params.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -2,10 +2,11 @@ import { Abi, MulticallResponse, MulticallParameters } from 'viem';
 import { AbstractAdapter } from './abstract-adapter';
 import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
 import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
-import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
 import BigNumber from 'bignumber.js';
 import { SolanaRawInstruction } from './models/solana-web3-types';
+import { SolanaTxConfig } from '../../utils/models/solana-transaction-config';
 export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
+export declare const DEFAULT_CU_LIMIT = 400000;
 export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
     private readonly httpClient;
     constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger);
@@ -14,7 +15,9 @@ export declare class SolanaAdapter extends AbstractAdapter<Connection, Connectio
     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>;
+    simulateTransaction(config: SolanaTxConfig, timeout?: number): Promise<string>;
+    private getFailedIxProgramId;
+    private getAddressLookupTableAccounts;
     checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
     getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
     /**

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

@@ -1,17 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapter = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
+exports.SolanaAdapter = exports.DEFAULT_CU_LIMIT = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const abstract_adapter_1 = require("./abstract-adapter");
 const web3_js_1 = require("@solana/web3.js");
 const core_1 = require("@cryptorubic/core");
 const web3_pure_1 = require("../../utils/web3-pure");
 const bignumber_js_1 = require("bignumber.js");
-const solana_tokens_service_1 = require("./utils/solana-tokens-service");
 const bs58_1 = require("bs58");
 const js_base64_1 = require("js-base64");
+const solana_tokens_service_1 = require("./utils/solana-utils/solana-tokens-service");
+const timeout_1 = require("./utils/timeout");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
+/* minimal amount for tx (in lamports) */
+exports.DEFAULT_CU_LIMIT = 400_000;
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
+    httpClient;
     constructor(rpcList, httpClient, logger) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
         this.httpClient = httpClient;
@@ -38,7 +42,67 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
     async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
         throw new Error('Method multicall is not supported');
     }
-    async simulateTransaction(_config, _from) { }
+    async simulateTransaction(config, timeout = 15_000) {
+        try {
+            const bufferData = config.data.startsWith('0x') ? Buffer.from(config.data.slice(2), 'hex') : Buffer.from(config.data, 'base64');
+            const { blockhash } = await this.public.getLatestBlockhash();
+            const tx = web3_js_1.VersionedTransaction.deserialize(bufferData);
+            tx.message.recentBlockhash = blockhash;
+            const simulation = this.public.simulateTransaction(tx, {
+                replaceRecentBlockhash: true,
+                commitment: 'confirmed',
+                accounts: {
+                    encoding: 'base64',
+                    addresses: [config.walletAddress]
+                }
+            });
+            const resp = await (0, timeout_1.withTimeout)(simulation, timeout, 'Solana Simulation Timeout!');
+            const err = resp.value.err;
+            const defineCuLimit = () => {
+                const cuLimit = resp.value.unitsConsumed || 0;
+                const defaultGreaterEstimated = new bignumber_js_1.default(exports.DEFAULT_CU_LIMIT).gt(cuLimit);
+                return new bignumber_js_1.default(defaultGreaterEstimated ? exports.DEFAULT_CU_LIMIT : cuLimit).toFixed(0);
+            };
+            if (err) {
+                if (Array.isArray(err['InstructionError'])) {
+                    const [failedInstructionIdx, errorData] = err['InstructionError'];
+                    const failedInstructionProgramId = await this.getFailedIxProgramId(tx, failedInstructionIdx);
+                    this.logger?.customLog('FAILED INSTRUCTION INFO', { programId: failedInstructionProgramId, errorData });
+                    const weirdError = errorData?.Custom === 1;
+                    if (weirdError)
+                        return defineCuLimit();
+                }
+                throw new Error('Transaction simulation failed.');
+            }
+            return defineCuLimit();
+        }
+        catch (err) {
+            this.logger?.customError('Error while simulating transaction', err);
+            throw err;
+        }
+    }
+    async getFailedIxProgramId(tx, failedInstructionIdx) {
+        const lutKeys = (tx.message.addressTableLookups ?? []).map((l) => l.accountKey.toBase58());
+        const lutAccounts = lutKeys.length ? await this.getAddressLookupTableAccounts(lutKeys) : [];
+        const decompiled = web3_js_1.TransactionMessage.decompile(tx.message, { addressLookupTableAccounts: lutAccounts });
+        const programId = decompiled.instructions[failedInstructionIdx].programId;
+        return programId.toBase58();
+    }
+    async getAddressLookupTableAccounts(keys) {
+        const result = [];
+        const infos = await this.public.getMultipleAccountsInfo(keys.map((k) => new web3_js_1.PublicKey(k)));
+        keys.forEach((address, i) => {
+            const ai = infos[i];
+            if (ai) {
+                const alt = new web3_js_1.AddressLookupTableAccount({
+                    key: new web3_js_1.PublicKey(address),
+                    state: web3_js_1.AddressLookupTableAccount.deserialize(ai.data)
+                });
+                result.push(alt);
+            }
+        });
+        return result;
+    }
     async checkEnoughBalance(token, walletAddress) {
         const balance = await this.getBalance(walletAddress, token.address);
         return balance.gte(token.tokenAmount);

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

@@ -8,6 +8,8 @@ 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 {
+    tonApi;
+    tonClient;
     constructor(httpClient, config, logger) {
         super(core_1.BLOCKCHAIN_NAME.TON, logger);
         this.tonApi = new ton_api_service_1.TonApiService(httpClient, config.tonApiConfig, logger);

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

@@ -10,13 +10,13 @@ const core_1 = require("@cryptorubic/core");
 const web3_pure_1 = require("../../utils/web3-pure");
 const tron_web3_pure_1 = require("../../utils/web3-types/tron-web3-pure");
 class TronAdapter extends abstract_adapter_1.AbstractAdapter {
+    multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
     async needPreswapAction(token, contractAddress, walletAddress, amount) {
         // return this.needApprove()
         return false;
     }
     constructor(rpcList, logger) {
         super(core_1.BLOCKCHAIN_NAME.TRON, logger);
-        this.multicallAddress = 'T9ziQU4EBteJzjzMzhHELdhgWFqwzS5Vki';
         this.public = new tronweb_1.TronWeb({ fullHost: rpcList[0] });
     }
     async checkEnoughBalance(token, walletAddress) {

package/src/lib/adapter/adapters/utils/{solana-tokens-service.d.ts → solana-utils/solana-tokens-service.d.ts}

@@ -1,6 +1,6 @@
 import { Connection, PublicKey } from '@solana/web3.js';
 import { HttpClient } from '@cryptorubic/core';
-import { SolanaToken } from '../models/solana-web3-types';
+import { SolanaToken } from '../../models/solana-web3-types';
 export declare class SolanaTokensService {
     private readonly httpClient;
     private connection;

package/src/lib/adapter/adapters/utils/{solana-tokens-service.js → solana-utils/solana-tokens-service.js}

@@ -3,16 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SolanaTokensService = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const utl_sdk_1 = require("@solflare-wallet/utl-sdk");
-const timeout_1 = require("./timeout");
+const timeout_1 = require("../timeout");
 class SolanaTokensService {
+    httpClient;
+    connection;
+    // key - address of token, value - idx of token in initial tokensAddress
+    tokensOrder = {};
+    initialMints = [];
+    apiEndpoint = 'https://x-api.rubic.exchange/sol_token_list';
+    newTokensEndpoint = 'https://api.rubic.exchange/api/v2';
+    xApiKey = 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4';
     constructor(connection, httpClient) {
         this.httpClient = httpClient;
-        // key - address of token, value - idx of token in initial tokensAddress
-        this.tokensOrder = {};
-        this.initialMints = [];
-        this.apiEndpoint = 'https://x-api.rubic.exchange/sol_token_list';
-        this.newTokensEndpoint = 'https://api.rubic.exchange/api/v2';
-        this.xApiKey = 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4';
         this.connection = connection;
     }
     async fetchTokensData(mints) {
@@ -57,7 +59,7 @@ class SolanaTokensService {
     }
     async fetchTokensFromOldBackend(mints, prevFetchedTokens) {
         const tokensAddresses = mints.map((mint) => mint.toString());
-        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3000, 'Api Timeout!').catch(() => ({ content: [] }));
+        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3_000, 'Api Timeout!').catch(() => ({ content: [] }));
         const notSortedTokensList = [...prevFetchedTokens, ...tokensFromOlbBackend];
         const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
         return {

package/src/lib/adapter/adapters/utils/ton-api.service.js

@@ -2,6 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TonApiService = void 0;
 class TonApiService {
+    httpClient;
+    logger;
+    tonApiUrl;
+    apiKey;
+    tonCenterV3Url;
     constructor(httpClient, params, logger) {
         this.httpClient = httpClient;
         this.logger = logger;

package/src/lib/adapter/blockchain-adapter-factory.service.d.ts

@@ -2,21 +2,19 @@ import { SolanaAdapter } from './adapters/solana-adapter';
 import { TronAdapter } from './adapters/tron-adapter';
 import { AbstractAdapter } from './adapters/abstract-adapter';
 import { WalletProvider } from './constants/models/wallet-provider';
-import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName } from '@cryptorubic/core';
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName } from '@cryptorubic/core';
 import { TonAdapter } from './adapters/ton-adapter';
-import { TonAdapterConfig } from './adapters/models/ton-adapter-config';
 import { EvmAdapter } from './adapters/evm-adapter';
 import { BitcoinAdapter } from './adapters/bitcoin-adapter';
 import { SuiAdapter } from './adapters/sui-adapter';
+import { AdaptersFactoryParams } from './adapters/models/adapter-factory-params';
 export declare class BlockchainAdapterFactoryService {
     private readonly rpcList;
-    private readonly createLogger?;
-    private readonly httpClient?;
-    private readonly tonParams?;
+    private readonly params;
     readonly adapterStore: Partial<Record<BlockchainName, AbstractAdapter<unknown, unknown, BlockchainName>>>;
     protected readonly logger?: ICustomLogger;
     private constructor();
-    static createFactory(rpcList: Partial<Record<EvmBlockchainName, string[]>>, httpClient?: HttpClient, tonParams?: TonAdapterConfig, createLogger?: (label: string) => ICustomLogger): Promise<BlockchainAdapterFactoryService>;
+    static createFactory(rpcList: Partial<Record<EvmBlockchainName, string[]>>, params: AdaptersFactoryParams): Promise<BlockchainAdapterFactoryService>;
     getAdapter(blockchain: SolanaBlockchainName): SolanaAdapter;
     getAdapter(blockchain: EvmBlockchainName): EvmAdapter;
     getAdapter(blockchain: TronBlockchainName): TronAdapter;

package/src/lib/adapter/blockchain-adapter-factory.service.js

@@ -11,22 +11,24 @@ const evm_adapter_1 = require("./adapters/evm-adapter");
 const bitcoin_adapter_1 = require("./adapters/bitcoin-adapter");
 const sui_adapter_1 = require("./adapters/sui-adapter");
 class BlockchainAdapterFactoryService {
-    constructor(rpcList, createLogger, httpClient, tonParams) {
+    rpcList;
+    params;
+    adapterStore = {};
+    logger;
+    constructor(rpcList, params) {
         this.rpcList = rpcList;
-        this.createLogger = createLogger;
-        this.httpClient = httpClient;
-        this.tonParams = tonParams;
-        this.adapterStore = {};
+        this.params = params;
         this.adapterStore = this.createStorage();
-        if (this.createLogger) {
-            this.logger = this.createLogger('BlockchainAdapterFactory');
+        if (this.params.createLogger) {
+            this.logger = this.params.createLogger('BlockchainAdapterFactory');
         }
     }
-    static async createFactory(rpcList, httpClient, tonParams, createLogger) {
+    static async createFactory(rpcList, params) {
         // @TODO Add default logger
-        const loggerFn = createLogger || undefined;
-        const resolvedHttpClient = httpClient ?? (await Promise.resolve().then(() => require('axios')));
-        return new this(rpcList, createLogger, resolvedHttpClient, tonParams);
+        const loggerFn = params.createLogger || undefined;
+        const resolvedHttpClient = params.httpClient ?? (await Promise.resolve().then(() => require('axios')));
+        params.httpClient = resolvedHttpClient;
+        return new this(rpcList, params);
     }
     getAdapter(blockchain) {
         const adapter = this.adapterStore?.[blockchain];
@@ -64,24 +66,24 @@ class BlockchainAdapterFactoryService {
                     return new evm_adapter_1.EvmAdapter({
                         blockchain: blockchain,
                         rpcList: rpcs
-                    }, this.createLogger?.(`EVM_ADAPTER_${blockchain}`));
+                    }, this.params.createLogger?.(`EVM_ADAPTER_${blockchain}`));
                 }
             }
             if (blockchainType === core_1.CHAIN_TYPE.TRON) {
-                return new tron_adapter_1.TronAdapter(rpcs, this.createLogger?.(`TRON_ADAPTER`));
+                return new tron_adapter_1.TronAdapter(rpcs, this.params.createLogger?.(`TRON_ADAPTER`));
             }
             if (blockchainType === core_1.CHAIN_TYPE.SUI) {
-                return new sui_adapter_1.SuiAdapter(rpcs, this.createLogger?.(`SUI_ADAPTER`));
+                return new sui_adapter_1.SuiAdapter(rpcs, this.params.createLogger?.(`SUI_ADAPTER`));
             }
             if (blockchainType === core_1.CHAIN_TYPE.SOLANA) {
-                return new solana_adapter_1.SolanaAdapter(rpcs, this.httpClient, this.createLogger?.(`SOLANA_ADAPTER`));
+                return new solana_adapter_1.SolanaAdapter(rpcs, this.params.httpClient, this.params.createLogger?.(`SOLANA_ADAPTER`));
             }
         }
-        if (blockchain === core_1.BLOCKCHAIN_NAME.TON && this.tonParams?.tonApiConfig && this.tonParams?.tonClientConfig) {
-            return new ton_adapter_1.TonAdapter(this.httpClient, this.tonParams, this.createLogger?.(`TON_ADAPTER`));
+        if (blockchain === core_1.BLOCKCHAIN_NAME.TON && this.params.tonParams?.tonApiConfig && this.params.tonParams?.tonClientConfig) {
+            return new ton_adapter_1.TonAdapter(this.params.httpClient, this.params.tonParams, this.params.createLogger?.(`TON_ADAPTER`));
         }
-        if (blockchain === core_1.BLOCKCHAIN_NAME.BITCOIN && this.httpClient) {
-            return new bitcoin_adapter_1.BitcoinAdapter(this.httpClient, this.createLogger?.(`BTC_ADAPTER`));
+        if (blockchain === core_1.BLOCKCHAIN_NAME.BITCOIN && this.params.httpClient) {
+            return new bitcoin_adapter_1.BitcoinAdapter(this.params.httpClient, this.params.createLogger?.(`BTC_ADAPTER`));
         }
         return null;
     }

package/src/lib/utils/models/solana-transaction-config.d.ts

@@ -0,0 +1,6 @@
+type Base64String = `AQA${string}`;
+export interface SolanaTxConfig {
+    data: Base64String;
+    walletAddress: string;
+}
+export {};

package/src/lib/utils/models/solana-transaction-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonWeb3Pure = void 0;
 const axios_1 = require("axios");
 class CommonWeb3Pure {
+    nativeTokenAddress = '0x0000000000000000000000000000000000000000';
+    emptyAddress = '0x0000000000000000000000000000000000000000';
+    cnApiKey;
+    regEx;
     constructor(commonParams) {
-        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000';
-        this.emptyAddress = '0x0000000000000000000000000000000000000000';
         this.cnApiKey = commonParams?.cnApiKey || undefined;
         this.regEx = commonParams?.regex || undefined;
     }

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

@@ -4,12 +4,12 @@ exports.NearWeb3Pure = void 0;
 const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchain");
 const common_web3_pure_1 = require("./common-web3-pure");
 class NearWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    nativeTokenAddress = 'near';
     constructor() {
         super({
             cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.NEAR,
             regex: /(^(?=.{2,64}$)([a-z0-9][a-z0-9\-_]*(?<![-_])\.)*[a-z0-9][a-z0-9\-_]*(?<![-_])(\.near)$)|(^[0-9a-f]{64}$)/
         });
-        this.nativeTokenAddress = 'near';
     }
     async isAddressCorrect(address) {
         if (this.isNativeAddress(address)) {

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

@@ -5,12 +5,12 @@ const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchai
 const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 class SolanaWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     constructor() {
         super({
             cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.SOLANA,
             regex: /^(?!.*([1-9A-HJ-NP-Za-km-z])\1{31,43}$)[1-9A-HJ-NP-Za-km-z]{32,44}$/
         });
-        this.nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     }
     async isAddressCorrect(address) {
         if ((0, core_1.compareAddresses)(address, this.nativeTokenAddress)) {

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

@@ -5,6 +5,8 @@ const common_web3_pure_1 = require("./common-web3-pure");
 const core_1 = require("@cryptorubic/core");
 const bignumber_js_1 = require("bignumber.js");
 class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+    emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     static compareAddress(addressA, addressB) {
         const pureAddressA = addressA.split(':')[0];
         const pureAddressB = addressB.split(':')[0];
@@ -20,8 +22,6 @@ class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         super({
             regex: /(^0[xX][a-fA-F0-9]{0,64}::[a-zA-Z0-9_]*::[A-Z0-9_]*$)|(^0[xX][a-fA-F0-9]{64}$)/
         });
-        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
-        this.emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
     }
 }
 exports.SuiWeb3Pure = SuiWeb3Pure;