@cityofzion/bs-neo-legacy 1.13.4 → 1.13.6

package/dist/services/exchange-data/CryptoCompareEDSNeoLegacy.js

@@ -19,23 +19,23 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _CryptoCompareEDSNeoLegacy_network;
+var _CryptoCompareEDSNeoLegacy_service;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CryptoCompareEDSNeoLegacy = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const BSNeoLegacyHelper_1 = require("../../helpers/BSNeoLegacyHelper");
 class CryptoCompareEDSNeoLegacy extends blockchain_service_1.CryptoCompareEDS {
-    constructor(network) {
+    constructor(service) {
         super();
-        _CryptoCompareEDSNeoLegacy_network.set(this, void 0);
-        __classPrivateFieldSet(this, _CryptoCompareEDSNeoLegacy_network, network, "f");
+        _CryptoCompareEDSNeoLegacy_service.set(this, void 0);
+        __classPrivateFieldSet(this, _CryptoCompareEDSNeoLegacy_service, service, "f");
     }
     getTokenPriceHistory(params) {
         const _super = Object.create(null, {
             getTokenPriceHistory: { get: () => super.getTokenPriceHistory }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(__classPrivateFieldGet(this, _CryptoCompareEDSNeoLegacy_network, "f")))
+            if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _CryptoCompareEDSNeoLegacy_service, "f").network))
                 throw new Error('Exchange is only available on mainnet');
             return yield _super.getTokenPriceHistory.call(this, params);
         });
@@ -45,11 +45,11 @@ class CryptoCompareEDSNeoLegacy extends blockchain_service_1.CryptoCompareEDS {
             getTokenPrices: { get: () => super.getTokenPrices }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(__classPrivateFieldGet(this, _CryptoCompareEDSNeoLegacy_network, "f")))
+            if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _CryptoCompareEDSNeoLegacy_service, "f").network))
                 throw new Error('Exchange is only available on mainnet');
             return yield _super.getTokenPrices.call(this, params);
         });
     }
 }
 exports.CryptoCompareEDSNeoLegacy = CryptoCompareEDSNeoLegacy;
-_CryptoCompareEDSNeoLegacy_network = new WeakMap();
+_CryptoCompareEDSNeoLegacy_service = new WeakMap();

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

@@ -1,11 +1,12 @@
-import { BuildNftUrlParams, ExplorerService, Network, TokenService } from '@cityofzion/blockchain-service';
-import { BSNeoLegacyNetworkId } from '../../constants/BSNeoLegacyConstants';
-export declare class NeoTubeESNeoLegacy implements ExplorerService {
+import { TBuildNftUrlParams, IExplorerService } from '@cityofzion/blockchain-service';
+import { IBSNeoLegacy } from '../../types';
+export declare class NeoTubeESNeoLegacy<N extends string> implements IExplorerService {
     #private;
-    constructor(network: Network<BSNeoLegacyNetworkId>, tokenService: TokenService);
+    static readonly BASE_URL: string;
+    constructor(service: IBSNeoLegacy<N>);
     buildTransactionUrl(hash: string): string;
     buildContractUrl(contractHash: string): string;
-    buildNftUrl(_params: BuildNftUrlParams): string;
+    buildNftUrl(_params: TBuildNftUrlParams): string;
     getAddressTemplateUrl(): string | undefined;
     getTxTemplateUrl(): string | undefined;
     getNftTemplateUrl(): undefined;

package/dist/services/explorer/NeoTubeESNeoLegacy.js

@@ -10,49 +10,47 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _NeoTubeESNeoLegacy_BASE_URL, _NeoTubeESNeoLegacy_network, _NeoTubeESNeoLegacy_tokenService;
+var _NeoTubeESNeoLegacy_service;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NeoTubeESNeoLegacy = void 0;
 const BSNeoLegacyHelper_1 = require("../../helpers/BSNeoLegacyHelper");
 class NeoTubeESNeoLegacy {
-    constructor(network, tokenService) {
-        _NeoTubeESNeoLegacy_BASE_URL.set(this, 'https://neo2.neotube.io');
-        _NeoTubeESNeoLegacy_network.set(this, void 0);
-        _NeoTubeESNeoLegacy_tokenService.set(this, void 0);
-        __classPrivateFieldSet(this, _NeoTubeESNeoLegacy_network, network, "f");
-        __classPrivateFieldSet(this, _NeoTubeESNeoLegacy_tokenService, tokenService, "f");
+    constructor(service) {
+        _NeoTubeESNeoLegacy_service.set(this, void 0);
+        __classPrivateFieldSet(this, _NeoTubeESNeoLegacy_service, service, "f");
     }
     buildTransactionUrl(hash) {
-        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_network, "f")))
+        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_service, "f").network))
             throw new Error('NeoTube is only available on mainnet');
-        return `${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_BASE_URL, "f")}/transaction/${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_tokenService, "f").normalizeHash(hash)}`;
+        return `${NeoTubeESNeoLegacy.BASE_URL}/transaction/${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_service, "f").tokenService.normalizeHash(hash)}`;
     }
     buildContractUrl(contractHash) {
-        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_network, "f")))
+        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_service, "f").network))
             throw new Error('NeoTube is only available on mainnet');
-        return `${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_BASE_URL, "f")}/asset/${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_tokenService, "f").normalizeHash(contractHash)}/page/1`;
+        return `${NeoTubeESNeoLegacy.BASE_URL}/asset/${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_service, "f").tokenService.normalizeHash(contractHash)}/page/1`;
     }
     buildNftUrl(_params) {
         throw new Error('NeoTube does not support nft');
     }
     getAddressTemplateUrl() {
-        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_network, "f")))
+        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_service, "f").network))
             return undefined;
-        return `${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_BASE_URL, "f")}/address/{address}`;
+        return `${NeoTubeESNeoLegacy.BASE_URL}/address/{address}`;
     }
     getTxTemplateUrl() {
-        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_network, "f")))
+        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_service, "f").network))
             return undefined;
-        return `${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_BASE_URL, "f")}/transaction/{txId}`;
+        return `${NeoTubeESNeoLegacy.BASE_URL}/transaction/{txId}`;
     }
     getNftTemplateUrl() {
         return undefined;
     }
     getContractTemplateUrl() {
-        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnet(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_network, "f")))
+        if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_service, "f").network))
             return undefined;
-        return `${__classPrivateFieldGet(this, _NeoTubeESNeoLegacy_BASE_URL, "f")}/asset/{hash}/page/1`;
+        return `${NeoTubeESNeoLegacy.BASE_URL}/asset/{hash}/page/1`;
     }
 }
 exports.NeoTubeESNeoLegacy = NeoTubeESNeoLegacy;
-_NeoTubeESNeoLegacy_BASE_URL = new WeakMap(), _NeoTubeESNeoLegacy_network = new WeakMap(), _NeoTubeESNeoLegacy_tokenService = new WeakMap();
+_NeoTubeESNeoLegacy_service = new WeakMap();
+NeoTubeESNeoLegacy.BASE_URL = 'https://neo2.neotube.io';

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

@@ -1,12 +1,12 @@
-import { Account, GetLedgerTransport, LedgerService, LedgerServiceEmitter, UntilIndexRecord } from '@cityofzion/blockchain-service';
+import { TBSAccount, TGetLedgerTransport, ILedgerService, TLedgerServiceEmitter, TUntilIndexRecord } from '@cityofzion/blockchain-service';
 import { BSNeoLegacy } from '../../BSNeoLegacy';
 import Transport from '@ledgerhq/hw-transport';
-export declare class NeonJsLedgerServiceNeoLegacy<BSName extends string = string> implements LedgerService<BSName> {
+export declare class NeonJsLedgerServiceNeoLegacy<N extends string = string> implements ILedgerService<N> {
     #private;
-    emitter: LedgerServiceEmitter;
-    getLedgerTransport?: GetLedgerTransport<BSName>;
-    constructor(blockchainService: BSNeoLegacy<BSName>, getLedgerTransport?: GetLedgerTransport<BSName>);
-    getAccount(transport: Transport, index: number): Promise<Account<BSName>>;
-    getAccounts(transport: Transport, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Account<BSName>[]>;
-    getSigningCallback(transport: Transport, account: Account): (transaction: string, publicKey: string) => Promise<string | string[]>;
+    readonly getLedgerTransport?: TGetLedgerTransport<N>;
+    emitter: TLedgerServiceEmitter;
+    constructor(blockchainService: BSNeoLegacy<N>, getLedgerTransport?: TGetLedgerTransport<N>);
+    getAccount(transport: Transport, index: number): Promise<TBSAccount<N>>;
+    getAccounts(transport: Transport, untilIndexByBlockchainService?: TUntilIndexRecord<N>): Promise<TBSAccount<N>[]>;
+    getSigningCallback(transport: Transport, account: TBSAccount): (transaction: string, publicKey: string) => Promise<string | string[]>;
 }

package/dist/services/ledger/NeonJsLedgerServiceNeoLegacy.js

@@ -22,57 +22,45 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _NeonJsLedgerServiceNeoLegacy_instances, _NeonJsLedgerServiceNeoLegacy_blockchainService, _NeonJsLedgerServiceNeoLegacy_sendChunk, _NeonJsLedgerServiceNeoLegacy_bip44PathToHex, _NeonJsLedgerServiceNeoLegacy_derSignatureToHex;
+var _NeonJsLedgerServiceNeoLegacy_instances, _NeonJsLedgerServiceNeoLegacy_service, _NeonJsLedgerServiceNeoLegacy_sendChunk, _NeonJsLedgerServiceNeoLegacy_bip44PathToHex, _NeonJsLedgerServiceNeoLegacy_derSignatureToHex;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NeonJsLedgerServiceNeoLegacy = void 0;
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const events_1 = __importDefault(require("events"));
-const neon_js_1 = require("@cityofzion/neon-js");
-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 LedgerParameter;
-(function (LedgerParameter) {
-    LedgerParameter[LedgerParameter["MORE_DATA"] = 0] = "MORE_DATA";
-    LedgerParameter[LedgerParameter["LAST_DATA"] = 128] = "LAST_DATA";
-})(LedgerParameter || (LedgerParameter = {}));
+const types_1 = require("../../types");
+const BSNeoLegacyNeonJsSingletonHelper_1 = require("../../helpers/BSNeoLegacyNeonJsSingletonHelper");
 class NeonJsLedgerServiceNeoLegacy {
     constructor(blockchainService, getLedgerTransport) {
         _NeonJsLedgerServiceNeoLegacy_instances.add(this);
-        _NeonJsLedgerServiceNeoLegacy_blockchainService.set(this, void 0);
+        _NeonJsLedgerServiceNeoLegacy_service.set(this, void 0);
         this.emitter = new events_1.default();
-        __classPrivateFieldSet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, blockchainService, "f");
+        __classPrivateFieldSet(this, _NeonJsLedgerServiceNeoLegacy_service, blockchainService, "f");
         this.getLedgerTransport = getLedgerTransport;
     }
     getAccount(transport, index) {
         return __awaiter(this, void 0, void 0, function* () {
-            const bip44Path = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f").bip44DerivationPath.replace('?', index.toString());
+            const bip44Path = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_service, "f").bip44DerivationPath.replace('?', index.toString());
             const bip44PathHex = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_bip44PathToHex).call(this, bip44Path);
-            const result = yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, LedgerCommand.GET_PUBLIC_KEY, LedgerParameter.LAST_DATA, bip44PathHex);
+            const result = yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, types_1.ENeonJsLedgerServiceNeoLegacyCommand.GET_PUBLIC_KEY, types_1.ENeonJsLedgerServiceNeoLegacyParameter.LAST_DATA, bip44PathHex);
             const publicKey = result.toString('hex').substring(0, 130);
-            const { address } = new neon_js_1.wallet.Account(publicKey);
+            const { wallet } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+            const { address } = new wallet.Account(publicKey);
             return {
                 address,
                 key: publicKey,
                 type: 'publicKey',
                 bip44Path,
-                blockchain: __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f").name,
+                blockchain: __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_service, "f").name,
                 isHardware: true,
             };
         });
     }
     getAccounts(transport, untilIndexByBlockchainService) {
         return __awaiter(this, void 0, void 0, function* () {
-            const accountsByBlockchainService = yield (0, blockchain_service_1.generateAccountForBlockchainService)([__classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f")], (_service, index) => __awaiter(this, void 0, void 0, function* () {
+            const accountsByBlockchainService = yield (0, blockchain_service_1.generateAccountForBlockchainService)([__classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_service, "f")], (_service, index) => __awaiter(this, void 0, void 0, function* () {
                 return this.getAccount(transport, index);
             }), untilIndexByBlockchainService);
-            const accounts = accountsByBlockchainService.get(__classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f").name);
+            const accounts = accountsByBlockchainService.get(__classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_service, "f").name);
             return accounts !== null && accounts !== void 0 ? accounts : [];
         });
     }
@@ -83,8 +71,9 @@ class NeonJsLedgerServiceNeoLegacy {
                 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.getScriptHashFromPublicKey(publicKey);
+                const { wallet, tx } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+                const neonJsAccount = new wallet.Account(account.key);
+                const witnessScriptHash = wallet.getScriptHashFromPublicKey(publicKey);
                 if (neonJsAccount.scriptHash !== witnessScriptHash) {
                     throw new Error('Public key does not match the account key');
                 }
@@ -94,15 +83,15 @@ class NeonJsLedgerServiceNeoLegacy {
                 const chunks = payload.match(/.{1,510}/g) || [];
                 // Send all chunks except the last one
                 for (let i = 0; i < chunks.length - 1; i++) {
-                    yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, LedgerCommand.SIGN, LedgerParameter.MORE_DATA, chunks[i]);
+                    yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, types_1.ENeonJsLedgerServiceNeoLegacyCommand.SIGN, types_1.ENeonJsLedgerServiceNeoLegacyParameter.MORE_DATA, chunks[i]);
                 }
                 // Send the last chunk signaling that it is the last one and get the signature
-                const response = yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, LedgerCommand.SIGN, LedgerParameter.LAST_DATA, chunks[chunks.length - 1]);
-                if (response.readUIntBE(0, 2) === LedgerStatus.OK) {
+                const response = yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, types_1.ENeonJsLedgerServiceNeoLegacyCommand.SIGN, types_1.ENeonJsLedgerServiceNeoLegacyParameter.LAST_DATA, chunks[chunks.length - 1]);
+                if (response.readUIntBE(0, 2) === types_1.ENeonJsLedgerServiceNeoLegacyStatus.OK) {
                     throw new Error('No more data but Ledger did not return signature!');
                 }
                 const signature = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_derSignatureToHex).call(this, response.toString('hex'));
-                const witness = neon_js_1.tx.Witness.fromSignature(signature, publicKey);
+                const witness = tx.Witness.fromSignature(signature, publicKey);
                 return witness.serialize();
             }
             finally {
@@ -112,8 +101,10 @@ class NeonJsLedgerServiceNeoLegacy {
     }
 }
 exports.NeonJsLedgerServiceNeoLegacy = NeonJsLedgerServiceNeoLegacy;
-_NeonJsLedgerServiceNeoLegacy_blockchainService = new WeakMap(), _NeonJsLedgerServiceNeoLegacy_instances = new WeakSet(), _NeonJsLedgerServiceNeoLegacy_sendChunk = function _NeonJsLedgerServiceNeoLegacy_sendChunk(transport, command, parameter, chunk) {
-    return transport.send(0x80, command, parameter, 0x00, Buffer.from(chunk, 'hex'), [LedgerStatus.OK]);
+_NeonJsLedgerServiceNeoLegacy_service = new WeakMap(), _NeonJsLedgerServiceNeoLegacy_instances = new WeakSet(), _NeonJsLedgerServiceNeoLegacy_sendChunk = function _NeonJsLedgerServiceNeoLegacy_sendChunk(transport, command, parameter, chunk) {
+    return transport.send(0x80, command, parameter, 0x00, Buffer.from(chunk, 'hex'), [
+        types_1.ENeonJsLedgerServiceNeoLegacyStatus.OK,
+    ]);
 }, _NeonJsLedgerServiceNeoLegacy_bip44PathToHex = function _NeonJsLedgerServiceNeoLegacy_bip44PathToHex(path) {
     let result = '';
     const components = path.split('/');
@@ -129,7 +120,8 @@ _NeonJsLedgerServiceNeoLegacy_blockchainService = new WeakMap(), _NeonJsLedgerSe
     });
     return result;
 }, _NeonJsLedgerServiceNeoLegacy_derSignatureToHex = function _NeonJsLedgerServiceNeoLegacy_derSignatureToHex(response) {
-    const ss = new neon_js_1.u.StringStream(response);
+    const { u } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+    const ss = new 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);

package/dist/services/migration/Neo3NeoLegacyMigrationService.d.ts

@@ -0,0 +1,16 @@
+import { IBSNeoLegacy, TNeo3NeoLegacyMigrationNeo3Amounts, TNeo3NeoLegacyMigrationNeoLegacyAmounts, TNeo3NeoLegacyMigrateParams, TNeo3NeoLegacyWaitForMigrationParams } from '../../types';
+import { TBalanceResponse } from '@cityofzion/blockchain-service';
+export declare class Neo3NeoLegacyMigrationService<N extends string> {
+    #private;
+    constructor(service: IBSNeoLegacy<N>);
+    migrate({ account, neo3Address, neoLegacyMigrationAmounts }: TNeo3NeoLegacyMigrateParams<N>): Promise<string>;
+    /**
+     * Reference: https://github.com/CityOfZion/legacy-n3-swap-service/blob/master/policy/policy.go
+     */
+    calculateNeo3MigrationAmounts(neoLegacyMigrationAmounts: TNeo3NeoLegacyMigrationNeoLegacyAmounts): TNeo3NeoLegacyMigrationNeo3Amounts;
+    calculateNeoLegacyMigrationAmounts(balance: TBalanceResponse[]): TNeo3NeoLegacyMigrationNeoLegacyAmounts;
+    static waitForMigration(params: TNeo3NeoLegacyWaitForMigrationParams): Promise<{
+        isTransactionConfirmed: boolean;
+        isNeo3TransactionConfirmed: boolean;
+    }>;
+}

package/dist/services/migration/Neo3NeoLegacyMigrationService.js

@@ -0,0 +1,173 @@
+"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 __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 _Neo3NeoLegacyMigrationService_service;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Neo3NeoLegacyMigrationService = void 0;
+const BSNeoLegacyHelper_1 = require("../../helpers/BSNeoLegacyHelper");
+const BSNeoLegacyConstants_1 = require("../../constants/BSNeoLegacyConstants");
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSNeoLegacyNeonJsSingletonHelper_1 = require("../../helpers/BSNeoLegacyNeonJsSingletonHelper");
+class Neo3NeoLegacyMigrationService {
+    constructor(service) {
+        _Neo3NeoLegacyMigrationService_service.set(this, void 0);
+        __classPrivateFieldSet(this, _Neo3NeoLegacyMigrationService_service, service, "f");
+    }
+    migrate(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ account, neo3Address, neoLegacyMigrationAmounts }) {
+            if (!BSNeoLegacyHelper_1.BSNeoLegacyHelper.isMainnetNetwork(__classPrivateFieldGet(this, _Neo3NeoLegacyMigrationService_service, "f").network)) {
+                throw new Error('Must use Mainnet network');
+            }
+            if ((!neoLegacyMigrationAmounts.hasEnoughGasBalance && !neoLegacyMigrationAmounts.hasEnoughNeoBalance) ||
+                (!neoLegacyMigrationAmounts.gasBalance && !neoLegacyMigrationAmounts.neoBalance)) {
+                throw new Error('Must have at least 0.1 GAS or 2 NEO');
+            }
+            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _Neo3NeoLegacyMigrationService_service, "f").generateSigningCallback(account);
+            const { api, tx, u } = BSNeoLegacyNeonJsSingletonHelper_1.BSNeoLegacyNeonJsSingletonHelper.getInstance();
+            const provider = new api.neoCli.instance(__classPrivateFieldGet(this, _Neo3NeoLegacyMigrationService_service, "f").network.url);
+            const intents = [];
+            if (neoLegacyMigrationAmounts.hasEnoughGasBalance && neoLegacyMigrationAmounts.gasBalance)
+                intents.push(...api.makeIntent({ [BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET.symbol]: Number(neoLegacyMigrationAmounts.gasBalance.amount) }, BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_LEGACY_ADDRESS));
+            if (neoLegacyMigrationAmounts.hasEnoughNeoBalance && neoLegacyMigrationAmounts.neoBalance)
+                intents.push(...api.makeIntent({ [BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET.symbol]: Number(neoLegacyMigrationAmounts.neoBalance.amount) }, BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_LEGACY_ADDRESS));
+            return yield __classPrivateFieldGet(this, _Neo3NeoLegacyMigrationService_service, "f").sendTransfer({
+                url: __classPrivateFieldGet(this, _Neo3NeoLegacyMigrationService_service, "f").network.url,
+                api: provider,
+                account: neonJsAccount,
+                intents,
+                signingFunction: signingCallback,
+                override: {
+                    attributes: [
+                        new tx.TransactionAttribute({
+                            usage: tx.TxAttrUsage.Remark14,
+                            data: u.str2hexstring(neo3Address),
+                        }),
+                        new tx.TransactionAttribute({
+                            usage: tx.TxAttrUsage.Remark15,
+                            data: u.str2hexstring('Neon Desktop Migration'),
+                        }),
+                    ],
+                },
+            });
+        });
+    }
+    /**
+     * Reference: https://github.com/CityOfZion/legacy-n3-swap-service/blob/master/policy/policy.go
+     */
+    calculateNeo3MigrationAmounts(neoLegacyMigrationAmounts) {
+        const response = {
+            gasMigrationReceiveAmount: undefined,
+            gasMigrationTotalFees: undefined,
+            neoMigrationReceiveAmount: undefined,
+            neoMigrationTotalFees: undefined,
+        };
+        if (neoLegacyMigrationAmounts.gasBalance && neoLegacyMigrationAmounts.hasEnoughGasBalance) {
+            // Two transfers fee and one transfer fee left over
+            const allNep17TransfersFee = BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_NEP_17_TRANSFER_FEE * 3;
+            const gasMigrationAmountNumber = Number(neoLegacyMigrationAmounts.gasBalance.amount);
+            // Necessary to calculate the COZ fee
+            const gasAmountNumberLessAllNep17TransfersFee = gasMigrationAmountNumber - allNep17TransfersFee;
+            // Example: ~0.06635710 * 0.01 = ~0.00066357
+            const cozFee = gasAmountNumberLessAllNep17TransfersFee * BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_FEE;
+            // Example: ~0.06635710 - ~0.00066357 = ~0.06569352
+            const gasAmountNumberLessCozFee = gasAmountNumberLessAllNep17TransfersFee - cozFee;
+            const allGasFeeNumberThatUserWillPay = cozFee + BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_NEP_17_TRANSFER_FEE * 2;
+            const allGasAmountNumberThatUserWillReceive = gasAmountNumberLessCozFee + BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_NEP_17_TRANSFER_FEE;
+            response.gasMigrationTotalFees = blockchain_service_1.BSBigNumberHelper.format(allGasFeeNumberThatUserWillPay, {
+                decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET.decimals,
+            });
+            response.gasMigrationReceiveAmount = blockchain_service_1.BSBigNumberHelper.format(allGasAmountNumberThatUserWillReceive, {
+                decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET.decimals,
+            });
+        }
+        if (neoLegacyMigrationAmounts.neoBalance && neoLegacyMigrationAmounts.hasEnoughNeoBalance) {
+            const neoMigrationAmountNumber = Number(neoLegacyMigrationAmounts.neoBalance.amount);
+            response.neoMigrationTotalFees = blockchain_service_1.BSBigNumberHelper.format(Math.ceil(neoMigrationAmountNumber * BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_FEE), { decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET.decimals });
+            response.neoMigrationReceiveAmount = blockchain_service_1.BSBigNumberHelper.format(neoMigrationAmountNumber - Number(response.neoMigrationTotalFees), { decimals: BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET.decimals });
+        }
+        return response;
+    }
+    calculateNeoLegacyMigrationAmounts(balance) {
+        const gasBalance = balance.find(({ token }) => __classPrivateFieldGet(this, _Neo3NeoLegacyMigrationService_service, "f").tokenService.predicateByHash(BSNeoLegacyConstants_1.BSNeoLegacyConstants.GAS_ASSET, token));
+        const neoBalance = balance.find(({ token }) => __classPrivateFieldGet(this, _Neo3NeoLegacyMigrationService_service, "f").tokenService.predicateByHash(BSNeoLegacyConstants_1.BSNeoLegacyConstants.NEO_ASSET, token));
+        let hasEnoughGasBalance = false;
+        let hasEnoughNeoBalance = false;
+        if (gasBalance) {
+            const gasBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(gasBalance.amount);
+            hasEnoughGasBalance = gasBalanceNumber.isGreaterThanOrEqualTo(BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_MIN_GAS);
+        }
+        if (neoBalance) {
+            const neoBalanceNumber = blockchain_service_1.BSBigNumberHelper.fromNumber(neoBalance.amount);
+            hasEnoughNeoBalance = neoBalanceNumber.isGreaterThanOrEqualTo(BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_MIN_NEO);
+        }
+        return {
+            gasBalance,
+            neoBalance,
+            hasEnoughGasBalance,
+            hasEnoughNeoBalance,
+        };
+    }
+    static waitForMigration(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { neo3Address, neo3Service, transactionHash, neoLegacyService } = params;
+            const MAX_ATTEMPTS = 10;
+            const NEO3_MAX_ATTEMPTS = 20;
+            const response = {
+                isTransactionConfirmed: false,
+                isNeo3TransactionConfirmed: false,
+            };
+            let transactionResponse;
+            for (let i = 0; i < MAX_ATTEMPTS; i++) {
+                yield blockchain_service_1.BSUtilsHelper.wait(30000);
+                try {
+                    transactionResponse = yield neoLegacyService.blockchainDataService.getTransaction(transactionHash);
+                    response.isTransactionConfirmed = true;
+                    break;
+                }
+                catch (_a) {
+                    // Empty block
+                }
+            }
+            if (!response.isTransactionConfirmed)
+                return response;
+            for (let i = 0; i < NEO3_MAX_ATTEMPTS; i++) {
+                yield blockchain_service_1.BSUtilsHelper.wait(60000);
+                try {
+                    const neo3Response = yield neo3Service.blockchainDataService.getTransactionsByAddress({
+                        address: neo3Address,
+                    });
+                    const isTransactionConfirmed = neo3Response.transactions.some(transaction => transaction.time > transactionResponse.time &&
+                        transaction.transfers.some(transfer => transfer.from === BSNeoLegacyConstants_1.BSNeoLegacyConstants.MIGRATION_COZ_NEO3_ADDRESS));
+                    if (isTransactionConfirmed) {
+                        response.isNeo3TransactionConfirmed = true;
+                        break;
+                    }
+                }
+                catch (_b) {
+                    // Empty block
+                }
+            }
+            return response;
+        });
+    }
+}
+exports.Neo3NeoLegacyMigrationService = Neo3NeoLegacyMigrationService;
+_Neo3NeoLegacyMigrationService_service = new WeakMap();

package/dist/types.d.ts

@@ -0,0 +1,44 @@
+import { TBSAccount, TBalanceResponse, IBlockchainService, IBSWithClaim, IBSWithEncryption, IBSWithExplorer, IBSWithLedger, TBSNetworkId } from '@cityofzion/blockchain-service';
+export type TBSNeoLegacyNetworkId = TBSNetworkId<'mainnet' | 'testnet'>;
+export type TSigningCallback = (transaction: string, publicKey: string) => Promise<string | string[]>;
+export interface IBSNeoLegacy<N extends string = string> extends IBlockchainService<N, TBSNeoLegacyNetworkId>, IBSWithClaim<N>, IBSWithExplorer, IBSWithLedger<N>, IBSWithEncryption<N> {
+    generateSigningCallback(account: TBSAccount<N>): Promise<{
+        neonJsAccount: any;
+        signingCallback: TSigningCallback;
+    }>;
+    sendTransfer(config: any, nep5ScriptBuilder?: any): Promise<string>;
+}
+export type TNeo3NeoLegacyWaitForMigrationParams = {
+    transactionHash: string;
+    neo3Address: string;
+    neo3Service: IBlockchainService;
+    neoLegacyService: IBlockchainService;
+};
+export type TNeo3NeoLegacyMigrateParams<N extends string = string> = {
+    account: TBSAccount<N>;
+    neo3Address: string;
+    neoLegacyMigrationAmounts: TNeo3NeoLegacyMigrationNeoLegacyAmounts;
+};
+export type TNeo3NeoLegacyMigrationNeo3Amounts = {
+    gasMigrationTotalFees?: string;
+    neoMigrationTotalFees?: string;
+    gasMigrationReceiveAmount?: string;
+    neoMigrationReceiveAmount?: string;
+};
+export type TNeo3NeoLegacyMigrationNeoLegacyAmounts = {
+    hasEnoughGasBalance: boolean;
+    hasEnoughNeoBalance: boolean;
+    gasBalance?: TBalanceResponse;
+    neoBalance?: TBalanceResponse;
+};
+export declare enum ENeonJsLedgerServiceNeoLegacyStatus {
+    OK = 36864
+}
+export declare enum ENeonJsLedgerServiceNeoLegacyCommand {
+    GET_PUBLIC_KEY = 4,
+    SIGN = 2
+}
+export declare enum ENeonJsLedgerServiceNeoLegacyParameter {
+    MORE_DATA = 0,
+    LAST_DATA = 128
+}

package/dist/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENeonJsLedgerServiceNeoLegacyParameter = exports.ENeonJsLedgerServiceNeoLegacyCommand = exports.ENeonJsLedgerServiceNeoLegacyStatus = void 0;
+var ENeonJsLedgerServiceNeoLegacyStatus;
+(function (ENeonJsLedgerServiceNeoLegacyStatus) {
+    ENeonJsLedgerServiceNeoLegacyStatus[ENeonJsLedgerServiceNeoLegacyStatus["OK"] = 36864] = "OK";
+})(ENeonJsLedgerServiceNeoLegacyStatus || (exports.ENeonJsLedgerServiceNeoLegacyStatus = ENeonJsLedgerServiceNeoLegacyStatus = {}));
+var ENeonJsLedgerServiceNeoLegacyCommand;
+(function (ENeonJsLedgerServiceNeoLegacyCommand) {
+    ENeonJsLedgerServiceNeoLegacyCommand[ENeonJsLedgerServiceNeoLegacyCommand["GET_PUBLIC_KEY"] = 4] = "GET_PUBLIC_KEY";
+    ENeonJsLedgerServiceNeoLegacyCommand[ENeonJsLedgerServiceNeoLegacyCommand["SIGN"] = 2] = "SIGN";
+})(ENeonJsLedgerServiceNeoLegacyCommand || (exports.ENeonJsLedgerServiceNeoLegacyCommand = ENeonJsLedgerServiceNeoLegacyCommand = {}));
+var ENeonJsLedgerServiceNeoLegacyParameter;
+(function (ENeonJsLedgerServiceNeoLegacyParameter) {
+    ENeonJsLedgerServiceNeoLegacyParameter[ENeonJsLedgerServiceNeoLegacyParameter["MORE_DATA"] = 0] = "MORE_DATA";
+    ENeonJsLedgerServiceNeoLegacyParameter[ENeonJsLedgerServiceNeoLegacyParameter["LAST_DATA"] = 128] = "LAST_DATA";
+})(ENeonJsLedgerServiceNeoLegacyParameter || (exports.ENeonJsLedgerServiceNeoLegacyParameter = ENeonJsLedgerServiceNeoLegacyParameter = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo-legacy",
-  "version": "1.13.4",
+  "version": "1.13.6",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Coz",
@@ -9,30 +9,28 @@
     "/dist"
   ],
   "dependencies": {
-    "@cityofzion/dora-ts": "0.5.1",
+    "@cityofzion/dora-ts": "~0.5.1",
     "@cityofzion/neon-js": "4.8.3",
-    "@ledgerhq/hw-transport": "~6.31.8",
-    "axios": "~1.8.2",
-    "date-fns": "~4.1.0",
-    "@cityofzion/blockchain-service": "1.21.2",
-    "@cityofzion/bs-asteroid-sdk": "0.9.1"
+    "axios": "~1.12.2",
+    "@cityofzion/blockchain-service": "1.22.1"
   },
   "devDependencies": {
-    "@types/jest": "29.5.3",
-    "@typescript-eslint/eslint-plugin": "^6.5.0",
-    "@typescript-eslint/parser": "^6.5.0",
-    "@ledgerhq/hw-transport-node-hid": "~6.28.5",
-    "dotenv": "16.3.1",
-    "eslint": "^8.48.0",
-    "jest": "29.6.2",
-    "ts-jest": "~29.4.0",
+    "@types/jest": "~30.0.0",
+    "@ledgerhq/hw-transport": "~6.31.11",
+    "@ledgerhq/hw-transport-node-hid": "~6.29.12",
+    "date-fns": "~4.1.0",
+    "dotenv": "~17.2.2",
+    "eslint": "~9.36.0",
+    "jest": "~30.1.3",
+    "ts-jest": "~29.4.4",
     "ts-node": "~10.9.2",
-    "typescript": "4.9.5"
+    "typescript": "~5.9.2"
   },
   "scripts": {
-    "build": "tsc  --project tsconfig.build.json",
+    "build": "rm -rf ./dist && tsc  --project tsconfig.build.json",
     "test": "jest --config jest.config.ts",
     "lint": "eslint .",
-    "format": "eslint --fix"
+    "format": "eslint . --fix",
+    "package": "npm run build && npm pack"
   }
 }