@cityofzion/blockchain-service 1.15.0 → 1.15.2

package/dist/BSAggregator.d.ts

@@ -1,4 +1,4 @@
-import { Account, BlockchainService } from './interfaces';
+import { Account, BlockchainService, UntilIndexRecord } from './interfaces';
 export declare class BSAggregator<BSName extends string = string> {
     #private;
     readonly blockchainServicesByName: Record<BSName, BlockchainService<BSName>>;
@@ -10,5 +10,5 @@ export declare class BSAggregator<BSName extends string = string> {
     getBlockchainNameByAddress(address: string): BSName[];
     getBlockchainNameByKey(wif: string): BSName[];
     getBlockchainNameByEncrypted(keyOrJson: string): BSName[];
-    generateAccountsFromMnemonic(mnemonic: string, untilIndex?: number): Promise<Map<BSName, Account<BSName>[]>>;
+    generateAccountsFromMnemonic(mnemonic: string, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Map<BSName, Account<BSName>[]>>;
 }

package/dist/BSAggregator.js

@@ -56,16 +56,11 @@ class BSAggregator {
     getBlockchainNameByEncrypted(keyOrJson) {
         return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateEncrypted(keyOrJson)).map(bs => bs.name);
     }
-    generateAccountsFromMnemonic(mnemonic, untilIndex) {
+    generateAccountsFromMnemonic(mnemonic, untilIndexByBlockchainService) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (untilIndex === undefined) {
-                return (0, functions_1.fetchAccountsForBlockchainServices)(__classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f"), (service, index) => __awaiter(this, void 0, void 0, function* () {
-                    return service.generateAccountFromMnemonic(mnemonic, index);
-                }));
-            }
-            return (0, functions_1.generateAccountUntilIndexForBlockchainService)(__classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f"), untilIndex, (service, index) => __awaiter(this, void 0, void 0, function* () {
+            return (0, functions_1.generateAccountForBlockchainService)(__classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f"), (service, index) => __awaiter(this, void 0, void 0, function* () {
                 return service.generateAccountFromMnemonic(mnemonic, index);
-            }));
+            }), untilIndexByBlockchainService);
         });
     }
 }

package/dist/functions.d.ts

@@ -1,6 +1,7 @@
-import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft } from './interfaces';
+import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSMigrationNeo3, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, UntilIndexRecord } from './interfaces';
 export declare function hasNameService<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithNameService;
 export declare function isClaimable<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSClaimable<BSName>;
+export declare function hasMigrationNeo3<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSMigrationNeo3<BSName>;
 export declare function isCalculableFee<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSCalculableFee<BSName>;
 export declare function hasNft<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithNft;
 export declare function hasExplorerService<BSName extends string = string>(service: BlockchainService<BSName>): service is BlockchainService<BSName> & BSWithExplorerService;
@@ -11,8 +12,9 @@ export declare function wait(ms: number): Promise<unknown>;
  */
 export declare function waitForTransaction<BSName extends string = string>(service: BlockchainService<BSName>, txId: string): Promise<boolean>;
 export declare function waitForAccountTransaction<BSName extends string = string>(service: BlockchainService<BSName>, txId: string, account: Account<BSName>, maxAttempts?: number): Promise<boolean>;
-export declare function fetchAccountsForBlockchainServices<BSName extends string = string>(blockchainServices: BlockchainService<BSName>[], getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Map<BSName, Account<BSName>[]>>;
-export declare function generateAccountUntilIndexForBlockchainService<BSName extends string = string>(blockchainServices: BlockchainService<BSName>[], untilIndex: number, getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Map<BSName, Account<BSName>[]>>;
+export declare function fetchAccounts<BSName extends string = string>(blockchainServices: BlockchainService<BSName>, initialIndex: number, getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Account<BSName>[]>;
+export declare function generateAccount<BSName extends string = string>(blockchainServices: BlockchainService<BSName>, initialIndex: number, untilIndex: number, getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>): Promise<Account<BSName>[]>;
+export declare function generateAccountForBlockchainService<BSName extends string = string>(blockchainServices: BlockchainService<BSName>[], getAccountCallback: (service: BlockchainService<BSName>, index: number) => Promise<Account<BSName>>, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Map<BSName, Account<BSName>[]>>;
 export declare function normalizeHash(hash: string): string;
 export declare function denormalizeHash(hash: string): string;
 export declare function countDecimals(value: string | number): number;

package/dist/functions.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatNumber = exports.countDecimals = exports.denormalizeHash = exports.normalizeHash = exports.generateAccountUntilIndexForBlockchainService = exports.fetchAccountsForBlockchainServices = exports.waitForAccountTransaction = exports.waitForTransaction = exports.wait = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+exports.formatNumber = exports.countDecimals = exports.denormalizeHash = exports.normalizeHash = exports.generateAccountForBlockchainService = exports.generateAccount = exports.fetchAccounts = exports.waitForAccountTransaction = exports.waitForTransaction = exports.wait = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.hasMigrationNeo3 = exports.isClaimable = exports.hasNameService = void 0;
 function hasNameService(service) {
     return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
 }
@@ -18,6 +18,10 @@ function isClaimable(service) {
     return 'claim' in service && 'claimToken' in service && 'getUnclaimed' in service.blockchainDataService;
 }
 exports.isClaimable = isClaimable;
+function hasMigrationNeo3(service) {
+    return 'migrateToNeo3' in service && 'calculateToMigrateToNeo3Values' in service;
+}
+exports.hasMigrationNeo3 = hasMigrationNeo3;
 function isCalculableFee(service) {
     return 'calculateTransferFee' in service;
 }
@@ -81,58 +85,64 @@ function waitForAccountTransaction(service, txId, account, maxAttempts = 10) {
     });
 }
 exports.waitForAccountTransaction = waitForAccountTransaction;
-function fetchAccountsForBlockchainServices(blockchainServices, getAccountCallback) {
+function fetchAccounts(blockchainServices, initialIndex, getAccountCallback) {
     return __awaiter(this, void 0, void 0, function* () {
-        const accountsByBlockchainService = new Map();
-        const promises = blockchainServices.map((service) => __awaiter(this, void 0, void 0, function* () {
-            let index = 0;
-            const accounts = [];
-            let shouldBreak = false;
-            while (!shouldBreak) {
-                const generatedAccount = yield getAccountCallback(service, index);
-                if (index !== 0) {
-                    try {
-                        const { transactions } = yield service.blockchainDataService.getTransactionsByAddress({
-                            address: generatedAccount.address,
-                        });
-                        if (!transactions || transactions.length <= 0)
-                            shouldBreak = true;
-                    }
-                    catch (_b) {
-                        shouldBreak = true;
-                    }
-                }
-                accounts.push(generatedAccount);
-                index++;
+        const accounts = [];
+        let index = initialIndex;
+        let shouldBreak = false;
+        while (!shouldBreak) {
+            const generatedAccount = yield getAccountCallback(blockchainServices, index);
+            try {
+                const { transactions } = yield blockchainServices.blockchainDataService.getTransactionsByAddress({
+                    address: generatedAccount.address,
+                });
+                if (!transactions || transactions.length <= 0)
+                    shouldBreak = true;
             }
-            accountsByBlockchainService.set(service.name, accounts);
-        }));
-        yield Promise.allSettled(promises);
-        return accountsByBlockchainService;
+            catch (_b) {
+                shouldBreak = true;
+            }
+            accounts.push(generatedAccount);
+            index++;
+        }
+        return accounts;
     });
 }
-exports.fetchAccountsForBlockchainServices = fetchAccountsForBlockchainServices;
-function generateAccountUntilIndexForBlockchainService(blockchainServices, untilIndex, getAccountCallback) {
+exports.fetchAccounts = fetchAccounts;
+function generateAccount(blockchainServices, initialIndex, untilIndex, getAccountCallback) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (untilIndex < 0) {
-            throw new Error('Invalid index');
+        const accounts = [];
+        let index = initialIndex;
+        while (index <= untilIndex) {
+            const generatedAccount = yield getAccountCallback(blockchainServices, index);
+            accounts.push(generatedAccount);
+            index++;
         }
+        return accounts;
+    });
+}
+exports.generateAccount = generateAccount;
+function generateAccountForBlockchainService(blockchainServices, getAccountCallback, untilIndexByBlockchainService) {
+    return __awaiter(this, void 0, void 0, function* () {
         const accountsByBlockchainService = new Map();
         const promises = blockchainServices.map((service) => __awaiter(this, void 0, void 0, function* () {
-            let index = 0;
-            const accounts = [];
-            while (index <= untilIndex) {
-                const generatedAccount = yield getAccountCallback(service, index);
-                accounts.push(generatedAccount);
-                index++;
+            var _b;
+            const firstAccount = yield getAccountCallback(service, 0);
+            const untilIndex = (_b = untilIndexByBlockchainService === null || untilIndexByBlockchainService === void 0 ? void 0 : untilIndexByBlockchainService[service.name]) === null || _b === void 0 ? void 0 : _b[firstAccount.address];
+            if (untilIndex === undefined) {
+                const accounts = yield fetchAccounts(service, 1, getAccountCallback);
+                accountsByBlockchainService.set(service.name, [firstAccount, ...accounts]);
+            }
+            else {
+                const accounts = yield generateAccount(service, 1, untilIndex, getAccountCallback);
+                accountsByBlockchainService.set(service.name, [firstAccount, ...accounts]);
             }
-            accountsByBlockchainService.set(service.name, accounts);
         }));
-        yield Promise.allSettled(promises);
+        yield Promise.all(promises);
         return accountsByBlockchainService;
     });
 }
-exports.generateAccountUntilIndexForBlockchainService = generateAccountUntilIndexForBlockchainService;
+exports.generateAccountForBlockchainService = generateAccountForBlockchainService;
 function normalizeHash(hash) {
     return hash.replace('0x', '').toLowerCase();
 }

package/dist/interfaces.d.ts

@@ -1,5 +1,6 @@
 import Transport from '@ledgerhq/hw-transport';
 import TypedEmitter from 'typed-emitter';
+export type UntilIndexRecord<BSName extends string = string> = Partial<Record<BSName, Record<string, number>>>;
 export type Account<BSName extends string = string> = {
     key: string;
     type: 'wif' | 'privateKey' | 'publicKey';
@@ -60,6 +61,23 @@ export interface BSClaimable<BSName extends string = string> {
     blockchainDataService: BlockchainDataService & BDSClaimable;
     claim(account: Account<BSName>): Promise<string>;
 }
+export type MigrateToNeo3Params<BSName extends string = string> = {
+    account: Account<BSName>;
+    address: string;
+};
+export type CalculateToMigrateToNeo3ValuesParams<BSName extends string = string> = {
+    account: Account<BSName>;
+};
+export type CalculateToMigrateToNeo3ValuesResponse = {
+    gasMigrationTotalFees?: string;
+    neoMigrationTotalFees?: string;
+    gasMigrationAmount?: string;
+    neoMigrationAmount?: string;
+};
+export interface BSMigrationNeo3<BSName extends string = string> {
+    migrateToNeo3(params: MigrateToNeo3Params<BSName>): Promise<string[]>;
+    calculateToMigrateToNeo3Values(params: CalculateToMigrateToNeo3ValuesParams<BSName>): Promise<CalculateToMigrateToNeo3ValuesResponse>;
+}
 export interface BSWithNameService {
     resolveNameServiceDomain(domainName: string): Promise<string>;
     validateNameServiceDomainFormat(domainName: string): boolean;
@@ -226,7 +244,7 @@ export type GetLedgerTransport<BSName extends string = string> = (account: Accou
 export interface LedgerService<BSName extends string = string> {
     emitter: LedgerServiceEmitter;
     getLedgerTransport?: GetLedgerTransport<BSName>;
-    getAccounts(transport: Transport, untilIndex?: number): Promise<Account<BSName>[]>;
+    getAccounts(transport: Transport, getUntilIndex?: UntilIndexRecord<BSName>): Promise<Account<BSName>[]>;
     getAccount(transport: Transport, index: number): Promise<Account<BSName>>;
 }
 export type SwapServiceToken<BSName extends string = string> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/blockchain-service",
-  "version": "1.15.0",
+  "version": "1.15.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",