@cityofzion/blockchain-service 1.3.1 → 1.4.0

package/dist/BSAggregator.d.ts

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

package/dist/BSAggregator.js

@@ -22,6 +22,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _BSAggregator_blockchainServices;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSAggregator = void 0;
+const functions_1 = require("./functions");
 class BSAggregator {
     constructor(blockchainServices) {
         _BSAggregator_blockchainServices.set(this, void 0);
@@ -55,38 +56,11 @@ class BSAggregator {
     getBlockchainNameByEncrypted(keyOrJson) {
         return __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").filter(bs => bs.validateEncrypted(keyOrJson)).map(bs => bs.blockchainName);
     }
-    generateAccountFromMnemonicAllBlockchains(mnemonic, skippedAddresses) {
+    generateAccountsFromMnemonic(mnemonic) {
         return __awaiter(this, void 0, void 0, function* () {
-            const mnemonicAccounts = new Map();
-            const promises = __classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f").map((service) => __awaiter(this, void 0, void 0, function* () {
-                let index = 0;
-                const accounts = [];
-                let hasError = false;
-                while (!hasError) {
-                    const generatedAccount = service.generateAccountFromMnemonic(mnemonic, index);
-                    if (skippedAddresses && skippedAddresses.find(address => address === generatedAccount.address)) {
-                        index++;
-                        continue;
-                    }
-                    if (index !== 0) {
-                        try {
-                            const { transactions } = yield service.blockchainDataService.getTransactionsByAddress({
-                                address: generatedAccount.address,
-                            });
-                            if (!transactions || transactions.length <= 0)
-                                hasError = true;
-                        }
-                        catch (_a) {
-                            hasError = true;
-                        }
-                    }
-                    accounts.push(generatedAccount);
-                    index++;
-                }
-                mnemonicAccounts.set(service.blockchainName, accounts);
+            return (0, functions_1.fetchAccountsForBlockchainServices)(__classPrivateFieldGet(this, _BSAggregator_blockchainServices, "f"), (service, index) => __awaiter(this, void 0, void 0, function* () {
+                return service.generateAccountFromMnemonic(mnemonic, index);
             }));
-            yield Promise.all(promises);
-            return mnemonicAccounts;
         });
     }
 }

package/dist/functions.d.ts

@@ -1,8 +1,10 @@
-import { BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft } from './interfaces';
+import { Account, BlockchainService, BSCalculableFee, BSClaimable, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, BSWithSwap } from './interfaces';
 export declare function hasNameService(service: BlockchainService): service is BlockchainService & BSWithNameService;
 export declare function isClaimable(service: BlockchainService): service is BlockchainService & BSClaimable;
 export declare function isCalculableFee(service: BlockchainService): service is BlockchainService & BSCalculableFee;
 export declare function hasNft(service: BlockchainService): service is BlockchainService & BSWithNft;
 export declare function hasExplorerService(service: BlockchainService): service is BlockchainService & BSWithExplorerService;
 export declare function hasLedger(service: BlockchainService): service is BlockchainService & BSWithLedger;
+export declare function hasSwap(service: BlockchainService): service is BlockchainService & BSWithSwap;
 export declare function waitForTransaction(service: BlockchainService, txId: string): Promise<boolean>;
+export declare function fetchAccountsForBlockchainServices<BSCustomName extends string = string>(blockchainServices: BlockchainService<BSCustomName>[], getAccountCallback: (service: BlockchainService<BSCustomName>, index: number) => Promise<Account>): Promise<Map<BSCustomName, Account[]>>;

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.waitForTransaction = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
+exports.fetchAccountsForBlockchainServices = exports.waitForTransaction = exports.hasSwap = exports.hasLedger = exports.hasExplorerService = exports.hasNft = exports.isCalculableFee = exports.isClaimable = exports.hasNameService = void 0;
 function hasNameService(service) {
     return 'resolveNameServiceDomain' in service && 'validateNameServiceDomainFormat' in service;
 }
@@ -34,6 +34,10 @@ function hasLedger(service) {
     return 'ledgerService' in service;
 }
 exports.hasLedger = hasLedger;
+function hasSwap(service) {
+    return 'createSwapService' in service;
+}
+exports.hasSwap = hasSwap;
 function wait(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -57,3 +61,34 @@ function waitForTransaction(service, txId) {
     });
 }
 exports.waitForTransaction = waitForTransaction;
+function fetchAccountsForBlockchainServices(blockchainServices, 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 (_a) {
+                        shouldBreak = true;
+                    }
+                }
+                accounts.push(generatedAccount);
+                index++;
+            }
+            accountsByBlockchainService.set(service.blockchainName, accounts);
+        }));
+        yield Promise.all(promises);
+        return accountsByBlockchainService;
+    });
+}
+exports.fetchAccountsForBlockchainServices = fetchAccountsForBlockchainServices;

package/dist/interfaces.d.ts

@@ -4,9 +4,7 @@ export type Account = {
     key: string;
     type: 'wif' | 'privateKey' | 'publicKey';
     address: string;
-};
-export type AccountWithDerivationPath = Account & {
-    derivationPath: string;
+    bip44Path?: string;
 };
 export interface Token {
     symbol: string;
@@ -28,28 +26,28 @@ export type IntentTransferParam = {
 };
 export type TransferParam = {
     senderAccount: Account;
-    intent: IntentTransferParam;
+    intents: IntentTransferParam[];
     tipIntent?: IntentTransferParam;
     priorityFee?: string;
     isLedger?: boolean;
 };
 export interface BlockchainService<BSCustomName extends string = string, BSAvailableNetworks extends string = string> {
     readonly blockchainName: BSCustomName;
-    readonly derivationPath: string;
+    readonly bip44DerivationPath: string;
     readonly feeToken: Token;
     exchangeDataService: ExchangeDataService;
     blockchainDataService: BlockchainDataService;
     tokens: Token[];
     network: Network<BSAvailableNetworks>;
     setNetwork: (partialNetwork: Network<BSAvailableNetworks>) => void;
-    generateAccountFromMnemonic(mnemonic: string | string, index: number): AccountWithDerivationPath;
+    generateAccountFromMnemonic(mnemonic: string | string, index: number): Account;
     generateAccountFromKey(key: string): Account;
     decrypt(keyOrJson: string, password: string): Promise<Account>;
     encrypt(key: string, password: string): Promise<string>;
     validateAddress(address: string): boolean;
     validateEncrypted(keyOrJson: string): boolean;
     validateKey(key: string): boolean;
-    transfer(param: TransferParam): Promise<string>;
+    transfer(param: TransferParam): Promise<string[]>;
 }
 export interface BSCalculableFee {
     calculateTransferFee(param: TransferParam, details?: boolean): Promise<string>;
@@ -74,6 +72,9 @@ export interface BSWithLedger {
     ledgerService: LedgerService;
     generateAccountFromPublicKey(publicKey: string): Account;
 }
+export interface BSWithSwap<BSAvailableNetworks extends string = string> {
+    createSwapService(): SwapService<BSAvailableNetworks>;
+}
 export type TransactionNotifications = {
     eventName: string;
     state: {
@@ -223,8 +224,8 @@ export type LedgerServiceEmitter = TypedEmitter<{
 export interface LedgerService {
     emitter: LedgerServiceEmitter;
     getLedgerTransport?: (account: Account) => Promise<Transport>;
-    getAddress(transport: Transport): Promise<string>;
-    getPublicKey(transport: Transport): Promise<string>;
+    getAccounts(transport: Transport): Promise<Account[]>;
+    getAccount(transport: Transport, index: number): Promise<Account>;
 }
 export type SwapRoute = {
     tokenToUse: Token;
@@ -279,6 +280,5 @@ export interface SwapService<AvailableNetworkIds extends string> {
     setTokenToReceive(token: Token | null): void;
     startListeningBlockGeneration(): void;
     stopListeningBlockGeneration(): void;
-    listSwappableTokensSymbol(network: Network<AvailableNetworkIds>): string[];
     swap(isLedger?: boolean): void;
 }

package/package.json

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