@cityofzion/bs-neo3 0.9.3 → 0.11.0

package/dist/BSNeo3.d.ts

@@ -1,5 +1,7 @@
-import { BlockchainDataService, BlockchainService, BSClaimable, Account, ExchangeDataService, BDSClaimable, Token, BSWithNameService, Network, PartialBy, TransferParam, BSCalculableFee, NftDataService, BSWithNft, AccountWithDerivationPath, BSWithExplorerService, ExplorerService } from '@cityofzion/blockchain-service';
-export declare class BSNeo3<BSCustomName extends string = string> implements BlockchainService, BSClaimable, BSWithNameService, BSCalculableFee, BSWithNft, BSWithExplorerService {
+import { BlockchainDataService, BlockchainService, BSClaimable, Account, ExchangeDataService, BDSClaimable, Token, BSWithNameService, Network, PartialBy, TransferParam, BSCalculableFee, NftDataService, BSWithNft, AccountWithDerivationPath, BSWithExplorerService, ExplorerService, BSWithLedger } from '@cityofzion/blockchain-service';
+import { LedgerServiceNeo3 } from './LedgerServiceNeo3';
+import Transport from '@ledgerhq/hw-transport';
+export declare class BSNeo3<BSCustomName extends string = string> implements BlockchainService, BSClaimable, BSWithNameService, BSCalculableFee, BSWithNft, BSWithExplorerService, BSWithLedger {
     readonly blockchainName: BSCustomName;
     readonly feeToken: Token;
     readonly claimToken: Token;
@@ -7,23 +9,25 @@ export declare class BSNeo3<BSCustomName extends string = string> implements Blo
     readonly derivationPath: string;
     blockchainDataService: BlockchainDataService & BDSClaimable;
     nftDataService: NftDataService;
+    ledgerService: LedgerServiceNeo3;
     exchangeDataService: ExchangeDataService;
     explorerService: ExplorerService;
     tokens: Token[];
     network: Network;
-    constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>);
+    constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>, getLedgerTransport?: (account: Account) => Promise<Transport>);
     setNetwork(param: PartialBy<Network, 'url'>): void;
     validateAddress(address: string): boolean;
     validateEncrypted(encryptedKey: string): boolean;
     validateKey(key: string): boolean;
     validateNameServiceDomainFormat(domainName: string): boolean;
     generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath;
+    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>;
-    claim(account: Account): Promise<string>;
+    claim(account: Account, isLedger?: boolean): Promise<string>;
     resolveNameServiceDomain(domainName: string): Promise<any>;
     private buildTransferInvocation;
 }

package/dist/BSNeo3.js

@@ -11,9 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeo3 = void 0;
 const neon_js_1 = require("@cityofzion/neon-js");
-const neon_invoker_1 = require("@cityofzion/neon-invoker");
-const neon_parser_1 = require("@cityofzion/neon-parser");
-const neo3_parser_1 = require("@cityofzion/neo3-parser");
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
 const RpcBDSNeo3_1 = require("./RpcBDSNeo3");
 const DoraBDSNeo3_1 = require("./DoraBDSNeo3");
 const constants_1 = require("./constants");
@@ -21,9 +19,11 @@ const FlamingoEDSNeo3_1 = require("./FlamingoEDSNeo3");
 const GhostMarketNDSNeo3_1 = require("./GhostMarketNDSNeo3");
 const bs_asteroid_sdk_1 = require("@cityofzion/bs-asteroid-sdk");
 const DoraESNeo3_1 = require("./DoraESNeo3");
+const LedgerServiceNeo3_1 = require("./LedgerServiceNeo3");
 class BSNeo3 {
-    constructor(blockchainName, network) {
+    constructor(blockchainName, network, getLedgerTransport) {
         this.blockchainName = blockchainName;
+        this.ledgerService = new LedgerServiceNeo3_1.LedgerServiceNeo3(getLedgerTransport);
         this.tokens = constants_1.TOKENS[network.type];
         this.derivationPath = constants_1.DERIVATION_PATH;
         this.feeToken = this.tokens.find(token => token.symbol === 'GAS');
@@ -70,6 +70,16 @@ class BSNeo3 {
         const { address } = new neon_js_1.wallet.Account(key);
         return { address, key, type: 'wif', derivationPath: path };
     }
+    generateAccountFromPublicKey(publicKey) {
+        if (!neon_js_1.wallet.isPublicKey(publicKey))
+            throw new Error('Invalid public key');
+        const account = new neon_js_1.wallet.Account(publicKey);
+        return {
+            address: account.address,
+            key: account.publicKey,
+            type: 'publicKey',
+        };
+    }
     generateAccountFromKey(key) {
         const type = neon_js_1.wallet.isWIF(key) ? 'wif' : neon_js_1.wallet.isPrivateKey(key) ? 'privateKey' : undefined;
         if (!type)
@@ -101,24 +111,31 @@ class BSNeo3 {
     calculateTransferFee(param) {
         return __awaiter(this, void 0, void 0, function* () {
             const account = new neon_js_1.wallet.Account(param.senderAccount.key);
-            const invoker = yield neon_invoker_1.NeonInvoker.init({
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({
                 rpcAddress: this.network.url,
                 account,
             });
             const invocations = this.buildTransferInvocation(param, account);
-            const { networkFee, systemFee } = yield invoker.calculateFee({
+            const { total } = yield invoker.calculateFee({
                 invocations,
                 signers: [],
             });
-            return networkFee.add(systemFee).toDecimal(this.feeToken.decimals);
+            return total.toString();
         });
     }
     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 invoker = yield neon_invoker_1.NeonInvoker.init({
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({
                 rpcAddress: this.network.url,
                 account,
+                signingCallback: ledgerTransport ? this.ledgerService.getSigningCallback(ledgerTransport) : undefined,
             });
             const invocations = this.buildTransferInvocation(param, account);
             const transactionHash = yield invoker.invokeFunction({
@@ -128,12 +145,20 @@ class BSNeo3 {
             return transactionHash;
         });
     }
-    claim(account) {
+    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 facade = yield neon_js_1.api.NetworkFacade.fromConfig({ node: this.network.url });
             const transactionHash = yield facade.claimGas(neoAccount, {
-                signingCallback: neon_js_1.api.signWithAccount(neoAccount),
+                signingCallback: ledgerTransport
+                    ? this.ledgerService.getSigningCallback(ledgerTransport)
+                    : neon_js_1.api.signWithAccount(neoAccount),
             });
             return transactionHash;
         });
@@ -141,8 +166,8 @@ class BSNeo3 {
     resolveNameServiceDomain(domainName) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const parser = neon_parser_1.NeonParser;
-            const invoker = yield neon_invoker_1.NeonInvoker.init({ rpcAddress: this.network.url });
+            const parser = neon_dappkit_1.NeonParser;
+            const invoker = yield neon_dappkit_1.NeonInvoker.init({ rpcAddress: this.network.url });
             const response = yield invoker.testInvoke({
                 invocations: [
                     {
@@ -156,7 +181,7 @@ class BSNeo3 {
                 throw new Error((_a = response.exception) !== null && _a !== void 0 ? _a : 'unrecognized response');
             }
             const parsed = parser.parseRpcResponse(response.stack[0], {
-                type: neo3_parser_1.ABI_TYPES.HASH160.name,
+                type: 'Hash160',
             });
             const address = parser.accountInputToAddress(parsed.replace('0x', ''));
             return address;

package/dist/DoraBDSNeo3.d.ts

@@ -1,7 +1,6 @@
 import { BalanceResponse, ContractResponse, TransactionsByAddressParams, TransactionsByAddressResponse, TransactionResponse, Network, Token } from '@cityofzion/blockchain-service';
 import { RPCBDSNeo3 } from './RpcBDSNeo3';
 export declare class DoraBDSNeo3 extends RPCBDSNeo3 {
-    readonly network: Network;
     constructor(network: Network, feeToken: Token, claimToken: Token);
     getTransaction(hash: string): Promise<TransactionResponse>;
     getTransactionsByAddress({ address, page, }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;

package/dist/DoraBDSNeo3.js

@@ -24,20 +24,19 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
             throw new Error('DoraBDSNeo3 does not support custom networks');
         }
         super(network, feeToken, claimToken);
-        this.network = network;
     }
     getTransaction(hash) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const data = yield NeoRest.transaction(hash, this.network.type);
+                const data = yield NeoRest.transaction(hash, this._network.type);
                 return {
                     block: data.block,
                     time: Number(data.time),
                     hash: data.hash,
                     fee: neon_js_1.u.BigInteger.fromNumber((_a = data.netfee) !== null && _a !== void 0 ? _a : 0)
                         .add(neon_js_1.u.BigInteger.fromNumber((_b = data.sysfee) !== null && _b !== void 0 ? _b : 0))
-                        .toDecimal(this.feeToken.decimals),
+                        .toDecimal(this._feeToken.decimals),
                     notifications: [],
                     transfers: [],
                 };
@@ -49,7 +48,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
     }
     getTransactionsByAddress({ address, page = 1, }) {
         return __awaiter(this, void 0, void 0, function* () {
-            const data = yield NeoRest.addressTXFull(address, page, this.network.type);
+            const data = yield NeoRest.addressTXFull(address, page, this._network.type);
             const promises = data.items.map((item) => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 const transferPromises = [];
@@ -97,7 +96,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
                     hash: item.hash,
                     fee: neon_js_1.u.BigInteger.fromNumber((_a = item.netfee) !== null && _a !== void 0 ? _a : 0)
                         .add(neon_js_1.u.BigInteger.fromNumber((_b = item.sysfee) !== null && _b !== void 0 ? _b : 0))
-                        .toDecimal(this.feeToken.decimals),
+                        .toDecimal(this._feeToken.decimals),
                     transfers,
                     notifications,
                 };
@@ -114,7 +113,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const data = yield NeoRest.contract(contractHash, this.network.type);
+                const data = yield NeoRest.contract(contractHash, this._network.type);
                 return {
                     hash: data.hash,
                     methods: (_b = (_a = data.manifest.abi) === null || _a === void 0 ? void 0 : _a.methods) !== null && _b !== void 0 ? _b : [],
@@ -128,21 +127,21 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
     }
     getTokenInfo(tokenHash) {
         return __awaiter(this, void 0, void 0, function* () {
-            const localToken = constants_1.TOKENS[this.network.type].find(token => token.hash === tokenHash);
+            const localToken = constants_1.TOKENS[this._network.type].find(token => token.hash === tokenHash);
             if (localToken)
                 return localToken;
-            if (this.tokenCache.has(tokenHash)) {
-                return this.tokenCache.get(tokenHash);
+            if (this._tokenCache.has(tokenHash)) {
+                return this._tokenCache.get(tokenHash);
             }
             try {
-                const { decimals, symbol, name, scripthash } = yield NeoRest.asset(tokenHash, this.network.type);
+                const { decimals, symbol, name, scripthash } = yield NeoRest.asset(tokenHash, this._network.type);
                 const token = {
                     decimals: Number(decimals),
                     symbol,
                     name,
                     hash: scripthash,
                 };
-                this.tokenCache.set(tokenHash, token);
+                this._tokenCache.set(tokenHash, token);
                 return token;
             }
             catch (_a) {
@@ -152,7 +151,7 @@ class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
     }
     getBalance(address) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield NeoRest.balance(address, this.network.type);
+            const response = yield NeoRest.balance(address, this._network.type);
             const promises = response.map((balance) => __awaiter(this, void 0, void 0, function* () {
                 try {
                     const token = yield this.getTokenInfo(balance.asset);

package/dist/DoraESNeo3.d.ts

@@ -1,6 +1,6 @@
 import { ExplorerService, NetworkType, BuildNftUrlParams } from '@cityofzion/blockchain-service';
 export declare class DoraESNeo3 implements ExplorerService {
-    private networkType;
+    #private;
     constructor(networkType: NetworkType);
     buildTransactionUrl(hash: string): string;
     buildNftUrl({ contractHash, tokenId }: BuildNftUrlParams): string;

package/dist/DoraESNeo3.js

@@ -1,19 +1,33 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _DoraESNeo3_networkType;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoraESNeo3 = void 0;
 class DoraESNeo3 {
     constructor(networkType) {
-        this.networkType = networkType;
+        _DoraESNeo3_networkType.set(this, void 0);
+        __classPrivateFieldSet(this, _DoraESNeo3_networkType, networkType, "f");
     }
     buildTransactionUrl(hash) {
-        if (this.networkType === 'custom')
+        if (__classPrivateFieldGet(this, _DoraESNeo3_networkType, "f") === 'custom')
             throw new Error('DoraESNeo3 does not support custom network');
-        return `https://dora.coz.io/transaction/neo3/${this.networkType}/${hash}`;
+        return `https://dora.coz.io/transaction/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_networkType, "f")}/${hash}`;
     }
     buildNftUrl({ contractHash, tokenId }) {
-        if (this.networkType === 'custom')
+        if (__classPrivateFieldGet(this, _DoraESNeo3_networkType, "f") === 'custom')
             throw new Error('DoraESNeo3 does not support custom network');
-        return `https://dora.coz.io/nft/neo3/${this.networkType}/${contractHash}/${tokenId}`;
+        return `https://dora.coz.io/nft/neo3/${__classPrivateFieldGet(this, _DoraESNeo3_networkType, "f")}/${contractHash}/${tokenId}`;
     }
 }
 exports.DoraESNeo3 = DoraESNeo3;
+_DoraESNeo3_networkType = new WeakMap();

package/dist/FlamingoEDSNeo3.d.ts

@@ -1,7 +1,6 @@
 import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service';
 export declare class FlamingoEDSNeo3 implements ExchangeDataService {
-    readonly networkType: NetworkType;
-    private axiosInstance;
+    #private;
     constructor(networkType: NetworkType);
     getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]>;
     private getCurrencyRatio;

package/dist/FlamingoEDSNeo3.js

@@ -8,22 +8,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _FlamingoEDSNeo3_networkType, _FlamingoEDSNeo3_axiosInstance;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlamingoEDSNeo3 = void 0;
 const axios_1 = __importDefault(require("axios"));
 class FlamingoEDSNeo3 {
     constructor(networkType) {
-        this.networkType = networkType;
-        this.axiosInstance = axios_1.default.create({ baseURL: 'https://api.flamingo.finance' });
+        _FlamingoEDSNeo3_networkType.set(this, void 0);
+        _FlamingoEDSNeo3_axiosInstance.set(this, void 0);
+        __classPrivateFieldSet(this, _FlamingoEDSNeo3_networkType, networkType, "f");
+        __classPrivateFieldSet(this, _FlamingoEDSNeo3_axiosInstance, axios_1.default.create({ baseURL: 'https://api.flamingo.finance' }), "f");
     }
     getTokenPrices(currency) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.networkType !== 'mainnet')
+            if (__classPrivateFieldGet(this, _FlamingoEDSNeo3_networkType, "f") !== 'mainnet')
                 throw new Error('Exchange is only available on mainnet');
-            const { data: prices } = yield this.axiosInstance.get('/token-info/prices');
+            const { data: prices } = yield __classPrivateFieldGet(this, _FlamingoEDSNeo3_axiosInstance, "f").get('/token-info/prices');
             let currencyRatio = 1;
             if (currency !== 'USD') {
                 currencyRatio = yield this.getCurrencyRatio(currency);
@@ -37,9 +51,10 @@ class FlamingoEDSNeo3 {
     }
     getCurrencyRatio(currency) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { data } = yield this.axiosInstance.get(`/fiat/exchange-rate?pair=USD_${currency}`);
+            const { data } = yield __classPrivateFieldGet(this, _FlamingoEDSNeo3_axiosInstance, "f").get(`/fiat/exchange-rate?pair=USD_${currency}`);
             return data;
         });
     }
 }
 exports.FlamingoEDSNeo3 = FlamingoEDSNeo3;
+_FlamingoEDSNeo3_networkType = new WeakMap(), _FlamingoEDSNeo3_axiosInstance = new WeakMap();

package/dist/GhostMarketNDSNeo3.d.ts

@@ -1,6 +1,6 @@
 import { NftResponse, NftsResponse, NetworkType, NftDataService, GetNftParam, GetNftsByAddressParams } from '@cityofzion/blockchain-service';
 export declare class GhostMarketNDSNeo3 implements NftDataService {
-    private networkType;
+    #private;
     constructor(networkType: NetworkType);
     getNftsByAddress({ address, size, cursor }: GetNftsByAddressParams): Promise<NftsResponse>;
     getNft({ contractHash, tokenId }: GetNftParam): Promise<NftResponse>;

package/dist/GhostMarketNDSNeo3.js

@@ -8,9 +8,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _GhostMarketNDSNeo3_networkType;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GhostMarketNDSNeo3 = void 0;
 const query_string_1 = __importDefault(require("query-string"));
@@ -18,7 +30,8 @@ const axios_1 = __importDefault(require("axios"));
 const constants_1 = require("./constants");
 class GhostMarketNDSNeo3 {
     constructor(networkType) {
-        this.networkType = networkType;
+        _GhostMarketNDSNeo3_networkType.set(this, void 0);
+        __classPrivateFieldSet(this, _GhostMarketNDSNeo3_networkType, networkType, "f");
     }
     getNftsByAddress({ address, size = 18, cursor }) {
         var _a;
@@ -54,8 +67,8 @@ class GhostMarketNDSNeo3 {
         return srcImage;
     }
     getUrlWithParams(params) {
-        const parameters = query_string_1.default.stringify(Object.assign({ chain: constants_1.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE[this.networkType] }, params), { arrayFormat: 'bracket' });
-        return `${constants_1.GHOSTMARKET_URL_BY_NETWORK_TYPE[this.networkType]}/assets?${parameters}`;
+        const parameters = query_string_1.default.stringify(Object.assign({ chain: constants_1.GHOSTMARKET_CHAIN_BY_NETWORK_TYPE[__classPrivateFieldGet(this, _GhostMarketNDSNeo3_networkType, "f")] }, params), { arrayFormat: 'bracket' });
+        return `${constants_1.GHOSTMARKET_URL_BY_NETWORK_TYPE[__classPrivateFieldGet(this, _GhostMarketNDSNeo3_networkType, "f")]}/assets?${parameters}`;
     }
     parse(data) {
         var _a, _b;
@@ -77,3 +90,4 @@ class GhostMarketNDSNeo3 {
     }
 }
 exports.GhostMarketNDSNeo3 = GhostMarketNDSNeo3;
+_GhostMarketNDSNeo3_networkType = new WeakMap();

package/dist/LedgerServiceNeo3.d.ts

@@ -0,0 +1,14 @@
+import { Account, LedgerService } from '@cityofzion/blockchain-service';
+import Transport from '@ledgerhq/hw-transport';
+import { api } from '@cityofzion/neon-js';
+export declare class LedgerServiceNeo3 implements LedgerService {
+    getLedgerTransport?: ((account: Account) => Promise<Transport>) | undefined;
+    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>;
+    private toBip44Buffer;
+    private to8BitHex;
+    private derSignatureToHex;
+}

package/dist/LedgerServiceNeo3.js

@@ -0,0 +1,96 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerServiceNeo3 = void 0;
+const neon_js_1 = require("@cityofzion/neon-js");
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
+class LedgerServiceNeo3 {
+    constructor(getLedgerTransport) {
+        this.getLedgerTransport = getLedgerTransport;
+    }
+    getAddress(transport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const publicKey = yield this.getPublicKey(transport);
+            const { address } = new neon_js_1.wallet.Account(publicKey);
+            return address;
+        });
+    }
+    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;
+        });
+    }
+    getSignature(transport, serializedTransaction, networkMagic, addressIndex = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bip44Buffer = this.toBip44Buffer(addressIndex);
+            yield transport.send(0x80, 0x02, 0, 0x80, bip44Buffer, [0x9000]);
+            yield transport.send(0x80, 0x02, 1, 0x80, Buffer.from(neon_dappkit_1.NeonParser.numToHex(networkMagic, 4, true), 'hex'), [0x9000]);
+            const chunks = serializedTransaction.match(/.{1,510}/g) || [];
+            for (let i = 0; i < chunks.length - 1; i++) {
+                yield transport.send(0x80, 0x02, 2 + i, 0x80, Buffer.from(chunks[i], 'hex'), [0x9000]);
+            }
+            const response = yield transport.send(0x80, 0x02, 2 + chunks.length, 0x00, Buffer.from(chunks[chunks.length - 1], 'hex'), [0x9000]);
+            if (response.length <= 2) {
+                throw new Error(`No more data but Ledger did not return signature!`);
+            }
+            return this.derSignatureToHex(response.toString('hex'));
+        });
+    }
+    getPublicKey(transport, addressIndex = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bip44Buffer = this.toBip44Buffer(addressIndex);
+            const result = yield transport.send(0x80, 0x04, 0x00, 0x00, bip44Buffer, [0x9000]);
+            const publicKey = result.toString('hex').substring(0, 130);
+            return publicKey;
+        });
+    }
+    toBip44Buffer(addressIndex = 0, changeIndex = 0, accountIndex = 0) {
+        const accountHex = this.to8BitHex(accountIndex + 0x80000000);
+        const changeHex = this.to8BitHex(changeIndex);
+        const addressHex = this.to8BitHex(addressIndex);
+        return Buffer.from('8000002C' + '80000378' + accountHex + changeHex + addressHex, 'hex');
+    }
+    to8BitHex(num) {
+        const hex = num.toString(16);
+        return '0'.repeat(8 - hex.length) + hex;
+    }
+    derSignatureToHex(response) {
+        const ss = new neon_js_1.u.StringStream(response);
+        // The first byte is format. It is usually 0x30 (SEQ) or 0x31 (SET)
+        // The second byte represents the total length of the DER module.
+        ss.read(2);
+        // Now we read each field off
+        // Each field is encoded with a type byte, length byte followed by the data itself
+        ss.read(1); // Read and drop the type
+        const r = ss.readVarBytes();
+        ss.read(1);
+        const s = ss.readVarBytes();
+        // We will need to ensure both integers are 32 bytes long
+        const integers = [r, s].map(i => {
+            if (i.length < 64) {
+                i = '0'.repeat(i.length - 64) + i;
+            }
+            if (i.length > 64) {
+                i = i.substr(-64);
+            }
+            return i;
+        });
+        return integers.join('');
+    }
+}
+exports.LedgerServiceNeo3 = LedgerServiceNeo3;

package/dist/RpcBDSNeo3.d.ts

@@ -1,9 +1,9 @@
 import { BDSClaimable, BalanceResponse, BlockchainDataService, ContractResponse, Network, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
 export declare class RPCBDSNeo3 implements BlockchainDataService, BDSClaimable {
-    protected readonly tokenCache: Map<string, Token>;
-    protected readonly feeToken: Token;
-    protected readonly claimToken: Token;
-    readonly network: Network;
+    readonly _tokenCache: Map<string, Token>;
+    readonly _feeToken: Token;
+    readonly _claimToken: Token;
+    readonly _network: Network;
     maxTimeToConfirmTransactionInMs: number;
     constructor(network: Network, feeToken: Token, claimToken: Token);
     getTransaction(hash: string): Promise<TransactionResponse>;