@cityofzion/bs-ethereum 2.2.13 → 2.4.0

package/dist/BSEthereum.d.ts

@@ -1,11 +1,10 @@
-import { Account, AccountWithDerivationPath, BSCalculableFee, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, BlockchainDataService, BlockchainService, ExchangeDataService, ExplorerService, Network, NftDataService, Token, TransferParam } from '@cityofzion/blockchain-service';
-import { EthersLedgerServiceEthereum } from './EthersLedgerServiceEthereum';
-import Transport from '@ledgerhq/hw-transport';
-import { BSEthereumNetworkId } from './BSEthereumHelper';
+import { Account, BSCalculableFee, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, BlockchainDataService, BlockchainService, ExchangeDataService, ExplorerService, Network, NftDataService, Token, TransferParam, GetLedgerTransport } from '@cityofzion/blockchain-service';
+import { BSEthereumNetworkId } from './constants/BSEthereumConstants';
+import { EthersLedgerServiceEthereum } from './services/ledger/EthersLedgerServiceEthereum';
 export declare class BSEthereum<BSCustomName extends string = string> implements BlockchainService<BSCustomName, BSEthereumNetworkId>, BSWithNft, BSWithNameService, BSCalculableFee, BSWithLedger, BSWithExplorerService {
     #private;
     readonly blockchainName: BSCustomName;
-    readonly derivationPath: string;
+    readonly bip44DerivationPath: string;
     feeToken: Token;
     blockchainDataService: BlockchainDataService;
     exchangeDataService: ExchangeDataService;
@@ -14,18 +13,19 @@ export declare class BSEthereum<BSCustomName extends string = string> implements
     nftDataService: NftDataService;
     network: Network<BSEthereumNetworkId>;
     explorerService: ExplorerService;
-    constructor(blockchainName: BSCustomName, network?: Network<BSEthereumNetworkId>, getLedgerTransport?: (account: Account) => Promise<Transport>);
+    constructor(blockchainName: BSCustomName, network?: Network<BSEthereumNetworkId>, getLedgerTransport?: GetLedgerTransport);
+    clone(): BSEthereum<BSCustomName>;
     setNetwork(network: Network<BSEthereumNetworkId>): void;
     validateAddress(address: string): boolean;
     validateEncrypted(json: string): boolean;
     validateKey(key: string): boolean;
     validateNameServiceDomainFormat(domainName: string): boolean;
-    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Account;
     generateAccountFromKey(key: string): Account;
     generateAccountFromPublicKey(publicKey: string): Account;
     decrypt(json: string, password: string): Promise<Account>;
     encrypt(key: string, password: string): Promise<string>;
-    transfer(param: TransferParam): Promise<string>;
+    transfer(param: TransferParam): Promise<string[]>;
     calculateTransferFee(param: TransferParam): Promise<string>;
     resolveNameServiceDomain(domainName: string): Promise<string>;
 }

package/dist/BSEthereum.js

@@ -31,48 +31,60 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _BSEthereum_instances, _BSEthereum_buildTransferParams, _BSEthereum_setTokens;
+var _BSEthereum_instances, _BSEthereum_getLedgerTransport, _BSEthereum_generateSigner, _BSEthereum_buildTransferParams, _BSEthereum_setTokens;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSEthereum = void 0;
 const ethers_1 = require("ethers");
 const ethersJsonWallets = __importStar(require("@ethersproject/json-wallets"));
 const ethersBytes = __importStar(require("@ethersproject/bytes"));
 const ethersBigNumber = __importStar(require("@ethersproject/bignumber"));
-const GhostMarketNDSEthereum_1 = require("./GhostMarketNDSEthereum");
-const EthersLedgerServiceEthereum_1 = require("./EthersLedgerServiceEthereum");
-const BSEthereumHelper_1 = require("./BSEthereumHelper");
-const MoralisBDSEthereum_1 = require("./MoralisBDSEthereum");
-const MoralisEDSEthereum_1 = require("./MoralisEDSEthereum");
-const BlockscoutNeoXBDSEthereum_1 = require("./BlockscoutNeoXBDSEthereum");
-const BlockscoutNeoXEDSEthereum_1 = require("./BlockscoutNeoXEDSEthereum");
-const BlockscoutNeoXESEthereum_1 = require("./BlockscoutNeoXESEthereum");
+const BSEthereumConstants_1 = require("./constants/BSEthereumConstants");
+const EthersLedgerServiceEthereum_1 = require("./services/ledger/EthersLedgerServiceEthereum");
+const BSEthereumHelper_1 = require("./helpers/BSEthereumHelper");
+const BlockscoutBDSEthereum_1 = require("./services/blockchain-data/BlockscoutBDSEthereum");
+const BlockscoutEDSEthereum_1 = require("./services/exchange-data/BlockscoutEDSEthereum");
+const MoralisBDSEthereum_1 = require("./services/blockchain-data/MoralisBDSEthereum");
+const MoralisEDSEthereum_1 = require("./services/exchange-data/MoralisEDSEthereum");
+const GhostMarketNDSEthereum_1 = require("./services/nft-data/GhostMarketNDSEthereum");
+const BlockscoutESEthereum_1 = require("./services/explorer/BlockscoutESEthereum");
 class BSEthereum {
     constructor(blockchainName, network, getLedgerTransport) {
         _BSEthereum_instances.add(this);
-        network = network !== null && network !== void 0 ? network : BSEthereumHelper_1.BSEthereumHelper.DEFAULT_NETWORK;
+        _BSEthereum_getLedgerTransport.set(this, void 0);
+        network = network !== null && network !== void 0 ? network : BSEthereumConstants_1.BSEthereumConstants.DEFAULT_NETWORK;
         this.blockchainName = blockchainName;
-        this.ledgerService = new EthersLedgerServiceEthereum_1.EthersLedgerServiceEthereum(getLedgerTransport);
-        this.derivationPath = BSEthereumHelper_1.BSEthereumHelper.DERIVATION_PATH;
+        this.ledgerService = new EthersLedgerServiceEthereum_1.EthersLedgerServiceEthereum(this, getLedgerTransport);
+        __classPrivateFieldSet(this, _BSEthereum_getLedgerTransport, getLedgerTransport, "f");
+        this.bip44DerivationPath = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_BIP44_DERIVATION_PATH;
         this.setNetwork(network);
     }
+    clone() {
+        return new BSEthereum(this.blockchainName, this.network, __classPrivateFieldGet(this, _BSEthereum_getLedgerTransport, "f"));
+    }
     setNetwork(network) {
         __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_setTokens).call(this, network);
         this.network = network;
-        if (BlockscoutNeoXBDSEthereum_1.BlockscoutNeoXBDSEthereum.isSupported(network)) {
-            this.exchangeDataService = new BlockscoutNeoXEDSEthereum_1.BlockscoutNeoXEDSEthereum(network);
-            this.blockchainDataService = new BlockscoutNeoXBDSEthereum_1.BlockscoutNeoXBDSEthereum(network);
+        if (BlockscoutBDSEthereum_1.BlockscoutBDSEthereum.isSupported(network)) {
+            this.exchangeDataService = new BlockscoutEDSEthereum_1.BlockscoutEDSEthereum(network);
+            this.blockchainDataService = new BlockscoutBDSEthereum_1.BlockscoutBDSEthereum(network);
         }
         else {
             this.exchangeDataService = new MoralisEDSEthereum_1.MoralisEDSEthereum(network, this.blockchainDataService);
             this.blockchainDataService = new MoralisBDSEthereum_1.MoralisBDSEthereum(network);
         }
         this.nftDataService = new GhostMarketNDSEthereum_1.GhostMarketNDSEthereum(network);
-        this.explorerService = new BlockscoutNeoXESEthereum_1.BlockscoutNeoXESEthereum(network);
+        this.explorerService = new BlockscoutESEthereum_1.BlockscoutESEthereum(network);
     }
     validateAddress(address) {
         return ethers_1.ethers.utils.isAddress(address);
@@ -99,13 +111,13 @@ class BSEthereum {
         return true;
     }
     generateAccountFromMnemonic(mnemonic, index) {
-        const path = this.derivationPath.replace('?', index.toString());
-        const wallet = ethers_1.ethers.Wallet.fromMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic, path);
+        const bip44Path = this.bip44DerivationPath.replace('?', index.toString());
+        const wallet = ethers_1.ethers.Wallet.fromMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic, bip44Path);
         return {
             address: wallet.address,
             key: wallet.privateKey,
             type: 'privateKey',
-            derivationPath: path,
+            bip44Path,
         };
     }
     generateAccountFromKey(key) {
@@ -142,23 +154,41 @@ class BSEthereum {
     }
     transfer(param) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { signer, transactionParams, gasPrice } = yield __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_buildTransferParams).call(this, param);
-            let gasLimit;
-            try {
-                gasLimit = yield signer.estimateGas(transactionParams);
-            }
-            catch (_a) {
-                gasLimit = BSEthereumHelper_1.BSEthereumHelper.DEFAULT_GAS_LIMIT;
+            const signer = yield __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_generateSigner).call(this, param.senderAccount, param.isLedger);
+            const sentTransactionHashes = [];
+            for (const intent of param.intents) {
+                let transactionHash = '';
+                try {
+                    const { transactionParams, gasPrice } = yield __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_buildTransferParams).call(this, intent);
+                    let gasLimit;
+                    try {
+                        gasLimit = yield signer.estimateGas(transactionParams);
+                    }
+                    catch (_a) {
+                        gasLimit = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
+                    }
+                    const transaction = yield signer.sendTransaction(Object.assign(Object.assign({}, transactionParams), { gasLimit, maxPriorityFeePerGas: gasPrice, maxFeePerGas: gasPrice }));
+                    transactionHash = transaction.hash;
+                }
+                catch (_b) {
+                    /* empty */
+                }
+                sentTransactionHashes.push(transactionHash);
             }
-            const transaction = yield signer.sendTransaction(Object.assign(Object.assign({}, transactionParams), { gasLimit, maxPriorityFeePerGas: gasPrice, maxFeePerGas: gasPrice }));
-            return transaction.hash;
+            return sentTransactionHashes;
         });
     }
     calculateTransferFee(param) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { signer, transactionParams, gasPrice } = yield __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_buildTransferParams).call(this, param);
-            const estimated = yield signer.estimateGas(transactionParams);
-            return ethers_1.ethers.utils.formatEther(gasPrice.mul(estimated));
+            const signer = yield __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_generateSigner).call(this, param.senderAccount, param.isLedger);
+            let fee = ethers_1.ethers.utils.parseEther('0');
+            for (const intent of param.intents) {
+                const { gasPrice, transactionParams } = yield __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_buildTransferParams).call(this, intent);
+                const estimated = yield signer.estimateGas(transactionParams);
+                const intentFee = gasPrice.mul(estimated);
+                fee = fee.add(intentFee);
+            }
+            return ethers_1.ethers.utils.formatEther(fee);
         });
     }
     resolveNameServiceDomain(domainName) {
@@ -172,44 +202,43 @@ class BSEthereum {
     }
 }
 exports.BSEthereum = BSEthereum;
-_BSEthereum_instances = new WeakSet(), _BSEthereum_buildTransferParams = function _BSEthereum_buildTransferParams(param) {
-    var _a;
+_BSEthereum_getLedgerTransport = new WeakMap(), _BSEthereum_instances = new WeakSet(), _BSEthereum_generateSigner = function _BSEthereum_generateSigner(account, isLedger) {
     return __awaiter(this, void 0, void 0, function* () {
         const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
-        let ledgerTransport;
-        if (param.isLedger) {
+        if (isLedger) {
             if (!this.ledgerService.getLedgerTransport)
                 throw new Error('You must provide getLedgerTransport function to use Ledger');
-            ledgerTransport = yield this.ledgerService.getLedgerTransport(param.senderAccount);
-        }
-        let signer;
-        if (ledgerTransport) {
-            signer = this.ledgerService.getSigner(ledgerTransport, provider);
+            if (typeof account.bip44Path !== 'string')
+                throw new Error('Your account must have bip44 path to use Ledger');
+            const ledgerTransport = yield this.ledgerService.getLedgerTransport(account);
+            return this.ledgerService.getSigner(ledgerTransport, account.bip44Path, provider);
         }
-        else {
-            signer = new ethers_1.ethers.Wallet(param.senderAccount.key, provider);
-        }
-        const decimals = (_a = param.intent.tokenDecimals) !== null && _a !== void 0 ? _a : 18;
-        const amount = ethersBigNumber.parseFixed(param.intent.amount, decimals);
+        return new ethers_1.ethers.Wallet(account.key, provider);
+    });
+}, _BSEthereum_buildTransferParams = function _BSEthereum_buildTransferParams(intent) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const provider = new ethers_1.ethers.providers.JsonRpcProvider(this.network.url);
+        const decimals = (_a = intent.tokenDecimals) !== null && _a !== void 0 ? _a : 18;
+        const amount = ethersBigNumber.parseFixed(intent.amount, decimals);
         const gasPrice = yield provider.getGasPrice();
         let transactionParams = {
             type: 2,
         };
-        const isNative = BSEthereumHelper_1.BSEthereumHelper.normalizeHash(this.feeToken.hash) === BSEthereumHelper_1.BSEthereumHelper.normalizeHash(param.intent.tokenHash);
+        const isNative = BSEthereumHelper_1.BSEthereumHelper.normalizeHash(this.feeToken.hash) === BSEthereumHelper_1.BSEthereumHelper.normalizeHash(intent.tokenHash);
         if (isNative) {
-            transactionParams.to = param.intent.receiverAddress;
+            transactionParams.to = intent.receiverAddress;
             transactionParams.value = amount;
         }
         else {
-            const contract = new ethers_1.ethers.Contract(param.intent.tokenHash, [
+            const contract = new ethers_1.ethers.Contract(intent.tokenHash, [
                 'function transfer(address to, uint amount) returns (bool)',
             ]);
-            const populatedTransaction = yield contract.populateTransaction.transfer(param.intent.receiverAddress, amount);
+            const populatedTransaction = yield contract.populateTransaction.transfer(intent.receiverAddress, amount);
             transactionParams = Object.assign(Object.assign({}, populatedTransaction), transactionParams);
         }
         return {
             transactionParams,
-            signer,
             gasPrice,
         };
     });

package/dist/{BSEthereumHelper.d.ts → constants/BSEthereumConstants.d.ts}

@@ -1,11 +1,12 @@
-import { Network, NetworkId } from '@cityofzion/blockchain-service';
+import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
 export type BSEthereumNetworkId = NetworkId<'1' | '10' | '25' | '56' | '137' | '250' | '1101' | '8453' | '80002' | '42161' | '42220' | '43114' | '59144' | '11155111' | '47763' | '12227332'>;
-export declare class BSEthereumHelper {
-    #private;
+export declare class BSEthereumConstants {
     static DEFAULT_DECIMALS: number;
     static DEFAULT_GAS_LIMIT: number;
-    static DERIVATION_PATH: string;
-    static DEFAULT_PATH: string;
+    static NATIVE_ASSET: Token;
+    static NATIVE_SYMBOL_BY_NETWORK_ID: Record<BSEthereumNetworkId, string>;
+    static RPC_LIST_BY_NETWORK_ID: Record<BSEthereumNetworkId, string[]>;
+    static DEFAULT_BIP44_DERIVATION_PATH: string;
     static NEOX_TESTNET_NETWORK_ID: BSEthereumNetworkId;
     static NEOX_MAINNET_NETWORK_ID: BSEthereumNetworkId;
     static NEOX_NETWORK_IDS: BSEthereumNetworkId[];
@@ -19,14 +20,4 @@ export declare class BSEthereumHelper {
     static TESTNET_NETWORKS: Network<BSEthereumNetworkId>[];
     static ALL_NETWORKS: Network<BSEthereumNetworkId>[];
     static DEFAULT_NETWORK: Network<BSEthereumNetworkId>;
-    static getNativeAsset(network: Network<BSEthereumNetworkId>): {
-        symbol: string;
-        name: string;
-        hash: string;
-        decimals: number;
-    };
-    static getNativeSymbol(network: Network<BSEthereumNetworkId>): string;
-    static getRpcList(network: Network<BSEthereumNetworkId>): string[];
-    static isMainnet(network: Network<BSEthereumNetworkId>): boolean;
-    static normalizeHash(hash: string): string;
 }

package/dist/constants/BSEthereumConstants.js

@@ -0,0 +1,235 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSEthereumConstants = void 0;
+class BSEthereumConstants {
+}
+exports.BSEthereumConstants = BSEthereumConstants;
+_a = BSEthereumConstants;
+BSEthereumConstants.DEFAULT_DECIMALS = 18;
+BSEthereumConstants.DEFAULT_GAS_LIMIT = 0x5208;
+BSEthereumConstants.NATIVE_ASSET = {
+    decimals: 18,
+    hash: '-',
+    name: 'ETH',
+    symbol: 'ETH',
+};
+BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID = {
+    '1': 'ETH',
+    '10': 'ETH',
+    '25': 'CRO',
+    '56': 'BNB',
+    '137': 'MATIC',
+    '1101': 'ETH',
+    '250': 'FTM',
+    '8453': 'ETH',
+    '80002': 'MATIC',
+    '42161': 'ETH',
+    '42220': 'CELO',
+    '43114': 'AVAX',
+    '59144': 'ETH',
+    '11155111': 'ETH',
+    '47763': 'GAS',
+    '12227332': 'GAS',
+};
+BSEthereumConstants.RPC_LIST_BY_NETWORK_ID = {
+    '1': [
+        'https://eth.llamarpc.com',
+        'https://mainnet.infura.io/v3/',
+        'https://ethereum-rpc.publicnode.com',
+        'https://endpoints.omniatech.io/v1/eth/mainnet/public',
+        'https://rpc.flashbots.net',
+        'https://rpc.mevblocker.io',
+    ],
+    '10': [
+        'https://optimism.llamarpc.com',
+        'https://endpoints.omniatech.io/v1/op/mainnet/public',
+        'https://optimism-rpc.publicnode.com',
+        'https://optimism.meowrpc.com',
+        'https://optimism.rpc.subquery.network/public',
+    ],
+    '25': ['https://cronos-evm-rpc.publicnode.com', 'https://1rpc.io/cro', 'https://rpc.vvs.finance'],
+    '56': [
+        'https://bsc-dataseed.binance.org/',
+        'https://binance.llamarpc.com',
+        'https://bsc-dataseed.bnbchain.org',
+        'https://endpoints.omniatech.io/v1/bsc/mainnet/public',
+        'https://bsc-rpc.publicnode.com',
+    ],
+    '137': [
+        'https://polygon-mainnet.infura.io',
+        'https://polygon.llamarpc.com',
+        'https://endpoints.omniatech.io/v1/matic/mainnet/public',
+        'https://polygon.drpc.org',
+        'https://polygon.meowrpc.com',
+    ],
+    '250': [
+        'https://endpoints.omniatech.io/v1/fantom/mainnet/public',
+        'https://rpcapi.fantom.network',
+        'https://fantom-pokt.nodies.app',
+        'https://fantom-rpc.publicnode.com',
+        'https://fantom.drpc.org',
+    ],
+    '1101': [
+        'https://polygon-zkevm.drpc.org',
+        'https://polygon-zkevm.blockpi.network/v1/rpc/public',
+        'https://1rpc.io/polygon/zkevm',
+    ],
+    '80002': [
+        'https://polygon-amoy.drpc.org',
+        'https://rpc.ankr.com/polygon_amoy',
+        'https://polygon-amoy-bor-rpc.publicnode.com',
+    ],
+    '8453': [
+        'https://base.rpc.subquery.network/public',
+        'https://base.llamarpc.com',
+        'https://mainnet.base.org',
+        'https://1rpc.io/base',
+        'https://base.meowrpc.com',
+        'https://base-rpc.publicnode.com',
+        'https://endpoints.omniatech.io/v1/base/mainnet/public',
+    ],
+    '42161': [
+        'https://arbitrum.llamarpc.com',
+        'https://arbitrum-one-rpc.publicnode.com',
+        'https://arb-mainnet-public.unifra.io',
+        'https://arbitrum-one.publicnode.com',
+    ],
+    '42220': [
+        'https://forno.celo.org',
+        'https://api.tatum.io/v3/blockchain/node/celo-mainnet',
+        'https://rpc.ankr.com/celo',
+    ],
+    '43114': [
+        'https://avalanche-mainnet.infura.io',
+        'https://avalanche-c-chain-rpc.publicnode.com',
+        'https://avalanche.public-rpc.com',
+        'https://endpoints.omniatech.io/v1/avax/mainnet/public',
+        'https://avalanche.drpc.org',
+    ],
+    '59144': [
+        'https://linea.decubate.com',
+        'https://linea.blockpi.network/v1/rpc/public',
+        'https://linea.decubate.com',
+    ],
+    '11155111': [
+        'https://ethereum-sepolia.rpc.subquery.network/public',
+        'https://ethereum-sepolia-rpc.publicnode.com',
+        'https://endpoints.omniatech.io/v1/eth/sepolia/public',
+        'https://eth-sepolia.public.blastapi.io',
+        'https://eth-sepolia-public.unifra.io',
+        'https://1rpc.io/sepolia',
+        'https://eth-sepolia.api.onfinality.io/public',
+    ],
+    '47763': ['https://mainnet-1.rpc.banelabs.org'],
+    '12227332': ['https://neoxt4seed1.ngd.network'],
+};
+BSEthereumConstants.DEFAULT_BIP44_DERIVATION_PATH = "m/44'/60'/0'/0/?";
+BSEthereumConstants.NEOX_TESTNET_NETWORK_ID = '12227332';
+BSEthereumConstants.NEOX_MAINNET_NETWORK_ID = '47763';
+BSEthereumConstants.NEOX_NETWORK_IDS = [_a.NEOX_TESTNET_NETWORK_ID, _a.NEOX_MAINNET_NETWORK_ID];
+BSEthereumConstants.NEOX_TESTNET_NETWORK = {
+    id: _a.NEOX_TESTNET_NETWORK_ID,
+    name: 'NeoX Testnet',
+    url: _a.RPC_LIST_BY_NETWORK_ID[_a.NEOX_TESTNET_NETWORK_ID][0],
+};
+BSEthereumConstants.NEOX_MAINNET_NETWORK = {
+    id: _a.NEOX_MAINNET_NETWORK_ID,
+    name: 'NeoX Mainnet',
+    url: _a.RPC_LIST_BY_NETWORK_ID[_a.NEOX_MAINNET_NETWORK_ID][0],
+};
+BSEthereumConstants.NEOX_NETWORKS = [_a.NEOX_TESTNET_NETWORK, _a.NEOX_MAINNET_NETWORK];
+BSEthereumConstants.MAINNET_NETWORK_IDS = [
+    '1',
+    '10',
+    '25',
+    '56',
+    '137',
+    '250',
+    '8453',
+    '42161',
+    '42220',
+    '43114',
+    '59144',
+    _a.NEOX_MAINNET_NETWORK_ID,
+];
+BSEthereumConstants.TESTNET_NETWORK_IDS = ['1101', '80002', '11155111', _a.NEOX_TESTNET_NETWORK_ID];
+BSEthereumConstants.ALL_NETWORK_IDS = [..._a.MAINNET_NETWORK_IDS, ..._a.TESTNET_NETWORK_IDS];
+BSEthereumConstants.MAINNET_NETWORKS = [
+    {
+        id: '1',
+        name: 'Ethereum Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['1'][0],
+    },
+    {
+        id: '10',
+        name: 'Optimism Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['10'][0],
+    },
+    {
+        id: '25',
+        name: 'Cronos Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['25'][0],
+    },
+    {
+        id: '56',
+        name: 'Binance Smart Chain Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['56'][0],
+    },
+    {
+        id: '137',
+        name: 'Polygon Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['137'][0],
+    },
+    {
+        id: '250',
+        name: 'Fantom Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['250'][0],
+    },
+    {
+        id: '8453',
+        name: 'Base Protocol Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['8453'][0],
+    },
+    {
+        id: '42161',
+        name: 'Arbitrum Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['42161'][0],
+    },
+    {
+        id: '42220',
+        name: 'Celo Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['42220'][0],
+    },
+    {
+        id: '43114',
+        name: 'Avalanche Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['43114'][0],
+    },
+    {
+        id: '59144',
+        name: 'Linea Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['59144'][0],
+    },
+    _a.NEOX_MAINNET_NETWORK,
+];
+BSEthereumConstants.TESTNET_NETWORKS = [
+    {
+        id: '1101',
+        name: 'Polygon zkEVM Testnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['1101'][0],
+    },
+    {
+        id: '80002',
+        name: 'Polygon Testnet Amoy',
+        url: _a.RPC_LIST_BY_NETWORK_ID['80002'][0],
+    },
+    {
+        id: '11155111',
+        name: 'Sepolia Testnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['11155111'][0],
+    },
+    _a.NEOX_TESTNET_NETWORK,
+];
+BSEthereumConstants.ALL_NETWORKS = [..._a.MAINNET_NETWORKS, ..._a.TESTNET_NETWORKS];
+BSEthereumConstants.DEFAULT_NETWORK = _a.MAINNET_NETWORKS[0];

package/dist/helpers/BSEthereumHelper.d.ts

@@ -0,0 +1,16 @@
+import { Network } from '@cityofzion/blockchain-service';
+import { BSEthereumNetworkId } from '../constants/BSEthereumConstants';
+export declare class BSEthereumHelper {
+    static getNativeAsset(network: Network<BSEthereumNetworkId>): {
+        symbol: string;
+        name: string;
+        hash: string;
+        decimals: number;
+    };
+    static getNativeSymbol(network: Network<BSEthereumNetworkId>): string;
+    static getRpcList(network: Network<BSEthereumNetworkId>): string[];
+    static isMainnet(network: Network<BSEthereumNetworkId>): boolean;
+    static normalizeHash(hash: string): string;
+    static wait(duration: number): Promise<void>;
+    static retry<T = any>(callback: () => Promise<T>): Promise<T>;
+}

package/dist/helpers/BSEthereumHelper.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSEthereumHelper = void 0;
+const BSEthereumConstants_1 = require("../constants/BSEthereumConstants");
+class BSEthereumHelper {
+    static getNativeAsset(network) {
+        const symbol = this.getNativeSymbol(network);
+        return Object.assign(Object.assign({}, BSEthereumConstants_1.BSEthereumConstants.NATIVE_ASSET), { symbol, name: symbol });
+    }
+    static getNativeSymbol(network) {
+        var _a;
+        return (_a = BSEthereumConstants_1.BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : 'ETH';
+    }
+    static getRpcList(network) {
+        var _a;
+        return (_a = BSEthereumConstants_1.BSEthereumConstants.RPC_LIST_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : [];
+    }
+    static isMainnet(network) {
+        return BSEthereumConstants_1.BSEthereumConstants.MAINNET_NETWORK_IDS.includes(network.id);
+    }
+    static normalizeHash(hash) {
+        return hash.startsWith('0x') ? hash.slice(2) : hash;
+    }
+    static wait(duration) {
+        return new Promise(resolve => {
+            setTimeout(resolve, duration);
+        });
+    }
+    static retry(callback) {
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            // Wait up to 5 seconds
+            for (let i = 0; i < 50; i++) {
+                try {
+                    const result = yield callback();
+                    return resolve(result);
+                }
+                catch (error) {
+                    if (error.id !== 'TransportLocked') {
+                        return reject(error);
+                    }
+                }
+                yield this.wait(100);
+            }
+            return reject(new Error('timeout'));
+        }));
+    }
+}
+exports.BSEthereumHelper = BSEthereumHelper;

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 export * from './BSEthereum';
-export * from './BSEthereumHelper';
-export * from './EthersLedgerServiceEthereum';
-export * from './GhostMarketNDSEthereum';
-export * from './MoralisBDSEthereum';
-export * from './MoralisEDSEthereum';
-export * from './RpcBDSEthereum';
-export * from './RpcNDSEthereum';
+export * from './helpers/BSEthereumHelper';
+export * from './constants/BSEthereumConstants';
+export * from './services/blockchain-data/BlockscoutBDSEthereum';
+export * from './services/blockchain-data/MoralisBDSEthereum';
+export * from './services/blockchain-data/RpcBDSEthereum';
+export * from './services/exchange-data/BlockscoutEDSEthereum';
+export * from './services/exchange-data/MoralisEDSEthereum';
+export * from './services/explorer/BlockscoutESEthereum';
+export * from './services/ledger/EthersLedgerServiceEthereum';
+export * from './services/nft-data/GhostMarketNDSEthereum';
+export * from './services/nft-data/RpcNDSEthereum';

package/dist/index.js

@@ -15,10 +15,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./BSEthereum"), exports);
-__exportStar(require("./BSEthereumHelper"), exports);
-__exportStar(require("./EthersLedgerServiceEthereum"), exports);
-__exportStar(require("./GhostMarketNDSEthereum"), exports);
-__exportStar(require("./MoralisBDSEthereum"), exports);
-__exportStar(require("./MoralisEDSEthereum"), exports);
-__exportStar(require("./RpcBDSEthereum"), exports);
-__exportStar(require("./RpcNDSEthereum"), exports);
+__exportStar(require("./helpers/BSEthereumHelper"), exports);
+__exportStar(require("./constants/BSEthereumConstants"), exports);
+__exportStar(require("./services/blockchain-data/BlockscoutBDSEthereum"), exports);
+__exportStar(require("./services/blockchain-data/MoralisBDSEthereum"), exports);
+__exportStar(require("./services/blockchain-data/RpcBDSEthereum"), exports);
+__exportStar(require("./services/exchange-data/BlockscoutEDSEthereum"), exports);
+__exportStar(require("./services/exchange-data/MoralisEDSEthereum"), exports);
+__exportStar(require("./services/explorer/BlockscoutESEthereum"), exports);
+__exportStar(require("./services/ledger/EthersLedgerServiceEthereum"), exports);
+__exportStar(require("./services/nft-data/GhostMarketNDSEthereum"), exports);
+__exportStar(require("./services/nft-data/RpcNDSEthereum"), exports);

package/dist/{BlockscoutNeoXBDSEthereum.d.ts → services/blockchain-data/BlockscoutBDSEthereum.d.ts}

@@ -1,7 +1,7 @@
 import { BalanceResponse, ContractResponse, Network, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
 import { RpcBDSEthereum } from './RpcBDSEthereum';
-import { BSEthereumNetworkId } from './BSEthereumHelper';
-export declare class BlockscoutNeoXBDSEthereum extends RpcBDSEthereum {
+import { BSEthereumNetworkId } from '../../constants/BSEthereumConstants';
+export declare class BlockscoutBDSEthereum extends RpcBDSEthereum {
     static BASE_URL_BY_CHAIN_ID: Partial<Record<BSEthereumNetworkId, string>>;
     static isSupported(network: Network<BSEthereumNetworkId>): boolean;
     static getClient(network: Network<BSEthereumNetworkId>): import("axios").AxiosInstance;