@wallfree-dev/angular-core 0.0.59-beta.1

package/esm2022/lib/services/image/fetcher/image-direct.fetcher.mjs

@@ -0,0 +1,16 @@
+import { RemoteDataFactory } from '@wallfree-dev/coinlib-core/utils/remote-data/RemoteDataFactory';
+export class ImageDirectFetcher {
+    constructor(uriService) {
+        this.uriService = uriService;
+        this.remoteDataFactory = new RemoteDataFactory();
+    }
+    async fetch(uri) {
+        const remoteData = this.remoteDataFactory.create(uri, {});
+        const rawData = await remoteData?.getRaw();
+        if (!rawData) {
+            return undefined;
+        }
+        return this.uriService.data(rawData.bytes.toString('base64'), rawData.contentType, true);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/image/fetcher/image-proxy.fetcher.mjs

@@ -0,0 +1,45 @@
+import axios from 'axios';
+function isApiResponseSuccess(response) {
+    return response.result !== undefined;
+}
+function isApiResponseError(response) {
+    return response.error !== undefined;
+}
+const API_URL = 'https://imgproxy-prod.cryptonomic-infra.tech';
+const API_KEY = ''; // TODO: set apikey
+export class ImageProxyFetcher {
+    constructor(apiUrl = API_URL, apiKey = API_KEY) {
+        this.apiUrl = apiUrl;
+        this.apiKey = apiKey;
+    }
+    async fetch(uri) {
+        const result = await this.send('img_proxy_fetch', {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            response_type: 'Raw',
+            url: uri,
+            force: false
+        });
+        return result.data;
+    }
+    async send(method, params) {
+        const response = await axios.post(this.apiUrl, {
+            jsonrpc: '1.0.0',
+            method,
+            params
+        }, {
+            headers: {
+                apikey: this.apiKey,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'Content-Type': 'application/json'
+            }
+        });
+        if (isApiResponseError(response.data)) {
+            throw response.data.error;
+        }
+        if (isApiResponseSuccess(response.data)) {
+            return response.data.result;
+        }
+        throw new Error('Unknown error');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/image/image.service.mjs

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { ImageDirectFetcher } from './fetcher/image-direct.fetcher';
+import { ImageProxyFetcher } from './fetcher/image-proxy.fetcher';
+import * as i0 from "@angular/core";
+import * as i1 from "../uri/uri.service";
+const DEFAULT_FETCH_OPTIONS = {
+    useProxy: false
+};
+export class ImageService {
+    constructor(uriService) {
+        this.uriService = uriService;
+    }
+    async fetch(uri, options = DEFAULT_FETCH_OPTIONS) {
+        return this.getFetcher(options).fetch(uri);
+    }
+    getFetcher(options) {
+        if (options.useProxy) {
+            const proxyFetcher = this.proxyFetcher ?? new ImageProxyFetcher();
+            if (!this.proxyFetcher) {
+                this.proxyFetcher = proxyFetcher;
+            }
+            return proxyFetcher;
+        }
+        const directFetcher = this.directFetcher ?? new ImageDirectFetcher(this.uriService);
+        if (!this.directFetcher) {
+            this.directFetcher = directFetcher;
+        }
+        return directFetcher;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageService, deps: [{ token: i1.UriService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ImageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.UriService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/key-pair/key-pair.service.mjs

@@ -0,0 +1,57 @@
+import { MainProtocolSymbols } from '@wallfree-dev/coinlib-core';
+import { Injectable } from '@angular/core';
+import { ICoinProtocolAdapter } from '../../protocol/adapter/protocol-v0-adapter';
+import * as i0 from "@angular/core";
+export class KeyPairService {
+    async signWithWallet(wallet, unsigned, mnemonic, password) {
+        return this.signWithProtocol(wallet.protocol, unsigned, mnemonic, password, wallet.isExtendedPublicKey, wallet.derivationPath);
+    }
+    async signWithProtocol(protocol, unsigned, mnemonic, password, withExtendedPrivateKey = false, optionalDerivationPath, childDerivationPath) {
+        const derivationPath = optionalDerivationPath ?? (await protocol.getStandardDerivationPath());
+        if (!(await this.checkPassword(protocol, unsigned, mnemonic, withExtendedPrivateKey, derivationPath, password))) {
+            throw new Error('Invalid BIP-39 passphrase');
+        }
+        if (withExtendedPrivateKey) {
+            const extendedPrivateKey = await protocol.getExtendedPrivateKeyFromMnemonic(mnemonic, derivationPath, password);
+            if (this.isUnsignedTransaction(unsigned)) {
+                return protocol.signWithExtendedPrivateKey(extendedPrivateKey, unsigned.transaction, childDerivationPath);
+            }
+            else {
+                const privateKey = (await protocol.getIdentifier()).startsWith(MainProtocolSymbols.ETH)
+                    ? protocol instanceof ICoinProtocolAdapter
+                        ? await protocol.getPrivateKeyFromExtendedPrivateKey(extendedPrivateKey, childDerivationPath)
+                        : await protocol.getPrivateKeyFromExtendedPrivateKey(extendedPrivateKey, childDerivationPath) // This only exists on ETH
+                    : extendedPrivateKey;
+                return protocol.signMessage(unsigned.message, { privateKey });
+            }
+        }
+        else {
+            const privateKey = await protocol.getPrivateKeyFromMnemonic(mnemonic, derivationPath, password);
+            return this.isUnsignedTransaction(unsigned)
+                ? protocol.signWithPrivateKey(privateKey, unsigned.transaction)
+                : protocol.signMessage(unsigned.message, { privateKey });
+        }
+    }
+    async checkPassword(protocol, unsigned, mnemonic, withExtendedPrivateKey = false, derivationPath, password) {
+        if (unsigned.publicKey.length === 0) {
+            // the password can't be verified
+            return true;
+        }
+        const publicKey = withExtendedPrivateKey && (await protocol.getSupportsHD())
+            ? await protocol.getExtendedPublicKeyFromMnemonic(mnemonic, derivationPath, password)
+            : await protocol.getPublicKeyFromMnemonic(mnemonic, derivationPath, password);
+        return publicKey === unsigned.publicKey;
+    }
+    isUnsignedTransaction(unsigned) {
+        return 'transaction' in unsigned;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyPairService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyPairService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: KeyPairService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/language/language.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export class LanguageService {
+    static { this.defaultLanguage = 'en'; }
+    get supportedLanguages() {
+        return this.translateService.getLangs();
+    }
+    constructor(translateService) {
+        this.translateService = translateService;
+    }
+    async init(config = {
+        supportedLanguages: [LanguageService.defaultLanguage],
+        defaultLanguage: LanguageService.defaultLanguage,
+        useBrowserLanguage: true
+    }) {
+        const supportedLanguages = config.supportedLanguages;
+        const defaultLanguage = config.defaultLanguage;
+        const useBrowserLanguage = config.useBrowserLanguage ?? true;
+        if (supportedLanguages.find((supported) => supported === defaultLanguage) === undefined) {
+            supportedLanguages.push(defaultLanguage);
+        }
+        this.translateService.addLangs(supportedLanguages);
+        this.translateService.setDefaultLang(defaultLanguage);
+        const language = useBrowserLanguage ? this.translateService.getBrowserLang().toLowerCase() : defaultLanguage;
+        return this.changeLanguage(language);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    loadTranslation(language, translation, merge = true) {
+        this.translateService.setTranslation(language, translation, merge);
+    }
+    async changeLanguage(language) {
+        return this.translateService.use(language).toPromise();
+    }
+    isLanguageSupported(language) {
+        return this.supportedLanguages.find((supported) => supported === language) !== undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LanguageService, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LanguageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: LanguageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2Uuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvbGFuZ3VhZ2UvbGFuZ3VhZ2Uuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFBOzs7QUFhMUMsTUFBTSxPQUFPLGVBQWU7YUFDRixvQkFBZSxHQUFzQixJQUFJLEFBQTFCLENBQTBCO0lBRWpFLElBQVcsa0JBQWtCO1FBQzNCLE9BQU8sSUFBSSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxDQUFBO0lBQ3pDLENBQUM7SUFFRCxZQUE2QixnQkFBa0M7UUFBbEMscUJBQWdCLEdBQWhCLGdCQUFnQixDQUFrQjtJQUFHLENBQUM7SUFFNUQsS0FBSyxDQUFDLElBQUksQ0FDZixTQUFnQztRQUM5QixrQkFBa0IsRUFBRSxDQUFDLGVBQWUsQ0FBQyxlQUFlLENBQUM7UUFDckQsZUFBZSxFQUFFLGVBQWUsQ0FBQyxlQUFlO1FBQ2hELGtCQUFrQixFQUFFLElBQUk7S0FDekI7UUFFRCxNQUFNLGtCQUFrQixHQUF3QixNQUFNLENBQUMsa0JBQWtCLENBQUE7UUFDekUsTUFBTSxlQUFlLEdBQXNCLE1BQU0sQ0FBQyxlQUFlLENBQUE7UUFDakUsTUFBTSxrQkFBa0IsR0FBWSxNQUFNLENBQUMsa0JBQWtCLElBQUksSUFBSSxDQUFBO1FBRXJFLElBQUksa0JBQWtCLENBQUMsSUFBSSxDQUFDLENBQUMsU0FBNEIsRUFBRSxFQUFFLENBQUMsU0FBUyxLQUFLLGVBQWUsQ0FBQyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQzNHLGtCQUFrQixDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQTtRQUMxQyxDQUFDO1FBRUQsSUFBSSxDQUFDLGdCQUFnQixDQUFDLFFBQVEsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFBO1FBQ2xELElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxjQUFjLENBQUMsZUFBZSxDQUFDLENBQUE7UUFFckQsTUFBTSxRQUFRLEdBQVcsa0JBQWtCLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxjQUFjLEVBQUUsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFDLENBQUMsZUFBZSxDQUFBO1FBRXBILE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUN0QyxDQUFDO0lBRUQsaUhBQWlIO0lBQzFHLGVBQWUsQ0FBQyxRQUFnQixFQUFFLFdBQWdCLEVBQUUsUUFBaUIsSUFBSTtRQUM5RSxJQUFJLENBQUMsZ0JBQWdCLENBQUMsY0FBYyxDQUFDLFFBQVEsRUFBRSxXQUFXLEVBQUUsS0FBSyxDQUFDLENBQUE7SUFDcEUsQ0FBQztJQUVNLEtBQUssQ0FBQyxjQUFjLENBQUMsUUFBZ0I7UUFDMUMsT0FBTyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDLFNBQVMsRUFBRSxDQUFBO0lBQ3hELENBQUM7SUFFTSxtQkFBbUIsQ0FBQyxRQUFnQjtRQUN6QyxPQUFPLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsQ0FBQyxTQUFpQixFQUFFLEVBQUUsQ0FBQyxTQUFTLEtBQUssUUFBUSxDQUFDLEtBQUssU0FBUyxDQUFBO0lBQ2xHLENBQUM7K0dBM0NVLGVBQWU7bUhBQWYsZUFBZSxjQUZkLE1BQU07OzRGQUVQLGVBQWU7a0JBSDNCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBUcmFuc2xhdGVTZXJ2aWNlIH0gZnJvbSAnQG5neC10cmFuc2xhdGUvY29yZSdcbmltcG9ydCB7IFN1cHBvcnRlZExhbmd1YWdlIH0gZnJvbSAnLi4vLi4vdHlwZXMvU3VwcG9ydGVkTGFuZ3VhZ2UnXG5cbmV4cG9ydCBpbnRlcmZhY2UgTGFuZ3VhZ2VTZXJ2aWNlQ29uZmlnIHtcbiAgc3VwcG9ydGVkTGFuZ3VhZ2VzOiBTdXBwb3J0ZWRMYW5ndWFnZVtdXG4gIGRlZmF1bHRMYW5ndWFnZTogU3VwcG9ydGVkTGFuZ3VhZ2VcbiAgdXNlQnJvd3Nlckxhbmd1YWdlPzogYm9vbGVhblxufVxuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290J1xufSlcbmV4cG9ydCBjbGFzcyBMYW5ndWFnZVNlcnZpY2Uge1xuICBwcml2YXRlIHN0YXRpYyByZWFkb25seSBkZWZhdWx0TGFuZ3VhZ2U6IFN1cHBvcnRlZExhbmd1YWdlID0gJ2VuJ1xuXG4gIHB1YmxpYyBnZXQgc3VwcG9ydGVkTGFuZ3VhZ2VzKCk6IHN0cmluZ1tdIHtcbiAgICByZXR1cm4gdGhpcy50cmFuc2xhdGVTZXJ2aWNlLmdldExhbmdzKClcbiAgfVxuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgdHJhbnNsYXRlU2VydmljZTogVHJhbnNsYXRlU2VydmljZSkge31cblxuICBwdWJsaWMgYXN5bmMgaW5pdChcbiAgICBjb25maWc6IExhbmd1YWdlU2VydmljZUNvbmZpZyA9IHtcbiAgICAgIHN1cHBvcnRlZExhbmd1YWdlczogW0xhbmd1YWdlU2VydmljZS5kZWZhdWx0TGFuZ3VhZ2VdLFxuICAgICAgZGVmYXVsdExhbmd1YWdlOiBMYW5ndWFnZVNlcnZpY2UuZGVmYXVsdExhbmd1YWdlLFxuICAgICAgdXNlQnJvd3Nlckxhbmd1YWdlOiB0cnVlXG4gICAgfVxuICApOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBjb25zdCBzdXBwb3J0ZWRMYW5ndWFnZXM6IFN1cHBvcnRlZExhbmd1YWdlW10gPSBjb25maWcuc3VwcG9ydGVkTGFuZ3VhZ2VzXG4gICAgY29uc3QgZGVmYXVsdExhbmd1YWdlOiBTdXBwb3J0ZWRMYW5ndWFnZSA9IGNvbmZpZy5kZWZhdWx0TGFuZ3VhZ2VcbiAgICBjb25zdCB1c2VCcm93c2VyTGFuZ3VhZ2U6IGJvb2xlYW4gPSBjb25maWcudXNlQnJvd3Nlckxhbmd1YWdlID8/IHRydWVcblxuICAgIGlmIChzdXBwb3J0ZWRMYW5ndWFnZXMuZmluZCgoc3VwcG9ydGVkOiBTdXBwb3J0ZWRMYW5ndWFnZSkgPT4gc3VwcG9ydGVkID09PSBkZWZhdWx0TGFuZ3VhZ2UpID09PSB1bmRlZmluZWQpIHtcbiAgICAgIHN1cHBvcnRlZExhbmd1YWdlcy5wdXNoKGRlZmF1bHRMYW5ndWFnZSlcbiAgICB9XG5cbiAgICB0aGlzLnRyYW5zbGF0ZVNlcnZpY2UuYWRkTGFuZ3Moc3VwcG9ydGVkTGFuZ3VhZ2VzKVxuICAgIHRoaXMudHJhbnNsYXRlU2VydmljZS5zZXREZWZhdWx0TGFuZyhkZWZhdWx0TGFuZ3VhZ2UpXG5cbiAgICBjb25zdCBsYW5ndWFnZTogc3RyaW5nID0gdXNlQnJvd3Nlckxhbmd1YWdlID8gdGhpcy50cmFuc2xhdGVTZXJ2aWNlLmdldEJyb3dzZXJMYW5nKCkudG9Mb3dlckNhc2UoKSA6IGRlZmF1bHRMYW5ndWFnZVxuXG4gICAgcmV0dXJuIHRoaXMuY2hhbmdlTGFuZ3VhZ2UobGFuZ3VhZ2UpXG4gIH1cblxuICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWV4cGxpY2l0LWFueSwgQHR5cGVzY3JpcHQtZXNsaW50L2V4cGxpY2l0LW1vZHVsZS1ib3VuZGFyeS10eXBlc1xuICBwdWJsaWMgbG9hZFRyYW5zbGF0aW9uKGxhbmd1YWdlOiBzdHJpbmcsIHRyYW5zbGF0aW9uOiBhbnksIG1lcmdlOiBib29sZWFuID0gdHJ1ZSk6IHZvaWQge1xuICAgIHRoaXMudHJhbnNsYXRlU2VydmljZS5zZXRUcmFuc2xhdGlvbihsYW5ndWFnZSwgdHJhbnNsYXRpb24sIG1lcmdlKVxuICB9XG5cbiAgcHVibGljIGFzeW5jIGNoYW5nZUxhbmd1YWdlKGxhbmd1YWdlOiBzdHJpbmcpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICByZXR1cm4gdGhpcy50cmFuc2xhdGVTZXJ2aWNlLnVzZShsYW5ndWFnZSkudG9Qcm9taXNlKClcbiAgfVxuXG4gIHB1YmxpYyBpc0xhbmd1YWdlU3VwcG9ydGVkKGxhbmd1YWdlOiBzdHJpbmcpOiBib29sZWFuIHtcbiAgICByZXR1cm4gdGhpcy5zdXBwb3J0ZWRMYW5ndWFnZXMuZmluZCgoc3VwcG9ydGVkOiBzdHJpbmcpID0+IHN1cHBvcnRlZCA9PT0gbGFuZ3VhZ2UpICE9PSB1bmRlZmluZWRcbiAgfVxufVxuIl19

package/esm2022/lib/services/modules/base-modules.service.mjs

@@ -0,0 +1,157 @@
+import { isOnlineProtocol, isSubProtocol, protocolNetworkIdentifier } from '@wallfree-dev/module-kit';
+import { SerializerV3 } from '@wallfree-dev/serializer';
+import { Injectable } from '@angular/core';
+import { createICoinProtocolAdapter, createICoinSubProtocolAdapter, TransactionValidatorAdapter } from '../../protocol/adapter/protocol-v0-adapter';
+import { flattened } from '../../utils/array';
+import * as i0 from "@angular/core";
+import * as i1 from "./controller/modules.controller";
+import * as i2 from "../protocol/protocol.service";
+export class BaseModulesService {
+    get isInitialized() {
+        return this.modulesController.isInitialized;
+    }
+    constructor(modulesController, protocolService) {
+        this.modulesController = modulesController;
+        this.protocolService = protocolService;
+    }
+    init(integralModules = []) {
+        if (this.isInitialized) {
+            // eslint-disable-next-line no-console
+            console.log('[ModulesService] already initialized');
+            return;
+        }
+        this.modulesController.init(integralModules);
+    }
+    async loadProtocols(type, ignore = []) {
+        const modules = await this.modulesController.loadModules(type, ignore);
+        const adaptedProtocols = await this.adaptProtocols(modules, type);
+        return this.processAdaptedProtocols(adaptedProtocols);
+    }
+    async deriveAddresses(walletOrWallets, amount = 50) {
+        const wallets = Array.isArray(walletOrWallets) ? walletOrWallets : [walletOrWallets];
+        return this.modulesController.deriveAddresses(wallets, amount);
+    }
+    async getModulesMetadata() {
+        return this.modulesController.getModulesMetadata();
+    }
+    async readModuleMetadata(name, path) {
+        return this.modulesController.readModuleMetadata(name, path);
+    }
+    async installModule(metadata) {
+        const loadedModule = await this.modulesController.installModule(metadata);
+        const adaptedProtocols = await this.adaptProtocols([loadedModule]);
+        const protocols = this.processAdaptedProtocols(adaptedProtocols);
+        await this.protocolService.addActiveMainProtocols(protocols.activeProtocols);
+        await this.protocolService.addActiveSubProtocols(protocols.activeSubProtocols.map(([_, protocol]) => protocol));
+    }
+    async removeInstalledModules(identifiers) {
+        const removedIdentifiers = await this.modulesController.removeInstalledModules(identifiers);
+        await this.protocolService.removeProtocols(removedIdentifiers);
+    }
+    async removeAllInstalledModules() {
+        const removedIdentifiers = await this.modulesController.removeAllInstalledModules();
+        await this.protocolService.removeProtocols(removedIdentifiers);
+    }
+    async adaptProtocols(modules, type) {
+        const adaptedProtocols = await Promise.all(modules.map(async (module) => {
+            this.loadSerializerCompanion(module.v3SerializerCompanion);
+            const activeProtocols = {};
+            const activeSubProtocols = [];
+            const groupedProtocols = await Promise.all(module.protocols.map(async (protocol) => [await this.getProtocolKey(protocol.protocol, type), protocol])).then((pairs) => {
+                return pairs.reduce((obj, next) => Object.assign(obj, { [next[0]]: next[1] }), {});
+            });
+            for (const { protocol, blockExplorer } of Object.values(groupedProtocols)) {
+                if (isSubProtocol(protocol)) {
+                    const adapter = await createICoinSubProtocolAdapter(protocol, blockExplorer, module.v3SerializerCompanion, { type });
+                    const mainKey = await this.getProtocolKey(await adapter.protocolV1.mainProtocol(), isOnlineProtocol(adapter.protocolV1) && (type === 'online' || type === 'full')
+                        ? await adapter.protocolV1.getNetwork()
+                        : undefined);
+                    if (!(mainKey in activeProtocols)) {
+                        const mainAdapter = await createICoinProtocolAdapter(groupedProtocols[mainKey].protocol, groupedProtocols[mainKey].blockExplorer, module.v3SerializerCompanion, { type });
+                        activeProtocols[mainKey] = mainAdapter;
+                    }
+                    activeSubProtocols.push([activeProtocols[mainKey], adapter]);
+                }
+                else {
+                    const key = await this.getProtocolKey(protocol, type);
+                    if (activeProtocols[key] !== undefined) {
+                        continue;
+                    }
+                    const adapter = await createICoinProtocolAdapter(protocol, blockExplorer, module.v3SerializerCompanion, {
+                        type
+                    });
+                    activeProtocols[key] = adapter;
+                }
+            }
+            const adaptedMainProtocols = Object.values(activeProtocols).map((protocol) => ({
+                type: 'main',
+                status: 'active',
+                value: protocol
+            }));
+            const adaptedSubProtocols = activeSubProtocols.map((protocol) => ({
+                type: 'sub',
+                status: 'active',
+                value: protocol
+            }));
+            return adaptedMainProtocols.concat(adaptedSubProtocols);
+        }));
+        return flattened(adaptedProtocols);
+    }
+    loadSerializerCompanion(v3SerializerCompanion) {
+        v3SerializerCompanion.schemas.forEach((configuration) => {
+            SerializerV3.addSchema(configuration.type, configuration.schema, configuration.protocolIdentifier);
+            if (configuration.protocolIdentifier) {
+                SerializerV3.addValidator(configuration.protocolIdentifier, {
+                    create() {
+                        return new TransactionValidatorAdapter(configuration.protocolIdentifier, v3SerializerCompanion);
+                    }
+                });
+            }
+        });
+    }
+    processAdaptedProtocols(protocols) {
+        const activeProtocols = [];
+        const passiveProtocols = [];
+        const activeSubProtocols = [];
+        const passiveSubProtocols = [];
+        for (const protocol of protocols) {
+            if (protocol.type === 'main' && protocol.status === 'active') {
+                activeProtocols.push(protocol.value);
+            }
+            if (protocol.type === 'main' && protocol.status === 'passive') {
+                passiveProtocols.push(protocol.value);
+            }
+            if (protocol.type === 'sub' && protocol.status === 'active') {
+                activeSubProtocols.push(protocol.value);
+            }
+            if (protocol.type === 'sub' && protocol.status === 'passive') {
+                passiveSubProtocols.push(protocol.value);
+            }
+        }
+        return {
+            activeProtocols,
+            passiveProtocols,
+            activeSubProtocols,
+            passiveSubProtocols
+        };
+    }
+    async getProtocolKey(protocolOrIdentifier, networkOrTypeOrUndefined) {
+        const protocolIdentifier = typeof protocolOrIdentifier === 'string' ? protocolOrIdentifier : (await protocolOrIdentifier.getMetadata()).identifier;
+        const type = typeof networkOrTypeOrUndefined === 'string' ? networkOrTypeOrUndefined : undefined;
+        const network = isOnlineProtocol(protocolOrIdentifier) && (type === 'online' || type === 'full')
+            ? await protocolOrIdentifier.getNetwork()
+            : typeof networkOrTypeOrUndefined === 'object'
+                ? networkOrTypeOrUndefined
+                : undefined;
+        if (!network) {
+            return protocolIdentifier;
+        }
+        return `${protocolIdentifier}_${protocolNetworkIdentifier(network)}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseModulesService, deps: [{ token: i1.ModulesController }, { token: i2.ProtocolService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseModulesService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseModulesService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.ModulesController }, { type: i2.ProtocolService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-modules.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/modules/base-modules.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { AirGapWallet, ICoinProtocol, ICoinSubProtocol, ProtocolSymbols } from '@wallfree-dev/coinlib-core'\nimport {\n  AirGapAnyProtocol,\n  AirGapModule,\n  AirGapV3SerializerCompanion,\n  isOnlineProtocol,\n  isSubProtocol,\n  ProtocolConfiguration,\n  ProtocolNetwork,\n  protocolNetworkIdentifier,\n  V3SchemaConfiguration\n} from '@wallfree-dev/module-kit'\nimport { SerializerV3, TransactionValidator } from '@wallfree-dev/serializer'\nimport { Injectable } from '@angular/core'\nimport {\n  createICoinProtocolAdapter,\n  createICoinSubProtocolAdapter,\n  ICoinProtocolAdapter,\n  ICoinSubProtocolAdapter,\n  TransactionValidatorAdapter\n} from '../../protocol/adapter/protocol-v0-adapter'\nimport { IsolatedModuleMetadata, IsolatedModulePreviewMetadata } from '../../types/isolated-modules/IsolatedModuleMetadata'\nimport { flattened } from '../../utils/array'\nimport { ProtocolService } from '../protocol/protocol.service'\nimport { LoadedModule, LoadedProtocol } from './controller/base-modules.controller'\nimport { ModulesController } from './controller/modules.controller'\n\ntype AdaptedProtocolStatus = 'active' | 'passive'\n\ninterface AdaptedMainProtocol {\n  type: 'main'\n  status: AdaptedProtocolStatus\n  value: ICoinProtocolAdapter\n}\n\ninterface AdaptedSubProtocol {\n  type: 'sub'\n  status: AdaptedProtocolStatus\n  value: [ICoinProtocolAdapter, ICoinSubProtocolAdapter]\n}\n\ntype AdaptedProtocol = AdaptedMainProtocol | AdaptedSubProtocol\n\ninterface Protocols {\n  activeProtocols: ICoinProtocol[]\n  passiveProtocols: ICoinProtocol[]\n  activeSubProtocols: [ICoinProtocol, ICoinSubProtocol][]\n  passiveSubProtocols: [ICoinProtocol, ICoinSubProtocol][]\n}\n\n@Injectable()\nexport abstract class BaseModulesService {\n  private get isInitialized(): boolean {\n    return this.modulesController.isInitialized\n  }\n\n  constructor(protected readonly modulesController: ModulesController, protected readonly protocolService: ProtocolService) {}\n\n  public init(integralModules: AirGapModule[] = []): void {\n    if (this.isInitialized) {\n      // eslint-disable-next-line no-console\n      console.log('[ModulesService] already initialized')\n\n      return\n    }\n\n    this.modulesController.init(integralModules)\n  }\n\n  public async loadProtocols(type?: ProtocolConfiguration['type'], ignore: string[] = []): Promise<Protocols> {\n    const modules: LoadedModule[] = await this.modulesController.loadModules(type, ignore)\n    const adaptedProtocols: AdaptedProtocol[] = await this.adaptProtocols(modules, type)\n\n    return this.processAdaptedProtocols(adaptedProtocols)\n  }\n\n  public async deriveAddresses(walletOrWallets: AirGapWallet | AirGapWallet[], amount: number = 50): Promise<Record<string, string[]>> {\n    const wallets: AirGapWallet[] = Array.isArray(walletOrWallets) ? walletOrWallets : [walletOrWallets]\n\n    return this.modulesController.deriveAddresses(wallets, amount)\n  }\n\n  public async getModulesMetadata(): Promise<IsolatedModuleMetadata[]> {\n    return this.modulesController.getModulesMetadata()\n  }\n\n  public async readModuleMetadata(name: string, path: string): Promise<IsolatedModulePreviewMetadata> {\n    return this.modulesController.readModuleMetadata(name, path)\n  }\n\n  public async installModule(metadata: IsolatedModulePreviewMetadata): Promise<void> {\n    const loadedModule: LoadedModule = await this.modulesController.installModule(metadata)\n    const adaptedProtocols: AdaptedProtocol[] = await this.adaptProtocols([loadedModule])\n    const protocols: Protocols = this.processAdaptedProtocols(adaptedProtocols)\n\n    await this.protocolService.addActiveMainProtocols(protocols.activeProtocols)\n    await this.protocolService.addActiveSubProtocols(protocols.activeSubProtocols.map(([_, protocol]) => protocol))\n  }\n\n  public async removeInstalledModules(identifiers: string[]): Promise<void> {\n    const removedIdentifiers: string[] = await this.modulesController.removeInstalledModules(identifiers)\n    await this.protocolService.removeProtocols(removedIdentifiers as ProtocolSymbols[])\n  }\n\n  public async removeAllInstalledModules(): Promise<void> {\n    const removedIdentifiers: string[] = await this.modulesController.removeAllInstalledModules()\n    await this.protocolService.removeProtocols(removedIdentifiers as ProtocolSymbols[])\n  }\n\n  private async adaptProtocols(modules: LoadedModule[], type?: ProtocolConfiguration['type']): Promise<AdaptedProtocol[]> {\n    const adaptedProtocols: AdaptedProtocol[][] = await Promise.all(\n      modules.map(async (module: LoadedModule) => {\n        this.loadSerializerCompanion(module.v3SerializerCompanion)\n\n        const activeProtocols: Record<string, ICoinProtocolAdapter> = {}\n        const activeSubProtocols: [ICoinProtocolAdapter, ICoinSubProtocolAdapter][] = []\n\n        const groupedProtocols: Record<string, LoadedProtocol> = await Promise.all(\n          module.protocols.map(async (protocol: LoadedProtocol) => [await this.getProtocolKey(protocol.protocol, type), protocol])\n        ).then((pairs: [string, LoadedProtocol][]) => {\n          return pairs.reduce(\n            (obj: Record<string, LoadedProtocol>, next: [string, LoadedProtocol]) => Object.assign(obj, { [next[0]]: next[1] }),\n            {}\n          )\n        })\n\n        for (const { protocol, blockExplorer } of Object.values(groupedProtocols)) {\n          if (isSubProtocol(protocol)) {\n            const adapter: ICoinSubProtocolAdapter = await createICoinSubProtocolAdapter(\n              protocol,\n              blockExplorer,\n              module.v3SerializerCompanion,\n              { type }\n            )\n\n            const mainKey: string = await this.getProtocolKey(\n              await adapter.protocolV1.mainProtocol(),\n              isOnlineProtocol(adapter.protocolV1) && (type === 'online' || type === 'full')\n                ? await adapter.protocolV1.getNetwork()\n                : undefined\n            )\n\n            if (!(mainKey in activeProtocols)) {\n              const mainAdapter: ICoinProtocolAdapter = await createICoinProtocolAdapter(\n                groupedProtocols[mainKey].protocol,\n                groupedProtocols[mainKey].blockExplorer,\n                module.v3SerializerCompanion,\n                { type }\n              )\n              activeProtocols[mainKey] = mainAdapter\n            }\n\n            activeSubProtocols.push([activeProtocols[mainKey], adapter])\n          } else {\n            const key: string = await this.getProtocolKey(protocol, type)\n            if (activeProtocols[key] !== undefined) {\n              continue\n            }\n\n            const adapter: ICoinProtocolAdapter = await createICoinProtocolAdapter(protocol, blockExplorer, module.v3SerializerCompanion, {\n              type\n            })\n            activeProtocols[key] = adapter\n          }\n        }\n\n        const adaptedMainProtocols: AdaptedProtocol[] = Object.values(activeProtocols).map(\n          (protocol): AdaptedMainProtocol => ({\n            type: 'main',\n            status: 'active',\n            value: protocol\n          })\n        )\n\n        const adaptedSubProtocols: AdaptedProtocol[] = activeSubProtocols.map(\n          (protocol): AdaptedSubProtocol => ({\n            type: 'sub',\n            status: 'active',\n            value: protocol\n          })\n        )\n\n        return adaptedMainProtocols.concat(adaptedSubProtocols)\n      })\n    )\n\n    return flattened(adaptedProtocols)\n  }\n\n  private loadSerializerCompanion(v3SerializerCompanion: AirGapV3SerializerCompanion) {\n    v3SerializerCompanion.schemas.forEach((configuration: V3SchemaConfiguration) => {\n      SerializerV3.addSchema(configuration.type, configuration.schema, configuration.protocolIdentifier as ProtocolSymbols)\n\n      if (configuration.protocolIdentifier) {\n        SerializerV3.addValidator(configuration.protocolIdentifier as ProtocolSymbols, {\n          create(): TransactionValidator {\n            return new TransactionValidatorAdapter(configuration.protocolIdentifier, v3SerializerCompanion)\n          }\n        })\n      }\n    })\n  }\n\n  private processAdaptedProtocols(protocols: AdaptedProtocol[]): Protocols {\n    const activeProtocols: ICoinProtocol[] = []\n    const passiveProtocols: ICoinProtocol[] = []\n\n    const activeSubProtocols: [ICoinProtocol, ICoinSubProtocol][] = []\n    const passiveSubProtocols: [ICoinProtocol, ICoinSubProtocol][] = []\n\n    for (const protocol of protocols) {\n      if (protocol.type === 'main' && protocol.status === 'active') {\n        activeProtocols.push(protocol.value)\n      }\n\n      if (protocol.type === 'main' && protocol.status === 'passive') {\n        passiveProtocols.push(protocol.value)\n      }\n\n      if (protocol.type === 'sub' && protocol.status === 'active') {\n        activeSubProtocols.push(protocol.value)\n      }\n\n      if (protocol.type === 'sub' && protocol.status === 'passive') {\n        passiveSubProtocols.push(protocol.value)\n      }\n    }\n\n    return {\n      activeProtocols,\n      passiveProtocols,\n      activeSubProtocols,\n      passiveSubProtocols\n    }\n  }\n\n  private async getProtocolKey(protocol: AirGapAnyProtocol, type?: ProtocolConfiguration['type']): Promise<string>\n  private async getProtocolKey(protocolIdentifier: string, network: ProtocolNetwork | undefined): Promise<string>\n  private async getProtocolKey(\n    protocolOrIdentifier: AirGapAnyProtocol | string,\n    networkOrTypeOrUndefined?: ProtocolNetwork | ProtocolConfiguration['type'] | undefined\n  ): Promise<string> {\n    const protocolIdentifier: string =\n      typeof protocolOrIdentifier === 'string' ? protocolOrIdentifier : (await protocolOrIdentifier.getMetadata()).identifier\n\n    const type: ProtocolConfiguration['type'] | undefined =\n      typeof networkOrTypeOrUndefined === 'string' ? networkOrTypeOrUndefined : undefined\n\n    const network: ProtocolNetwork | undefined =\n      isOnlineProtocol(protocolOrIdentifier) && (type === 'online' || type === 'full')\n        ? await protocolOrIdentifier.getNetwork()\n        : typeof networkOrTypeOrUndefined === 'object'\n        ? networkOrTypeOrUndefined\n        : undefined\n\n    if (!network) {\n      return protocolIdentifier\n    }\n\n    return `${protocolIdentifier}_${protocolNetworkIdentifier(network)}`\n  }\n}\n"]}

package/esm2022/lib/services/modules/controller/base-modules.controller.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1tb2R1bGVzLmNvbnRyb2xsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL3NlcnZpY2VzL21vZHVsZXMvY29udHJvbGxlci9iYXNlLW1vZHVsZXMuY29udHJvbGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWlyR2FwV2FsbGV0IH0gZnJvbSAnQHdhbGxmcmVlLWRldi9jb2lubGliLWNvcmUnXG5pbXBvcnQge1xuICBBaXJHYXBBbnlQcm90b2NvbCxcbiAgQWlyR2FwQmxvY2tFeHBsb3JlcixcbiAgQWlyR2FwVjNTZXJpYWxpemVyQ29tcGFuaW9uLFxuICBQcm90b2NvbENvbmZpZ3VyYXRpb24sXG4gIFByb3RvY29sTmV0d29ya1xufSBmcm9tICdAd2FsbGZyZWUtZGV2L21vZHVsZS1raXQnXG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9hZGVkTW9kdWxlIHtcbiAgcHJvdG9jb2xzOiBMb2FkZWRQcm90b2NvbFtdXG4gIHYzU2VyaWFsaXplckNvbXBhbmlvbjogQWlyR2FwVjNTZXJpYWxpemVyQ29tcGFuaW9uXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTG9hZGVkUHJvdG9jb2wge1xuICBpZGVudGlmaWVyOiBzdHJpbmdcbiAgcHJvdG9jb2w6IEFpckdhcEFueVByb3RvY29sXG4gIGJsb2NrRXhwbG9yZXI/OiBBaXJHYXBCbG9ja0V4cGxvcmVyXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQmFzZU1vZHVsZXNDb250cm9sbGVyIHtcbiAgbG9hZE1vZHVsZXMocHJvdG9jb2xUeXBlPzogUHJvdG9jb2xDb25maWd1cmF0aW9uWyd0eXBlJ10sIGlnbm9yZVByb3RvY29scz86IHN0cmluZ1tdKTogUHJvbWlzZTxMb2FkZWRNb2R1bGVbXT5cbiAgaXNQcm90b2NvbFN1cHBvcnRlZChpZGVudGlmaWVyOiBzdHJpbmcpOiBib29sZWFuXG5cbiAgZ2V0UHJvdG9jb2xOZXR3b3JrKHByb3RvY29sSWRlbnRpZmllcjogc3RyaW5nLCBuZXR3b3JrSWQ/OiBzdHJpbmcpOiBQcm9taXNlPFByb3RvY29sTmV0d29yayB8IHVuZGVmaW5lZD5cbiAgZ2V0UHJvdG9jb2xCbG9ja0V4cGxvcmVyKHByb3RvY29sSWRlbnRpZmllcjogc3RyaW5nLCBuZXR3b3JrOiBzdHJpbmcgfCBQcm90b2NvbE5ldHdvcmspOiBQcm9taXNlPEFpckdhcEJsb2NrRXhwbG9yZXIgfCB1bmRlZmluZWQ+XG5cbiAgZGVyaXZlQWRkcmVzc2VzKHdhbGxldHM6IEFpckdhcFdhbGxldFtdLCBhbW91bnQ/OiBudW1iZXIpOiBQcm9taXNlPFJlY29yZDxzdHJpbmcsIHN0cmluZ1tdPj5cbn1cbiJdfQ==

package/esm2022/lib/services/modules/controller/integral/integral-modules.controller.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import { flattened } from '../../../../utils/array';
+import { getOfflineProtocolConfiguration, getOnlineProtocolConfiguration } from '../../../../utils/modules/load-protocol';
+import { deriveAddressesAsync } from '../../../../utils/worker';
+import * as i0 from "@angular/core";
+export class IntegralModulesController {
+    constructor() {
+        this.isInitialized = false;
+        this.modules = [];
+        this.supportedProtocols = new Set();
+    }
+    init(modules) {
+        this.isInitialized = true;
+        this.modules = modules;
+    }
+    async loadModules(protocolType, ignoreProtocols = []) {
+        return Promise.all(this.modules.map((module) => this.loadModule(module, protocolType, new Set(ignoreProtocols))));
+    }
+    async loadModule(module, protocolType, ignoreProtocols) {
+        const v3SerializerCompanion = await module.createV3SerializerCompanion();
+        const protocols = flattened(await Promise.all(Object.entries(module.supportedProtocols)
+            .filter(([identifier, _]) => !ignoreProtocols.has(identifier))
+            .map(([identifier, configuration]) => this.loadModuleProtocols(module, identifier, configuration, protocolType))));
+        protocols.forEach((protocol) => {
+            this.supportedProtocols.add(protocol.identifier);
+        });
+        return { protocols, v3SerializerCompanion };
+    }
+    async loadModuleProtocols(module, identifier, configuration, protocolType) {
+        const offlineConfiguration = getOfflineProtocolConfiguration(configuration, protocolType);
+        const onlineConfiguration = getOnlineProtocolConfiguration(configuration, protocolType);
+        const [offlineProtocols, onlineProtocols] = await Promise.all([
+            offlineConfiguration ? this.loadOfflineProtocols(module, identifier, offlineConfiguration) : Promise.resolve([]),
+            onlineConfiguration ? this.loadOnlineProtocols(module, identifier, onlineConfiguration) : Promise.resolve([])
+        ]);
+        return offlineProtocols.concat(onlineProtocols);
+    }
+    async loadOfflineProtocols(module, identifier, _configuration) {
+        const protocol = await module.createOfflineProtocol(identifier);
+        if (protocol === undefined) {
+            return [];
+        }
+        return [{ identifier, protocol }];
+    }
+    async loadOnlineProtocols(module, identifier, configuration) {
+        const protocols = await Promise.all(Object.entries(configuration.networks).map(async ([networkId, _]) => {
+            const [protocol, blockExplorer] = await Promise.all([
+                module.createOnlineProtocol(identifier, networkId),
+                module.createBlockExplorer(identifier, networkId)
+            ]);
+            if (protocol === undefined) {
+                return undefined;
+            }
+            return { identifier, protocol, blockExplorer };
+        }));
+        return protocols.filter((protocol) => protocol !== undefined);
+    }
+    isProtocolSupported(identifier) {
+        return this.supportedProtocols.has(identifier);
+    }
+    async getProtocolNetwork(protocolIdentifier, networkId) {
+        const targetModule = this.modules.find((module) => module.supportedProtocols[protocolIdentifier] !== undefined);
+        if (targetModule === undefined) {
+            return undefined;
+        }
+        const onlineProtocol = await targetModule.createOnlineProtocol(protocolIdentifier, networkId);
+        if (onlineProtocol === undefined) {
+            return undefined;
+        }
+        return onlineProtocol.getNetwork();
+    }
+    async getProtocolBlockExplorer(protocolIdentifier, network) {
+        const targetModule = this.modules.find((module) => module.supportedProtocols[protocolIdentifier] !== undefined);
+        if (targetModule === undefined) {
+            return undefined;
+        }
+        return targetModule.createBlockExplorer(protocolIdentifier, network);
+    }
+    async deriveAddresses(wallets, amount) {
+        return deriveAddressesAsync(wallets, amount);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntegralModulesController, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntegralModulesController, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IntegralModulesController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"integral-modules.controller.js","sourceRoot":"","sources":["../../../../../../../src/lib/services/modules/controller/integral/integral-modules.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { AirGapWallet } from '@wallfree-dev/coinlib-core'\nimport {\n  AirGapBlockExplorer,\n  AirGapModule,\n  AirGapOfflineProtocol,\n  AirGapOnlineProtocol,\n  AirGapV3SerializerCompanion,\n  OfflineProtocolConfiguration,\n  OnlineProtocolConfiguration,\n  ProtocolConfiguration,\n  ProtocolNetwork\n} from '@wallfree-dev/module-kit'\nimport { Injectable } from '@angular/core'\nimport { flattened } from '../../../../utils/array'\nimport { getOfflineProtocolConfiguration, getOnlineProtocolConfiguration } from '../../../../utils/modules/load-protocol'\nimport { deriveAddressesAsync } from '../../../../utils/worker'\nimport { BaseModulesController, LoadedModule, LoadedProtocol } from '../base-modules.controller'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class IntegralModulesController implements BaseModulesController {\n  public isInitialized: boolean = false\n\n  private modules: AirGapModule[] = []\n\n  private readonly supportedProtocols: Set<string> = new Set()\n\n  public init(modules: AirGapModule[]): void {\n    this.isInitialized = true\n    this.modules = modules\n  }\n\n  public async loadModules(protocolType?: ProtocolConfiguration['type'], ignoreProtocols: string[] = []): Promise<LoadedModule[]> {\n    return Promise.all(this.modules.map((module: AirGapModule) => this.loadModule(module, protocolType, new Set(ignoreProtocols))))\n  }\n\n  private async loadModule(\n    module: AirGapModule,\n    protocolType: ProtocolConfiguration['type'] | undefined,\n    ignoreProtocols: Set<string>\n  ): Promise<LoadedModule> {\n    const v3SerializerCompanion: AirGapV3SerializerCompanion = await module.createV3SerializerCompanion()\n    const protocols: LoadedProtocol[] = flattened(\n      await Promise.all(\n        Object.entries(module.supportedProtocols)\n          .filter(([identifier, _]) => !ignoreProtocols.has(identifier))\n          .map(([identifier, configuration]: [string, ProtocolConfiguration]) =>\n            this.loadModuleProtocols(module, identifier, configuration, protocolType)\n          )\n      )\n    )\n\n    protocols.forEach((protocol: LoadedProtocol) => {\n      this.supportedProtocols.add(protocol.identifier)\n    })\n\n    return { protocols, v3SerializerCompanion }\n  }\n\n  private async loadModuleProtocols(\n    module: AirGapModule,\n    identifier: string,\n    configuration: ProtocolConfiguration,\n    protocolType?: ProtocolConfiguration['type']\n  ): Promise<LoadedProtocol[]> {\n    const offlineConfiguration: OfflineProtocolConfiguration | undefined = getOfflineProtocolConfiguration(configuration, protocolType)\n    const onlineConfiguration: OnlineProtocolConfiguration | undefined = getOnlineProtocolConfiguration(configuration, protocolType)\n\n    const [offlineProtocols, onlineProtocols]: [LoadedProtocol[], LoadedProtocol[]] = await Promise.all([\n      offlineConfiguration ? this.loadOfflineProtocols(module, identifier, offlineConfiguration) : Promise.resolve([]),\n      onlineConfiguration ? this.loadOnlineProtocols(module, identifier, onlineConfiguration) : Promise.resolve([])\n    ])\n\n    return offlineProtocols.concat(onlineProtocols)\n  }\n\n  private async loadOfflineProtocols(\n    module: AirGapModule,\n    identifier: string,\n    _configuration: OfflineProtocolConfiguration\n  ): Promise<LoadedProtocol[]> {\n    const protocol: AirGapOfflineProtocol | undefined = await module.createOfflineProtocol(identifier)\n    if (protocol === undefined) {\n      return []\n    }\n\n    return [{ identifier, protocol }]\n  }\n\n  private async loadOnlineProtocols(\n    module: AirGapModule,\n    identifier: string,\n    configuration: OnlineProtocolConfiguration\n  ): Promise<LoadedProtocol[]> {\n    const protocols: (LoadedProtocol | undefined)[] = await Promise.all(\n      Object.entries(configuration.networks).map(async ([networkId, _]: [string, ProtocolNetwork]) => {\n        const [protocol, blockExplorer]: [AirGapOnlineProtocol | undefined, AirGapBlockExplorer | undefined] = await Promise.all([\n          module.createOnlineProtocol(identifier, networkId),\n          module.createBlockExplorer(identifier, networkId)\n        ])\n        if (protocol === undefined) {\n          return undefined\n        }\n\n        return { identifier, protocol, blockExplorer }\n      })\n    )\n\n    return protocols.filter((protocol: LoadedProtocol | undefined) => protocol !== undefined)\n  }\n\n  public isProtocolSupported(identifier: string): boolean {\n    return this.supportedProtocols.has(identifier)\n  }\n\n  public async getProtocolNetwork(protocolIdentifier: string, networkId?: string): Promise<ProtocolNetwork | undefined> {\n    const targetModule: AirGapModule | undefined = this.modules.find(\n      (module: AirGapModule) => module.supportedProtocols[protocolIdentifier] !== undefined\n    )\n    if (targetModule === undefined) {\n      return undefined\n    }\n\n    const onlineProtocol: AirGapOnlineProtocol | undefined = await targetModule.createOnlineProtocol(protocolIdentifier, networkId)\n    if (onlineProtocol === undefined) {\n      return undefined\n    }\n\n    return onlineProtocol.getNetwork()\n  }\n\n  public async getProtocolBlockExplorer(\n    protocolIdentifier: string,\n    network: string | ProtocolNetwork\n  ): Promise<AirGapBlockExplorer | undefined> {\n    const targetModule: AirGapModule | undefined = this.modules.find(\n      (module: AirGapModule) => module.supportedProtocols[protocolIdentifier] !== undefined\n    )\n    if (targetModule === undefined) {\n      return undefined\n    }\n\n    return targetModule.createBlockExplorer(protocolIdentifier, network)\n  }\n\n  public async deriveAddresses(wallets: AirGapWallet[], amount?: number): Promise<Record<string, string[]>> {\n    return deriveAddressesAsync(wallets, amount)\n  }\n}\n"]}