@cityofzion/bs-neo3 1.3.2 → 1.4.0

package/dist/BSNeo3.d.ts

@@ -1,11 +1,13 @@
-import { Account, AccountWithDerivationPath, BDSClaimable, BlockchainDataService, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, BSWithSwap, ExchangeDataService, ExplorerService, Network, NftDataService, SwapService, Token, TransferParam } from '@cityofzion/blockchain-service';
+import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, BSWithSwap, ExchangeDataService, ExplorerService, Network, NftDataService, SwapService, Token, TransferParam } from '@cityofzion/blockchain-service';
+import Neon from '@cityofzion/neon-core';
+import { api } from '@cityofzion/neon-js';
 import Transport from '@ledgerhq/hw-transport';
-import { BSNeo3NetworkId } from './helpers/BSNeo3Helper';
 import { NeonDappKitLedgerServiceNeo3 } from './services/ledger/NeonDappKitLedgerServiceNeo3';
+import { BSNeo3NetworkId } from './constants/BSNeo3Constants';
 export declare class BSNeo3<BSCustomName extends string = string> implements BlockchainService<BSCustomName, BSNeo3NetworkId>, BSClaimable, BSWithNameService, BSCalculableFee, BSWithNft, BSWithExplorerService, BSWithLedger, BSWithSwap<BSNeo3NetworkId> {
     #private;
     blockchainName: BSCustomName;
-    derivationPath: string;
+    bip44DerivationPath: string;
     tokens: Token[];
     feeToken: Token;
     claimToken: Token;
@@ -17,19 +19,23 @@ export declare class BSNeo3<BSCustomName extends string = string> implements Blo
     explorerService: ExplorerService;
     network: Network<BSNeo3NetworkId>;
     constructor(blockchainName: BSCustomName, network?: Network<BSNeo3NetworkId>, getLedgerTransport?: (account: Account) => Promise<Transport>);
+    generateSigningCallback(account: Account, isLedger?: boolean): Promise<{
+        neonJsAccount: Neon.wallet.Account;
+        signingCallback: api.SigningFunction;
+    }>;
     createSwapService(): SwapService<BSNeo3NetworkId>;
     setNetwork(network: Network<BSNeo3NetworkId>): void;
     validateAddress(address: string): boolean;
     validateEncrypted(encryptedKey: string): boolean;
     validateKey(key: string): boolean;
     validateNameServiceDomainFormat(domainName: string): boolean;
-    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath;
+    generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Account;
     generateAccountFromPublicKey(publicKey: string): Account;
     generateAccountFromKey(key: string): Account;
     decrypt(encryptedKey: string, password: string): Promise<Account>;
     encrypt(key: string, password: string): Promise<string>;
     calculateTransferFee(param: TransferParam): Promise<string>;
-    transfer(param: TransferParam): Promise<string>;
+    transfer(param: TransferParam): Promise<string[]>;
     claim(account: Account, isLedger?: boolean): Promise<string>;
     resolveNameServiceDomain(domainName: string): Promise<any>;
 }

package/dist/BSNeo3.js

@@ -26,17 +26,38 @@ const DoraESNeo3_1 = require("./services/explorer/DoraESNeo3");
 const NeonDappKitLedgerServiceNeo3_1 = require("./services/ledger/NeonDappKitLedgerServiceNeo3");
 const GhostMarketNDSNeo3_1 = require("./services/nft-data/GhostMarketNDSNeo3");
 const FlamingoSwapServiceNeo3_1 = require("./services/swap/FlamingoSwapServiceNeo3");
+const BSNeo3Constants_1 = require("./constants/BSNeo3Constants");
 class BSNeo3 {
     constructor(blockchainName, network, getLedgerTransport) {
         _BSNeo3_instances.add(this);
-        network = network !== null && network !== void 0 ? network : BSNeo3Helper_1.BSNeo3Helper.DEFAULT_NETWORK;
+        network = network !== null && network !== void 0 ? network : BSNeo3Constants_1.BSNeo3Constants.DEFAULT_NETWORK;
         this.blockchainName = blockchainName;
-        this.ledgerService = new NeonDappKitLedgerServiceNeo3_1.NeonDappKitLedgerServiceNeo3(getLedgerTransport);
-        this.derivationPath = BSNeo3Helper_1.BSNeo3Helper.DERIVATION_PATH;
+        this.ledgerService = new NeonDappKitLedgerServiceNeo3_1.NeonDappKitLedgerServiceNeo3(this, getLedgerTransport);
+        this.bip44DerivationPath = BSNeo3Constants_1.BSNeo3Constants.DEFAULT_BIP44_DERIVATION_PATH;
         this.setNetwork(network);
     }
+    generateSigningCallback(account, isLedger) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const neonJsAccount = new neon_js_1.wallet.Account(account.key);
+            if (isLedger) {
+                if (!this.ledgerService.getLedgerTransport)
+                    throw new Error('You must provide a getLedgerTransport function to use Ledger');
+                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 {
+                    neonJsAccount,
+                    signingCallback: this.ledgerService.getSigningCallback(ledgerTransport, account),
+                };
+            }
+            return {
+                neonJsAccount,
+                signingCallback: neon_js_1.api.signWithAccount(neonJsAccount),
+            };
+        });
+    }
     createSwapService() {
-        return new FlamingoSwapServiceNeo3_1.FlamingoSwapServiceNeo3(this.network, this.ledgerService);
+        return new FlamingoSwapServiceNeo3_1.FlamingoSwapServiceNeo3(this.network, this);
     }
     setNetwork(network) {
         __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_setTokens).call(this, network);
@@ -62,11 +83,11 @@ class BSNeo3 {
     }
     generateAccountFromMnemonic(mnemonic, index) {
         bs_asteroid_sdk_1.keychain.importMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic);
-        const path = this.derivationPath.replace('?', index.toString());
-        const childKey = bs_asteroid_sdk_1.keychain.generateChildKey('neo', path);
+        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', derivationPath: path };
+        return { address, key, type: 'wif', bip44Path };
     }
     generateAccountFromPublicKey(publicKey) {
         if (!neon_js_1.wallet.isPublicKey(publicKey))
@@ -99,12 +120,12 @@ class BSNeo3 {
     }
     calculateTransferFee(param) {
         return __awaiter(this, void 0, void 0, function* () {
-            const account = new neon_js_1.wallet.Account(param.senderAccount.key);
+            const { neonJsAccount } = yield this.generateSigningCallback(param.senderAccount, param.isLedger);
             const invoker = yield neon_dappkit_1.NeonInvoker.init({
                 rpcAddress: this.network.url,
-                account,
+                account: neonJsAccount,
             });
-            const invocations = __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, account);
+            const invocations = __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, neonJsAccount);
             const { total } = yield invoker.calculateFee({
                 invocations,
                 signers: [],
@@ -114,40 +135,26 @@ class BSNeo3 {
     }
     transfer(param) {
         return __awaiter(this, void 0, void 0, function* () {
-            let ledgerTransport;
-            if (param.isLedger) {
-                if (!this.ledgerService.getLedgerTransport)
-                    throw new Error('You must provide a getLedgerTransport function to use Ledger');
-                ledgerTransport = yield this.ledgerService.getLedgerTransport(param.senderAccount);
-            }
-            const account = new neon_js_1.wallet.Account(param.senderAccount.key);
+            const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(param.senderAccount, param.isLedger);
             const invoker = yield neon_dappkit_1.NeonInvoker.init({
                 rpcAddress: this.network.url,
-                account,
-                signingCallback: ledgerTransport ? this.ledgerService.getSigningCallback(ledgerTransport) : undefined,
+                account: neonJsAccount,
+                signingCallback: signingCallback,
             });
-            const invocations = __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, account);
+            const invocations = __classPrivateFieldGet(this, _BSNeo3_instances, "m", _BSNeo3_buildTransferInvocation).call(this, param, neonJsAccount);
             const transactionHash = yield invoker.invokeFunction({
                 invocations,
                 signers: [],
             });
-            return transactionHash;
+            return [transactionHash];
         });
     }
     claim(account, isLedger) {
         return __awaiter(this, void 0, void 0, function* () {
-            let ledgerTransport;
-            if (isLedger) {
-                if (!this.ledgerService.getLedgerTransport)
-                    throw new Error('You must provide a getLedgerTransport function to use Ledger');
-                ledgerTransport = yield this.ledgerService.getLedgerTransport(account);
-            }
-            const neoAccount = new neon_js_1.wallet.Account(account.key);
+            const { neonJsAccount, signingCallback } = yield this.generateSigningCallback(account, isLedger);
             const facade = yield neon_js_1.api.NetworkFacade.fromConfig({ node: this.network.url });
-            const transactionHash = yield facade.claimGas(neoAccount, {
-                signingCallback: ledgerTransport
-                    ? this.ledgerService.getSigningCallback(ledgerTransport)
-                    : neon_js_1.api.signWithAccount(neoAccount),
+            const transactionHash = yield facade.claimGas(neonJsAccount, {
+                signingCallback: signingCallback,
             });
             return transactionHash;
         });
@@ -160,7 +167,7 @@ class BSNeo3 {
             const response = yield invoker.testInvoke({
                 invocations: [
                     {
-                        scriptHash: BSNeo3Helper_1.BSNeo3Helper.NEO_NS_HASH,
+                        scriptHash: BSNeo3Constants_1.BSNeo3Constants.NEO_NS_HASH,
                         operation: 'ownerOf',
                         args: [{ type: 'String', value: domainName }],
                     },
@@ -184,9 +191,9 @@ _BSNeo3_instances = new WeakSet(), _BSNeo3_setTokens = function _BSNeo3_setToken
     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({ intent, tipIntent }, account) {
-    const intents = [intent, ...(tipIntent ? [tipIntent] : [])];
-    const invocations = intents.map(intent => {
+}, _BSNeo3_buildTransferInvocation = function _BSNeo3_buildTransferInvocation({ intents, tipIntent }, account) {
+    const concatIntents = [...intents, ...(tipIntent ? [tipIntent] : [])];
+    const invocations = concatIntents.map(intent => {
         return {
             operation: 'transfer',
             scriptHash: intent.tokenHash,

package/dist/builder/invocation/FlamingoSwapInvocationBuilderNeo3.d.ts

@@ -1,6 +1,6 @@
 import { SwapServiceSwapToReceiveArgs, SwapServiceSwapToUseArgs } from '@cityofzion/blockchain-service';
 import { ContractInvocationMulti } from '@cityofzion/neon-dappkit-types';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 export declare class FlamingoSwapInvocationBuilderNeo3 {
     #private;
     static swapInvocation(data: SwapServiceSwapToReceiveArgs<BSNeo3NetworkId> | SwapServiceSwapToUseArgs<BSNeo3NetworkId>): ContractInvocationMulti;

package/dist/builder/invocation/FlamingoSwapInvocationBuilderNeo3.js

@@ -23,9 +23,10 @@ _a = FlamingoSwapInvocationBuilderNeo3, _FlamingoSwapInvocationBuilderNeo3_build
     const [tokenToUse] = routePath;
     const tokenToReceive = routePath[routePath.length - 1];
     const scriptHashes = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapScriptHashes(network);
-    const tokenToReceiveOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToReceive);
     const invocations = [];
-    const allowedContracts = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts).call(this, scriptHashes, routePath);
+    const allowedContracts = [];
+    const tokenToReceiveOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToReceive);
+    const routePathOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideRoutePath(network, routePath);
     const amountToReceiveFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(amountToReceive, tokenToReceiveOverrode.decimals);
     const maximumSellingFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(maximumSelling, tokenToUse.decimals);
     const swapInvocation = NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.swapTokenOutForTokenInContractInvocation({
@@ -34,13 +35,16 @@ _a = FlamingoSwapInvocationBuilderNeo3, _FlamingoSwapInvocationBuilderNeo3_build
         amountToReceive: amountToReceiveFormatted,
         maximumSelling: maximumSellingFormatted,
         deadline,
-        args: __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs).call(this, routePath),
+        args: __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs).call(this, routePathOverrode),
     });
     invocations.push(swapInvocation);
+    allowedContracts.push(...__classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts).call(this, scriptHashes, routePath));
     if (FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, tokenToReceive)) {
         const amountToReceiveTransfer = neon_core_1.u.BigInteger.fromNumber(Number(amountToReceiveFormatted) * FlamingoSwapConstants_1.FlamingoSwapConstants.GAS_PER_NEO).toString();
-        const neoTransferInvocation = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation).call(this, address, amountToReceiveTransfer, network);
+        const gasHash = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, 'GAS').hash;
+        const neoTransferInvocation = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation).call(this, address, gasHash, amountToReceiveTransfer, network);
         invocations.push(neoTransferInvocation);
+        allowedContracts.push(FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapPool(network, 'FLP-bNEO-GAS').hash);
     }
     return {
         invocations,
@@ -51,12 +55,16 @@ _a = FlamingoSwapInvocationBuilderNeo3, _FlamingoSwapInvocationBuilderNeo3_build
     const tokenToReceive = routePath[routePath.length - 1];
     const scriptHashes = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapScriptHashes(network);
     const invocations = [];
-    const allowedContracts = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts).call(this, scriptHashes, routePath);
+    const allowedContracts = [];
     if (FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, tokenToUse)) {
-        const neoTransferInvocation = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation).call(this, address, amountToUse, network);
+        const neoHash = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, 'NEO').hash;
+        const neoTransferInvocation = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation).call(this, address, neoHash, amountToUse, network);
         invocations.push(neoTransferInvocation);
+        allowedContracts.push(FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapPool(network, 'FLP-bNEO-GAS').hash);
     }
-    const amountToUseFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(amountToUse, tokenToUse.decimals);
+    const tokenToUseOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideToken(network, tokenToUse);
+    const routePathOverrode = FlamingoSwapHelper_1.FlamingoSwapHelper.overrideRoutePath(network, routePath);
+    const amountToUseFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(amountToUse, tokenToUseOverrode.decimals);
     const minimumReceivedFormatted = FlamingoSwapHelper_1.FlamingoSwapHelper.formatAmount(minimumReceived, tokenToReceive.decimals);
     const swapInvocation = NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.swapTokenInForTokenOutContractInvocation({
         routerScriptHash: scriptHashes.flamingoSwapRouter,
@@ -64,9 +72,10 @@ _a = FlamingoSwapInvocationBuilderNeo3, _FlamingoSwapInvocationBuilderNeo3_build
         minimumReceived: minimumReceivedFormatted,
         senderAddress: address,
         deadline,
-        args: __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs).call(this, routePath),
+        args: __classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_mapRoutePathToArgs).call(this, routePathOverrode),
     });
     invocations.push(swapInvocation);
+    allowedContracts.push(...__classPrivateFieldGet(this, _a, "m", _FlamingoSwapInvocationBuilderNeo3_getAllowedContracts).call(this, scriptHashes, routePath));
     return {
         invocations,
         signers: [{ scopes: neon_core_1.tx.WitnessScope.CustomContracts, allowedContracts }],
@@ -83,13 +92,12 @@ _a = FlamingoSwapInvocationBuilderNeo3, _FlamingoSwapInvocationBuilderNeo3_build
         scriptHashes.flamingoPairWhiteList,
         ...routePath.map(token => token.hash),
     ];
-}, _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation = function _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation(address, amount, network) {
+}, _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation = function _FlamingoSwapInvocationBuilderNeo3_buildNEOTransferInvocation(senderAddress, contractHash, amount, network) {
     const bNEO = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, 'bNEO');
-    const GAS = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, 'GAS');
     return NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.transferContractInvocation({
-        senderAddress: address,
-        amount,
+        contractHash,
         tokenHash: bNEO.hash,
-        contractHash: GAS.hash,
+        senderAddress,
+        amount,
     });
 };

package/dist/constants/BSNeo3Constants.d.ts

@@ -0,0 +1,15 @@
+import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
+export type BSNeo3NetworkId = NetworkId<'mainnet' | 'testnet'>;
+export declare class BSNeo3Constants {
+    static EXTRA_TOKENS_BY_NETWORK_ID: Partial<Record<BSNeo3NetworkId, 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;
+}

package/dist/constants/BSNeo3Constants.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSNeo3Constants = void 0;
+const mainnet_json_1 = __importDefault(require("../assets/tokens/mainnet.json"));
+class BSNeo3Constants {
+}
+exports.BSNeo3Constants = BSNeo3Constants;
+_a = BSNeo3Constants;
+BSNeo3Constants.EXTRA_TOKENS_BY_NETWORK_ID = {
+    mainnet: mainnet_json_1.default,
+};
+BSNeo3Constants.RPC_LIST_BY_NETWORK_ID = {
+    mainnet: [
+        'https://mainnet1.neo.coz.io:443',
+        'https://mainnet4.neo.coz.io:443',
+        'http://seed1.neo.org:10332',
+        'http://seed2.neo.org:10332',
+        'https://mainnet2.neo.coz.io:443',
+        'https://mainnet5.neo.coz.io:443',
+        'https://mainnet3.neo.coz.io:443',
+        'https://rpc10.n3.nspcc.ru:10331',
+        'https://neo1-nodes.ghostmarket.io:443',
+    ],
+    testnet: [
+        'https://testnet1.neo.coz.io:443',
+        'https://testnet2.neo.coz.io:443',
+        'https://rpc.t5.n3.nspcc.ru:20331',
+        'http://seed1t5.neo.org:20332',
+        'http://seed2t5.neo.org:20332',
+        'http://seed3t5.neo.org:20332',
+        'http://seed4t5.neo.org:20332',
+        'http://seed5t5.neo.org:20332',
+    ],
+};
+BSNeo3Constants.MAINNET_NETWORK_IDS = ['mainnet'];
+BSNeo3Constants.TESTNET_NETWORK_IDS = ['testnet'];
+BSNeo3Constants.ALL_NETWORK_IDS = [..._a.MAINNET_NETWORK_IDS, ..._a.TESTNET_NETWORK_IDS];
+BSNeo3Constants.MAINNET_NETWORKS = [
+    {
+        id: 'mainnet',
+        name: 'Mainnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['mainnet'][0],
+    },
+];
+BSNeo3Constants.TESTNET_NETWORKS = [
+    {
+        id: 'testnet',
+        name: 'Testnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['testnet'][0],
+    },
+];
+BSNeo3Constants.ALL_NETWORKS = [..._a.MAINNET_NETWORKS, ..._a.TESTNET_NETWORKS];
+BSNeo3Constants.DEFAULT_NETWORK = _a.MAINNET_NETWORKS[0];
+BSNeo3Constants.NEO_NS_HASH = '0x50ac1c37690cc2cfc594472833cf57505d5f46de';
+BSNeo3Constants.DEFAULT_BIP44_DERIVATION_PATH = "m/44'/888'/0'/0/?";

package/dist/constants/FlamingoSwapConstants.d.ts

@@ -1,6 +1,6 @@
 import { Token } from '@cityofzion/blockchain-service';
 import BigNumber from 'bignumber.js';
-import { BSNeo3NetworkId } from '../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from './BSNeo3Constants';
 export type FlamingoSwapScriptHashes = {
     flamingoSwapRouter: string;
     flamingoPairWhiteList: string;

package/dist/constants/FlamingoSwapConstants.js

@@ -178,12 +178,6 @@ FlamingoSwapConstants.MAINNET_FLAMINGO_SWAP_TOKENS = {
         hash: '0x8c07b4c9f5bc170a3922eac4f5bb7ef17b0acc8b',
         name: 'LRB',
     },
-    USDL: {
-        symbol: 'USDL',
-        decimals: 8,
-        hash: '0xa8c51aa0c177187aeed3db88bdfa908ccbc9b1a5',
-        name: 'USDL',
-    },
     SOM: {
         symbol: 'SOM',
         decimals: 8,
@@ -666,12 +660,6 @@ FlamingoSwapConstants.MAINNET_FLAMINGO_SWAP_POOLS = {
         hash: '0x1f86bab6d548a3bd4e9292be0937c074da78ab77',
         tokens: [_a.FLAMINGO_SWAP_TOKENS.mainnet.LRB, _a.FLAMINGO_SWAP_TOKENS.mainnet.FLM],
     },
-    'FRP-FLM-USDL': {
-        symbol: 'FRP-FLM-USDL',
-        decimals: 8,
-        hash: '0x33a1e91d8187d6f62b5b2c9847b450c90d770b32',
-        tokens: [_a.FLAMINGO_SWAP_TOKENS.mainnet.USDL, _a.FLAMINGO_SWAP_TOKENS.mainnet.FLM],
-    },
     'FLP-FLM-FUSD': {
         symbol: 'FLP-FLM-FUSD',
         decimals: 8,

package/dist/helpers/BSNeo3Helper.d.ts

@@ -1,22 +1,7 @@
-import { Network, NetworkId } from '@cityofzion/blockchain-service';
-export type BSNeo3NetworkId = NetworkId<'mainnet' | 'testnet'>;
+import { Network } from '@cityofzion/blockchain-service';
+import { BSNeo3NetworkId } from '../constants/BSNeo3Constants';
 export declare class BSNeo3Helper {
-    #private;
-    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 DERIVATION_PATH: string;
-    static getTokens(network: Network<BSNeo3NetworkId>): {
-        symbol: string;
-        name: string;
-        hash: string;
-        decimals: number;
-    }[];
+    static getTokens(network: Network<BSNeo3NetworkId>): import("@cityofzion/blockchain-service").Token[];
     static getRpcList(network: Network<BSNeo3NetworkId>): string[];
     static isMainnet(network: Network<BSNeo3NetworkId>): boolean;
     static isCustomNet(network: Network<BSNeo3NetworkId>): boolean;

package/dist/helpers/BSNeo3Helper.js

@@ -1,83 +1,29 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _a, _BSNeo3Helper_EXTRA_TOKENS_BY_NETWORK_ID, _BSNeo3Helper_RPC_LIST_BY_NETWORK_ID;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeo3Helper = void 0;
 const common_json_1 = __importDefault(require("../assets/tokens/common.json"));
-const mainnet_json_1 = __importDefault(require("../assets/tokens/mainnet.json"));
+const BSNeo3Constants_1 = require("../constants/BSNeo3Constants");
 class BSNeo3Helper {
     static getTokens(network) {
-        var _b;
-        const extraTokens = (_b = __classPrivateFieldGet(this, _a, "f", _BSNeo3Helper_EXTRA_TOKENS_BY_NETWORK_ID)[network.id]) !== null && _b !== void 0 ? _b : [];
+        var _a;
+        const extraTokens = (_a = BSNeo3Constants_1.BSNeo3Constants.EXTRA_TOKENS_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : [];
         return [...extraTokens, ...common_json_1.default];
     }
     static getRpcList(network) {
-        var _b;
-        return (_b = __classPrivateFieldGet(this, _a, "f", _BSNeo3Helper_RPC_LIST_BY_NETWORK_ID)[network.id]) !== null && _b !== void 0 ? _b : [];
+        var _a;
+        return (_a = BSNeo3Constants_1.BSNeo3Constants.RPC_LIST_BY_NETWORK_ID[network.id]) !== null && _a !== void 0 ? _a : [];
     }
     static isMainnet(network) {
-        return this.MAINNET_NETWORK_IDS.includes(network.id);
+        return BSNeo3Constants_1.BSNeo3Constants.MAINNET_NETWORK_IDS.includes(network.id);
     }
     static isCustomNet(network) {
-        return !this.ALL_NETWORK_IDS.includes(network.id);
+        return !BSNeo3Constants_1.BSNeo3Constants.ALL_NETWORK_IDS.includes(network.id);
     }
     static normalizeHash(hash) {
         return hash.startsWith('0x') ? hash.slice(2) : hash;
     }
 }
 exports.BSNeo3Helper = BSNeo3Helper;
-_a = BSNeo3Helper;
-_BSNeo3Helper_EXTRA_TOKENS_BY_NETWORK_ID = { value: {
-        mainnet: mainnet_json_1.default,
-    } };
-_BSNeo3Helper_RPC_LIST_BY_NETWORK_ID = { value: {
-        mainnet: [
-            'https://mainnet1.neo.coz.io:443',
-            'https://mainnet4.neo.coz.io:443',
-            'http://seed1.neo.org:10332',
-            'http://seed2.neo.org:10332',
-            'https://mainnet2.neo.coz.io:443',
-            'https://mainnet5.neo.coz.io:443',
-            'https://mainnet3.neo.coz.io:443',
-            'https://rpc10.n3.nspcc.ru:10331',
-            'https://neo1-nodes.ghostmarket.io:443',
-        ],
-        testnet: [
-            'https://testnet1.neo.coz.io:443',
-            'https://testnet2.neo.coz.io:443',
-            'https://rpc.t5.n3.nspcc.ru:20331',
-            'http://seed1t5.neo.org:20332',
-            'http://seed2t5.neo.org:20332',
-            'http://seed3t5.neo.org:20332',
-            'http://seed4t5.neo.org:20332',
-            'http://seed5t5.neo.org:20332',
-        ],
-    } };
-BSNeo3Helper.MAINNET_NETWORK_IDS = ['mainnet'];
-BSNeo3Helper.TESTNET_NETWORK_IDS = ['testnet'];
-BSNeo3Helper.ALL_NETWORK_IDS = [..._a.MAINNET_NETWORK_IDS, ..._a.TESTNET_NETWORK_IDS];
-BSNeo3Helper.MAINNET_NETWORKS = [
-    {
-        id: 'mainnet',
-        name: 'Mainnet',
-        url: __classPrivateFieldGet(_a, _a, "f", _BSNeo3Helper_RPC_LIST_BY_NETWORK_ID)['mainnet'][0],
-    },
-];
-BSNeo3Helper.TESTNET_NETWORKS = [
-    {
-        id: 'testnet',
-        name: 'Testnet',
-        url: __classPrivateFieldGet(_a, _a, "f", _BSNeo3Helper_RPC_LIST_BY_NETWORK_ID)['testnet'][0],
-    },
-];
-BSNeo3Helper.ALL_NETWORKS = [..._a.MAINNET_NETWORKS, ..._a.TESTNET_NETWORKS];
-BSNeo3Helper.DEFAULT_NETWORK = _a.MAINNET_NETWORKS[0];
-BSNeo3Helper.NEO_NS_HASH = '0x50ac1c37690cc2cfc594472833cf57505d5f46de';
-BSNeo3Helper.DERIVATION_PATH = "m/44'/888'/0'/0/?";

package/dist/helpers/FlamingoSwapHelper.d.ts

@@ -1,7 +1,7 @@
 import { Network, SwapRoute, Token } from '@cityofzion/blockchain-service';
 import BigNumber from 'bignumber.js';
 import { FlamingoSwapPoolInfo, FlamingoSwapPools, FlamingoSwapScriptHashes, FlamingoSwapTokens } from '../constants/FlamingoSwapConstants';
-import { BSNeo3NetworkId } from './BSNeo3Helper';
+import { BSNeo3NetworkId } from '../constants/BSNeo3Constants';
 export declare class FlamingoSwapHelper {
     static listSwappableTokensSymbol(network: Network<BSNeo3NetworkId>): string[];
     static getFlamingoSwapPools(network: Network<BSNeo3NetworkId>): FlamingoSwapPools;
@@ -14,6 +14,7 @@ export declare class FlamingoSwapHelper {
     static overrideAmountInput(network: Network<BSNeo3NetworkId>, amount: string, token: Token): BigNumber;
     static overrideAmountToDisplay(network: Network<BSNeo3NetworkId>, amount: string, token: Token): string;
     static overrideRoute(network: Network<BSNeo3NetworkId>, route: SwapRoute[]): SwapRoute[];
+    static overrideRoutePath(network: Network<BSNeo3NetworkId>, routePath: Token[]): Token[];
     static normalizeHash(hash: string): string;
     static isNeoToken(network: Network<BSNeo3NetworkId>, token: Token): boolean;
     static formatAmount(amount: string, decimals: number): string;

package/dist/helpers/FlamingoSwapHelper.js

@@ -74,6 +74,10 @@ class FlamingoSwapHelper {
         }
         return overrodeRoute;
     }
+    static overrideRoutePath(network, routePath) {
+        const overrodeRoutePath = routePath.map(token => this.overrideToken(network, token));
+        return overrodeRoutePath.filter((item, index, arr) => arr.indexOf(item) === index);
+    }
     static normalizeHash(hash) {
         return hash.startsWith('0x') ? hash.slice(2) : hash;
     }

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

@@ -1,6 +1,6 @@
 import { BalanceResponse, ContractResponse, Network, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
 import { RpcBDSNeo3 } from './RpcBDSNeo3';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 export declare class DoraBDSNeo3 extends RpcBDSNeo3 {
     constructor(network: Network<BSNeo3NetworkId>, feeToken: Token, claimToken: Token, tokens: Token[]);
     getTransaction(hash: string): Promise<TransactionResponse>;

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

@@ -1,5 +1,5 @@
 import { BDSClaimable, BalanceResponse, BlockchainDataService, ContractResponse, Network, RpcResponse, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 export declare class RpcBDSNeo3 implements BlockchainDataService, BDSClaimable {
     readonly _tokenCache: Map<string, Token>;
     readonly _feeToken: Token;

package/dist/services/exchange-data/FlamingoEDSNeo3.d.ts

@@ -1,5 +1,5 @@
 import { CryptoCompareEDS, ExchangeDataService, GetTokenPriceHistoryParams, GetTokenPricesParams, Network, TokenPricesHistoryResponse, TokenPricesResponse } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 export declare class FlamingoEDSNeo3 extends CryptoCompareEDS implements ExchangeDataService {
     #private;
     constructor(network: Network<BSNeo3NetworkId>);

package/dist/services/explorer/DoraESNeo3.d.ts

@@ -1,5 +1,5 @@
 import { BuildNftUrlParams, ExplorerService, Network } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 export declare class DoraESNeo3 implements ExplorerService {
     #private;
     constructor(network: Network<BSNeo3NetworkId>);

package/dist/services/ledger/NeonDappKitLedgerServiceNeo3.d.ts

@@ -1,13 +1,13 @@
 import { Account, LedgerService, LedgerServiceEmitter } from '@cityofzion/blockchain-service';
 import { api } from '@cityofzion/neon-js';
 import Transport from '@ledgerhq/hw-transport';
+import { BSNeo3 } from '../../BSNeo3';
 export declare class NeonDappKitLedgerServiceNeo3 implements LedgerService {
     #private;
-    getLedgerTransport?: ((account: Account) => Promise<Transport>) | undefined;
     emitter: LedgerServiceEmitter;
-    constructor(getLedgerTransport?: ((account: Account) => Promise<Transport>) | undefined);
-    getAddress(transport: Transport): Promise<string>;
-    getSigningCallback(transport: Transport): api.SigningFunction;
-    getSignature(transport: Transport, serializedTransaction: string, networkMagic: number, addressIndex?: number): Promise<string>;
-    getPublicKey(transport: Transport, addressIndex?: number): Promise<string>;
+    getLedgerTransport?: (account: Account) => Promise<Transport>;
+    constructor(blockchainService: BSNeo3, getLedgerTransport?: (account: Account) => Promise<Transport>);
+    getAccount(transport: Transport, index: number): Promise<Account>;
+    getAccounts(transport: Transport): Promise<Account[]>;
+    getSigningCallback(transport: Transport, account: Account): api.SigningFunction;
 }

package/dist/services/ledger/NeonDappKitLedgerServiceNeo3.js

@@ -8,6 +8,12 @@ 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");
@@ -16,9 +22,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _NeonDappKitLedgerServiceNeo3_instances, _NeonDappKitLedgerServiceNeo3_sendChunk, _NeonDappKitLedgerServiceNeo3_toBip44, _NeonDappKitLedgerServiceNeo3_to8BitHex, _NeonDappKitLedgerServiceNeo3_derSignatureToHex;
+var _NeonDappKitLedgerServiceNeo3_instances, _NeonDappKitLedgerServiceNeo3_blockchainService, _NeonDappKitLedgerServiceNeo3_sendChunk, _NeonDappKitLedgerServiceNeo3_bip44PathToHex, _NeonDappKitLedgerServiceNeo3_derSignatureToHex;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NeonDappKitLedgerServiceNeo3 = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
 const neon_js_1 = require("@cityofzion/neon-js");
 const events_1 = __importDefault(require("events"));
@@ -37,50 +44,69 @@ var LedgerSecondParameter;
     LedgerSecondParameter[LedgerSecondParameter["LAST_DATA"] = 0] = "LAST_DATA";
 })(LedgerSecondParameter || (LedgerSecondParameter = {}));
 class NeonDappKitLedgerServiceNeo3 {
-    constructor(getLedgerTransport) {
-        this.getLedgerTransport = getLedgerTransport;
+    constructor(blockchainService, getLedgerTransport) {
         _NeonDappKitLedgerServiceNeo3_instances.add(this);
+        _NeonDappKitLedgerServiceNeo3_blockchainService.set(this, void 0);
         this.emitter = new events_1.default();
+        __classPrivateFieldSet(this, _NeonDappKitLedgerServiceNeo3_blockchainService, blockchainService, "f");
+        this.getLedgerTransport = getLedgerTransport;
     }
-    getAddress(transport) {
+    getAccount(transport, index) {
         return __awaiter(this, void 0, void 0, function* () {
-            const publicKey = yield this.getPublicKey(transport);
+            const bip44Path = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_blockchainService, "f").bip44DerivationPath.replace('?', index.toString());
+            const bip44PathHex = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_bip44PathToHex).call(this, bip44Path);
+            const result = yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.GET_PUBLIC_KEY, 0x00, LedgerSecondParameter.LAST_DATA, bip44PathHex);
+            const publicKey = result.toString('hex').substring(0, 130);
             const { address } = new neon_js_1.wallet.Account(publicKey);
-            return address;
+            return {
+                address,
+                key: publicKey,
+                type: 'publicKey',
+                bip44Path,
+            };
         });
     }
-    getSigningCallback(transport) {
-        return (transaction, { witnessIndex, network }) => __awaiter(this, void 0, void 0, function* () {
-            const publicKey = yield this.getPublicKey(transport);
-            const account = new neon_js_1.wallet.Account(publicKey);
-            const witnessScriptHash = neon_js_1.wallet.getScriptHashFromVerificationScript(transaction.witnesses[witnessIndex].verificationScript.toString());
-            if (account.scriptHash !== witnessScriptHash) {
-                throw new Error('Invalid witness script hash');
-            }
-            const signature = yield this.getSignature(transport, transaction.serialize(false), network, witnessIndex);
-            return signature;
+    getAccounts(transport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountsByBlockchainService = yield (0, blockchain_service_1.fetchAccountsForBlockchainServices)([__classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_blockchainService, "f")], (_service, index) => __awaiter(this, void 0, void 0, function* () {
+                return this.getAccount(transport, index);
+            }));
+            const accounts = accountsByBlockchainService.get(__classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_blockchainService, "f").blockchainName);
+            return accounts !== null && accounts !== void 0 ? accounts : [];
         });
     }
-    getSignature(transport, serializedTransaction, networkMagic, addressIndex = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
+    getSigningCallback(transport, account) {
+        return (transaction, { witnessIndex, network }) => __awaiter(this, void 0, void 0, function* () {
             try {
                 this.emitter.emit('getSignatureStart');
-                const bip44 = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_toBip44).call(this, addressIndex);
+                if (!account.bip44Path) {
+                    throw new Error('Account must have a bip 44 path to sign with Ledger');
+                }
+                const neonJsAccount = new neon_js_1.wallet.Account(account.key);
+                const witnessScriptHash = neon_js_1.wallet.getScriptHashFromVerificationScript(transaction.witnesses[witnessIndex].verificationScript.toString());
+                if (neonJsAccount.scriptHash !== witnessScriptHash) {
+                    throw new Error('Invalid witness script hash');
+                }
+                const bip44PathHex = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_bip44PathToHex).call(this, account.bip44Path);
                 // Send the BIP44 account as first chunk
-                yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.SIGN, 0, LedgerSecondParameter.MORE_DATA, bip44);
+                yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.SIGN, 0, LedgerSecondParameter.MORE_DATA, bip44PathHex);
                 // Send the network magic as second chunk
-                yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.SIGN, 1, LedgerSecondParameter.MORE_DATA, neon_dappkit_1.NeonParser.numToHex(networkMagic, 4, true));
+                yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.SIGN, 1, LedgerSecondParameter.MORE_DATA, neon_dappkit_1.NeonParser.numToHex(network, 4, true));
+                const serializedTransaction = transaction.serialize(false);
+                // Split the serialized transaction into chunks of 510 bytes
                 const chunks = serializedTransaction.match(/.{1,510}/g) || [];
+                // Send all chunks except the last one
                 for (let i = 0; i < chunks.length - 1; i++) {
                     // We plus 2 because we already sent 2 chunks before
                     const commandIndex = 2 + i;
                     yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.SIGN, commandIndex, LedgerSecondParameter.MORE_DATA, chunks[i]);
                 }
-                // Again we plus 2 because we already sent 2 chunks before getting the chunks
+                // Again, we plus 2 because we already sent 2 chunks before getting the chunks
                 const lastChunkIndex = 2 + chunks.length;
+                // Send the last chunk signaling that it is the last one and get the signature
                 const response = yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.SIGN, lastChunkIndex, LedgerSecondParameter.LAST_DATA, chunks[chunks.length - 1]);
                 if (response.length <= 2) {
-                    throw new Error(`No more data but Ledger did not return signature!`);
+                    throw new Error('Invalid signature returned from Ledger');
                 }
                 const signature = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_derSignatureToHex).call(this, response.toString('hex'));
                 return signature;
@@ -90,26 +116,24 @@ class NeonDappKitLedgerServiceNeo3 {
             }
         });
     }
-    getPublicKey(transport, addressIndex = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const bip44 = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_toBip44).call(this, addressIndex);
-            const result = yield __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_sendChunk).call(this, transport, LedgerCommand.GET_PUBLIC_KEY, 0x00, LedgerSecondParameter.LAST_DATA, bip44);
-            const publicKey = result.toString('hex').substring(0, 130);
-            return publicKey;
-        });
-    }
 }
 exports.NeonDappKitLedgerServiceNeo3 = NeonDappKitLedgerServiceNeo3;
-_NeonDappKitLedgerServiceNeo3_instances = new WeakSet(), _NeonDappKitLedgerServiceNeo3_sendChunk = function _NeonDappKitLedgerServiceNeo3_sendChunk(transport, command, commandIndex, secondParameter, chunk) {
+_NeonDappKitLedgerServiceNeo3_blockchainService = new WeakMap(), _NeonDappKitLedgerServiceNeo3_instances = new WeakSet(), _NeonDappKitLedgerServiceNeo3_sendChunk = function _NeonDappKitLedgerServiceNeo3_sendChunk(transport, command, commandIndex, secondParameter, chunk) {
     return transport.send(0x80, command, commandIndex, secondParameter, Buffer.from(chunk, 'hex'), [LedgerStatus.OK]);
-}, _NeonDappKitLedgerServiceNeo3_toBip44 = function _NeonDappKitLedgerServiceNeo3_toBip44(addressIndex = 0, changeIndex = 0, accountIndex = 0) {
-    const accountHex = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_to8BitHex).call(this, accountIndex + 0x80000000);
-    const changeHex = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_to8BitHex).call(this, changeIndex);
-    const addressHex = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_to8BitHex).call(this, addressIndex);
-    return '8000002C' + '80000378' + accountHex + changeHex + addressHex;
-}, _NeonDappKitLedgerServiceNeo3_to8BitHex = function _NeonDappKitLedgerServiceNeo3_to8BitHex(num) {
-    const hex = num.toString(16);
-    return '0'.repeat(8 - hex.length) + hex;
+}, _NeonDappKitLedgerServiceNeo3_bip44PathToHex = function _NeonDappKitLedgerServiceNeo3_bip44PathToHex(path) {
+    let result = '';
+    const components = path.split('/');
+    components.forEach(element => {
+        let number = parseInt(element, 10);
+        if (isNaN(number)) {
+            return;
+        }
+        if (element.length > 1 && element[element.length - 1] === "'") {
+            number += 0x80000000;
+        }
+        result += number.toString(16).padStart(8, '0');
+    });
+    return result;
 }, _NeonDappKitLedgerServiceNeo3_derSignatureToHex = function _NeonDappKitLedgerServiceNeo3_derSignatureToHex(response) {
     const ss = new neon_js_1.u.StringStream(response);
     // The first byte is format. It is usually 0x30 (SEQ) or 0x31 (SET)

package/dist/services/nft-data/GhostMarketNDSNeo3.d.ts

@@ -1,6 +1,6 @@
 import { GetNftParam, GetNftsByAddressParams, Network, NftResponse, NftsResponse } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
 import { RpcNDSNeo3 } from './RpcNDSNeo3';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 export declare class GhostMarketNDSNeo3 extends RpcNDSNeo3 {
     #private;
     static CONFIG_BY_NETWORK_ID: Partial<Record<BSNeo3NetworkId, {

package/dist/services/nft-data/RpcNDSNeo3.d.ts

@@ -1,5 +1,5 @@
 import { GetNftParam, GetNftsByAddressParams, HasTokenParam, Network, NftDataService, NftResponse, NftsResponse } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 export declare abstract class RpcNDSNeo3 implements NftDataService {
     #private;
     protected constructor(network: Network<BSNeo3NetworkId>);

package/dist/services/swap/FlamingoSwapServiceNeo3.d.ts

@@ -1,12 +1,12 @@
 import { Account, Network, SwapService, SwapServiceEvents, SwapServiceSwapToReceiveArgs, SwapServiceSwapToUseArgs, Token } from '@cityofzion/blockchain-service';
 import TypedEmitter from 'typed-emitter';
-import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
-import { NeonDappKitLedgerServiceNeo3 } from '../ledger/NeonDappKitLedgerServiceNeo3';
+import { BSNeo3 } from '../../BSNeo3';
+import { BSNeo3NetworkId } from '../../constants/BSNeo3Constants';
 type BuildSwapInvocationArgs = SwapServiceSwapToUseArgs<BSNeo3NetworkId> | SwapServiceSwapToReceiveArgs<BSNeo3NetworkId>;
 export declare class FlamingoSwapServiceNeo3 implements SwapService<BSNeo3NetworkId> {
     #private;
     eventEmitter: TypedEmitter<SwapServiceEvents>;
-    constructor(network: Network<BSNeo3NetworkId>, ledgerService?: NeonDappKitLedgerServiceNeo3);
+    constructor(network: Network<BSNeo3NetworkId>, blockchainService: BSNeo3);
     buildSwapInvocationArgs(): BuildSwapInvocationArgs;
     swap(isLedger?: boolean): Promise<void>;
     startListeningBlockGeneration(): void;

package/dist/services/swap/FlamingoSwapServiceNeo3.js

@@ -22,10 +22,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _FlamingoSwapServiceNeo3_instances, _FlamingoSwapServiceNeo3_ledgerService, _FlamingoSwapServiceNeo3_network, _FlamingoSwapServiceNeo3_privateAccountToUse, _FlamingoSwapServiceNeo3_privateTokenToReceive, _FlamingoSwapServiceNeo3_privateTokenToUse, _FlamingoSwapServiceNeo3_privateAmountToReceive, _FlamingoSwapServiceNeo3_privateAmountToUse, _FlamingoSwapServiceNeo3_privateMinimumReceived, _FlamingoSwapServiceNeo3_privateMaximumSelling, _FlamingoSwapServiceNeo3_privateSlippage, _FlamingoSwapServiceNeo3_privateDeadline, _FlamingoSwapServiceNeo3_privatePriceInverse, _FlamingoSwapServiceNeo3_privatePriceImpact, _FlamingoSwapServiceNeo3_privateLiquidityProviderFee, _FlamingoSwapServiceNeo3_privateRoute, _FlamingoSwapServiceNeo3_privateLastAmountChanged, _FlamingoSwapServiceNeo3_socket, _FlamingoSwapServiceNeo3_setReserves, _FlamingoSwapServiceNeo3_clearFields, _FlamingoSwapServiceNeo3_recalculateSwapArguments, _FlamingoSwapServiceNeo3_recalculateRoute, _FlamingoSwapServiceNeo3_lastAmountChanged_get, _FlamingoSwapServiceNeo3_lastAmountChanged_set, _FlamingoSwapServiceNeo3_accountToUse_get, _FlamingoSwapServiceNeo3_accountToUse_set, _FlamingoSwapServiceNeo3_amountToUse_get, _FlamingoSwapServiceNeo3_amountToUse_set, _FlamingoSwapServiceNeo3_minimumReceived_get, _FlamingoSwapServiceNeo3_minimumReceived_set, _FlamingoSwapServiceNeo3_maximumSelling_get, _FlamingoSwapServiceNeo3_maximumSelling_set, _FlamingoSwapServiceNeo3_amountToReceive_get, _FlamingoSwapServiceNeo3_amountToReceive_set, _FlamingoSwapServiceNeo3_deadline_get, _FlamingoSwapServiceNeo3_deadline_set, _FlamingoSwapServiceNeo3_liquidityProviderFee_get, _FlamingoSwapServiceNeo3_liquidityProviderFee_set, _FlamingoSwapServiceNeo3_priceImpact_get, _FlamingoSwapServiceNeo3_priceImpact_set, _FlamingoSwapServiceNeo3_priceInverse_get, _FlamingoSwapServiceNeo3_priceInverse_set, _FlamingoSwapServiceNeo3_route_get, _FlamingoSwapServiceNeo3_route_set, _FlamingoSwapServiceNeo3_slippage_get, _FlamingoSwapServiceNeo3_slippage_set, _FlamingoSwapServiceNeo3_tokenToReceive_get, _FlamingoSwapServiceNeo3_tokenToReceive_set, _FlamingoSwapServiceNeo3_tokenToUse_get, _FlamingoSwapServiceNeo3_tokenToUse_set;
+var _FlamingoSwapServiceNeo3_instances, _FlamingoSwapServiceNeo3_blockchainService, _FlamingoSwapServiceNeo3_network, _FlamingoSwapServiceNeo3_privateAccountToUse, _FlamingoSwapServiceNeo3_privateTokenToReceive, _FlamingoSwapServiceNeo3_privateTokenToUse, _FlamingoSwapServiceNeo3_privateAmountToReceive, _FlamingoSwapServiceNeo3_privateAmountToUse, _FlamingoSwapServiceNeo3_privateMinimumReceived, _FlamingoSwapServiceNeo3_privateMaximumSelling, _FlamingoSwapServiceNeo3_privateSlippage, _FlamingoSwapServiceNeo3_privateDeadline, _FlamingoSwapServiceNeo3_privatePriceInverse, _FlamingoSwapServiceNeo3_privatePriceImpact, _FlamingoSwapServiceNeo3_privateLiquidityProviderFee, _FlamingoSwapServiceNeo3_privateRoute, _FlamingoSwapServiceNeo3_privateLastAmountChanged, _FlamingoSwapServiceNeo3_socket, _FlamingoSwapServiceNeo3_setReserves, _FlamingoSwapServiceNeo3_clearFields, _FlamingoSwapServiceNeo3_recalculateSwapArguments, _FlamingoSwapServiceNeo3_recalculateRoute, _FlamingoSwapServiceNeo3_lastAmountChanged_get, _FlamingoSwapServiceNeo3_lastAmountChanged_set, _FlamingoSwapServiceNeo3_accountToUse_get, _FlamingoSwapServiceNeo3_accountToUse_set, _FlamingoSwapServiceNeo3_amountToUse_get, _FlamingoSwapServiceNeo3_amountToUse_set, _FlamingoSwapServiceNeo3_minimumReceived_get, _FlamingoSwapServiceNeo3_minimumReceived_set, _FlamingoSwapServiceNeo3_maximumSelling_get, _FlamingoSwapServiceNeo3_maximumSelling_set, _FlamingoSwapServiceNeo3_amountToReceive_get, _FlamingoSwapServiceNeo3_amountToReceive_set, _FlamingoSwapServiceNeo3_deadline_get, _FlamingoSwapServiceNeo3_deadline_set, _FlamingoSwapServiceNeo3_liquidityProviderFee_get, _FlamingoSwapServiceNeo3_liquidityProviderFee_set, _FlamingoSwapServiceNeo3_priceImpact_get, _FlamingoSwapServiceNeo3_priceImpact_set, _FlamingoSwapServiceNeo3_priceInverse_get, _FlamingoSwapServiceNeo3_priceInverse_set, _FlamingoSwapServiceNeo3_route_get, _FlamingoSwapServiceNeo3_route_set, _FlamingoSwapServiceNeo3_slippage_get, _FlamingoSwapServiceNeo3_slippage_set, _FlamingoSwapServiceNeo3_tokenToReceive_get, _FlamingoSwapServiceNeo3_tokenToReceive_set, _FlamingoSwapServiceNeo3_tokenToUse_get, _FlamingoSwapServiceNeo3_tokenToUse_set;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlamingoSwapServiceNeo3 = void 0;
-const neon_core_1 = require("@cityofzion/neon-core");
 const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
 const events_1 = __importDefault(require("events"));
 const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
@@ -33,9 +32,9 @@ const FlamingoSwapInvocationBuilderNeo3_1 = require("../../builder/invocation/Fl
 const FlamingoSwapHelper_1 = require("../../helpers/FlamingoSwapHelper");
 const handlers_1 = require("./handlers");
 class FlamingoSwapServiceNeo3 {
-    constructor(network, ledgerService) {
+    constructor(network, blockchainService) {
         _FlamingoSwapServiceNeo3_instances.add(this);
-        _FlamingoSwapServiceNeo3_ledgerService.set(this, void 0);
+        _FlamingoSwapServiceNeo3_blockchainService.set(this, void 0);
         _FlamingoSwapServiceNeo3_network.set(this, void 0);
         _FlamingoSwapServiceNeo3_privateAccountToUse.set(this, null);
         _FlamingoSwapServiceNeo3_privateTokenToReceive.set(this, null);
@@ -54,7 +53,7 @@ class FlamingoSwapServiceNeo3 {
         _FlamingoSwapServiceNeo3_socket.set(this, new handlers_1.FlamingoSwapSocketService());
         this.eventEmitter = new events_1.default();
         __classPrivateFieldSet(this, _FlamingoSwapServiceNeo3_network, network, "f");
-        __classPrivateFieldSet(this, _FlamingoSwapServiceNeo3_ledgerService, ledgerService, "f");
+        __classPrivateFieldSet(this, _FlamingoSwapServiceNeo3_blockchainService, blockchainService, "f");
     }
     buildSwapInvocationArgs() {
         if (!__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_instances, "a", _FlamingoSwapServiceNeo3_accountToUse_get) ||
@@ -84,22 +83,12 @@ class FlamingoSwapServiceNeo3 {
     swap(isLedger) {
         return __awaiter(this, void 0, void 0, function* () {
             const swapInvocationArgs = this.buildSwapInvocationArgs();
-            let ledgerTransport;
-            let signingCallback;
-            if (isLedger) {
-                if (!__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_ledgerService, "f")) {
-                    throw new Error('You must provide a ledger service to use Ledger');
-                }
-                if (!__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_ledgerService, "f").getLedgerTransport) {
-                    throw new Error('You must provide a getLedgerTransport function to use Ledger');
-                }
-                ledgerTransport = yield __classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_ledgerService, "f").getLedgerTransport(__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_instances, "a", _FlamingoSwapServiceNeo3_accountToUse_get));
-                signingCallback = __classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_ledgerService, "f").getSigningCallback(ledgerTransport);
-            }
-            const account = new neon_core_1.wallet.Account(__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_instances, "a", _FlamingoSwapServiceNeo3_accountToUse_get).key);
+            if (!__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_instances, "a", _FlamingoSwapServiceNeo3_accountToUse_get))
+                throw new Error('Account to use is not set');
+            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_blockchainService, "f").generateSigningCallback(__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_instances, "a", _FlamingoSwapServiceNeo3_accountToUse_get), isLedger);
             const invoker = yield neon_dappkit_1.NeonInvoker.init({
                 rpcAddress: __classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_network, "f").url,
-                account,
+                account: neonJsAccount,
                 signingCallback,
             });
             yield invoker.invokeFunction(FlamingoSwapInvocationBuilderNeo3_1.FlamingoSwapInvocationBuilderNeo3.swapInvocation(swapInvocationArgs));
@@ -149,7 +138,7 @@ class FlamingoSwapServiceNeo3 {
     }
 }
 exports.FlamingoSwapServiceNeo3 = FlamingoSwapServiceNeo3;
-_FlamingoSwapServiceNeo3_ledgerService = new WeakMap(), _FlamingoSwapServiceNeo3_network = new WeakMap(), _FlamingoSwapServiceNeo3_privateAccountToUse = new WeakMap(), _FlamingoSwapServiceNeo3_privateTokenToReceive = new WeakMap(), _FlamingoSwapServiceNeo3_privateTokenToUse = new WeakMap(), _FlamingoSwapServiceNeo3_privateAmountToReceive = new WeakMap(), _FlamingoSwapServiceNeo3_privateAmountToUse = new WeakMap(), _FlamingoSwapServiceNeo3_privateMinimumReceived = new WeakMap(), _FlamingoSwapServiceNeo3_privateMaximumSelling = new WeakMap(), _FlamingoSwapServiceNeo3_privateSlippage = new WeakMap(), _FlamingoSwapServiceNeo3_privateDeadline = new WeakMap(), _FlamingoSwapServiceNeo3_privatePriceInverse = new WeakMap(), _FlamingoSwapServiceNeo3_privatePriceImpact = new WeakMap(), _FlamingoSwapServiceNeo3_privateLiquidityProviderFee = new WeakMap(), _FlamingoSwapServiceNeo3_privateRoute = new WeakMap(), _FlamingoSwapServiceNeo3_privateLastAmountChanged = new WeakMap(), _FlamingoSwapServiceNeo3_socket = new WeakMap(), _FlamingoSwapServiceNeo3_instances = new WeakSet(), _FlamingoSwapServiceNeo3_setReserves = function _FlamingoSwapServiceNeo3_setReserves() {
+_FlamingoSwapServiceNeo3_blockchainService = new WeakMap(), _FlamingoSwapServiceNeo3_network = new WeakMap(), _FlamingoSwapServiceNeo3_privateAccountToUse = new WeakMap(), _FlamingoSwapServiceNeo3_privateTokenToReceive = new WeakMap(), _FlamingoSwapServiceNeo3_privateTokenToUse = new WeakMap(), _FlamingoSwapServiceNeo3_privateAmountToReceive = new WeakMap(), _FlamingoSwapServiceNeo3_privateAmountToUse = new WeakMap(), _FlamingoSwapServiceNeo3_privateMinimumReceived = new WeakMap(), _FlamingoSwapServiceNeo3_privateMaximumSelling = new WeakMap(), _FlamingoSwapServiceNeo3_privateSlippage = new WeakMap(), _FlamingoSwapServiceNeo3_privateDeadline = new WeakMap(), _FlamingoSwapServiceNeo3_privatePriceInverse = new WeakMap(), _FlamingoSwapServiceNeo3_privatePriceImpact = new WeakMap(), _FlamingoSwapServiceNeo3_privateLiquidityProviderFee = new WeakMap(), _FlamingoSwapServiceNeo3_privateRoute = new WeakMap(), _FlamingoSwapServiceNeo3_privateLastAmountChanged = new WeakMap(), _FlamingoSwapServiceNeo3_socket = new WeakMap(), _FlamingoSwapServiceNeo3_instances = new WeakSet(), _FlamingoSwapServiceNeo3_setReserves = function _FlamingoSwapServiceNeo3_setReserves() {
     return __awaiter(this, void 0, void 0, function* () {
         if (!__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_instances, "a", _FlamingoSwapServiceNeo3_tokenToReceive_get) || !__classPrivateFieldGet(this, _FlamingoSwapServiceNeo3_instances, "a", _FlamingoSwapServiceNeo3_tokenToUse_get))
             return;

package/dist/services/swap/handlers/FlamingoSwapDetailsHandler.d.ts

@@ -1,5 +1,5 @@
 import { Network, SwapRoute, Token } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../../constants/BSNeo3Constants';
 type CalculateSwapDetailsArgs = {
     amountToUse: string | null;
     amountToReceive: string | null;

package/dist/services/swap/handlers/FlamingoSwapRouteHandler.d.ts

@@ -1,5 +1,5 @@
 import { Network, PoolGraph, SwapRoute, Token } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from '../../../helpers/BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../../constants/BSNeo3Constants';
 type CalculateBestRouteForSwapArgs = {
     tokenToUse: Token;
     tokenToReceive: Token;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -20,7 +20,7 @@
     "bignumber.js": "^9.1.2",
     "isomorphic-ws": "^5.0.0",
     "lodash.clonedeep": "^4.5.0",
-    "@cityofzion/blockchain-service": "1.3.2",
+    "@cityofzion/blockchain-service": "1.4.0",
     "@cityofzion/bs-asteroid-sdk": "0.9.0"
   },
   "devDependencies": {