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

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

@@ -0,0 +1,190 @@
+import { Inject, Injectable } from '@angular/core';
+import { ISOLATED_MODULES_PLUGIN } from '../../../../capacitor-plugins/injection-tokens';
+import { IsolatedAirGapV3SerializerCompanion } from '../../../../protocol/isolated/v3-serializer-companion-isolated';
+import { flattened } from '../../../../utils/array';
+import { IsolatedAirGapOfflineProtocol } from '../../../../protocol/isolated/protocol-offline-isolated';
+import { IsolatedAirGapOnlineProtocol } from '../../../../protocol/isolated/protocol-online-isolated';
+import { IsolatedAirGapBlockExplorer } from '../../../../protocol/isolated/block-explorer-isolated';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../filesystem/filesystem.service";
+const AIRGAP_PUBLIC_KEY = '';
+export class IsolatedModulesController {
+    constructor(isolatedModules, filesystemService) {
+        this.isolatedModules = isolatedModules;
+        this.filesystemService = filesystemService;
+        this.staticModules = new Map();
+        this.dynamicModules = new Map();
+        this.supportedProtocols = new Set();
+    }
+    async loadModules(protocolType, ignoreProtocols = []) {
+        const { modules } = await this.isolatedModules.loadAllModules({ protocolType, ignoreProtocols });
+        modules.forEach((module) => {
+            if (module.type === 'static') {
+                this.staticModules.set(module.identifier, module);
+            }
+            else {
+                this.dynamicModules.set(module.identifier, module);
+            }
+        });
+        return this.processIsolatedModules(modules, protocolType, new Set(ignoreProtocols));
+    }
+    async processIsolatedModules(modules, type, ignore = new Set()) {
+        const loadedModules = await Promise.all(modules.map((module) => this.processIsolatedModule(module, type, ignore)));
+        return loadedModules.filter((module) => module !== undefined);
+    }
+    async processIsolatedModule(module, type, ignore = new Set()) {
+        const protocols = module.protocols
+            .filter((protocol) => !ignore.has(protocol.identifier) && (type ? protocol.mode === type : true))
+            .map((protocol) => {
+            const wrappedProtocol = protocol.mode === 'offline'
+                ? new IsolatedAirGapOfflineProtocol(this.isolatedModules, protocol)
+                : new IsolatedAirGapOnlineProtocol(this.isolatedModules, protocol);
+            const wrappedBlockExplorer = new IsolatedAirGapBlockExplorer(this.isolatedModules, protocol.identifier, protocol.network, protocol.blockExplorerMetadata);
+            this.supportedProtocols.add(protocol.identifier);
+            return { identifier: protocol.identifier, protocol: wrappedProtocol, blockExplorer: wrappedBlockExplorer };
+        });
+        if (protocols.length === 0) {
+            return undefined;
+        }
+        const v3SerializerCompanion = new IsolatedAirGapV3SerializerCompanion(this.isolatedModules, module.v3SchemaConfigurations, module.identifier);
+        return {
+            protocols,
+            v3SerializerCompanion
+        };
+    }
+    isProtocolSupported(identifier) {
+        return this.supportedProtocols.has(identifier);
+    }
+    async getProtocolNetwork(protocolIdentifier, networkId) {
+        const { value } = await this.isolatedModules.callMethod({
+            target: 'onlineProtocol',
+            method: 'getNetwork',
+            protocolIdentifier,
+            networkId
+        });
+        return value;
+    }
+    async getProtocolBlockExplorer(protocolIdentifier, network) {
+        const networkObject = typeof network === 'string' ? await this.getProtocolNetwork(protocolIdentifier, network) : network;
+        return new IsolatedAirGapBlockExplorer(this.isolatedModules, protocolIdentifier, networkObject);
+    }
+    async deriveAddresses(wallets, amount = 50) {
+        // TODO: optimize?
+        const addressesByKey = await Promise.all(wallets.map(async (wallet) => {
+            const addresses = await wallet.deriveAddresses(amount);
+            return { [`${await wallet.protocol.getIdentifier()}_${wallet.publicKey}`]: addresses };
+        }));
+        return addressesByKey.reduce((obj, next) => Object.assign(obj, next), {});
+    }
+    async getModulesMetadata() {
+        const metadata = await Promise.all([
+            this.getAssetModulesMetadata(),
+            this.getDynamicModulesMetadata()
+        ]);
+        return flattened(metadata);
+    }
+    async getAssetModulesMetadata() {
+        return Promise.all(Array.from(this.staticModules.values()).map(async (module) => {
+            const { manifest } = await this.isolatedModules.readAssetModule({
+                identifier: module.identifier
+            });
+            return {
+                type: 'asset',
+                manifest,
+                module,
+                source: manifest.publicKey === AIRGAP_PUBLIC_KEY ? 'airgap' : '3rd_party'
+            };
+        }));
+    }
+    async getDynamicModulesMetadata() {
+        return Promise.all(Array.from(this.dynamicModules.values()).map(async (module) => {
+            const { manifest, installedAt } = await this.isolatedModules.readDynamicModule({
+                identifier: module.identifier
+            });
+            return {
+                type: 'installed',
+                manifest,
+                module,
+                installedAt,
+                source: manifest.publicKey === AIRGAP_PUBLIC_KEY ? 'airgap' : '3rd_party'
+            };
+        }));
+    }
+    async readModuleMetadata(name, path) {
+        if (!name.endsWith('.zip')) {
+            throw new Error('Invalid protocol module format, expected .zip');
+        }
+        const tempDir = await this.filesystemService.createTempProtocolModule(name, path);
+        try {
+            const root = await this.filesystemService.findProtocolModuleRoot(tempDir.path, tempDir.directory);
+            if (root === undefined) {
+                throw new Error('Invalid protocol module structure, manifest not found');
+            }
+            const preview = await this.isolatedModules.previewDynamicModule({
+                path: `${tempDir.path}/${root}`.replace(/\/+$/, ''),
+                directory: tempDir.directory
+            });
+            return {
+                type: 'preview',
+                module: preview.module,
+                manifest: preview.manifest,
+                path: tempDir.path,
+                root,
+                directory: tempDir.directory,
+                source: preview.manifest.publicKey === AIRGAP_PUBLIC_KEY ? 'airgap' : '3rd_party'
+            };
+        }
+        catch (error) {
+            await this.filesystemService.removeTempProtocolModule(tempDir.path, tempDir.directory).catch(() => {
+                /* no action */
+            });
+            throw error;
+        }
+    }
+    async installModule(metadata) {
+        const newIdentifier = metadata.manifest.name
+            .replace(/\s+/, '_')
+            .replace(/[^a-zA-Z\d_-]/g, '')
+            .toLocaleLowerCase();
+        await this.filesystemService.installProtocolModule(newIdentifier, metadata.manifest.include, metadata.manifest.res?.symbol ?? {}, {
+            path: metadata.path,
+            root: metadata.root,
+            directory: metadata.directory
+        });
+        await this.isolatedModules.registerDynamicModule({
+            identifier: newIdentifier,
+            protocolIdentifiers: metadata.module.protocols.map((protocol) => protocol.identifier)
+        });
+        this.dynamicModules.set(newIdentifier, {
+            ...metadata.module,
+            identifier: newIdentifier
+        });
+        return this.processIsolatedModule(metadata.module);
+    }
+    async removeInstalledModules(identifiers) {
+        await this.isolatedModules.removeDynamicModules({ identifiers });
+        const protocolIdentifiers = flattened(identifiers.map((identifier) => this.dynamicModules.get(identifier)?.protocols.map((protocol) => protocol.identifier) ?? []));
+        identifiers.forEach((identifier) => {
+            this.dynamicModules.delete(identifier);
+        });
+        return protocolIdentifiers;
+    }
+    async removeAllInstalledModules() {
+        await this.isolatedModules.removeDynamicModules();
+        const protocolIdentifiers = flattened(Array.from(this.dynamicModules.values()).map((module) => module.protocols.map((protocol) => protocol.identifier)));
+        this.dynamicModules.clear();
+        return protocolIdentifiers;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesController, deps: [{ token: ISOLATED_MODULES_PLUGIN }, { token: i1.FilesystemService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesController, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IsolatedModulesController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ISOLATED_MODULES_PLUGIN]
+                }] }, { type: i1.FilesystemService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"isolated-modules.controller.js","sourceRoot":"","sources":["../../../../../../../src/lib/services/modules/controller/isolated/isolated-modules.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { AirGapWallet } from '@wallfree-dev/coinlib-core'\nimport { Inject, Injectable } from '@angular/core'\nimport {\n  AirGapAnyProtocol,\n  AirGapBlockExplorer,\n  AirGapV3SerializerCompanion,\n  ProtocolConfiguration,\n  ProtocolNetwork\n} from '@wallfree-dev/module-kit'\nimport { ISOLATED_MODULES_PLUGIN } from '../../../../capacitor-plugins/injection-tokens'\nimport {\n  CallMethodResult,\n  IsolatedModulesPlugin,\n  LoadAllModulesResult,\n  PreviewDynamicModuleResult,\n  ReadAssetModuleResult,\n  ReadDynamicModuleResult\n} from '../../../../capacitor-plugins/definitions'\nimport { IsolatedModule, IsolatedProtocol } from '../../../../types/isolated-modules/IsolatedModule'\nimport { IsolatedAirGapV3SerializerCompanion } from '../../../../protocol/isolated/v3-serializer-companion-isolated'\nimport { flattened } from '../../../../utils/array'\nimport { IsolatedAirGapOfflineProtocol } from '../../../../protocol/isolated/protocol-offline-isolated'\nimport { IsolatedAirGapOnlineProtocol } from '../../../../protocol/isolated/protocol-online-isolated'\nimport { IsolatedAirGapBlockExplorer } from '../../../../protocol/isolated/block-explorer-isolated'\nimport {\n  IsolatedModuleAssetMetadata,\n  IsolatedModuleInstalledMetadata,\n  IsolatedModuleMetadata,\n  IsolatedModulePreviewMetadata\n} from '../../../../types/isolated-modules/IsolatedModuleMetadata'\nimport { BaseModulesController, LoadedModule, LoadedProtocol } from '../base-modules.controller'\nimport { FilesystemService } from '../../../filesystem/filesystem.service'\n\nconst AIRGAP_PUBLIC_KEY: string = ''\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class IsolatedModulesController implements BaseModulesController {\n  private readonly staticModules: Map<string, IsolatedModule> = new Map()\n  private readonly dynamicModules: Map<string, IsolatedModule> = new Map()\n\n  private readonly supportedProtocols: Set<string> = new Set()\n\n  constructor(\n    @Inject(ISOLATED_MODULES_PLUGIN) private readonly isolatedModules: IsolatedModulesPlugin,\n    private readonly filesystemService: FilesystemService\n  ) {}\n\n  public async loadModules(protocolType?: ProtocolConfiguration['type'], ignoreProtocols: string[] = []): Promise<LoadedModule[]> {\n    const { modules }: LoadAllModulesResult = await this.isolatedModules.loadAllModules({ protocolType, ignoreProtocols })\n    modules.forEach((module: IsolatedModule) => {\n      if (module.type === 'static') {\n        this.staticModules.set(module.identifier, module)\n      } else {\n        this.dynamicModules.set(module.identifier, module)\n      }\n    })\n\n    return this.processIsolatedModules(modules, protocolType, new Set(ignoreProtocols))\n  }\n\n  private async processIsolatedModules(\n    modules: IsolatedModule[],\n    type?: ProtocolConfiguration['type'],\n    ignore: Set<string> = new Set()\n  ): Promise<LoadedModule[]> {\n    const loadedModules: (LoadedModule | undefined)[] = await Promise.all(\n      modules.map((module: IsolatedModule) => this.processIsolatedModule(module, type, ignore))\n    )\n\n    return loadedModules.filter((module: LoadedModule | undefined) => module !== undefined)\n  }\n\n  private async processIsolatedModule(\n    module: IsolatedModule,\n    type?: ProtocolConfiguration['type'],\n    ignore: Set<string> = new Set()\n  ): Promise<LoadedModule | undefined> {\n    const protocols: LoadedProtocol[] = module.protocols\n      .filter((protocol: IsolatedProtocol) => !ignore.has(protocol.identifier) && (type ? protocol.mode === type : true))\n      .map((protocol: IsolatedProtocol) => {\n        const wrappedProtocol: AirGapAnyProtocol =\n          protocol.mode === 'offline'\n            ? new IsolatedAirGapOfflineProtocol(this.isolatedModules, protocol)\n            : new IsolatedAirGapOnlineProtocol(this.isolatedModules, protocol)\n\n        const wrappedBlockExplorer: AirGapBlockExplorer = new IsolatedAirGapBlockExplorer(\n          this.isolatedModules,\n          protocol.identifier,\n          protocol.network,\n          protocol.blockExplorerMetadata\n        )\n\n        this.supportedProtocols.add(protocol.identifier)\n\n        return { identifier: protocol.identifier, protocol: wrappedProtocol, blockExplorer: wrappedBlockExplorer }\n      })\n\n    if (protocols.length === 0) {\n      return undefined\n    }\n\n    const v3SerializerCompanion: AirGapV3SerializerCompanion = new IsolatedAirGapV3SerializerCompanion(\n      this.isolatedModules,\n      module.v3SchemaConfigurations,\n      module.identifier\n    )\n\n    return {\n      protocols,\n      v3SerializerCompanion\n    }\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 { value }: CallMethodResult = await this.isolatedModules.callMethod({\n      target: 'onlineProtocol',\n      method: 'getNetwork',\n      protocolIdentifier,\n      networkId\n    })\n\n    return value as ProtocolNetwork\n  }\n\n  public async getProtocolBlockExplorer(\n    protocolIdentifier: string,\n    network: string | ProtocolNetwork\n  ): Promise<AirGapBlockExplorer | undefined> {\n    const networkObject: ProtocolNetwork =\n      typeof network === 'string' ? await this.getProtocolNetwork(protocolIdentifier, network) : network\n\n    return new IsolatedAirGapBlockExplorer(this.isolatedModules, protocolIdentifier, networkObject)\n  }\n\n  public async deriveAddresses(wallets: AirGapWallet[], amount: number = 50): Promise<Record<string, string[]>> {\n    // TODO: optimize?\n    const addressesByKey: Record<string, string[]>[] = await Promise.all(\n      wallets.map(async (wallet: AirGapWallet) => {\n        const addresses: string[] = await wallet.deriveAddresses(amount)\n\n        return { [`${await wallet.protocol.getIdentifier()}_${wallet.publicKey}`]: addresses }\n      })\n    )\n\n    return addressesByKey.reduce((obj: Record<string, string[]>, next: Record<string, string[]>) => Object.assign(obj, next), {})\n  }\n\n  public async getModulesMetadata(): Promise<IsolatedModuleMetadata[]> {\n    const metadata: [IsolatedModuleAssetMetadata[], IsolatedModuleInstalledMetadata[]] = await Promise.all([\n      this.getAssetModulesMetadata(),\n      this.getDynamicModulesMetadata()\n    ])\n\n    return flattened<IsolatedModuleMetadata>(metadata)\n  }\n\n  private async getAssetModulesMetadata(): Promise<IsolatedModuleAssetMetadata[]> {\n    return Promise.all(\n      Array.from(this.staticModules.values()).map(async (module: IsolatedModule): Promise<IsolatedModuleAssetMetadata> => {\n        const { manifest }: ReadAssetModuleResult = await this.isolatedModules.readAssetModule({\n          identifier: module.identifier\n        })\n\n        return {\n          type: 'asset',\n          manifest,\n          module,\n          source: manifest.publicKey === AIRGAP_PUBLIC_KEY ? 'airgap' : '3rd_party'\n        }\n      })\n    )\n  }\n\n  private async getDynamicModulesMetadata(): Promise<IsolatedModuleInstalledMetadata[]> {\n    return Promise.all(\n      Array.from(this.dynamicModules.values()).map(async (module: IsolatedModule): Promise<IsolatedModuleInstalledMetadata> => {\n        const { manifest, installedAt }: ReadDynamicModuleResult = await this.isolatedModules.readDynamicModule({\n          identifier: module.identifier\n        })\n\n        return {\n          type: 'installed',\n          manifest,\n          module,\n          installedAt,\n          source: manifest.publicKey === AIRGAP_PUBLIC_KEY ? 'airgap' : '3rd_party'\n        }\n      })\n    )\n  }\n\n  public async readModuleMetadata(name: string, path: string): Promise<IsolatedModulePreviewMetadata> {\n    if (!name.endsWith('.zip')) {\n      throw new Error('Invalid protocol module format, expected .zip')\n    }\n\n    const tempDir = await this.filesystemService.createTempProtocolModule(name, path)\n\n    try {\n      const root: string | undefined = await this.filesystemService.findProtocolModuleRoot(tempDir.path, tempDir.directory)\n      if (root === undefined) {\n        throw new Error('Invalid protocol module structure, manifest not found')\n      }\n\n      const preview: PreviewDynamicModuleResult = await this.isolatedModules.previewDynamicModule({\n        path: `${tempDir.path}/${root}`.replace(/\\/+$/, ''),\n        directory: tempDir.directory\n      })\n\n      return {\n        type: 'preview',\n        module: preview.module,\n        manifest: preview.manifest,\n        path: tempDir.path,\n        root,\n        directory: tempDir.directory,\n        source: preview.manifest.publicKey === AIRGAP_PUBLIC_KEY ? 'airgap' : '3rd_party'\n      }\n    } catch (error) {\n      await this.filesystemService.removeTempProtocolModule(tempDir.path, tempDir.directory).catch(() => {\n        /* no action */\n      })\n      throw error\n    }\n  }\n\n  public async installModule(metadata: IsolatedModulePreviewMetadata): Promise<LoadedModule> {\n    const newIdentifier: string = metadata.manifest.name\n      .replace(/\\s+/, '_')\n      .replace(/[^a-zA-Z\\d_-]/g, '')\n      .toLocaleLowerCase()\n\n    await this.filesystemService.installProtocolModule(newIdentifier, metadata.manifest.include, metadata.manifest.res?.symbol ?? {}, {\n      path: metadata.path,\n      root: metadata.root,\n      directory: metadata.directory\n    })\n\n    await this.isolatedModules.registerDynamicModule({\n      identifier: newIdentifier,\n      protocolIdentifiers: metadata.module.protocols.map((protocol) => protocol.identifier)\n    })\n\n    this.dynamicModules.set(newIdentifier, {\n      ...metadata.module,\n      identifier: newIdentifier\n    })\n\n    return this.processIsolatedModule(metadata.module)\n  }\n\n  public async removeInstalledModules(identifiers: string[]): Promise<string[]> {\n    await this.isolatedModules.removeDynamicModules({ identifiers })\n    const protocolIdentifiers: string[] = flattened(\n      identifiers.map(\n        (identifier: string) =>\n          this.dynamicModules.get(identifier)?.protocols.map((protocol: IsolatedProtocol) => protocol.identifier) ?? []\n      )\n    )\n\n    identifiers.forEach((identifier: string) => {\n      this.dynamicModules.delete(identifier)\n    })\n\n    return protocolIdentifiers\n  }\n\n  public async removeAllInstalledModules(): Promise<string[]> {\n    await this.isolatedModules.removeDynamicModules()\n    const protocolIdentifiers: string[] = flattened(\n      Array.from(this.dynamicModules.values()).map((module: IsolatedModule) =>\n        module.protocols.map((protocol: IsolatedProtocol) => protocol.identifier)\n      )\n    )\n\n    this.dynamicModules.clear()\n\n    return protocolIdentifiers\n  }\n}\n"]}

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

@@ -0,0 +1,85 @@
+import { Injectable } from '@angular/core';
+import { flattened } from '../../../utils/array';
+import * as i0 from "@angular/core";
+import * as i1 from "./integral/integral-modules.controller";
+import * as i2 from "./isolated/isolated-modules.controller";
+export class ModulesController {
+    constructor(integralModulesController, isolatedModulesController) {
+        this.integralModulesController = integralModulesController;
+        this.isolatedModulesController = isolatedModulesController;
+        this.isInitialized = false;
+    }
+    init(integralModules) {
+        this.isInitialized = true;
+        this.integralModulesController.init(integralModules);
+    }
+    async loadModules(protocolType, ignoreProtocols) {
+        const integralModules = await this.integralModulesController.loadModules(protocolType, ignoreProtocols);
+        const integralProtocols = flattened(await Promise.all(integralModules.map((module) => Promise.all(module.protocols.map((protocol) => protocol.protocol.getMetadata().then((metadata) => metadata.identifier))))));
+        const isolatedModules = await this.isolatedModulesController.loadModules(protocolType, ignoreProtocols.concat(integralProtocols));
+        return integralModules.concat(isolatedModules);
+    }
+    async getProtocolNetwork(protocolIdentifier, networkId) {
+        if (this.integralModulesController.isProtocolSupported(protocolIdentifier)) {
+            return this.integralModulesController.getProtocolNetwork(protocolIdentifier, networkId);
+        }
+        else if (this.isolatedModulesController.isProtocolSupported(protocolIdentifier)) {
+            return this.isolatedModulesController.getProtocolNetwork(protocolIdentifier, networkId);
+        }
+        else {
+            return undefined;
+        }
+    }
+    async getProtocolBlockExplorer(protocolIdentifier, network) {
+        if (this.integralModulesController.isProtocolSupported(protocolIdentifier)) {
+            return this.integralModulesController.getProtocolBlockExplorer(protocolIdentifier, network);
+        }
+        else if (this.isolatedModulesController.isProtocolSupported(protocolIdentifier)) {
+            return this.isolatedModulesController.getProtocolBlockExplorer(protocolIdentifier, network);
+        }
+        else {
+            return undefined;
+        }
+    }
+    async deriveAddresses(wallets, amount) {
+        const [integralWallets, isolatedWallets] = await this.groupWalletsByControllers(wallets, [
+            this.integralModulesController,
+            this.isolatedModulesController
+        ]);
+        const [integralAddresses, isolatedAddresses] = await Promise.all([
+            this.integralModulesController.deriveAddresses(integralWallets, amount),
+            this.isolatedModulesController.deriveAddresses(isolatedWallets, amount)
+        ]);
+        return Object.assign({}, integralAddresses, isolatedAddresses);
+    }
+    async getModulesMetadata() {
+        return this.isolatedModulesController.getModulesMetadata();
+    }
+    async readModuleMetadata(name, path) {
+        return this.isolatedModulesController.readModuleMetadata(name, path);
+    }
+    async installModule(metadata) {
+        return this.isolatedModulesController.installModule(metadata);
+    }
+    async removeInstalledModules(identifiers) {
+        return this.isolatedModulesController.removeInstalledModules(identifiers);
+    }
+    async removeAllInstalledModules() {
+        return this.isolatedModulesController.removeAllInstalledModules();
+    }
+    async groupWalletsByControllers(wallets, controllers) {
+        const walletsWithProtocolIdentifiers = await Promise.all(wallets.map(async (wallet) => [wallet, await wallet.protocol.getIdentifier()]));
+        return controllers.map((controller) => walletsWithProtocolIdentifiers
+            .filter(([_, protocolIdentifier]) => controller.isProtocolSupported(protocolIdentifier))
+            .map(([wallet, _]) => wallet));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModulesController, deps: [{ token: i1.IntegralModulesController }, { token: i2.IsolatedModulesController }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModulesController, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ModulesController, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.IntegralModulesController }, { type: i2.IsolatedModulesController }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modules.controller.js","sourceRoot":"","sources":["../../../../../../src/lib/services/modules/controller/modules.controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { AirGapWallet } from '@wallfree-dev/coinlib-core'\nimport { AirGapBlockExplorer, AirGapModule, ProtocolConfiguration, ProtocolNetwork } from '@wallfree-dev/module-kit'\nimport { Injectable } from '@angular/core'\nimport { IsolatedModuleMetadata, IsolatedModulePreviewMetadata } from '../../../types/isolated-modules/IsolatedModuleMetadata'\nimport { flattened } from '../../../utils/array'\nimport { BaseModulesController, LoadedModule, LoadedProtocol } from './base-modules.controller'\nimport { IntegralModulesController } from './integral/integral-modules.controller'\nimport { IsolatedModulesController } from './isolated/isolated-modules.controller'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ModulesController {\n  public isInitialized: boolean = false\n\n  constructor(\n    private readonly integralModulesController: IntegralModulesController,\n    private readonly isolatedModulesController: IsolatedModulesController\n  ) {}\n\n  public init(integralModules: AirGapModule[]): void {\n    this.isInitialized = true\n    this.integralModulesController.init(integralModules)\n  }\n\n  public async loadModules(protocolType?: ProtocolConfiguration['type'], ignoreProtocols?: string[]): Promise<LoadedModule[]> {\n    const integralModules: LoadedModule[] = await this.integralModulesController.loadModules(protocolType, ignoreProtocols)\n    const integralProtocols: string[] = flattened(\n      await Promise.all(\n        integralModules.map((module: LoadedModule) =>\n          Promise.all(\n            module.protocols.map((protocol: LoadedProtocol) => protocol.protocol.getMetadata().then((metadata) => metadata.identifier))\n          )\n        )\n      )\n    )\n\n    const isolatedModules: LoadedModule[] = await this.isolatedModulesController.loadModules(\n      protocolType,\n      ignoreProtocols.concat(integralProtocols)\n    )\n\n    return integralModules.concat(isolatedModules)\n  }\n\n  public async getProtocolNetwork(protocolIdentifier: string, networkId?: string): Promise<ProtocolNetwork | undefined> {\n    if (this.integralModulesController.isProtocolSupported(protocolIdentifier)) {\n      return this.integralModulesController.getProtocolNetwork(protocolIdentifier, networkId)\n    } else if (this.isolatedModulesController.isProtocolSupported(protocolIdentifier)) {\n      return this.isolatedModulesController.getProtocolNetwork(protocolIdentifier, networkId)\n    } else {\n      return undefined\n    }\n  }\n\n  public async getProtocolBlockExplorer(\n    protocolIdentifier: string,\n    network: string | ProtocolNetwork\n  ): Promise<AirGapBlockExplorer | undefined> {\n    if (this.integralModulesController.isProtocolSupported(protocolIdentifier)) {\n      return this.integralModulesController.getProtocolBlockExplorer(protocolIdentifier, network)\n    } else if (this.isolatedModulesController.isProtocolSupported(protocolIdentifier)) {\n      return this.isolatedModulesController.getProtocolBlockExplorer(protocolIdentifier, network)\n    } else {\n      return undefined\n    }\n  }\n\n  public async deriveAddresses(wallets: AirGapWallet[], amount?: number): Promise<Record<string, string[]>> {\n    const [integralWallets, isolatedWallets]: AirGapWallet[][] = await this.groupWalletsByControllers(wallets, [\n      this.integralModulesController,\n      this.isolatedModulesController\n    ])\n\n    const [integralAddresses, isolatedAddresses]: [Record<string, string[]>, Record<string, string[]>] = await Promise.all([\n      this.integralModulesController.deriveAddresses(integralWallets, amount),\n      this.isolatedModulesController.deriveAddresses(isolatedWallets, amount)\n    ])\n\n    return Object.assign({}, integralAddresses, isolatedAddresses)\n  }\n\n  public async getModulesMetadata(): Promise<IsolatedModuleMetadata[]> {\n    return this.isolatedModulesController.getModulesMetadata()\n  }\n\n  public async readModuleMetadata(name: string, path: string): Promise<IsolatedModulePreviewMetadata> {\n    return this.isolatedModulesController.readModuleMetadata(name, path)\n  }\n\n  public async installModule(metadata: IsolatedModulePreviewMetadata): Promise<LoadedModule> {\n    return this.isolatedModulesController.installModule(metadata)\n  }\n\n  public async removeInstalledModules(identifiers: string[]): Promise<string[]> {\n    return this.isolatedModulesController.removeInstalledModules(identifiers)\n  }\n\n  public async removeAllInstalledModules(): Promise<string[]> {\n    return this.isolatedModulesController.removeAllInstalledModules()\n  }\n\n  private async groupWalletsByControllers(wallets: AirGapWallet[], controllers: BaseModulesController[]): Promise<AirGapWallet[][]> {\n    const walletsWithProtocolIdentifiers: [AirGapWallet, string][] = await Promise.all(\n      wallets.map(async (wallet: AirGapWallet) => [wallet, await wallet.protocol.getIdentifier()] as [AirGapWallet, string])\n    )\n\n    return controllers.map((controller: BaseModulesController) =>\n      walletsWithProtocolIdentifiers\n        .filter(([_, protocolIdentifier]: [AirGapWallet, string]) => controller.isProtocolSupported(protocolIdentifier))\n        .map(([wallet, _]: [AirGapWallet, string]) => wallet)\n    )\n  }\n}\n"]}

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

@@ -0,0 +1,140 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../ui-event-elements/ui-event-elements.service";
+import * as i2 from "@ionic/angular";
+import * as i3 from "@ionic-native/diagnostic/ngx";
+// import { ErrorCategory, handleErrorLocal } from '../error-handler/error-handler.service'
+export var PermissionStatus;
+(function (PermissionStatus) {
+    PermissionStatus["GRANTED"] = "GRANTED";
+    PermissionStatus["NOT_REQUESTED"] = "NOT_REQUESTED";
+    PermissionStatus["DENIED_ALWAYS"] = "DENIED_ALWAYS";
+    PermissionStatus["DENIED"] = "DENIED";
+    PermissionStatus["UNKNOWN"] = "UNKNOWN";
+})(PermissionStatus || (PermissionStatus = {}));
+export var PermissionTypes;
+(function (PermissionTypes) {
+    PermissionTypes["CAMERA"] = "CAMERA";
+    PermissionTypes["MICROPHONE"] = "MICROPHONE";
+})(PermissionTypes || (PermissionTypes = {}));
+export class PermissionsService {
+    constructor(uiEventElementsService, platform, diagnostic) {
+        this.uiEventElementsService = uiEventElementsService;
+        this.platform = platform;
+        this.diagnostic = diagnostic;
+    }
+    async hasCameraPermission() {
+        const permission = await this.diagnostic.getCameraAuthorizationStatus(false);
+        return this.getPermissionStatus(permission);
+    }
+    async hasMicrophonePermission() {
+        const permission = await this.diagnostic.getMicrophoneAuthorizationStatus();
+        return this.getPermissionStatus(permission);
+    }
+    async requestPermissions(permissions) {
+        if (this.platform.is('android')) {
+            const permissionsToRequest = [];
+            if (permissions.indexOf(PermissionTypes.CAMERA) >= 0) {
+                permissionsToRequest.push(this.diagnostic.permission.CAMERA);
+            }
+            if (permissions.indexOf(PermissionTypes.MICROPHONE) >= 0) {
+                permissionsToRequest.push(this.diagnostic.permission.RECORD_AUDIO);
+            }
+            await this.diagnostic.requestRuntimePermissions(permissionsToRequest);
+        }
+        else if (this.platform.is('ios')) {
+            if (permissions.indexOf(PermissionTypes.CAMERA) >= 0) {
+                await this.diagnostic.requestCameraAuthorization(false);
+            }
+            if (permissions.indexOf(PermissionTypes.MICROPHONE) >= 0) {
+                await this.diagnostic.requestMicrophoneAuthorization();
+            }
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn('requesting permission in browser');
+        }
+    }
+    /**
+     * The user actively wants to give permissions. This means we first check if we
+     * can ask him for the permissions natively, otherwise we show an alert with a
+     * link to the settings.
+     */
+    async userRequestsPermissions(permissions) {
+        let canRequestPermission = false;
+        for (const p of permissions) {
+            canRequestPermission = (await this.canAskForPermission(p)) || canRequestPermission;
+        }
+        if (canRequestPermission) {
+            await this.requestPermissions(permissions);
+        }
+        else {
+            await this.uiEventElementsService.showOpenSettingsAlert(() => {
+                // eslint-disable-next-line no-console
+                this.diagnostic.switchToSettings().catch(console.error);
+            });
+        }
+    }
+    async canAskForPermission(permission) {
+        let canAskForPermission = true;
+        if (this.platform.is('android')) {
+            if (permission === PermissionTypes.CAMERA) {
+                const permissionStatus = await this.hasCameraPermission();
+                canAskForPermission = !(permissionStatus === PermissionStatus.DENIED_ALWAYS);
+            }
+            else if (permission === PermissionTypes.MICROPHONE) {
+                const permissionStatus = await this.hasMicrophonePermission();
+                canAskForPermission = !(permissionStatus === PermissionStatus.DENIED_ALWAYS);
+            }
+        }
+        else if (this.platform.is('ios')) {
+            if (permission === PermissionTypes.CAMERA) {
+                const permissionStatus = await this.hasCameraPermission();
+                canAskForPermission = !(permissionStatus === PermissionStatus.DENIED);
+            }
+            else if (permission === PermissionTypes.MICROPHONE) {
+                const permissionStatus = await this.hasMicrophonePermission();
+                canAskForPermission = !(permissionStatus === PermissionStatus.DENIED);
+            }
+        }
+        return canAskForPermission;
+    }
+    async getPermissionStatus(permission) {
+        if (this.isGranted(permission)) {
+            return PermissionStatus.GRANTED;
+        }
+        else if (this.isNotRequested(permission)) {
+            return PermissionStatus.NOT_REQUESTED;
+        }
+        else if (this.isDeniedAlways(permission)) {
+            return PermissionStatus.DENIED_ALWAYS;
+        }
+        else if (this.isDenied(permission)) {
+            return PermissionStatus.DENIED;
+        }
+        else {
+            return PermissionStatus.UNKNOWN;
+        }
+    }
+    isGranted(permission) {
+        return permission === this.diagnostic.permissionStatus.GRANTED || permission === this.diagnostic.permissionStatus.GRANTED_WHEN_IN_USE;
+    }
+    isNotRequested(permission) {
+        return permission === this.diagnostic.permissionStatus.NOT_REQUESTED;
+    }
+    isDeniedAlways(permission) {
+        return permission === this.diagnostic.permissionStatus.DENIED_ALWAYS || permission === this.diagnostic.permissionStatus.RESTRICTED;
+    }
+    isDenied(permission) {
+        return !(this.isGranted(permission) || this.isNotRequested(permission));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PermissionsService, deps: [{ token: i1.UiEventElementsService }, { token: i2.Platform }, { token: i3.Diagnostic }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PermissionsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PermissionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.UiEventElementsService }, { type: i2.Platform }, { type: i3.Diagnostic }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"permissions.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/permissions/permissions.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport { Diagnostic } from '@ionic-native/diagnostic/ngx'\nimport { Platform } from '@ionic/angular'\nimport { UiEventElementsService } from '../ui-event-elements/ui-event-elements.service'\n// import { ErrorCategory, handleErrorLocal } from '../error-handler/error-handler.service'\n\nexport enum PermissionStatus {\n  GRANTED = 'GRANTED',\n  NOT_REQUESTED = 'NOT_REQUESTED',\n  DENIED_ALWAYS = 'DENIED_ALWAYS',\n  DENIED = 'DENIED',\n  UNKNOWN = 'UNKNOWN'\n}\n\nexport enum PermissionTypes {\n  CAMERA = 'CAMERA',\n  MICROPHONE = 'MICROPHONE'\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PermissionsService {\n  constructor(\n    private readonly uiEventElementsService: UiEventElementsService,\n    private readonly platform: Platform,\n    private readonly diagnostic: Diagnostic\n  ) {}\n\n  public async hasCameraPermission(): Promise<PermissionStatus> {\n    const permission: PermissionStatus = await this.diagnostic.getCameraAuthorizationStatus(false)\n\n    return this.getPermissionStatus(permission)\n  }\n\n  public async hasMicrophonePermission(): Promise<PermissionStatus> {\n    const permission: PermissionStatus = await this.diagnostic.getMicrophoneAuthorizationStatus()\n\n    return this.getPermissionStatus(permission)\n  }\n\n  public async requestPermissions(permissions: PermissionTypes[]): Promise<void> {\n    if (this.platform.is('android')) {\n      const permissionsToRequest: string[] = []\n      if (permissions.indexOf(PermissionTypes.CAMERA) >= 0) {\n        permissionsToRequest.push(this.diagnostic.permission.CAMERA)\n      }\n      if (permissions.indexOf(PermissionTypes.MICROPHONE) >= 0) {\n        permissionsToRequest.push(this.diagnostic.permission.RECORD_AUDIO)\n      }\n      await this.diagnostic.requestRuntimePermissions(permissionsToRequest)\n    } else if (this.platform.is('ios')) {\n      if (permissions.indexOf(PermissionTypes.CAMERA) >= 0) {\n        await this.diagnostic.requestCameraAuthorization(false)\n      }\n      if (permissions.indexOf(PermissionTypes.MICROPHONE) >= 0) {\n        await this.diagnostic.requestMicrophoneAuthorization()\n      }\n    } else {\n      // eslint-disable-next-line no-console\n      console.warn('requesting permission in browser')\n    }\n  }\n\n  /**\n   * The user actively wants to give permissions. This means we first check if we\n   * can ask him for the permissions natively, otherwise we show an alert with a\n   * link to the settings.\n   */\n  public async userRequestsPermissions(permissions: PermissionTypes[]): Promise<void> {\n    let canRequestPermission: boolean = false\n    for (const p of permissions) {\n      canRequestPermission = (await this.canAskForPermission(p)) || canRequestPermission\n    }\n    if (canRequestPermission) {\n      await this.requestPermissions(permissions)\n    } else {\n      await this.uiEventElementsService.showOpenSettingsAlert(() => {\n        // eslint-disable-next-line no-console\n        this.diagnostic.switchToSettings().catch(console.error)\n      })\n    }\n  }\n\n  private async canAskForPermission(permission: PermissionTypes): Promise<boolean> {\n    let canAskForPermission: boolean = true\n    if (this.platform.is('android')) {\n      if (permission === PermissionTypes.CAMERA) {\n        const permissionStatus: PermissionStatus = await this.hasCameraPermission()\n        canAskForPermission = !(permissionStatus === PermissionStatus.DENIED_ALWAYS)\n      } else if (permission === PermissionTypes.MICROPHONE) {\n        const permissionStatus: PermissionStatus = await this.hasMicrophonePermission()\n        canAskForPermission = !(permissionStatus === PermissionStatus.DENIED_ALWAYS)\n      }\n    } else if (this.platform.is('ios')) {\n      if (permission === PermissionTypes.CAMERA) {\n        const permissionStatus: PermissionStatus = await this.hasCameraPermission()\n        canAskForPermission = !(permissionStatus === PermissionStatus.DENIED)\n      } else if (permission === PermissionTypes.MICROPHONE) {\n        const permissionStatus: PermissionStatus = await this.hasMicrophonePermission()\n        canAskForPermission = !(permissionStatus === PermissionStatus.DENIED)\n      }\n    }\n\n    return canAskForPermission\n  }\n\n  private async getPermissionStatus(permission: PermissionStatus): Promise<PermissionStatus> {\n    if (this.isGranted(permission)) {\n      return PermissionStatus.GRANTED\n    } else if (this.isNotRequested(permission)) {\n      return PermissionStatus.NOT_REQUESTED\n    } else if (this.isDeniedAlways(permission)) {\n      return PermissionStatus.DENIED_ALWAYS\n    } else if (this.isDenied(permission)) {\n      return PermissionStatus.DENIED\n    } else {\n      return PermissionStatus.UNKNOWN\n    }\n  }\n\n  private isGranted(permission: PermissionStatus): boolean {\n    return permission === this.diagnostic.permissionStatus.GRANTED || permission === this.diagnostic.permissionStatus.GRANTED_WHEN_IN_USE\n  }\n\n  private isNotRequested(permission: PermissionStatus): boolean {\n    return permission === this.diagnostic.permissionStatus.NOT_REQUESTED\n  }\n\n  private isDeniedAlways(permission: PermissionStatus): boolean {\n    return permission === this.diagnostic.permissionStatus.DENIED_ALWAYS || permission === this.diagnostic.permissionStatus.RESTRICTED\n  }\n\n  private isDenied(permission: PermissionStatus): boolean {\n    return !(this.isGranted(permission) || this.isNotRequested(permission))\n  }\n}\n"]}

package/esm2022/lib/services/protocol/defaults.mjs

@@ -0,0 +1,55 @@
+import { erc20Tokens } from '@wallfree-dev/ethereum';
+import { createV0AeternityProtocol, createV0AstarProtocol, createV0BitcoinProtocol, createV0BitcoinSegwitProtocol, createV0CosmosProtocol, createV0EthereumERC20Token, createV0EthereumProtocol, createV0GroestlcoinProtocol, createV0KusamaProtocol, createV0MoonbeamProtocol, createV0MoonriverProtocol, createV0PolkadotProtocol, createV0ShidenProtocol, createV0SolanaProtocol, createV0TezosBTCTezProtocol, createV0TezosCTezProtocol, createV0TezosDogamiProtocol, createV0TezosETHTezProtocol, createV0TezosKolibriUSDProtocol, createV0TezosKtProtocol, createV0TezosPlentyProtocol, createV0TezosProtocol, createV0TezosQuipuswapProtocol, createV0TezosSiriusProtocol, createV0TezosTetherUSDProtocol, createV0TezosTzBTCProtocol, createV0TezosUBTCProtocol, createV0TezosUDEFIProtocol, createV0TezosUSDTezProtocol, createV0TezosUUSDProtocol, createV0TezosWrapProtocol, createV0TezosYouProtocol } from '../../utils/protocol/protocol-v0-adapter';
+export async function getDefaultPassiveProtocols() {
+    return [];
+}
+export async function getDefaultActiveProtocols() {
+    return Promise.all([
+        createV0BitcoinSegwitProtocol(),
+        createV0EthereumProtocol(),
+        createV0TezosProtocol(),
+        createV0PolkadotProtocol(),
+        createV0KusamaProtocol(),
+        createV0CosmosProtocol(),
+        createV0AeternityProtocol(),
+        createV0GroestlcoinProtocol(),
+        createV0MoonriverProtocol(),
+        createV0MoonbeamProtocol(),
+        createV0BitcoinProtocol(),
+        createV0AstarProtocol(),
+        createV0ShidenProtocol(),
+        createV0SolanaProtocol()
+    ]);
+}
+export async function getDefaultPassiveSubProtocols() {
+    return [];
+}
+export async function getDefaultActiveSubProtocols() {
+    const [tezosProtocol, ethereumProtocol] = await Promise.all([createV0TezosProtocol(), createV0EthereumProtocol()]);
+    return Promise.all([
+        createV0TezosUUSDProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosYouProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosTzBTCProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosUSDTezProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosUDEFIProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosCTezProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosPlentyProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosWrapProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosQuipuswapProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosKolibriUSDProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosUBTCProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosDogamiProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosSiriusProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosBTCTezProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosETHTezProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosTetherUSDProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        createV0TezosKtProtocol().then(pairWithMainProtocol(tezosProtocol)),
+        ...Object.values(erc20Tokens).map((token) => createV0EthereumERC20Token(token).then(pairWithMainProtocol(ethereumProtocol)))
+    ]);
+}
+function pairWithMainProtocol(mainProtocol) {
+    return (subProtocol) => {
+        return [mainProtocol, subProtocol];
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../../../../src/lib/services/protocol/defaults.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-use-before-define */\nimport { ICoinProtocol, ICoinSubProtocol } from '@wallfree-dev/coinlib-core'\nimport { erc20Tokens } from '@wallfree-dev/ethereum'\nimport { Token } from '../../types/Token'\nimport {\n  createV0AeternityProtocol,\n  createV0AstarProtocol,\n  createV0BitcoinProtocol,\n  createV0BitcoinSegwitProtocol,\n  createV0CosmosProtocol,\n  createV0EthereumERC20Token,\n  createV0EthereumProtocol,\n  createV0GroestlcoinProtocol,\n  createV0KusamaProtocol,\n  createV0MoonbeamProtocol,\n  createV0MoonriverProtocol,\n  createV0PolkadotProtocol,\n  createV0ShidenProtocol,\n  createV0SolanaProtocol,\n  createV0TezosBTCTezProtocol,\n  createV0TezosCTezProtocol,\n  createV0TezosDogamiProtocol,\n  createV0TezosETHTezProtocol,\n  createV0TezosKolibriUSDProtocol,\n  createV0TezosKtProtocol,\n  createV0TezosPlentyProtocol,\n  createV0TezosProtocol,\n  createV0TezosQuipuswapProtocol,\n  createV0TezosSiriusProtocol,\n  createV0TezosTetherUSDProtocol,\n  createV0TezosTzBTCProtocol,\n  createV0TezosUBTCProtocol,\n  createV0TezosUDEFIProtocol,\n  createV0TezosUSDTezProtocol,\n  createV0TezosUUSDProtocol,\n  createV0TezosWrapProtocol,\n  createV0TezosYouProtocol\n} from '../../utils/protocol/protocol-v0-adapter'\n\nexport async function getDefaultPassiveProtocols(): Promise<ICoinProtocol[]> {\n  return []\n}\n\nexport async function getDefaultActiveProtocols(): Promise<ICoinProtocol[]> {\n  return Promise.all<ICoinProtocol>([\n    createV0BitcoinSegwitProtocol(),\n    createV0EthereumProtocol(),\n    createV0TezosProtocol(),\n    createV0PolkadotProtocol(),\n    createV0KusamaProtocol(),\n    createV0CosmosProtocol(),\n    createV0AeternityProtocol(),\n    createV0GroestlcoinProtocol(),\n    createV0MoonriverProtocol(),\n    createV0MoonbeamProtocol(),\n    createV0BitcoinProtocol(),\n    createV0AstarProtocol(),\n    createV0ShidenProtocol(),\n    createV0SolanaProtocol()\n  ])\n}\n\nexport async function getDefaultPassiveSubProtocols(): Promise<[ICoinProtocol, ICoinSubProtocol][]> {\n  return []\n}\n\nexport async function getDefaultActiveSubProtocols(): Promise<[ICoinProtocol, ICoinSubProtocol][]> {\n  const [tezosProtocol, ethereumProtocol] = await Promise.all([createV0TezosProtocol(), createV0EthereumProtocol()])\n\n  return Promise.all([\n    createV0TezosUUSDProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosYouProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosTzBTCProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosUSDTezProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosUDEFIProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosCTezProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosPlentyProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosWrapProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosQuipuswapProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosKolibriUSDProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosUBTCProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosDogamiProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosSiriusProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosBTCTezProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosETHTezProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosTetherUSDProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    createV0TezosKtProtocol().then(pairWithMainProtocol(tezosProtocol)),\n    ...Object.values(erc20Tokens).map((token: Token) => createV0EthereumERC20Token(token).then(pairWithMainProtocol(ethereumProtocol)))\n  ])\n}\n\nfunction pairWithMainProtocol(mainProtocol: ICoinProtocol): (subProtocol: ICoinSubProtocol) => [ICoinProtocol, ICoinSubProtocol] {\n  return (subProtocol: ICoinSubProtocol): [ICoinProtocol, ICoinSubProtocol] => {\n    return [mainProtocol, subProtocol] as [ICoinProtocol, ICoinSubProtocol]\n  }\n}\n"]}