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

package/esm2022/lib/capacitor-plugins/isolated-modules/isolated-modules.plugin.mjs

@@ -0,0 +1,247 @@
+/* eslint-disable max-lines */
+/* eslint-disable max-classes-per-file */
+import { WebPlugin } from '@capacitor/core';
+import { AeternityModule } from '@wallfree-dev/aeternity';
+import { AstarModule } from '@wallfree-dev/astar';
+import { BitcoinModule } from '@wallfree-dev/bitcoin';
+import { CosmosModule } from '@wallfree-dev/cosmos';
+import { EthereumModule } from '@wallfree-dev/ethereum';
+import { GroestlcoinModule } from '@wallfree-dev/groestlcoin';
+import { ICPModule } from '@wallfree-dev/icp';
+import { CoreumModule } from '@wallfree-dev/coreum';
+import { AcurastModule } from '@wallfree-dev/acurast';
+import { StellarModule } from '@wallfree-dev/stellar';
+import { TronModule } from '@wallfree-dev/tron';
+import { hasConfigurableContract, isSubProtocol } from '@wallfree-dev/module-kit';
+import { MoonbeamModule } from '@wallfree-dev/moonbeam';
+import { OptimismModule } from '@wallfree-dev/optimism';
+import { PolkadotModule } from '@wallfree-dev/polkadot';
+import { TezosModule } from '@wallfree-dev/tezos';
+import { flattened } from '../../utils/array';
+import { assertNever } from '../../utils/utils';
+import { getOfflineProtocolConfiguration, getOnlineProtocolConfiguration } from '../../utils/modules/load-protocol';
+export class IsolatedModules extends WebPlugin {
+    constructor(modules = [
+        new BitcoinModule(),
+        new EthereumModule(),
+        new TezosModule(),
+        new PolkadotModule(),
+        new CosmosModule(),
+        new AeternityModule(),
+        new GroestlcoinModule(),
+        new MoonbeamModule(),
+        new AstarModule(),
+        new ICPModule(),
+        new CoreumModule(),
+        new OptimismModule(),
+        new AcurastModule(),
+        new StellarModule(),
+        new TronModule()
+    ]) {
+        super();
+        this.modules = modules;
+        this.offlineProtocols = {};
+        this.onlineProtocols = {};
+        this.blockExplorers = {};
+        this.v3SerializerCompanions = {};
+        this.moduleIndices = {};
+    }
+    async previewDynamicModule(_options) {
+        throw new Error('Dynamic isolated module preview not supported in a browser');
+    }
+    async verifyDynamicModule(_options) {
+        throw new Error('Dynamic isolated module verification not supported in a browser');
+    }
+    async registerDynamicModule(_options) {
+        throw new Error('Dynamic isolated module registration not supported in a browser');
+    }
+    async readDynamicModule(_options) {
+        throw new Error('Dynamic isolated module read not supported in a browser');
+    }
+    async removeDynamicModules(_options) {
+        throw new Error('Dynamic isolated module removal not supported in a browser');
+    }
+    async readAssetModule(_options) {
+        throw new Error('Asset isolated module read not supported in a browser');
+    }
+    async loadAllModules(options = {}) {
+        const modules = await Promise.all(this.modules.map((module, index) => this.loadModule(module, index, options.protocolType, new Set(options.ignoreProtocols ?? []))));
+        return { modules };
+    }
+    async loadModule(module, index, protocolType, ignoreProtocols) {
+        const moduleIdentifier = index.toString();
+        const v3SerializerCompanion = await module.createV3SerializerCompanion();
+        this.v3SerializerCompanions[moduleIdentifier] = v3SerializerCompanion;
+        const protocols = await Promise.all(Object.entries(module.supportedProtocols)
+            .filter(([identifier, _]) => !ignoreProtocols.has(identifier))
+            .map(([identifier, configuration]) => this.loadModuleProtocols(module, index, identifier, configuration, protocolType)));
+        return {
+            identifier: moduleIdentifier,
+            type: 'static',
+            protocols: flattened(protocols),
+            v3SchemaConfigurations: v3SerializerCompanion.schemas
+        };
+    }
+    async loadModuleProtocols(module, moduleIndex, identifier, configuration, protocolType) {
+        const offlineConfiguration = getOfflineProtocolConfiguration(configuration, protocolType);
+        const onlineConfiguration = getOnlineProtocolConfiguration(configuration, protocolType);
+        const [offlineProtocols, onlineProtocols] = await Promise.all([
+            offlineConfiguration ? this.loadOfflineProtocols(module, moduleIndex, identifier, offlineConfiguration) : Promise.resolve([]),
+            onlineConfiguration ? this.loadOnlineProtocols(module, moduleIndex, identifier, onlineConfiguration) : Promise.resolve([])
+        ]);
+        return offlineProtocols.concat(onlineProtocols);
+    }
+    async loadOfflineProtocols(module, moduleIndex, identifier, _configuration) {
+        const protocol = await module.createOfflineProtocol(identifier);
+        if (protocol === undefined) {
+            return [];
+        }
+        this.moduleIndices[identifier] = moduleIndex;
+        this.offlineProtocols[this.protocolKey(identifier)] = protocol;
+        const crypto = await protocol.getCryptoConfiguration();
+        return [await this.getIsolatedProtocolConfiguration(protocol, 'offline', undefined, undefined, crypto)];
+    }
+    async loadOnlineProtocols(module, moduleIndex, 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;
+            }
+            this.moduleIndices[identifier] = moduleIndex;
+            this.onlineProtocols[this.protocolKey(identifier, networkId)] = protocol;
+            if (blockExplorer !== undefined) {
+                this.blockExplorers[this.protocolKey(identifier, networkId)] = blockExplorer;
+            }
+            const [network, blockExplorerMetadata] = await Promise.all([
+                protocol.getNetwork(),
+                blockExplorer?.getMetadata() ?? Promise.resolve(undefined)
+            ]);
+            return this.getIsolatedProtocolConfiguration(protocol, 'online', blockExplorerMetadata, network);
+        }));
+        return protocols.filter((protocol) => protocol !== undefined);
+    }
+    async getIsolatedProtocolConfiguration(protocol, mode, blockExplorerMetadata, network, crypto) {
+        const protocolMetadata = await protocol.getMetadata();
+        const configuration = {
+            mode,
+            identifier: protocolMetadata.identifier,
+            protocolMetadata,
+            blockExplorerMetadata: blockExplorerMetadata ?? null,
+            network: network ?? null,
+            methods: this.collectMethods(protocol),
+            cachedValues: {
+                getCryptoConfiguration: crypto
+            }
+        };
+        if (isSubProtocol(protocol)) {
+            const [subType, mainProtocol, contractAddress] = await Promise.all([
+                protocol.getType(),
+                protocol.mainProtocol(),
+                hasConfigurableContract(protocol) ? protocol.getContractAddress() : Promise.resolve(undefined)
+            ]);
+            return {
+                ...configuration,
+                type: 'sub',
+                cachedValues: Object.assign(configuration.cachedValues, {
+                    getType: subType,
+                    mainProtocol,
+                    getContractAddress: contractAddress
+                }),
+                subType,
+                mainProtocolIdentifier: mainProtocol,
+                contractAddress: contractAddress ?? null
+            };
+        }
+        else {
+            return {
+                ...configuration,
+                type: 'main'
+            };
+        }
+    }
+    collectMethods(protocol) {
+        let propertyNames = [];
+        let obj = protocol;
+        while (obj) {
+            propertyNames = propertyNames.concat(Object.getOwnPropertyNames(obj));
+            obj = Object.getPrototypeOf(obj);
+        }
+        return propertyNames.filter((key) => typeof protocol[key] === 'function');
+    }
+    async callMethod(options) {
+        switch (options.target) {
+            case 'offlineProtocol':
+                return this.callOfflineProtocolMethod(options);
+            case 'onlineProtocol':
+                return this.callOnlineProtocolMethod(options);
+            case 'blockExplorer':
+                return this.callBlockExplorerMethod(options);
+            case 'v3SerializerCompanion':
+                return this.callV3SerializerCompanionMethod(options);
+            default:
+                assertNever('options', options);
+        }
+    }
+    async callOfflineProtocolMethod(options) {
+        const protocol = await this.getOfflineProtocol(options.protocolIdentifier);
+        const method = protocol[options.method].bind(protocol);
+        return { value: await method(...(options.args ?? [])) };
+    }
+    async callOnlineProtocolMethod(options) {
+        const protocol = await this.getOnlineProtocol(options.protocolIdentifier, options.networkId);
+        const method = protocol[options.method].bind(protocol);
+        return { value: await method(...(options.args ?? [])) };
+    }
+    async callBlockExplorerMethod(options) {
+        const blockExplorer = await this.getBlockExplorer(options.protocolIdentifier, options.networkId);
+        const method = blockExplorer[options.method].bind(blockExplorer);
+        return { value: await method(...(options.args ?? [])) };
+    }
+    async callV3SerializerCompanionMethod(options) {
+        const v3SerializerCompanion = await this.getV3SerializerCompanion(options.moduleIdentifier);
+        const method = v3SerializerCompanion[options.method].bind(v3SerializerCompanion);
+        return { value: await method(...(options.args ?? [])) };
+    }
+    async getOfflineProtocol(protocolIdentifier) {
+        return this.getModuleComponent(protocolIdentifier, undefined, this.offlineProtocols, (module) => module.createOfflineProtocol(protocolIdentifier), (identifier) => this.moduleIndices[identifier]);
+    }
+    async getOnlineProtocol(protocolIdentifier, networkId) {
+        return this.getModuleComponent(protocolIdentifier, networkId, this.onlineProtocols, (module) => module.createOnlineProtocol(protocolIdentifier, networkId), (identifier) => this.moduleIndices[identifier]);
+    }
+    async getBlockExplorer(protocolIdentifier, networkId) {
+        return this.getModuleComponent(protocolIdentifier, networkId, this.blockExplorers, (module) => module.createBlockExplorer(protocolIdentifier, networkId), (identifier) => this.moduleIndices[identifier]);
+    }
+    async getV3SerializerCompanion(moduleIdentifier) {
+        return this.getModuleComponent(moduleIdentifier, undefined, this.v3SerializerCompanions, (module) => module.createV3SerializerCompanion(), (identifier) => parseInt(identifier, 10));
+    }
+    async getModuleComponent(identifier, networkId, componentCollection, createComponent, identifierToModuleIndex) {
+        const protocolKey = this.protocolKey(identifier, networkId);
+        if (componentCollection[protocolKey] === undefined) {
+            const moduleIndex = identifierToModuleIndex(identifier);
+            if (moduleIndex === undefined) {
+                return undefined;
+            }
+            componentCollection[protocolKey] = await createComponent(this.modules[moduleIndex]);
+        }
+        return componentCollection[protocolKey];
+    }
+    async batchCallMethod(options) {
+        const values = await Promise.all(options.options.map(async (o) => {
+            try {
+                const { value } = await this.callMethod(o);
+                return { type: 'success', value };
+            }
+            catch (error) {
+                return { type: 'error', error };
+            }
+        }));
+        return { values };
+    }
+    protocolKey(identifier, networkId) {
+        return networkId ? `${identifier}_${networkId}` : identifier;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"isolated-modules.plugin.js","sourceRoot":"","sources":["../../../../../src/lib/capacitor-plugins/isolated-modules/isolated-modules.plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-lines */\n/* eslint-disable max-classes-per-file */\nimport { WebPlugin } from '@capacitor/core'\nimport { AeternityModule } from '@wallfree-dev/aeternity'\nimport { AstarModule } from '@wallfree-dev/astar'\nimport { BitcoinModule } from '@wallfree-dev/bitcoin'\nimport { CosmosModule } from '@wallfree-dev/cosmos'\nimport { EthereumModule } from '@wallfree-dev/ethereum'\nimport { GroestlcoinModule } from '@wallfree-dev/groestlcoin'\nimport { ICPModule } from '@wallfree-dev/icp'\nimport { CoreumModule } from '@wallfree-dev/coreum'\nimport { AcurastModule } from '@wallfree-dev/acurast'\nimport { StellarModule } from '@wallfree-dev/stellar'\nimport { TronModule } from '@wallfree-dev/tron'\n\nimport {\n  AirGapAnyProtocol,\n  AirGapBlockExplorer,\n  AirGapModule,\n  AirGapOfflineProtocol,\n  AirGapOnlineProtocol,\n  AirGapV3SerializerCompanion,\n  BlockExplorerMetadata,\n  CryptoConfiguration,\n  hasConfigurableContract,\n  isSubProtocol,\n  OfflineProtocolConfiguration,\n  OnlineProtocolConfiguration,\n  ProtocolConfiguration,\n  ProtocolMetadata,\n  ProtocolNetwork,\n  SubProtocolType\n} from '@wallfree-dev/module-kit'\nimport { MoonbeamModule } from '@wallfree-dev/moonbeam'\nimport { OptimismModule } from '@wallfree-dev/optimism'\nimport { PolkadotModule } from '@wallfree-dev/polkadot'\nimport { TezosModule } from '@wallfree-dev/tezos'\n\nimport {\n  BatchCallMethodOptions,\n  BatchCallMethodResult,\n  BatchCallMethodSingleResult,\n  BlockExplorerCallMethodOptions,\n  CallMethodOptions,\n  CallMethodResult,\n  IsolatedModulesPlugin,\n  LoadAllModulesOptions,\n  LoadAllModulesResult,\n  OfflineProtocolCallMethodOptions,\n  OnlineProtocolCallMethodOptions,\n  PreviewDynamicModuleOptions,\n  PreviewDynamicModuleResult,\n  ReadAssetModuleOptions,\n  ReadAssetModuleResult,\n  ReadDynamicModuleOptions,\n  ReadDynamicModuleResult,\n  RegisterDynamicModuleOptions,\n  RemoveDynamicModulesOptions,\n  V3SerializerCompanionCallMethodOptions,\n  VerifyDynamicModuleOptions,\n  VerifyDynamicModuleResult\n} from '../definitions'\nimport { flattened } from '../../utils/array'\nimport { assertNever } from '../../utils/utils'\nimport { IsolatedModule, IsolatedProtocol } from '../../types/isolated-modules/IsolatedModule'\nimport { getOfflineProtocolConfiguration, getOnlineProtocolConfiguration } from '../../utils/modules/load-protocol'\n\nexport class IsolatedModules extends WebPlugin implements IsolatedModulesPlugin {\n  private readonly offlineProtocols: Record<string, AirGapOfflineProtocol> = {}\n  private readonly onlineProtocols: Record<string, AirGapOnlineProtocol> = {}\n  private readonly blockExplorers: Record<string, AirGapBlockExplorer> = {}\n  private readonly v3SerializerCompanions: Record<string, AirGapV3SerializerCompanion> = {}\n\n  private readonly moduleIndices: Record<string, number> = {}\n\n  constructor(\n    private readonly modules: AirGapModule[] = [\n      new BitcoinModule(),\n      new EthereumModule(),\n      new TezosModule(),\n      new PolkadotModule(),\n      new CosmosModule(),\n      new AeternityModule(),\n      new GroestlcoinModule(),\n      new MoonbeamModule(),\n      new AstarModule(),\n      new ICPModule(),\n      new CoreumModule(),\n      new OptimismModule(),\n      new AcurastModule(),\n      new StellarModule(),\n      new TronModule()\n    ]\n  ) {\n    super()\n  }\n\n  public async previewDynamicModule(_options: PreviewDynamicModuleOptions): Promise<PreviewDynamicModuleResult> {\n    throw new Error('Dynamic isolated module preview not supported in a browser')\n  }\n\n  public async verifyDynamicModule(_options: VerifyDynamicModuleOptions): Promise<VerifyDynamicModuleResult> {\n    throw new Error('Dynamic isolated module verification not supported in a browser')\n  }\n\n  public async registerDynamicModule(_options: RegisterDynamicModuleOptions): Promise<void> {\n    throw new Error('Dynamic isolated module registration not supported in a browser')\n  }\n\n  public async readDynamicModule(_options: ReadDynamicModuleOptions): Promise<ReadDynamicModuleResult> {\n    throw new Error('Dynamic isolated module read not supported in a browser')\n  }\n\n  public async removeDynamicModules(_options: RemoveDynamicModulesOptions): Promise<void> {\n    throw new Error('Dynamic isolated module removal not supported in a browser')\n  }\n\n  public async readAssetModule(_options: ReadAssetModuleOptions): Promise<ReadAssetModuleResult> {\n    throw new Error('Asset isolated module read not supported in a browser')\n  }\n\n  public async loadAllModules(options: LoadAllModulesOptions = {}): Promise<LoadAllModulesResult> {\n    const modules: IsolatedModule[] = await Promise.all(\n      this.modules.map((module: AirGapModule, index: number) =>\n        this.loadModule(module, index, options.protocolType, new Set(options.ignoreProtocols ?? []))\n      )\n    )\n\n    return { modules }\n  }\n\n  private async loadModule(\n    module: AirGapModule,\n    index: number,\n    protocolType: ProtocolConfiguration['type'] | undefined,\n    ignoreProtocols: Set<string>\n  ): Promise<IsolatedModule> {\n    const moduleIdentifier: string = index.toString()\n    const v3SerializerCompanion: AirGapV3SerializerCompanion = await module.createV3SerializerCompanion()\n\n    this.v3SerializerCompanions[moduleIdentifier] = v3SerializerCompanion\n\n    const protocols: IsolatedProtocol[][] = await Promise.all(\n      Object.entries(module.supportedProtocols)\n        .filter(([identifier, _]) => !ignoreProtocols.has(identifier))\n        .map(([identifier, configuration]: [string, ProtocolConfiguration]) =>\n          this.loadModuleProtocols(module, index, identifier, configuration, protocolType)\n        )\n    )\n\n    return {\n      identifier: moduleIdentifier,\n      type: 'static',\n      protocols: flattened(protocols),\n      v3SchemaConfigurations: v3SerializerCompanion.schemas\n    }\n  }\n\n  private async loadModuleProtocols(\n    module: AirGapModule,\n    moduleIndex: number,\n    identifier: string,\n    configuration: ProtocolConfiguration,\n    protocolType?: ProtocolConfiguration['type']\n  ): Promise<IsolatedProtocol[]> {\n    const offlineConfiguration: OfflineProtocolConfiguration | undefined = getOfflineProtocolConfiguration(configuration, protocolType)\n    const onlineConfiguration: OnlineProtocolConfiguration | undefined = getOnlineProtocolConfiguration(configuration, protocolType)\n\n    const [offlineProtocols, onlineProtocols]: [IsolatedProtocol[], IsolatedProtocol[]] = await Promise.all([\n      offlineConfiguration ? this.loadOfflineProtocols(module, moduleIndex, identifier, offlineConfiguration) : Promise.resolve([]),\n      onlineConfiguration ? this.loadOnlineProtocols(module, moduleIndex, identifier, onlineConfiguration) : Promise.resolve([])\n    ])\n\n    return offlineProtocols.concat(onlineProtocols)\n  }\n\n  private async loadOfflineProtocols(\n    module: AirGapModule,\n    moduleIndex: number,\n    identifier: string,\n    _configuration: OfflineProtocolConfiguration\n  ): Promise<IsolatedProtocol[]> {\n    const protocol: AirGapOfflineProtocol | undefined = await module.createOfflineProtocol(identifier)\n    if (protocol === undefined) {\n      return []\n    }\n\n    this.moduleIndices[identifier] = moduleIndex\n    this.offlineProtocols[this.protocolKey(identifier)] = protocol\n\n    const crypto: CryptoConfiguration = await protocol.getCryptoConfiguration()\n\n    return [await this.getIsolatedProtocolConfiguration(protocol, 'offline', undefined, undefined, crypto)]\n  }\n\n  private async loadOnlineProtocols(\n    module: AirGapModule,\n    moduleIndex: number,\n    identifier: string,\n    configuration: OnlineProtocolConfiguration\n  ): Promise<IsolatedProtocol[]> {\n    const protocols: (IsolatedProtocol | 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        this.moduleIndices[identifier] = moduleIndex\n        this.onlineProtocols[this.protocolKey(identifier, networkId)] = protocol\n\n        if (blockExplorer !== undefined) {\n          this.blockExplorers[this.protocolKey(identifier, networkId)] = blockExplorer\n        }\n\n        const [network, blockExplorerMetadata]: [ProtocolNetwork, BlockExplorerMetadata | undefined] = await Promise.all([\n          protocol.getNetwork(),\n          blockExplorer?.getMetadata() ?? Promise.resolve(undefined)\n        ])\n\n        return this.getIsolatedProtocolConfiguration(protocol, 'online', blockExplorerMetadata, network)\n      })\n    )\n\n    return protocols.filter((protocol: IsolatedProtocol | undefined) => protocol !== undefined)\n  }\n\n  private async getIsolatedProtocolConfiguration(\n    protocol: AirGapAnyProtocol,\n    mode: IsolatedProtocol['mode'],\n    blockExplorerMetadata?: BlockExplorerMetadata,\n    network?: ProtocolNetwork,\n    crypto?: CryptoConfiguration\n  ): Promise<IsolatedProtocol> {\n    const protocolMetadata: ProtocolMetadata = await protocol.getMetadata()\n\n    const configuration: Omit<IsolatedProtocol, 'type'> = {\n      mode,\n      identifier: protocolMetadata.identifier,\n      protocolMetadata,\n      blockExplorerMetadata: blockExplorerMetadata ?? null,\n      network: network ?? null,\n      methods: this.collectMethods(protocol),\n      cachedValues: {\n        getCryptoConfiguration: crypto\n      }\n    }\n\n    if (isSubProtocol(protocol)) {\n      const [subType, mainProtocol, contractAddress]: [SubProtocolType, string, string | undefined] = await Promise.all([\n        protocol.getType(),\n        protocol.mainProtocol(),\n        hasConfigurableContract(protocol) ? protocol.getContractAddress() : Promise.resolve(undefined)\n      ])\n\n      return {\n        ...configuration,\n        type: 'sub',\n        cachedValues: Object.assign(configuration.cachedValues, {\n          getType: subType,\n          mainProtocol,\n          getContractAddress: contractAddress\n        }),\n        subType,\n        mainProtocolIdentifier: mainProtocol,\n        contractAddress: contractAddress ?? null\n      }\n    } else {\n      return {\n        ...configuration,\n        type: 'main'\n      }\n    }\n  }\n\n  private collectMethods(protocol: AirGapAnyProtocol): string[] {\n    let propertyNames: string[] = []\n    let obj = protocol\n    while (obj) {\n      propertyNames = propertyNames.concat(Object.getOwnPropertyNames(obj))\n      obj = Object.getPrototypeOf(obj)\n    }\n\n    return propertyNames.filter((key: string) => typeof protocol[key] === 'function')\n  }\n\n  public async callMethod(options: CallMethodOptions): Promise<CallMethodResult> {\n    switch (options.target) {\n      case 'offlineProtocol':\n        return this.callOfflineProtocolMethod(options)\n      case 'onlineProtocol':\n        return this.callOnlineProtocolMethod(options)\n      case 'blockExplorer':\n        return this.callBlockExplorerMethod(options)\n      case 'v3SerializerCompanion':\n        return this.callV3SerializerCompanionMethod(options)\n      default:\n        assertNever('options', options)\n    }\n  }\n\n  private async callOfflineProtocolMethod(options: OfflineProtocolCallMethodOptions): Promise<CallMethodResult> {\n    const protocol: AirGapOfflineProtocol = await this.getOfflineProtocol(options.protocolIdentifier)\n    const method = protocol[options.method].bind(protocol)\n\n    return { value: await method(...(options.args ?? [])) }\n  }\n\n  private async callOnlineProtocolMethod(options: OnlineProtocolCallMethodOptions): Promise<CallMethodResult> {\n    const protocol: AirGapOnlineProtocol = await this.getOnlineProtocol(options.protocolIdentifier, options.networkId)\n    const method = protocol[options.method].bind(protocol)\n\n    return { value: await method(...(options.args ?? [])) }\n  }\n\n  private async callBlockExplorerMethod(options: BlockExplorerCallMethodOptions): Promise<CallMethodResult> {\n    const blockExplorer: AirGapBlockExplorer = await this.getBlockExplorer(options.protocolIdentifier, options.networkId)\n    const method = blockExplorer[options.method].bind(blockExplorer)\n\n    return { value: await method(...(options.args ?? [])) }\n  }\n\n  private async callV3SerializerCompanionMethod(options: V3SerializerCompanionCallMethodOptions): Promise<CallMethodResult> {\n    const v3SerializerCompanion: AirGapV3SerializerCompanion = await this.getV3SerializerCompanion(options.moduleIdentifier)\n    const method = v3SerializerCompanion[options.method].bind(v3SerializerCompanion)\n\n    return { value: await method(...(options.args ?? [])) }\n  }\n\n  private async getOfflineProtocol(protocolIdentifier: string): Promise<AirGapOfflineProtocol | undefined> {\n    return this.getModuleComponent(\n      protocolIdentifier,\n      undefined,\n      this.offlineProtocols,\n      (module: AirGapModule) => module.createOfflineProtocol(protocolIdentifier),\n      (identifier: string) => this.moduleIndices[identifier]\n    )\n  }\n\n  private async getOnlineProtocol(protocolIdentifier: string, networkId?: string): Promise<AirGapOnlineProtocol | undefined> {\n    return this.getModuleComponent(\n      protocolIdentifier,\n      networkId,\n      this.onlineProtocols,\n      (module: AirGapModule) => module.createOnlineProtocol(protocolIdentifier, networkId),\n      (identifier: string) => this.moduleIndices[identifier]\n    )\n  }\n\n  private async getBlockExplorer(protocolIdentifier: string, networkId?: string): Promise<AirGapBlockExplorer | undefined> {\n    return this.getModuleComponent(\n      protocolIdentifier,\n      networkId,\n      this.blockExplorers,\n      (module: AirGapModule) => module.createBlockExplorer(protocolIdentifier, networkId),\n      (identifier: string) => this.moduleIndices[identifier]\n    )\n  }\n\n  private async getV3SerializerCompanion(moduleIdentifier: string): Promise<AirGapV3SerializerCompanion | undefined> {\n    return this.getModuleComponent(\n      moduleIdentifier,\n      undefined,\n      this.v3SerializerCompanions,\n      (module: AirGapModule) => module.createV3SerializerCompanion(),\n      (identifier: string) => parseInt(identifier, 10)\n    )\n  }\n\n  private async getModuleComponent<T>(\n    identifier: string,\n    networkId: string | undefined,\n    componentCollection: Record<string, T>,\n    createComponent: (module: AirGapModule) => Promise<T | undefined>,\n    identifierToModuleIndex: (id: string) => number | undefined\n  ): Promise<T | undefined> {\n    const protocolKey: string = this.protocolKey(identifier, networkId)\n    if (componentCollection[protocolKey] === undefined) {\n      const moduleIndex: number | undefined = identifierToModuleIndex(identifier)\n      if (moduleIndex === undefined) {\n        return undefined\n      }\n\n      componentCollection[protocolKey] = await createComponent(this.modules[moduleIndex])\n    }\n\n    return componentCollection[protocolKey]\n  }\n\n  public async batchCallMethod(options: BatchCallMethodOptions): Promise<BatchCallMethodResult> {\n    const values: BatchCallMethodSingleResult[] = await Promise.all(\n      options.options.map(async (o: CallMethodOptions): Promise<BatchCallMethodSingleResult> => {\n        try {\n          const { value } = await this.callMethod(o)\n\n          return { type: 'success', value }\n        } catch (error) {\n          return { type: 'error', error }\n        }\n      })\n    )\n\n    return { values }\n  }\n\n  private protocolKey(identifier: string, networkId?: string): string {\n    return networkId ? `${identifier}_${networkId}` : identifier\n  }\n}\n"]}

package/esm2022/lib/components/account-item/account-item.component.mjs

@@ -0,0 +1,30 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ionic/angular";
+import * as i3 from "../identicon/identicon.component";
+import * as i4 from "../currency-symbol/currency-symbol.component";
+export class AccountItemComponent {
+    async ngOnChanges(_changes) {
+        this.address = this.wallet?.receivingPublicAddress;
+        const [protocolSymbol, protocolIdentifier, protocolName] = await Promise.all([
+            this.wallet?.protocol.getSymbol() ?? Promise.resolve(undefined),
+            this.wallet?.protocol.getIdentifier() ?? Promise.resolve(undefined),
+            this.wallet?.protocol.getName() ?? Promise.resolve(undefined)
+        ]);
+        this.protocolSymbol = protocolSymbol;
+        this.protocolIdentifier = protocolIdentifier;
+        this.protocolName = protocolName;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AccountItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AccountItemComponent, selector: "airgap-account-item", inputs: { wallet: "wallet", label: "label" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"address && protocolSymbol && protocolIdentifier && protocolName\">\n  <ion-item lines=\"none\" class=\"ion-no-padding\">\n    <ion-avatar slot=\"start\">\n      <airgap-identicon [address]=\"address\"></airgap-identicon>\n      <airgap-currency-symbol [symbol]=\"protocolSymbol\" [protocolIdentifier]=\"protocolIdentifier\"></airgap-currency-symbol>\n    </ion-avatar>\n    <ion-label>\n      <div style=\"display: flex; justify-content: space-between; align-items: center\">\n        <h2>\n          <span class=\"font--weight__med\">{{ protocolName }}</span>\n          {{ protocolSymbol }}\n        </h2>\n        <p>{{ label }}</p>\n      </div>\n      <p class=\"typography--mono\">{{ wallet.receivingPublicAddress }}</p>\n    </ion-label>\n  </ion-item>\n</ng-container>\n", styles: ["airgap-currency-symbol{position:absolute;left:24px;top:32px;height:24px;width:24px}airgap-identicon,airgap-identicon img{height:40px;width:40px}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.IonAvatar, selector: "ion-avatar" }, { kind: "component", type: i2.IonItem, selector: "ion-item", inputs: ["button", "color", "counter", "counterFormatter", "detail", "detailIcon", "disabled", "download", "fill", "href", "lines", "mode", "rel", "routerAnimation", "routerDirection", "shape", "target", "type"] }, { kind: "component", type: i2.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { kind: "component", type: i3.IdenticonComponent, selector: "airgap-identicon", inputs: ["address"] }, { kind: "component", type: i4.CurrencySymbolComponent, selector: "airgap-currency-symbol", inputs: ["symbol", "protocolIdentifier"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AccountItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'airgap-account-item', template: "<ng-container *ngIf=\"address && protocolSymbol && protocolIdentifier && protocolName\">\n  <ion-item lines=\"none\" class=\"ion-no-padding\">\n    <ion-avatar slot=\"start\">\n      <airgap-identicon [address]=\"address\"></airgap-identicon>\n      <airgap-currency-symbol [symbol]=\"protocolSymbol\" [protocolIdentifier]=\"protocolIdentifier\"></airgap-currency-symbol>\n    </ion-avatar>\n    <ion-label>\n      <div style=\"display: flex; justify-content: space-between; align-items: center\">\n        <h2>\n          <span class=\"font--weight__med\">{{ protocolName }}</span>\n          {{ protocolSymbol }}\n        </h2>\n        <p>{{ label }}</p>\n      </div>\n      <p class=\"typography--mono\">{{ wallet.receivingPublicAddress }}</p>\n    </ion-label>\n  </ion-item>\n</ng-container>\n", styles: ["airgap-currency-symbol{position:absolute;left:24px;top:32px;height:24px;width:24px}airgap-identicon,airgap-identicon img{height:40px;width:40px}\n"] }]
+        }], propDecorators: { wallet: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjb3VudC1pdGVtLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29tcG9uZW50cy9hY2NvdW50LWl0ZW0vYWNjb3VudC1pdGVtLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29tcG9uZW50cy9hY2NvdW50LWl0ZW0vYWNjb3VudC1pdGVtLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUE0QixNQUFNLGVBQWUsQ0FBQTs7Ozs7O0FBUTFFLE1BQU0sT0FBTyxvQkFBb0I7SUFheEIsS0FBSyxDQUFDLFdBQVcsQ0FBQyxRQUF1QjtRQUM5QyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxNQUFNLEVBQUUsc0JBQXNCLENBQUE7UUFFbEQsTUFBTSxDQUFDLGNBQWMsRUFBRSxrQkFBa0IsRUFBRSxZQUFZLENBQUMsR0FBc0MsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUFDO1lBQzlHLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLFNBQVMsRUFBRSxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDO1lBQy9ELElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLGFBQWEsRUFBRSxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDO1lBQ25FLElBQUksQ0FBQyxNQUFNLEVBQUUsUUFBUSxDQUFDLE9BQU8sRUFBRSxJQUFJLE9BQU8sQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDO1NBQzlELENBQUMsQ0FBQTtRQUVGLElBQUksQ0FBQyxjQUFjLEdBQUcsY0FBYyxDQUFBO1FBQ3BDLElBQUksQ0FBQyxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQTtRQUM1QyxJQUFJLENBQUMsWUFBWSxHQUFHLFlBQVksQ0FBQTtJQUNsQyxDQUFDOytHQXpCVSxvQkFBb0I7bUdBQXBCLG9CQUFvQiw4SENSakMsa3lCQWtCQTs7NEZEVmEsb0JBQW9CO2tCQUxoQyxTQUFTOytCQUNFLHFCQUFxQjs4QkFNeEIsTUFBTTtzQkFEWixLQUFLO2dCQUlDLEtBQUs7c0JBRFgsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQsIE9uQ2hhbmdlcywgU2ltcGxlQ2hhbmdlcyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBBaXJHYXBXYWxsZXQsIFByb3RvY29sU3ltYm9scyB9IGZyb20gJ0B3YWxsZnJlZS1kZXYvY29pbmxpYi1jb3JlJ1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdhaXJnYXAtYWNjb3VudC1pdGVtJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2FjY291bnQtaXRlbS5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWycuL2FjY291bnQtaXRlbS5jb21wb25lbnQuc2NzcyddXG59KVxuZXhwb3J0IGNsYXNzIEFjY291bnRJdGVtQ29tcG9uZW50IGltcGxlbWVudHMgT25DaGFuZ2VzIHtcbiAgQElucHV0KClcbiAgcHVibGljIHdhbGxldDogQWlyR2FwV2FsbGV0IHwgdW5kZWZpbmVkXG5cbiAgQElucHV0KClcbiAgcHVibGljIGxhYmVsOiBzdHJpbmcgfCB1bmRlZmluZWRcblxuICBwdWJsaWMgYWRkcmVzczogc3RyaW5nIHwgdW5kZWZpbmVkXG5cbiAgcHVibGljIHByb3RvY29sU3ltYm9sOiBzdHJpbmcgfCB1bmRlZmluZWRcbiAgcHVibGljIHByb3RvY29sSWRlbnRpZmllcjogUHJvdG9jb2xTeW1ib2xzIHwgdW5kZWZpbmVkXG4gIHB1YmxpYyBwcm90b2NvbE5hbWU6IHN0cmluZyB8IHVuZGVmaW5lZFxuXG4gIHB1YmxpYyBhc3luYyBuZ09uQ2hhbmdlcyhfY2hhbmdlczogU2ltcGxlQ2hhbmdlcyk6IFByb21pc2U8dm9pZD4ge1xuICAgIHRoaXMuYWRkcmVzcyA9IHRoaXMud2FsbGV0Py5yZWNlaXZpbmdQdWJsaWNBZGRyZXNzXG5cbiAgICBjb25zdCBbcHJvdG9jb2xTeW1ib2wsIHByb3RvY29sSWRlbnRpZmllciwgcHJvdG9jb2xOYW1lXTogW3N0cmluZywgUHJvdG9jb2xTeW1ib2xzLCBzdHJpbmddID0gYXdhaXQgUHJvbWlzZS5hbGwoW1xuICAgICAgdGhpcy53YWxsZXQ/LnByb3RvY29sLmdldFN5bWJvbCgpID8/IFByb21pc2UucmVzb2x2ZSh1bmRlZmluZWQpLFxuICAgICAgdGhpcy53YWxsZXQ/LnByb3RvY29sLmdldElkZW50aWZpZXIoKSA/PyBQcm9taXNlLnJlc29sdmUodW5kZWZpbmVkKSxcbiAgICAgIHRoaXMud2FsbGV0Py5wcm90b2NvbC5nZXROYW1lKCkgPz8gUHJvbWlzZS5yZXNvbHZlKHVuZGVmaW5lZClcbiAgICBdKVxuXG4gICAgdGhpcy5wcm90b2NvbFN5bWJvbCA9IHByb3RvY29sU3ltYm9sXG4gICAgdGhpcy5wcm90b2NvbElkZW50aWZpZXIgPSBwcm90b2NvbElkZW50aWZpZXJcbiAgICB0aGlzLnByb3RvY29sTmFtZSA9IHByb3RvY29sTmFtZVxuICB9XG59XG4iLCI8bmctY29udGFpbmVyICpuZ0lmPVwiYWRkcmVzcyAmJiBwcm90b2NvbFN5bWJvbCAmJiBwcm90b2NvbElkZW50aWZpZXIgJiYgcHJvdG9jb2xOYW1lXCI+XG4gIDxpb24taXRlbSBsaW5lcz1cIm5vbmVcIiBjbGFzcz1cImlvbi1uby1wYWRkaW5nXCI+XG4gICAgPGlvbi1hdmF0YXIgc2xvdD1cInN0YXJ0XCI+XG4gICAgICA8YWlyZ2FwLWlkZW50aWNvbiBbYWRkcmVzc109XCJhZGRyZXNzXCI+PC9haXJnYXAtaWRlbnRpY29uPlxuICAgICAgPGFpcmdhcC1jdXJyZW5jeS1zeW1ib2wgW3N5bWJvbF09XCJwcm90b2NvbFN5bWJvbFwiIFtwcm90b2NvbElkZW50aWZpZXJdPVwicHJvdG9jb2xJZGVudGlmaWVyXCI+PC9haXJnYXAtY3VycmVuY3ktc3ltYm9sPlxuICAgIDwvaW9uLWF2YXRhcj5cbiAgICA8aW9uLWxhYmVsPlxuICAgICAgPGRpdiBzdHlsZT1cImRpc3BsYXk6IGZsZXg7IGp1c3RpZnktY29udGVudDogc3BhY2UtYmV0d2VlbjsgYWxpZ24taXRlbXM6IGNlbnRlclwiPlxuICAgICAgICA8aDI+XG4gICAgICAgICAgPHNwYW4gY2xhc3M9XCJmb250LS13ZWlnaHRfX21lZFwiPnt7IHByb3RvY29sTmFtZSB9fTwvc3Bhbj5cbiAgICAgICAgICB7eyBwcm90b2NvbFN5bWJvbCB9fVxuICAgICAgICA8L2gyPlxuICAgICAgICA8cD57eyBsYWJlbCB9fTwvcD5cbiAgICAgIDwvZGl2PlxuICAgICAgPHAgY2xhc3M9XCJ0eXBvZ3JhcGh5LS1tb25vXCI+e3sgd2FsbGV0LnJlY2VpdmluZ1B1YmxpY0FkZHJlc3MgfX08L3A+XG4gICAgPC9pb24tbGFiZWw+XG4gIDwvaW9uLWl0ZW0+XG48L25nLWNvbnRhaW5lcj5cbiJdfQ==

package/esm2022/lib/components/account-selection/account-selection.component.mjs

@@ -0,0 +1,61 @@
+import { Component, Input, EventEmitter, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ionic/angular";
+import * as i3 from "../account-item/account-item.component";
+export class AccountSelectionComponent {
+    constructor() {
+        this.walletSetEmitter = new EventEmitter();
+        this.dismissEmitter = new EventEmitter();
+        this.filteredWallets = [];
+    }
+    ngOnChanges(changes) {
+        if (changes.wallets && changes.wallets.currentValue) {
+            // Handle when wallets input changes or is set initially
+            this.filteredWallets = [...this.wallets];
+        }
+    }
+    filterItems(event) {
+        const value = this.isInputElement(event.target) ? event.target.value : undefined;
+        this.symbolFilter = this.isValidFilterQuery(value) ? value.trim().toLowerCase() : undefined;
+    }
+    filterWallet(event) {
+        const value = this.isInputElement(event.target) ? event.target.value : undefined;
+        this.filteredWallets = this.isValidFilterQuery(value)
+            ? this.wallets?.filter((wallet) => wallet.label?.trim().toLowerCase().startsWith(value.trim().toLowerCase())) || []
+            : this.wallets
+                ? [...this.wallets]
+                : [];
+    }
+    selectAccount(wallet) {
+        this.walletSetEmitter.emit(wallet);
+    }
+    dismiss() {
+        this.dismissEmitter.emit();
+    }
+    isInputElement(target) {
+        return target !== null && 'value' in target;
+    }
+    isValidFilterQuery(data) {
+        return typeof data === 'string' && data.length > 0;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AccountSelectionComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AccountSelectionComponent, selector: "airgap-account-selection", inputs: { title: "title", heading: "heading", placeholder: "placeholder", wallets: "wallets" }, outputs: { walletSetEmitter: "walletSetEmitter", dismissEmitter: "dismissEmitter" }, usesOnChanges: true, ngImport: i0, template: "<ion-header class=\"ion-no-border\">\n  <ion-grid fixed=\"true\" class=\"ion-no-padding\">\n    <ion-toolbar color=\"secondary\">\n      <ion-button (click)=\"dismiss()\" fill=\"clear\" color=\"primary\" float-right>\n        <ion-icon name=\"close\" slot=\"icon-only\"></ion-icon>\n      </ion-button>\n      <ion-title color=\"primary\">{{ title }}</ion-title>\n    </ion-toolbar>\n    <ion-toolbar color=\"secondary\">\n      <ion-searchbar placeholder=\"{{ placeholder }}\" (ionInput)=\"filterWallet($event)\"></ion-searchbar>\n    </ion-toolbar>\n  </ion-grid>\n</ion-header>\n<ion-content [fullscreen]=\"true\">\n  <h3 [innerHTML]=\"heading\" class=\"ion-padding\"></h3>\n  <ion-list class=\"ion-padding\" *ngIf=\"wallets\">\n    <ng-container *ngFor=\"let wallet of filteredWallets\">\n      <airgap-account-item [wallet]=\"wallet\" [label]=\"wallet.label\" (click)=\"selectAccount(wallet)\"></airgap-account-item>\n    </ng-container>\n  </ion-list>\n</ion-content>\n", styles: [""], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i2.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i2.IonGrid, selector: "ion-grid", inputs: ["fixed"] }, { kind: "component", type: i2.IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: i2.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i2.IonList, selector: "ion-list", inputs: ["inset", "lines", "mode"] }, { kind: "component", type: i2.IonSearchbar, selector: "ion-searchbar", inputs: ["animated", "autocapitalize", "autocomplete", "autocorrect", "cancelButtonIcon", "cancelButtonText", "clearIcon", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "maxlength", "minlength", "mode", "name", "placeholder", "searchIcon", "showCancelButton", "showClearButton", "spellcheck", "type", "value"] }, { kind: "component", type: i2.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i2.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "directive", type: i2.TextValueAccessor, selector: "ion-input:not([type=number]),ion-textarea,ion-searchbar,ion-range" }, { kind: "component", type: i3.AccountItemComponent, selector: "airgap-account-item", inputs: ["wallet", "label"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AccountSelectionComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'airgap-account-selection', template: "<ion-header class=\"ion-no-border\">\n  <ion-grid fixed=\"true\" class=\"ion-no-padding\">\n    <ion-toolbar color=\"secondary\">\n      <ion-button (click)=\"dismiss()\" fill=\"clear\" color=\"primary\" float-right>\n        <ion-icon name=\"close\" slot=\"icon-only\"></ion-icon>\n      </ion-button>\n      <ion-title color=\"primary\">{{ title }}</ion-title>\n    </ion-toolbar>\n    <ion-toolbar color=\"secondary\">\n      <ion-searchbar placeholder=\"{{ placeholder }}\" (ionInput)=\"filterWallet($event)\"></ion-searchbar>\n    </ion-toolbar>\n  </ion-grid>\n</ion-header>\n<ion-content [fullscreen]=\"true\">\n  <h3 [innerHTML]=\"heading\" class=\"ion-padding\"></h3>\n  <ion-list class=\"ion-padding\" *ngIf=\"wallets\">\n    <ng-container *ngFor=\"let wallet of filteredWallets\">\n      <airgap-account-item [wallet]=\"wallet\" [label]=\"wallet.label\" (click)=\"selectAccount(wallet)\"></airgap-account-item>\n    </ng-container>\n  </ion-list>\n</ion-content>\n" }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], heading: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], wallets: [{
+                type: Input
+            }], walletSetEmitter: [{
+                type: Output
+            }], dismissEmitter: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/components.module.mjs

@@ -0,0 +1,97 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { IonicModule } from '@ionic/angular';
+import { TranslateModule } from '@ngx-translate/core';
+import { QRCodeModule } from 'angularx-qrcode';
+import { FormsModule } from '@angular/forms';
+import { PipesModule } from '../pipes/pipes.module';
+import { CurrencySymbolComponent } from './currency-symbol/currency-symbol.component';
+import { FromToComponent } from './from-to/from-to.component';
+import { IdenticonComponent } from './identicon/identicon.component';
+import { NetworkBadgeComponent } from './network-badge/network-badge.component';
+import { TitledAddressComponent } from './titled-address/titled-address.component';
+import { TitledTextComponent } from './titled-text/titled-text.component';
+import { AccountItemComponent } from './account-item/account-item.component';
+import { AccountSelectionComponent } from './account-selection/account-selection.component';
+import { QrComponent } from './qr/qr.component';
+import { QrSettingsComponent } from './qr-settings/qr-settings.component';
+import { IACQrComponent } from './iac-qr/iac-qr.component';
+import { IsolatedModulesListComponent } from './isolated-modules-list/isolated-modules-list.component';
+import { IsolatedModulesOnboardingComponent } from './isolated-modules-onboarding/isolated-modules-onboarding.component';
+import { IsolatedModulesDetailsComponent } from './isolated-modules-details/isolated-modules-details.component';
+import { IsolatedModulesBadgesComponent } from './isolated-modules-badges/isolated-modules-badges.component';
+import * as i0 from "@angular/core";
+export class ComponentsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, declarations: [FromToComponent,
+            IdenticonComponent,
+            TitledTextComponent,
+            TitledAddressComponent,
+            CurrencySymbolComponent,
+            NetworkBadgeComponent,
+            QrComponent,
+            IACQrComponent,
+            AccountItemComponent,
+            AccountSelectionComponent,
+            QrSettingsComponent,
+            IsolatedModulesDetailsComponent,
+            IsolatedModulesListComponent,
+            IsolatedModulesOnboardingComponent,
+            IsolatedModulesBadgesComponent], imports: [CommonModule, IonicModule, TranslateModule, PipesModule, QRCodeModule, FormsModule], exports: [FromToComponent,
+            IdenticonComponent,
+            TitledTextComponent,
+            TitledAddressComponent,
+            CurrencySymbolComponent,
+            NetworkBadgeComponent,
+            AccountItemComponent,
+            AccountSelectionComponent,
+            QrComponent,
+            IACQrComponent,
+            QrSettingsComponent,
+            IsolatedModulesDetailsComponent,
+            IsolatedModulesListComponent,
+            IsolatedModulesOnboardingComponent,
+            IsolatedModulesBadgesComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, imports: [CommonModule, IonicModule, TranslateModule, PipesModule, QRCodeModule, FormsModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        FromToComponent,
+                        IdenticonComponent,
+                        TitledTextComponent,
+                        TitledAddressComponent,
+                        CurrencySymbolComponent,
+                        NetworkBadgeComponent,
+                        QrComponent,
+                        IACQrComponent,
+                        AccountItemComponent,
+                        AccountSelectionComponent,
+                        QrSettingsComponent,
+                        IsolatedModulesDetailsComponent,
+                        IsolatedModulesListComponent,
+                        IsolatedModulesOnboardingComponent,
+                        IsolatedModulesBadgesComponent
+                    ],
+                    imports: [CommonModule, IonicModule, TranslateModule, PipesModule, QRCodeModule, FormsModule],
+                    exports: [
+                        FromToComponent,
+                        IdenticonComponent,
+                        TitledTextComponent,
+                        TitledAddressComponent,
+                        CurrencySymbolComponent,
+                        NetworkBadgeComponent,
+                        AccountItemComponent,
+                        AccountSelectionComponent,
+                        QrComponent,
+                        IACQrComponent,
+                        QrSettingsComponent,
+                        IsolatedModulesDetailsComponent,
+                        IsolatedModulesListComponent,
+                        IsolatedModulesOnboardingComponent,
+                        IsolatedModulesBadgesComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/currency-symbol/currency-symbol.component.mjs

@@ -0,0 +1,45 @@
+import { Component, Inject, Injector, Input } from '@angular/core';
+import { first, map } from 'rxjs/operators';
+import { BaseComponent } from '../../base/base.component';
+import { currencySymbolFacade, CURRENCY_SYMBOL_FACADE } from './currency-symbol.facade';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+import * as i2 from "@angular/common";
+export class CurrencySymbolComponent extends BaseComponent {
+    constructor(facade, domSanitizer) {
+        super(facade);
+        this.domSanitizer = domSanitizer;
+        this.symbolSrc$ = facade.symbolSrc$.pipe(map((src) => this.domSanitizer.bypassSecurityTrustUrl(src)));
+    }
+    ngOnInit() {
+        this.facade.initWithSymbol(this.symbol, this.protocolIdentifier);
+        return super.ngOnInit();
+    }
+    ngOnChanges(changes) {
+        if (changes.symbol === undefined || changes.protocolIdentifier === undefined) {
+            return;
+        }
+        if (changes.symbol.previousValue !== changes.symbol.currentValue ||
+            changes.protocolIdentifier.previousValue !== changes.protocolIdentifier.currentValue) {
+            this.facade.onSymbolChanged(changes.symbol.currentValue, changes.protocolIdentifier.currentValue);
+        }
+    }
+    async onError() {
+        const symbolSrc = await this.facade.symbolSrc$.pipe(first()).toPromise();
+        this.facade.onError(this.symbol, this.protocolIdentifier, symbolSrc);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolComponent, deps: [{ token: CURRENCY_SYMBOL_FACADE }, { token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: CurrencySymbolComponent, selector: "airgap-currency-symbol", inputs: { symbol: "symbol", protocolIdentifier: "protocolIdentifier" }, providers: [{ provide: CURRENCY_SYMBOL_FACADE, useFactory: currencySymbolFacade, deps: [Injector] }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<img [src]=\"symbolSrc$ | async\" (error)=\"onError()\" />", styles: [""], dependencies: [{ kind: "pipe", type: i2.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CurrencySymbolComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'airgap-currency-symbol', providers: [{ provide: CURRENCY_SYMBOL_FACADE, useFactory: currencySymbolFacade, deps: [Injector] }], template: "<img [src]=\"symbolSrc$ | async\" (error)=\"onError()\" />" }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CURRENCY_SYMBOL_FACADE]
+                }] }, { type: i1.DomSanitizer }], propDecorators: { symbol: [{
+                type: Input
+            }], protocolIdentifier: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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