@cityofzion/bs-neo3 1.2.0 → 1.3.0

package/dist/{BSNeo3Helper.js → helpers/BSNeo3Helper.js}

@@ -10,8 +10,8 @@ var __importDefault = (this && this.__importDefault) || function (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 mainnet_json_1 = __importDefault(require("./assets/tokens/mainnet.json"));
-const common_json_1 = __importDefault(require("./assets/tokens/common.json"));
+const common_json_1 = __importDefault(require("../assets/tokens/common.json"));
+const mainnet_json_1 = __importDefault(require("../assets/tokens/mainnet.json"));
 class BSNeo3Helper {
     static getTokens(network) {
         var _b;

package/dist/helpers/FlamingoSwapHelper.d.ts

@@ -0,0 +1,19 @@
+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';
+export declare class FlamingoSwapHelper {
+    static getFlamingoSwapPools(network: Network<BSNeo3NetworkId>): FlamingoSwapPools;
+    static getFlamingoSwapPool(network: Network<BSNeo3NetworkId>, name: string): FlamingoSwapPoolInfo;
+    static getFlamingoSwapTokens(network: Network<BSNeo3NetworkId>): FlamingoSwapTokens;
+    static getFlamingoSwapToken(network: Network<BSNeo3NetworkId>, name: string): Token;
+    static getFlamingoSwapScriptHashes(network: Network<BSNeo3NetworkId>): FlamingoSwapScriptHashes;
+    static getRoutePath(route: SwapRoute[]): Token[];
+    static overrideToken(network: Network<BSNeo3NetworkId>, token: Token): Token;
+    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 normalizeHash(hash: string): string;
+    static isNeoToken(network: Network<BSNeo3NetworkId>, token: Token): boolean;
+    static formatAmount(amount: string, decimals: number): string;
+}

package/dist/helpers/FlamingoSwapHelper.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapHelper = void 0;
+const neon_core_1 = require("@cityofzion/neon-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const FlamingoSwapConstants_1 = require("../constants/FlamingoSwapConstants");
+class FlamingoSwapHelper {
+    static getFlamingoSwapPools(network) {
+        const pools = FlamingoSwapConstants_1.FlamingoSwapConstants.FLAMINGO_SWAP_POOLS[network.id];
+        if (!pools) {
+            throw new Error('Invalid network');
+        }
+        return pools;
+    }
+    static getFlamingoSwapPool(network, name) {
+        const pools = this.getFlamingoSwapPools(network);
+        const pool = pools[name];
+        if (!pool) {
+            throw new Error('Invalid pool');
+        }
+        return pool;
+    }
+    static getFlamingoSwapTokens(network) {
+        const tokens = FlamingoSwapConstants_1.FlamingoSwapConstants.FLAMINGO_SWAP_TOKENS[network.id];
+        if (!tokens) {
+            throw new Error('Invalid network');
+        }
+        return tokens;
+    }
+    static getFlamingoSwapToken(network, name) {
+        const tokens = this.getFlamingoSwapTokens(network);
+        const token = tokens[name];
+        if (!token) {
+            throw new Error('Invalid token');
+        }
+        return token;
+    }
+    static getFlamingoSwapScriptHashes(network) {
+        const swapScriptHashes = FlamingoSwapConstants_1.FlamingoSwapConstants.FLAMINGO_SWAP_SCRIPT_HASHES[network.id];
+        if (!swapScriptHashes) {
+            throw new Error('Invalid network');
+        }
+        return swapScriptHashes;
+    }
+    static getRoutePath(route) {
+        return route
+            .flatMap(item => [item.tokenToUse, item.tokenToReceive])
+            .filter((item, index, arr) => arr.indexOf(item) === index);
+    }
+    static overrideToken(network, token) {
+        return this.isNeoToken(network, token) ? this.getFlamingoSwapToken(network, 'bNEO') : token;
+    }
+    static overrideAmountInput(network, amount, token) {
+        const overrodeToken = this.overrideToken(network, token);
+        return new bignumber_js_1.default(amount).shiftedBy(overrodeToken.decimals);
+    }
+    static overrideAmountToDisplay(network, amount, token) {
+        const overrodeToken = this.overrideToken(network, token);
+        return new bignumber_js_1.default(amount).shiftedBy(-overrodeToken.decimals).toFixed();
+    }
+    static overrideRoute(network, route) {
+        const overrodeRoute = [];
+        for (const routeItem of route) {
+            if (!this.isNeoToken(network, routeItem.tokenToUse) && !this.isNeoToken(network, routeItem.tokenToReceive)) {
+                overrodeRoute.push(routeItem);
+            }
+        }
+        return overrodeRoute;
+    }
+    static normalizeHash(hash) {
+        return hash.startsWith('0x') ? hash.slice(2) : hash;
+    }
+    static isNeoToken(network, token) {
+        const NEO = this.getFlamingoSwapToken(network, 'NEO');
+        return this.normalizeHash(token.hash) === this.normalizeHash(NEO.hash);
+    }
+    static formatAmount(amount, decimals) {
+        return neon_core_1.u.BigInteger.fromDecimal(Number(amount), decimals).toString();
+    }
+}
+exports.FlamingoSwapHelper = FlamingoSwapHelper;

package/dist/index.d.ts

@@ -1,12 +1,14 @@
-export * from './flamingo-swap/FlamingoSwapControllerService';
-export * from './flamingo-swap/FlamingoSwapHelper';
-export * from './flamingo-swap/FlamingoSwapNeonDappKitInvocationBuilder';
 export * from './BSNeo3';
-export * from './BSNeo3Helper';
-export * from './DoraBDSNeo3';
-export * from './DoraESNeo3';
-export * from './FlamingoEDSNeo3';
-export * from './GhostMarketNDSNeo3';
-export * from './NeonDappKitLedgerServiceNeo3';
-export * from './RpcBDSNeo3';
-export * from './RpcNDSNeo3';
+export * from './builder/invocation/FlamingoSwapInvocationBuilderNeo3';
+export * from './builder/invocation/NeonDappKitInvocationBuilderNeo3';
+export * from './constants/FlamingoSwapConstants';
+export * from './helpers/BSNeo3Helper';
+export * from './helpers/FlamingoSwapHelper';
+export * from './services/blockchain-data/DoraBDSNeo3';
+export * from './services/blockchain-data/RpcBDSNeo3';
+export * from './services/exchange-data/FlamingoEDSNeo3';
+export * from './services/explorer/DoraESNeo3';
+export * from './services/ledger/NeonDappKitLedgerServiceNeo3';
+export * from './services/nft-data/GhostMarketNDSNeo3';
+export * from './services/nft-data/RpcNDSNeo3';
+export * from './services/swap/FlamingoSwapServiceNeo3';

package/dist/index.js

@@ -14,15 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./flamingo-swap/FlamingoSwapControllerService"), exports);
-__exportStar(require("./flamingo-swap/FlamingoSwapHelper"), exports);
-__exportStar(require("./flamingo-swap/FlamingoSwapNeonDappKitInvocationBuilder"), exports);
 __exportStar(require("./BSNeo3"), exports);
-__exportStar(require("./BSNeo3Helper"), exports);
-__exportStar(require("./DoraBDSNeo3"), exports);
-__exportStar(require("./DoraESNeo3"), exports);
-__exportStar(require("./FlamingoEDSNeo3"), exports);
-__exportStar(require("./GhostMarketNDSNeo3"), exports);
-__exportStar(require("./NeonDappKitLedgerServiceNeo3"), exports);
-__exportStar(require("./RpcBDSNeo3"), exports);
-__exportStar(require("./RpcNDSNeo3"), exports);
+__exportStar(require("./builder/invocation/FlamingoSwapInvocationBuilderNeo3"), exports);
+__exportStar(require("./builder/invocation/NeonDappKitInvocationBuilderNeo3"), exports);
+__exportStar(require("./constants/FlamingoSwapConstants"), exports);
+__exportStar(require("./helpers/BSNeo3Helper"), exports);
+__exportStar(require("./helpers/FlamingoSwapHelper"), exports);
+__exportStar(require("./services/blockchain-data/DoraBDSNeo3"), exports);
+__exportStar(require("./services/blockchain-data/RpcBDSNeo3"), exports);
+__exportStar(require("./services/exchange-data/FlamingoEDSNeo3"), exports);
+__exportStar(require("./services/explorer/DoraESNeo3"), exports);
+__exportStar(require("./services/ledger/NeonDappKitLedgerServiceNeo3"), exports);
+__exportStar(require("./services/nft-data/GhostMarketNDSNeo3"), exports);
+__exportStar(require("./services/nft-data/RpcNDSNeo3"), exports);
+__exportStar(require("./services/swap/FlamingoSwapServiceNeo3"), exports);

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

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

package/dist/{DoraBDSNeo3.js → services/blockchain-data/DoraBDSNeo3.js}

@@ -10,15 +10,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoraBDSNeo3 = void 0;
-const neon_js_1 = require("@cityofzion/neon-js");
 const api_1 = require("@cityofzion/dora-ts/dist/api");
+const neon_js_1 = require("@cityofzion/neon-js");
+const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 const RpcBDSNeo3_1 = require("./RpcBDSNeo3");
-const BSNeo3Helper_1 = require("./BSNeo3Helper");
 const NeoRest = new api_1.NeoRESTApi({
     doraUrl: 'https://dora.coz.io',
     endpoint: '/api/v2/neo3',
 });
-class DoraBDSNeo3 extends RpcBDSNeo3_1.RPCBDSNeo3 {
+class DoraBDSNeo3 extends RpcBDSNeo3_1.RpcBDSNeo3 {
     constructor(network, feeToken, claimToken, tokens) {
         super(network, feeToken, claimToken, tokens);
     }

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

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

package/dist/{RpcBDSNeo3.js → services/blockchain-data/RpcBDSNeo3.js}

@@ -9,11 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RPCBDSNeo3 = void 0;
+exports.RpcBDSNeo3 = void 0;
 const neon_core_1 = require("@cityofzion/neon-core");
 const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
-const BSNeo3Helper_1 = require("./BSNeo3Helper");
-class RPCBDSNeo3 {
+const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
+class RpcBDSNeo3 {
     constructor(network, feeToken, claimToken, tokens) {
         this._tokenCache = new Map();
         this._tokens = [];
@@ -185,4 +185,4 @@ class RPCBDSNeo3 {
         });
     }
 }
-exports.RPCBDSNeo3 = RPCBDSNeo3;
+exports.RpcBDSNeo3 = RpcBDSNeo3;

package/dist/{FlamingoEDSNeo3.d.ts → 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 './BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
 export declare class FlamingoEDSNeo3 extends CryptoCompareEDS implements ExchangeDataService {
     #private;
     constructor(network: Network<BSNeo3NetworkId>);

package/dist/{FlamingoEDSNeo3.js → services/exchange-data/FlamingoEDSNeo3.js}

@@ -27,7 +27,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlamingoEDSNeo3 = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const axios_1 = __importDefault(require("axios"));
-const BSNeo3Helper_1 = require("./BSNeo3Helper");
+const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 class FlamingoEDSNeo3 extends blockchain_service_1.CryptoCompareEDS {
     constructor(network) {
         super();

package/dist/{DoraESNeo3.d.ts → services/explorer/DoraESNeo3.d.ts}

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

package/dist/{DoraESNeo3.js → services/explorer/DoraESNeo3.js}

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _DoraESNeo3_network;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoraESNeo3 = void 0;
-const BSNeo3Helper_1 = require("./BSNeo3Helper");
+const BSNeo3Helper_1 = require("../../helpers/BSNeo3Helper");
 class DoraESNeo3 {
     constructor(network) {
         _DoraESNeo3_network.set(this, void 0);

package/dist/{NeonDappKitLedgerServiceNeo3.d.ts → services/ledger/NeonDappKitLedgerServiceNeo3.d.ts}

@@ -1,7 +1,8 @@
 import { Account, LedgerService, LedgerServiceEmitter } from '@cityofzion/blockchain-service';
-import Transport from '@ledgerhq/hw-transport';
 import { api } from '@cityofzion/neon-js';
+import Transport from '@ledgerhq/hw-transport';
 export declare class NeonDappKitLedgerServiceNeo3 implements LedgerService {
+    #private;
     getLedgerTransport?: ((account: Account) => Promise<Transport>) | undefined;
     emitter: LedgerServiceEmitter;
     constructor(getLedgerTransport?: ((account: Account) => Promise<Transport>) | undefined);
@@ -9,7 +10,4 @@ export declare class NeonDappKitLedgerServiceNeo3 implements LedgerService {
     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/services/ledger/NeonDappKitLedgerServiceNeo3.js

@@ -0,0 +1,135 @@
+"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());
+    });
+};
+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 _NeonDappKitLedgerServiceNeo3_instances, _NeonDappKitLedgerServiceNeo3_sendChunk, _NeonDappKitLedgerServiceNeo3_toBip44, _NeonDappKitLedgerServiceNeo3_to8BitHex, _NeonDappKitLedgerServiceNeo3_derSignatureToHex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeonDappKitLedgerServiceNeo3 = void 0;
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
+const neon_js_1 = require("@cityofzion/neon-js");
+const events_1 = __importDefault(require("events"));
+var LedgerStatus;
+(function (LedgerStatus) {
+    LedgerStatus[LedgerStatus["OK"] = 36864] = "OK";
+})(LedgerStatus || (LedgerStatus = {}));
+var LedgerCommand;
+(function (LedgerCommand) {
+    LedgerCommand[LedgerCommand["GET_PUBLIC_KEY"] = 4] = "GET_PUBLIC_KEY";
+    LedgerCommand[LedgerCommand["SIGN"] = 2] = "SIGN";
+})(LedgerCommand || (LedgerCommand = {}));
+var LedgerSecondParameter;
+(function (LedgerSecondParameter) {
+    LedgerSecondParameter[LedgerSecondParameter["MORE_DATA"] = 128] = "MORE_DATA";
+    LedgerSecondParameter[LedgerSecondParameter["LAST_DATA"] = 0] = "LAST_DATA";
+})(LedgerSecondParameter || (LedgerSecondParameter = {}));
+class NeonDappKitLedgerServiceNeo3 {
+    constructor(getLedgerTransport) {
+        this.getLedgerTransport = getLedgerTransport;
+        _NeonDappKitLedgerServiceNeo3_instances.add(this);
+        this.emitter = new events_1.default();
+    }
+    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* () {
+            try {
+                this.emitter.emit('getSignatureStart');
+                const bip44 = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_toBip44).call(this, addressIndex);
+                // 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);
+                // 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));
+                const chunks = serializedTransaction.match(/.{1,510}/g) || [];
+                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
+                const lastChunkIndex = 2 + chunks.length;
+                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!`);
+                }
+                const signature = __classPrivateFieldGet(this, _NeonDappKitLedgerServiceNeo3_instances, "m", _NeonDappKitLedgerServiceNeo3_derSignatureToHex).call(this, response.toString('hex'));
+                return signature;
+            }
+            finally {
+                this.emitter.emit('getSignatureEnd');
+            }
+        });
+    }
+    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) {
+    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_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)
+    // 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('');
+};

package/dist/{GhostMarketNDSNeo3.d.ts → services/nft-data/GhostMarketNDSNeo3.d.ts}

@@ -1,5 +1,5 @@
-import { NftResponse, NftsResponse, GetNftParam, GetNftsByAddressParams, Network } from '@cityofzion/blockchain-service';
-import { BSNeo3NetworkId } from './BSNeo3Helper';
+import { GetNftParam, GetNftsByAddressParams, Network, NftResponse, NftsResponse } from '@cityofzion/blockchain-service';
+import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
 import { RpcNDSNeo3 } from './RpcNDSNeo3';
 export declare class GhostMarketNDSNeo3 extends RpcNDSNeo3 {
     #private;

package/dist/{RpcNDSNeo3.d.ts → 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 './BSNeo3Helper';
+import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
 export declare abstract class RpcNDSNeo3 implements NftDataService {
     #private;
     protected constructor(network: Network<BSNeo3NetworkId>);

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

@@ -0,0 +1,23 @@
+import { Account, Network, PoolGraph, SwapService, SwapServiceEvents, SwapServiceSwapToReceiveArgs, SwapServiceSwapToUseArgs, Token } from '@cityofzion/blockchain-service';
+import TypedEmitter from 'typed-emitter';
+import { BSNeo3NetworkId } from '../../helpers/BSNeo3Helper';
+import { NeonDappKitLedgerServiceNeo3 } from '../ledger/NeonDappKitLedgerServiceNeo3';
+type BuildSwapInvocationArgs = SwapServiceSwapToUseArgs<BSNeo3NetworkId> | SwapServiceSwapToReceiveArgs<BSNeo3NetworkId>;
+export declare class FlamingoSwapServiceNeo3 implements SwapService<BSNeo3NetworkId> {
+    #private;
+    eventEmitter: TypedEmitter<SwapServiceEvents>;
+    constructor(network: Network<BSNeo3NetworkId>, ledgerService: NeonDappKitLedgerServiceNeo3);
+    buildSwapInvocationArgs(): BuildSwapInvocationArgs;
+    listSwappableTokens(network: Network<BSNeo3NetworkId>): PoolGraph;
+    swap(isLedger?: boolean): Promise<void>;
+    startListeningBlockGeneration(): void;
+    stopListeningBlockGeneration(): void;
+    setAccountToUse(account: Account | null): void;
+    setAmountToUse(val: string | null): void;
+    setAmountToReceive(val: string | null): void;
+    setDeadline(deadline: string): void;
+    setSlippage(slippage: number): void;
+    setTokenToUse(val: Token | null): Promise<void>;
+    setTokenToReceive(val: Token | null): Promise<void>;
+}
+export {};