@cityofzion/bs-neo3 1.16.3 → 1.17.0

package/dist/BSNeo3.d.ts

@@ -1,40 +1,50 @@
-import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSCalculableFee, BSClaimable, BSWithEncryption, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, ExchangeDataService, ExplorerService, GetLedgerTransport, IBSWithNeo3NeoXBridge, INeo3NeoXBridgeService, ITokenService, Network, NftDataService, Token, TransferParam } from '@cityofzion/blockchain-service';
+import { TBSAccount, TGetLedgerTransport, IBlockchainDataService, IClaimDataService, IExchangeDataService, IExplorerService, INeo3NeoXBridgeService, INftDataService, ITokenService, TBSNetwork, TBSToken, TTransferParam, TPingNetworkResponse, IWalletConnectService } from '@cityofzion/blockchain-service';
 import { NeonDappKitLedgerServiceNeo3 } from './services/ledger/NeonDappKitLedgerServiceNeo3';
-import { BSNeo3NetworkId } from './constants/BSNeo3Constants';
-import { GenerateSigningCallbackResponse, VoteService } from './interfaces';
-export declare class BSNeo3<BSName extends string = string> implements BlockchainService<BSName, BSNeo3NetworkId>, BSClaimable<BSName>, BSWithNameService, BSCalculableFee<BSName>, BSWithNft, BSWithExplorerService, BSWithLedger<BSName>, IBSWithNeo3NeoXBridge<BSName>, BSWithEncryption<BSName> {
+import { IBSNeo3, IVoteService, TBSNeo3NetworkId } from './types';
+import { api, wallet } from './helpers/BSNeo3NeonJsSingletonHelper';
+export declare class BSNeo3<N extends string = string> implements IBSNeo3<N> {
     #private;
-    name: BSName;
-    bip44DerivationPath: string;
-    nativeTokens: Token[];
-    tokens: Token[];
-    feeToken: Token;
-    claimToken: Token;
-    burnToken: Token;
-    blockchainDataService: BlockchainDataService & BDSClaimable;
-    nftDataService: NftDataService;
-    ledgerService: NeonDappKitLedgerServiceNeo3<BSName>;
-    exchangeDataService: ExchangeDataService;
-    explorerService: ExplorerService;
-    voteService: VoteService<BSName>;
-    neo3NeoXBridgeService: INeo3NeoXBridgeService<BSName>;
+    readonly name: N;
+    readonly bip44DerivationPath: string;
+    readonly isMultiTransferSupported = true;
+    readonly isCustomNetworkSupported = true;
+    tokens: TBSToken[];
+    readonly nativeTokens: TBSToken[];
+    readonly feeToken: TBSToken;
+    readonly claimToken: TBSToken;
+    readonly burnToken: TBSToken;
+    network: TBSNetwork<TBSNeo3NetworkId>;
+    availableNetworkURLs: string[];
+    readonly defaultNetwork: TBSNetwork<TBSNeo3NetworkId>;
+    readonly availableNetworks: TBSNetwork<TBSNeo3NetworkId>[];
+    blockchainDataService: IBlockchainDataService;
+    nftDataService: INftDataService;
+    ledgerService: NeonDappKitLedgerServiceNeo3<N>;
+    exchangeDataService: IExchangeDataService;
+    explorerService: IExplorerService;
+    voteService: IVoteService<N>;
+    neo3NeoXBridgeService: INeo3NeoXBridgeService<N>;
     tokenService: ITokenService;
-    network: Network<BSNeo3NetworkId>;
-    constructor(name: BSName, network?: Network<BSNeo3NetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
-    generateSigningCallback(account: Account<BSName>): Promise<GenerateSigningCallbackResponse>;
-    setNetwork(network: Network<BSNeo3NetworkId>): void;
-    testNetwork(network: Network<BSNeo3NetworkId>): Promise<void>;
+    claimDataService: IClaimDataService;
+    walletConnectService: IWalletConnectService;
+    constructor(name: N, network?: TBSNetwork<TBSNeo3NetworkId>, getLedgerTransport?: TGetLedgerTransport<N>);
+    setNetwork(network: TBSNetwork<TBSNeo3NetworkId>): void;
+    pingNetwork(network: TBSNetwork<TBSNeo3NetworkId>): Promise<TPingNetworkResponse>;
+    generateSigningCallback(account: TBSAccount<N>): Promise<{
+        neonJsAccount: wallet.Account;
+        signingCallback: api.SigningFunction;
+    }>;
     validateAddress(address: string): boolean;
     validateEncrypted(encryptedKey: string): boolean;
     validateKey(key: string): boolean;
     validateNameServiceDomainFormat(domainName: string): boolean;
-    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Account<BSName>;
-    generateAccountFromPublicKey(publicKey: string): Account<BSName>;
-    generateAccountFromKey(key: string): Account<BSName>;
-    decrypt(encryptedKey: string, password: string): Promise<Account<BSName>>;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): TBSAccount<N>;
+    generateAccountFromPublicKey(publicKey: string): TBSAccount<N>;
+    generateAccountFromKey(key: string): TBSAccount<N>;
+    decrypt(encryptedKey: string, password: string): Promise<TBSAccount<N>>;
     encrypt(key: string, password: string): Promise<string>;
-    calculateTransferFee(param: TransferParam<BSName>): Promise<string>;
-    transfer(param: TransferParam<BSName>): Promise<string[]>;
-    claim(account: Account<BSName>): Promise<string>;
+    calculateTransferFee(param: TTransferParam<N>): Promise<string>;
+    transfer(param: TTransferParam<N>): Promise<string[]>;
+    claim(account: TBSAccount<N>): Promise<string>;
     resolveNameServiceDomain(domainName: string): Promise<string>;
 }

package/dist/BSNeo3.js

@@ -13,13 +13,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 _BSNeo3_instances, _BSNeo3_setTokens, _BSNeo3_buildTransferInvocation;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeo3 = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
-const bs_asteroid_sdk_1 = require("@cityofzion/bs-asteroid-sdk");
-const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
-const neon_js_1 = require("@cityofzion/neon-js");
 const BSNeo3Helper_1 = require("./helpers/BSNeo3Helper");
 const DoraBDSNeo3_1 = require("./services/blockchain-data/DoraBDSNeo3");
 const FlamingoForthewinEDSNeo3_1 = require("./services/exchange-data/FlamingoForthewinEDSNeo3");
@@ -27,22 +27,83 @@ const DoraESNeo3_1 = require("./services/explorer/DoraESNeo3");
 const NeonDappKitLedgerServiceNeo3_1 = require("./services/ledger/NeonDappKitLedgerServiceNeo3");
 const GhostMarketNDSNeo3_1 = require("./services/nft-data/GhostMarketNDSNeo3");
 const BSNeo3Constants_1 = require("./constants/BSNeo3Constants");
-const RpcBDSNeo3_1 = require("./services/blockchain-data/RpcBDSNeo3");
 const Neo3NeoXBridgeService_1 = require("./services/neo3neoXBridge/Neo3NeoXBridgeService");
 const DoraVoteServiceNeo3_1 = require("./services/vote/DoraVoteServiceNeo3");
 const TokenServiceNeo3_1 = require("./services/token/TokenServiceNeo3");
+const RpcCDSNeo3_1 = require("./services/chaim-data/RpcCDSNeo3");
+const BSNeo3NeonJsSingletonHelper_1 = require("./helpers/BSNeo3NeonJsSingletonHelper");
+const BSNeo3NeonDappKitSingletonHelper_1 = require("./helpers/BSNeo3NeonDappKitSingletonHelper");
+const axios_1 = __importDefault(require("axios"));
+const WalletConnectServiceNeo3_1 = require("./services/wallet-connect/WalletConnectServiceNeo3");
 class BSNeo3 {
     constructor(name, network, getLedgerTransport) {
         _BSNeo3_instances.add(this);
-        network = network !== null && network !== void 0 ? network : BSNeo3Constants_1.BSNeo3Constants.DEFAULT_NETWORK;
+        this.isMultiTransferSupported = true;
+        this.isCustomNetworkSupported = true;
         this.name = name;
         this.ledgerService = new NeonDappKitLedgerServiceNeo3_1.NeonDappKitLedgerServiceNeo3(this, getLedgerTransport);
         this.bip44DerivationPath = BSNeo3Constants_1.BSNeo3Constants.DEFAULT_BIP44_DERIVATION_PATH;
-        this.setNetwork(network);
+        this.nativeTokens = BSNeo3Constants_1.BSNeo3Constants.NATIVE_ASSETS;
+        this.feeToken = BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN;
+        this.burnToken = BSNeo3Constants_1.BSNeo3Constants.NEO_TOKEN;
+        this.claimToken = BSNeo3Constants_1.BSNeo3Constants.GAS_TOKEN;
+        this.availableNetworks = BSNeo3Constants_1.BSNeo3Constants.ALL_NETWORKS;
+        this.defaultNetwork = BSNeo3Constants_1.BSNeo3Constants.MAINNET_NETWORK;
+        this.setNetwork(network !== null && network !== void 0 ? network : this.defaultNetwork);
+    }
+    setNetwork(network) {
+        const availableURLs = BSNeo3Constants_1.BSNeo3Constants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
+        if (network.type === 'custom') {
+            if (typeof network.url !== 'string' || network.url.length === 0) {
+                throw new Error('You must provide a valid url to use a custom network');
+            }
+        }
+        else {
+            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, _BSNeo3_instances, "m", _BSNeo3_setTokens).call(this, network);
+        this.network = network;
+        this.availableNetworkURLs = availableURLs;
+        this.tokenService = new TokenServiceNeo3_1.TokenServiceNeo3();
+        this.nftDataService = new GhostMarketNDSNeo3_1.GhostMarketNDSNeo3(this);
+        this.explorerService = new DoraESNeo3_1.DoraESNeo3(this);
+        this.voteService = new DoraVoteServiceNeo3_1.DoraVoteServiceNeo3(this);
+        this.neo3NeoXBridgeService = new Neo3NeoXBridgeService_1.Neo3NeoXBridgeService(this);
+        this.blockchainDataService = new DoraBDSNeo3_1.DoraBDSNeo3(this);
+        this.exchangeDataService = new FlamingoForthewinEDSNeo3_1.FlamingoForthewinEDSNeo3(this);
+        this.claimDataService = new RpcCDSNeo3_1.RpcCDSNeo3(this);
+        this.walletConnectService = new WalletConnectServiceNeo3_1.WalletConnectServiceNeo3(this);
+    }
+    // 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: 'getblockcount',
+                params: [],
+                id: 1234,
+            }, { timeout: 5000, signal: abortController.signal });
+            clearTimeout(timeout);
+            const latency = Date.now() - timeStart;
+            return {
+                latency,
+                url: network.url,
+                height: response.data.result,
+            };
+        });
     }
     generateSigningCallback(account) {
         return __awaiter(this, void 0, void 0, function* () {
-            const neonJsAccount = new neon_js_1.wallet.Account(account.key);
+            const { wallet, api } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+            const neonJsAccount = new wallet.Account(account.key);
             if (account.isHardware) {
                 if (!this.ledgerService.getLedgerTransport)
                     throw new Error('You must provide a getLedgerTransport function to use Ledger');
@@ -56,51 +117,38 @@ class BSNeo3 {
             }
             return {
                 neonJsAccount,
-                signingCallback: neon_js_1.api.signWithAccount(neonJsAccount),
+                signingCallback: api.signWithAccount(neonJsAccount),
             };
         });
     }
-    setNetwork(network) {
-        __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_setTokens).call(this, network);
-        this.network = network;
-        this.tokenService = new TokenServiceNeo3_1.TokenServiceNeo3();
-        this.nftDataService = new GhostMarketNDSNeo3_1.GhostMarketNDSNeo3(network);
-        this.explorerService = new DoraESNeo3_1.DoraESNeo3(network, this.tokenService);
-        this.voteService = new DoraVoteServiceNeo3_1.DoraVoteServiceNeo3(this);
-        this.neo3NeoXBridgeService = new Neo3NeoXBridgeService_1.Neo3NeoXBridgeService(this);
-        this.blockchainDataService = new DoraBDSNeo3_1.DoraBDSNeo3(network, this.feeToken, this.claimToken, this.tokens, this.nftDataService, this.explorerService, this.tokenService, this.neo3NeoXBridgeService);
-        this.exchangeDataService = new FlamingoForthewinEDSNeo3_1.FlamingoForthewinEDSNeo3(network, this.tokenService);
-    }
-    testNetwork(network) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const blockchainDataServiceClone = new RpcBDSNeo3_1.RpcBDSNeo3(network, this.feeToken, this.claimToken, this.tokens, this.tokenService);
-            yield blockchainDataServiceClone.getBlockHeight();
-        });
-    }
     validateAddress(address) {
-        return neon_js_1.wallet.isAddress(address, 53);
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        return wallet.isAddress(address, 53);
     }
     validateEncrypted(encryptedKey) {
-        return neon_js_1.wallet.isNEP2(encryptedKey);
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        return wallet.isNEP2(encryptedKey);
     }
     validateKey(key) {
-        return neon_js_1.wallet.isWIF(key) || neon_js_1.wallet.isPrivateKey(key);
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        return wallet.isWIF(key) || wallet.isPrivateKey(key);
     }
     validateNameServiceDomainFormat(domainName) {
         return domainName.endsWith('.neo');
     }
     generateAccountFromMnemonic(mnemonic, index) {
-        bs_asteroid_sdk_1.keychain.importMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic);
+        const mnemonicStr = Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic;
         const bip44Path = this.bip44DerivationPath.replace('?', index.toString());
-        const childKey = bs_asteroid_sdk_1.keychain.generateChildKey('neo', bip44Path);
-        const key = childKey.getWIF();
-        const { address } = new neon_js_1.wallet.Account(key);
-        return { address, key, type: 'wif', bip44Path, blockchain: this.name };
+        const key = blockchain_service_1.BSKeychainHelper.generateNeoPrivateKeyFromMnemonic(mnemonicStr, bip44Path);
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        const { address, WIF } = new wallet.Account(key);
+        return { address, key: WIF, type: 'wif', bip44Path, blockchain: this.name };
     }
     generateAccountFromPublicKey(publicKey) {
-        if (!neon_js_1.wallet.isPublicKey(publicKey))
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        if (!wallet.isPublicKey(publicKey))
             throw new Error('Invalid public key');
-        const account = new neon_js_1.wallet.Account(publicKey);
+        const account = new wallet.Account(publicKey);
         return {
             address: account.address,
             key: account.publicKey,
@@ -109,27 +157,31 @@ class BSNeo3 {
         };
     }
     generateAccountFromKey(key) {
-        const type = neon_js_1.wallet.isWIF(key) ? 'wif' : neon_js_1.wallet.isPrivateKey(key) ? 'privateKey' : undefined;
+        const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+        const type = wallet.isWIF(key) ? 'wif' : wallet.isPrivateKey(key) ? 'privateKey' : undefined;
         if (!type)
             throw new Error('Invalid key');
-        const { address } = new neon_js_1.wallet.Account(key);
+        const { address } = new wallet.Account(key);
         return { address, key, type, blockchain: this.name };
     }
     decrypt(encryptedKey, password) {
         return __awaiter(this, void 0, void 0, function* () {
-            const key = yield neon_js_1.wallet.decrypt(encryptedKey, password);
+            const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+            const key = yield wallet.decrypt(encryptedKey, password);
             return this.generateAccountFromKey(key);
         });
     }
     encrypt(key, password) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield neon_js_1.wallet.encrypt(key, password);
+            const { wallet } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+            return yield wallet.encrypt(key, password);
         });
     }
     calculateTransferFee(param) {
         return __awaiter(this, void 0, void 0, function* () {
             const { neonJsAccount } = yield this.generateSigningCallback(param.senderAccount);
-            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+            const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({
                 rpcAddress: this.network.url,
                 account: neonJsAccount,
             });
@@ -144,7 +196,8 @@ class BSNeo3 {
     transfer(param) {
         return __awaiter(this, void 0, void 0, function* () {
             const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(param.senderAccount);
-            const invoker = yield neon_dappkit_1.NeonInvoker.init({
+            const { NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({
                 rpcAddress: this.network.url,
                 account: neonJsAccount,
                 signingCallback: signingCallback,
@@ -160,17 +213,18 @@ class BSNeo3 {
     claim(account) {
         return __awaiter(this, void 0, void 0, function* () {
             const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(account);
-            const facade = yield neon_js_1.api.NetworkFacade.fromConfig({ node: this.network.url });
+            const { api } = BSNeo3NeonJsSingletonHelper_1.BSNeo3NeonJsSingletonHelper.getInstance();
+            const facade = yield api.NetworkFacade.fromConfig({ node: this.network.url });
             return yield facade.claimGas(neonJsAccount, {
                 signingCallback: signingCallback,
             });
         });
     }
     resolveNameServiceDomain(domainName) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const parser = neon_dappkit_1.NeonParser;
-            const invoker = yield neon_dappkit_1.NeonInvoker.init({ rpcAddress: this.network.url });
+            var _a;
+            const { NeonParser, NeonInvoker } = BSNeo3NeonDappKitSingletonHelper_1.BSNeo3NeonDappKitSingletonHelper.getInstance();
+            const invoker = yield NeonInvoker.init({ rpcAddress: this.network.url });
             const response = yield invoker.testInvoke({
                 invocations: [
                     {
@@ -183,23 +237,19 @@ class BSNeo3 {
             if (response.stack.length === 0) {
                 throw new Error((_a = response.exception) !== null && _a !== void 0 ? _a : 'unrecognized response');
             }
-            const parsed = parser.parseRpcResponse(response.stack[0], {
+            const parsed = NeonParser.parseRpcResponse(response.stack[0], {
                 type: 'Hash160',
             });
-            return parser.accountInputToAddress(parsed.replace('0x', ''));
+            return NeonParser.accountInputToAddress(parsed.replace('0x', ''));
         });
     }
 }
 exports.BSNeo3 = BSNeo3;
 _BSNeo3_instances = new WeakSet(), _BSNeo3_setTokens = function _BSNeo3_setTokens(network) {
     const tokens = BSNeo3Helper_1.BSNeo3Helper.getTokens(network);
-    this.nativeTokens = BSNeo3Constants_1.BSNeo3Constants.NATIVE_ASSETS;
     this.tokens = tokens;
-    this.feeToken = tokens.find(token => token.symbol === 'GAS');
-    this.burnToken = tokens.find(token => token.symbol === 'NEO');
-    this.claimToken = tokens.find(token => token.symbol === 'GAS');
-}, _BSNeo3_buildTransferInvocation = function _BSNeo3_buildTransferInvocation({ intents, tipIntent }, account) {
-    return __awaiter(this, void 0, void 0, function* () {
+}, _BSNeo3_buildTransferInvocation = function _BSNeo3_buildTransferInvocation(_a, account_1) {
+    return __awaiter(this, arguments, void 0, function* ({ intents, tipIntent }, account) {
         const concatIntents = [...intents, ...(tipIntent ? [tipIntent] : [])];
         const invocations = [];
         for (const intent of concatIntents) {
@@ -209,7 +259,7 @@ _BSNeo3_instances = new WeakSet(), _BSNeo3_setTokens = function _BSNeo3_setToken
                     const token = yield this.blockchainDataService.getTokenInfo(intent.tokenHash);
                     decimals = token.decimals;
                 }
-                catch (error) {
+                catch (_b) {
                     decimals = 8;
                 }
             }

package/dist/constants/BSNeo3Constants.d.ts

@@ -1,19 +1,14 @@
-import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
-export type BSNeo3NetworkId = NetworkId<'mainnet' | 'testnet'>;
+import { TBSNetwork, TBSToken } from '@cityofzion/blockchain-service';
+import { TBSNeo3NetworkId } from '../types';
 export declare class BSNeo3Constants {
-    #private;
-    static EXTRA_TOKENS_BY_NETWORK_ID: Partial<Record<BSNeo3NetworkId, Token[]>>;
-    static NATIVE_ASSETS: Token[];
-    static GAS_TOKEN: Token;
-    static NEO_TOKEN: Token;
-    static RPC_LIST_BY_NETWORK_ID: Partial<Record<BSNeo3NetworkId, string[]>>;
-    static MAINNET_NETWORK_IDS: BSNeo3NetworkId[];
-    static TESTNET_NETWORK_IDS: BSNeo3NetworkId[];
-    static ALL_NETWORK_IDS: BSNeo3NetworkId[];
-    static MAINNET_NETWORKS: Network<BSNeo3NetworkId>[];
-    static TESTNET_NETWORKS: Network<BSNeo3NetworkId>[];
-    static ALL_NETWORKS: Network<BSNeo3NetworkId>[];
-    static DEFAULT_NETWORK: Network<BSNeo3NetworkId>;
-    static NEO_NS_HASH: string;
-    static DEFAULT_BIP44_DERIVATION_PATH: string;
+    static readonly EXTRA_TOKENS_BY_NETWORK_ID: Partial<Record<TBSNeo3NetworkId, TBSToken[]>>;
+    static readonly GAS_TOKEN: TBSToken;
+    static readonly NEO_TOKEN: TBSToken;
+    static readonly NATIVE_ASSETS: TBSToken[];
+    static readonly RPC_LIST_BY_NETWORK_ID: Partial<Record<TBSNeo3NetworkId, string[]>>;
+    static readonly MAINNET_NETWORK: TBSNetwork<TBSNeo3NetworkId>;
+    static readonly TESTNET_NETWORK: TBSNetwork<TBSNeo3NetworkId>;
+    static readonly ALL_NETWORKS: TBSNetwork<TBSNeo3NetworkId>[];
+    static readonly NEO_NS_HASH = "0x50ac1c37690cc2cfc594472833cf57505d5f46de";
+    static readonly DEFAULT_BIP44_DERIVATION_PATH = "m/44'/888'/0'/0/?";
 }