@cityofzion/bs-ethereum 2.13.3 → 2.13.5

package/dist/BSEthereum.d.ts

@@ -1,35 +1,40 @@
-import { Account, BSCalculableFee, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, BlockchainDataService, BlockchainService, ExchangeDataService, ExplorerService, Network, NftDataService, Token, TransferParam, GetLedgerTransport, BSWithEncryption, ITokenService } from '@cityofzion/blockchain-service';
+import { TBSAccount, TBSToken, TTransferParam, TGetLedgerTransport, ITokenService, TBSNetwork, IBlockchainDataService, IExchangeDataService, INftDataService, IExplorerService, TPingNetworkResponse } from '@cityofzion/blockchain-service';
 import { ethers } from 'ethers';
-import { BSEthereumNetworkId } from './constants/BSEthereumConstants';
 import { EthersLedgerServiceEthereum } from './services/ledger/EthersLedgerServiceEthereum';
-export declare class BSEthereum<BSName extends string = string, NetworkId extends string = BSEthereumNetworkId> implements BlockchainService<BSName, NetworkId>, BSWithNft, BSWithNameService, BSCalculableFee<BSName>, BSWithLedger<BSName>, BSWithExplorerService, BSWithEncryption<BSName> {
+import { IBSEthereum, TBSEthereumNetworkId, TSupportedEVM } from './types';
+export declare class BSEthereum<N extends string = string, A extends string = TBSEthereumNetworkId> implements IBSEthereum<N, A> {
     #private;
-    readonly name: BSName;
+    readonly name: N;
     readonly bip44DerivationPath: string;
-    nativeTokens: Token[];
-    feeToken: Token;
-    blockchainDataService: BlockchainDataService;
-    exchangeDataService: ExchangeDataService;
-    ledgerService: EthersLedgerServiceEthereum<BSName>;
-    tokens: Token[];
-    nftDataService: NftDataService;
-    network: Network<NetworkId>;
-    explorerService: ExplorerService;
+    readonly isMultiTransferSupported = false;
+    readonly isCustomNetworkSupported = false;
+    tokens: TBSToken[];
+    nativeTokens: TBSToken[];
+    feeToken: TBSToken;
+    network: TBSNetwork<A>;
+    availableNetworkURLs: string[];
+    readonly defaultNetwork: TBSNetwork<A>;
+    readonly availableNetworks: TBSNetwork<A>[];
+    blockchainDataService: IBlockchainDataService;
+    exchangeDataService: IExchangeDataService;
+    ledgerService: EthersLedgerServiceEthereum<N>;
+    nftDataService: INftDataService;
+    explorerService: IExplorerService;
     tokenService: ITokenService;
-    constructor(name: BSName, network?: Network<NetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
-    generateSigner(account: Account<BSName>): Promise<ethers.Signer>;
-    testNetwork(network: Network<NetworkId>): Promise<void>;
-    setNetwork(network: Network<NetworkId>): void;
+    constructor(name: N, evm?: TSupportedEVM, network?: TBSNetwork<A>, getLedgerTransport?: TGetLedgerTransport<N>);
+    generateSigner(account: TBSAccount<N>): Promise<ethers.Signer>;
+    setNetwork(network: TBSNetwork<A>): void;
+    pingNetwork(network: TBSNetwork<A>): Promise<TPingNetworkResponse>;
     validateAddress(address: string): boolean;
     validateEncrypted(json: string): boolean;
     validateKey(key: string): boolean;
     validateNameServiceDomainFormat(domainName: string): boolean;
-    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Account<BSName>;
-    generateAccountFromKey(key: string): Account<BSName>;
-    generateAccountFromPublicKey(publicKey: string): Account<BSName>;
-    decrypt(json: string, password: string): Promise<Account<BSName>>;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): TBSAccount<N>;
+    generateAccountFromKey(key: string): TBSAccount<N>;
+    generateAccountFromPublicKey(publicKey: string): TBSAccount<N>;
+    decrypt(json: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
-    transfer(param: TransferParam<BSName>): Promise<string[]>;
-    calculateTransferFee(param: TransferParam<BSName>): Promise<string>;
+    transfer(param: TTransferParam<N>): Promise<string[]>;
+    calculateTransferFee(param: TTransferParam<N>): Promise<string>;
     resolveNameServiceDomain(domainName: string): Promise<string>;
 }

package/dist/BSEthereum.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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) {
@@ -36,9 +46,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _BSEthereum_instances, _BSEthereum_buildTransferParams, _BSEthereum_setTokens;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSEthereum = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const ethers_1 = require("ethers");
 const ethersJsonWallets = __importStar(require("@ethersproject/json-wallets"));
 const ethersBytes = __importStar(require("@ethersproject/bytes"));
@@ -50,16 +64,21 @@ const MoralisBDSEthereum_1 = require("./services/blockchain-data/MoralisBDSEther
 const MoralisEDSEthereum_1 = require("./services/exchange-data/MoralisEDSEthereum");
 const GhostMarketNDSEthereum_1 = require("./services/nft-data/GhostMarketNDSEthereum");
 const BlockscoutESEthereum_1 = require("./services/explorer/BlockscoutESEthereum");
-const RpcBDSEthereum_1 = require("./services/blockchain-data/RpcBDSEthereum");
 const TokenServiceEthereum_1 = require("./services/token/TokenServiceEthereum");
+const axios_1 = __importDefault(require("axios"));
 class BSEthereum {
-    constructor(name, network, getLedgerTransport) {
+    constructor(name, evm, network, getLedgerTransport) {
         _BSEthereum_instances.add(this);
-        network = network !== null && network !== void 0 ? network : BSEthereumConstants_1.BSEthereumConstants.DEFAULT_NETWORK;
+        this.isMultiTransferSupported = false;
+        this.isCustomNetworkSupported = false;
         this.name = name;
         this.ledgerService = new EthersLedgerServiceEthereum_1.EthersLedgerServiceEthereum(this, getLedgerTransport);
         this.bip44DerivationPath = BSEthereumConstants_1.BSEthereumConstants.DEFAULT_BIP44_DERIVATION_PATH;
-        this.setNetwork(network);
+        if (!evm)
+            return;
+        this.availableNetworks = BSEthereumConstants_1.BSEthereumConstants.NETWORKS_BY_EVM[evm];
+        this.defaultNetwork = this.availableNetworks.find(network => network.type === 'mainnet');
+        this.setNetwork(network !== null && network !== void 0 ? network : this.defaultNetwork);
     }
     generateSigner(account) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -75,21 +94,38 @@ class BSEthereum {
             return new ethers_1.ethers.Wallet(account.key, provider);
         });
     }
-    testNetwork(network) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.tokenService = new TokenServiceEthereum_1.TokenServiceEthereum();
-            const blockchainDataServiceClone = new RpcBDSEthereum_1.RpcBDSEthereum(network, this.tokenService);
-            yield blockchainDataServiceClone.getBlockHeight();
-        });
-    }
     setNetwork(network) {
+        const availableURLs = BSEthereumConstants_1.BSEthereumConstants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
+        const isValidNetwork = blockchain_service_1.BSUtilsHelper.validateNetwork(network, this.availableNetworks, availableURLs);
+        if (!isValidNetwork) {
+            throw new Error(`Network with id ${network.id} is not available for ${this.name}`);
+        }
         __classPrivateFieldGet(this, _BSEthereum_instances, "m", _BSEthereum_setTokens).call(this, network);
         this.network = network;
-        this.nftDataService = new GhostMarketNDSEthereum_1.GhostMarketNDSEthereum(network);
-        this.explorerService = new BlockscoutESEthereum_1.BlockscoutESEthereum(network, this.tokenService);
-        this.exchangeDataService = new MoralisEDSEthereum_1.MoralisEDSEthereum(network, this.blockchainDataService, this.tokenService);
+        this.availableNetworkURLs = availableURLs;
+        this.nftDataService = new GhostMarketNDSEthereum_1.GhostMarketNDSEthereum(this);
+        this.explorerService = new BlockscoutESEthereum_1.BlockscoutESEthereum(this);
+        this.exchangeDataService = new MoralisEDSEthereum_1.MoralisEDSEthereum(this);
+        this.blockchainDataService = new MoralisBDSEthereum_1.MoralisBDSEthereum(this);
         this.tokenService = new TokenServiceEthereum_1.TokenServiceEthereum();
-        this.blockchainDataService = new MoralisBDSEthereum_1.MoralisBDSEthereum(network, this.nftDataService, this.explorerService, this.tokenService);
+    }
+    // This method is done manually because we need to ensure that the request is aborted after timeout
+    pingNetwork(network) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const abortController = new AbortController();
+            const timeout = setTimeout(() => {
+                abortController.abort();
+            }, 5000);
+            const timeStart = Date.now();
+            const response = yield axios_1.default.post(network.url, { jsonrpc: '2.0', method: 'eth_blockNumber', params: [], id: 1234 }, { timeout: 5000, signal: abortController.signal });
+            clearTimeout(timeout);
+            const latency = Date.now() - timeStart;
+            return {
+                latency,
+                url: network.url,
+                height: ethers_1.ethers.BigNumber.from(response.data.result).toNumber(),
+            };
+        });
     }
     validateAddress(address) {
         return ethers_1.ethers.utils.isAddress(address);
@@ -104,7 +140,7 @@ class BSEthereum {
             }
             return ethersBytes.hexDataLength(key) === 32;
         }
-        catch (error) {
+        catch (_a) {
             return false;
         }
     }
@@ -220,7 +256,7 @@ _BSEthereum_instances = new WeakSet(), _BSEthereum_buildTransferParams = functio
                 const token = yield this.blockchainDataService.getTokenInfo(intent.tokenHash);
                 decimals = token.decimals;
             }
-            catch (error) {
+            catch (_a) {
                 decimals = 18;
             }
         }

package/dist/constants/BSEthereumConstants.d.ts

@@ -1,21 +1,11 @@
-import { Network, NetworkId } from '@cityofzion/blockchain-service';
-export type BSEthereumNetworkId = NetworkId<'1' | '10' | '25' | '56' | '137' | '250' | '1101' | '8453' | '80002' | '42161' | '42220' | '43114' | '59144' | '11155111'>;
+import { TBSNetwork } from '@cityofzion/blockchain-service';
+import { TBSEthereumNetworkId, TSupportedEVM } from '../types';
 export declare class BSEthereumConstants {
-    static DEFAULT_DECIMALS: number;
-    static DEFAULT_GAS_LIMIT: number;
-    static readonly ETHEREUM_MAINNET_NETWORK_ID: BSEthereumNetworkId;
-    static readonly POLYGON_MAINNET_NETWORK_ID: BSEthereumNetworkId;
-    static readonly BASE_MAINNET_NETWORK_ID: BSEthereumNetworkId;
-    static readonly ARBITRUM_MAINNET_NETWORK_ID: BSEthereumNetworkId;
-    static NATIVE_SYMBOL_BY_NETWORK_ID: Record<BSEthereumNetworkId, string>;
-    static NATIVE_WRAPPED_HASH_BY_NETWORK_ID: Partial<Record<BSEthereumNetworkId, string>>;
-    static RPC_LIST_BY_NETWORK_ID: Record<BSEthereumNetworkId, string[]>;
-    static DEFAULT_BIP44_DERIVATION_PATH: string;
-    static MAINNET_NETWORK_IDS: BSEthereumNetworkId[];
-    static TESTNET_NETWORK_IDS: BSEthereumNetworkId[];
-    static ALL_NETWORK_IDS: BSEthereumNetworkId[];
-    static MAINNET_NETWORKS: Network<BSEthereumNetworkId>[];
-    static TESTNET_NETWORKS: Network<BSEthereumNetworkId>[];
-    static ALL_NETWORKS: Network<BSEthereumNetworkId>[];
-    static DEFAULT_NETWORK: Network<BSEthereumNetworkId>;
+    static readonly DEFAULT_DECIMALS = 18;
+    static readonly DEFAULT_GAS_LIMIT = 21000;
+    static readonly DEFAULT_BIP44_DERIVATION_PATH = "m/44'/60'/0'/0/?";
+    static readonly NATIVE_SYMBOL_BY_NETWORK_ID: Record<TBSEthereumNetworkId, string>;
+    static readonly NATIVE_WRAPPED_HASH_BY_NETWORK_ID: Partial<Record<TBSEthereumNetworkId, string>>;
+    static readonly RPC_LIST_BY_NETWORK_ID: Record<TBSEthereumNetworkId, string[]>;
+    static readonly NETWORKS_BY_EVM: Record<TSupportedEVM, TBSNetwork<TBSEthereumNetworkId>[]>;
 }

package/dist/constants/BSEthereumConstants.js

@@ -8,10 +8,7 @@ exports.BSEthereumConstants = BSEthereumConstants;
 _a = BSEthereumConstants;
 BSEthereumConstants.DEFAULT_DECIMALS = 18;
 BSEthereumConstants.DEFAULT_GAS_LIMIT = 0x5208;
-BSEthereumConstants.ETHEREUM_MAINNET_NETWORK_ID = '1';
-BSEthereumConstants.POLYGON_MAINNET_NETWORK_ID = '137';
-BSEthereumConstants.BASE_MAINNET_NETWORK_ID = '8453';
-BSEthereumConstants.ARBITRUM_MAINNET_NETWORK_ID = '42161';
+BSEthereumConstants.DEFAULT_BIP44_DERIVATION_PATH = "m/44'/60'/0'/0/?";
 BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID = {
     '1': 'ETH',
     '10': 'ETH',
@@ -29,14 +26,14 @@ BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID = {
     '11155111': 'ETH',
 };
 BSEthereumConstants.NATIVE_WRAPPED_HASH_BY_NETWORK_ID = {
-    [_a.ETHEREUM_MAINNET_NETWORK_ID]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    '1': '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
     '10': '0x4200000000000000000000000000000000000006',
     '25': '0x5c7f8a570d578ed84e63fdfa7b1ee72deae1ae23',
     '56': '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c',
-    [_a.POLYGON_MAINNET_NETWORK_ID]: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
+    '137': '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
     '250': '0x21be370d5312f44cb42ce377bc9b8a0cef1a4c83',
-    [_a.BASE_MAINNET_NETWORK_ID]: '0x4200000000000000000000000000000000000006',
-    [_a.ARBITRUM_MAINNET_NETWORK_ID]: '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
+    '8453': '0x4200000000000000000000000000000000000006',
+    '42161': '0x82af49447d8a07e3bd95bd0d56f35241523fbab1',
     '42220': '0x471EcE3750Da237f93B8E339c536989b8978a438',
     '43114': '0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7',
     '59144': '0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f',
@@ -126,96 +123,98 @@ BSEthereumConstants.RPC_LIST_BY_NETWORK_ID = {
         'https://endpoints.omniatech.io/v1/eth/sepolia/public',
     ],
 };
-BSEthereumConstants.DEFAULT_BIP44_DERIVATION_PATH = "m/44'/60'/0'/0/?";
-BSEthereumConstants.MAINNET_NETWORK_IDS = [
-    _a.ETHEREUM_MAINNET_NETWORK_ID,
-    '10',
-    '25',
-    '56',
-    _a.POLYGON_MAINNET_NETWORK_ID,
-    '250',
-    _a.BASE_MAINNET_NETWORK_ID,
-    _a.ARBITRUM_MAINNET_NETWORK_ID,
-    '42220',
-    '43114',
-    '59144',
-];
-BSEthereumConstants.TESTNET_NETWORK_IDS = ['1101', '80002', '11155111'];
-BSEthereumConstants.ALL_NETWORK_IDS = [..._a.MAINNET_NETWORK_IDS, ..._a.TESTNET_NETWORK_IDS];
-BSEthereumConstants.MAINNET_NETWORKS = [
-    {
-        id: _a.ETHEREUM_MAINNET_NETWORK_ID,
-        name: 'Ethereum Mainnet',
-        url: _a.RPC_LIST_BY_NETWORK_ID[_a.ETHEREUM_MAINNET_NETWORK_ID][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: _a.POLYGON_MAINNET_NETWORK_ID,
-        name: 'Polygon Mainnet',
-        url: _a.RPC_LIST_BY_NETWORK_ID[_a.POLYGON_MAINNET_NETWORK_ID][0],
-    },
-    {
-        id: '250',
-        name: 'Fantom Mainnet',
-        url: _a.RPC_LIST_BY_NETWORK_ID['250'][0],
-    },
-    {
-        id: _a.BASE_MAINNET_NETWORK_ID,
-        name: 'Base Protocol Mainnet',
-        url: _a.RPC_LIST_BY_NETWORK_ID[_a.BASE_MAINNET_NETWORK_ID][0],
-    },
-    {
-        id: _a.ARBITRUM_MAINNET_NETWORK_ID,
-        name: 'Arbitrum Mainnet',
-        url: _a.RPC_LIST_BY_NETWORK_ID[_a.ARBITRUM_MAINNET_NETWORK_ID][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],
-    },
-];
-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],
-    },
-];
-BSEthereumConstants.ALL_NETWORKS = [..._a.MAINNET_NETWORKS, ..._a.TESTNET_NETWORKS];
-// If tou change this, make sure to update the tests accordingly
-BSEthereumConstants.DEFAULT_NETWORK = _a.MAINNET_NETWORKS[0];
+BSEthereumConstants.NETWORKS_BY_EVM = {
+    ethereum: [
+        {
+            id: '1',
+            name: 'Ethereum Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['1'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '11155111',
+            name: 'Sepolia Testnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['11155111'][0],
+            type: 'testnet',
+        },
+        // EVM compatible networks
+        {
+            id: '10',
+            name: 'Optimism Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['10'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '25',
+            name: 'Cronos Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['25'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '56',
+            name: 'Binance Smart Chain Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['56'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '250',
+            name: 'Fantom Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['250'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '42220',
+            name: 'Celo Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['42220'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '43114',
+            name: 'Avalanche Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['43114'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '59144',
+            name: 'Linea Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['59144'][0],
+            type: 'mainnet',
+        },
+    ],
+    arbitrum: [
+        {
+            id: '42161',
+            name: 'Arbitrum Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID[42161][0],
+            type: 'mainnet',
+        },
+    ],
+    base: [
+        {
+            id: '8453',
+            name: 'Base Protocol Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['8453'][0],
+            type: 'mainnet',
+        },
+    ],
+    polygon: [
+        {
+            id: '137',
+            name: 'Polygon Mainnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['137'][0],
+            type: 'mainnet',
+        },
+        {
+            id: '1101',
+            name: 'Polygon zkEVM Testnet',
+            url: _a.RPC_LIST_BY_NETWORK_ID['1101'][0],
+            type: 'testnet',
+        },
+        {
+            id: '80002',
+            name: 'Polygon Testnet Amoy',
+            url: _a.RPC_LIST_BY_NETWORK_ID['80002'][0],
+            type: 'testnet',
+        },
+    ],
+};

package/dist/helpers/BSEthereumHelper.d.ts

@@ -1,14 +1,11 @@
-import { Network } from '@cityofzion/blockchain-service';
-import { BSEthereumNetworkId } from '../constants/BSEthereumConstants';
-import { TokenServiceEthereum } from '../services/token/TokenServiceEthereum';
+import { TBSNetwork, TBSNetworkId } from '@cityofzion/blockchain-service';
+import { IBSEthereum, TBSEthereumNetworkId } from '../types';
 export declare class BSEthereumHelper {
-    static tokenService: TokenServiceEthereum;
-    static getNativeAsset(network: Network<BSEthereumNetworkId>): {
+    static getNativeAsset(network: TBSNetwork<TBSEthereumNetworkId>): {
         symbol: string;
         name: string;
         decimals: number;
         hash: string;
     };
-    static getRpcList(network: Network<BSEthereumNetworkId>): string[];
-    static isMainnet(network: Network<BSEthereumNetworkId>): boolean;
+    static isMainnetNetwork<N extends string, A extends TBSNetworkId>(service: IBSEthereum<N, A>): boolean;
 }

package/dist/helpers/BSEthereumHelper.js

@@ -2,20 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSEthereumHelper = void 0;
 const BSEthereumConstants_1 = require("../constants/BSEthereumConstants");
-const TokenServiceEthereum_1 = require("../services/token/TokenServiceEthereum");
 class BSEthereumHelper {
     static getNativeAsset(network) {
         var _a;
         const symbol = (_a = BSEthereumConstants_1.BSEthereumConstants.NATIVE_SYMBOL_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : 'ETH';
-        return { symbol, name: symbol, decimals: 18, hash: this.tokenService.normalizeHash('0x') };
+        return { symbol, name: symbol, decimals: 18, hash: '0x' };
     }
-    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 isMainnetNetwork(service) {
+        return (service.network.type === 'mainnet' && service.availableNetworks.some(network => network.id === service.network.id));
     }
 }
 exports.BSEthereumHelper = BSEthereumHelper;
-BSEthereumHelper.tokenService = new TokenServiceEthereum_1.TokenServiceEthereum();

package/dist/index.d.ts

@@ -2,13 +2,12 @@ export * from './BSEthereum';
 export * from './helpers/BSEthereumHelper';
 export * from './constants/BSEthereumConstants';
 export * from './services/blockchain-data/MoralisBDSEthereum';
-export * from './services/blockchain-data/DoraBDSEthereum';
 export * from './services/blockchain-data/RpcBDSEthereum';
 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';
 export * from './services/token/TokenServiceEthereum';
 export * from './assets/abis/ERC20';
 export * from './assets/abis/ERC721';
+export * from './types';

package/dist/index.js

@@ -18,13 +18,12 @@ __exportStar(require("./BSEthereum"), exports);
 __exportStar(require("./helpers/BSEthereumHelper"), exports);
 __exportStar(require("./constants/BSEthereumConstants"), exports);
 __exportStar(require("./services/blockchain-data/MoralisBDSEthereum"), exports);
-__exportStar(require("./services/blockchain-data/DoraBDSEthereum"), exports);
 __exportStar(require("./services/blockchain-data/RpcBDSEthereum"), 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);
 __exportStar(require("./services/token/TokenServiceEthereum"), exports);
 __exportStar(require("./assets/abis/ERC20"), exports);
 __exportStar(require("./assets/abis/ERC721"), exports);
+__exportStar(require("./types"), exports);

package/dist/services/blockchain-data/MoralisBDSEthereum.d.ts

@@ -1,18 +1,23 @@
-import { BalanceResponse, ContractResponse, Network, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse, FullTransactionsByAddressParams, FullTransactionsByAddressResponse, NftDataService, ExplorerService, ExportTransactionsByAddressParams, TokenService } from '@cityofzion/blockchain-service';
-import { BSEthereumNetworkId } from '../../constants/BSEthereumConstants';
-import { DoraBDSEthereum } from './DoraBDSEthereum';
-export declare class MoralisBDSEthereum extends DoraBDSEthereum {
+import { TBalanceResponse, ContractResponse, TBSToken, TTransactionResponse, TTransactionsByAddressParams, TTransactionsByAddressResponse, TFullTransactionsByAddressParams, TFullTransactionsByAddressResponse, TExportTransactionsByAddressParams, TBSNetwork, TBSNetworkId } from '@cityofzion/blockchain-service';
+import { AxiosInstance } from 'axios';
+import { IBSEthereum, TBSEthereumNetworkId } from '../../types';
+import { RpcBDSEthereum } from './RpcBDSEthereum';
+export declare class MoralisBDSEthereum<N extends string, A extends TBSNetworkId> extends RpcBDSEthereum<N, A> {
     #private;
-    static BASE_URL: string;
-    static SUPPORTED_CHAINS: string[];
-    static getClient(network: Network<BSEthereumNetworkId>): import("axios").AxiosInstance;
-    static isSupported(network: Network<BSEthereumNetworkId>): boolean;
-    constructor(network: Network<BSEthereumNetworkId>, nftDataService: NftDataService, explorerService: ExplorerService, tokenService: TokenService);
-    getBalance(address: string): Promise<BalanceResponse[]>;
-    getTokenInfo(hash: string): Promise<Token>;
-    getTransaction(hash: string): Promise<TransactionResponse>;
-    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
-    getFullTransactionsByAddress({ nextCursor, ...params }: FullTransactionsByAddressParams): Promise<FullTransactionsByAddressResponse>;
-    exportFullTransactionsByAddress(params: ExportTransactionsByAddressParams): Promise<string>;
+    static readonly BASE_URL: string;
+    static readonly FULL_TRANSACTIONS_SUPPORTED_NETWORKS_IDS: TBSEthereumNetworkId[];
+    static readonly FULL_TRANSACTIONS_ERC721_STANDARDS: string[];
+    static readonly FULL_TRANSACTIONS_ERC1155_STANDARDS: string[];
+    static readonly FULL_TRANSACTIONS_ERC20_STANDARDS: string[];
+    static readonly MORALIS_SUPPORTED_NETWORKS_IDS: TBSEthereumNetworkId[];
+    static getClient(network: TBSNetwork<TBSEthereumNetworkId>): AxiosInstance;
+    static isSupported(network: TBSNetwork<TBSEthereumNetworkId>): boolean;
+    constructor(service: IBSEthereum<N, A>);
+    getBalance(address: string): Promise<TBalanceResponse[]>;
+    getTokenInfo(hash: string): Promise<TBSToken>;
+    getTransaction(hash: string): Promise<TTransactionResponse>;
+    getTransactionsByAddress(params: TTransactionsByAddressParams): Promise<TTransactionsByAddressResponse>;
+    getFullTransactionsByAddress({ nextCursor, ...params }: TFullTransactionsByAddressParams): Promise<TFullTransactionsByAddressResponse>;
+    exportFullTransactionsByAddress(params: TExportTransactionsByAddressParams): Promise<string>;
     getContract(hash: string): Promise<ContractResponse>;
 }