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

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

@@ -0,0 +1,291 @@
+import { Inject, Injectable } from '@angular/core';
+import { Directory, Encoding } from '@capacitor/filesystem';
+import { FILESYSTEM_PLUGIN, ZIP_PLUGIN } from '../../capacitor-plugins/injection-tokens';
+import * as i0 from "@angular/core";
+import * as i1 from "../uri/uri.service";
+import * as i2 from "../image/image.service";
+const MANIFEST_FILENAME = 'manifest.json';
+const SIGNATURE_FILENAME = 'module.sig';
+const ISOLATED_MODULES_PATH = '__airgap_protocol_modules__';
+const ISOLATED_SYMBOLS_PATH = '__symbols__';
+export class FilesystemService {
+    constructor(uriService, imageService, filesystem, zip) {
+        this.uriService = uriService;
+        this.imageService = imageService;
+        this.filesystem = filesystem;
+        this.zip = zip;
+    }
+    async readLazyImage(path) {
+        try {
+            const { dir, filename } = this.splitPath(path);
+            const filesInDir = await this.filesInDir(dir);
+            if (filesInDir.has(filename)) {
+                const data = await this.readDataFile({ path }).then((result) => result.data);
+                const metadata = filesInDir.has(this.getMetadataFilePath(filename))
+                    ? await this.readImageMetadata(path)
+                    : undefined;
+                return this.uriService.data(data, metadata.mediaType, metadata.isBinary);
+            }
+            else if (filesInDir.has(this.getLinkFilePath(filename))) {
+                return this.downloadRemoteImage(path);
+            }
+            else {
+                return undefined;
+            }
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async writeLazyImage(path, uri) {
+        const dataEntry = this.createLazyDataEntry(path, uri);
+        await this.saveImageData(dataEntry.path, dataEntry.data, dataEntry.encoding, dataEntry.metadata);
+    }
+    async downloadRemoteImage(path) {
+        const uri = await this.readDataFile({
+            path: this.getLinkFilePath(path),
+            encoding: Encoding.UTF8
+        }).then((result) => result.data);
+        const base64 = await this.imageService.fetch(uri);
+        if (!base64) {
+            return undefined;
+        }
+        const splitData = this.uriService.splitDataUri(base64);
+        await this.saveImageData(path, splitData.data, Encoding.UTF8, { mediaType: splitData.mediaType, isBinary: splitData.isBinary });
+        return base64;
+    }
+    createLazyDataEntry(path, uri) {
+        const uriType = this.uriService.resolveUriType(uri);
+        // eslint-disable-next-line default-case
+        switch (uriType) {
+            case 'remote':
+            case 'unsupported':
+                return {
+                    path: this.getLinkFilePath(path),
+                    data: uri,
+                    encoding: Encoding.UTF8
+                };
+            case 'data':
+                const splitData = this.uriService.splitDataUri(uri);
+                return {
+                    path,
+                    data: splitData.data,
+                    encoding: Encoding.UTF8,
+                    metadata: splitData.mediaType ? { mediaType: splitData.mediaType, isBinary: splitData.isBinary } : undefined
+                };
+        }
+    }
+    async readIsolatedSymbol(name) {
+        try {
+            const dir = `${ISOLATED_MODULES_PATH}/${ISOLATED_SYMBOLS_PATH}`;
+            const path = `${dir}/${name.toLowerCase()}`;
+            const { data } = await this.readDataFile({ path });
+            const metadata = await this.readImageMetadata(path);
+            return this.uriService.data(data, metadata.mediaType, metadata.isBinary);
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    async createTempProtocolModule(name, path) {
+        const tempDir = await this.createTempProtocolModuleDir(name);
+        try {
+            await this.zip.unzip({
+                from: path,
+                to: tempDir.path,
+                toDirectory: tempDir.directory
+            });
+            return {
+                path: tempDir.path,
+                directory: tempDir.directory
+            };
+        }
+        catch (error) {
+            await this.removeTempProtocolModule(tempDir.path, tempDir.directory).catch(() => {
+                /* no action */
+            });
+            throw error;
+        }
+    }
+    async removeTempProtocolModule(path, directory) {
+        return this.filesystem.rmdir({
+            path,
+            directory,
+            recursive: true
+        });
+    }
+    async findProtocolModuleRoot(path, directory) {
+        const { type } = await this.filesystem.stat({ path, directory });
+        if (type === 'directory') {
+            const root = await this.findProtocolModuleRootInDir(path, directory);
+            return root?.replace(`${path}/`, '');
+        }
+        else {
+            return undefined;
+        }
+    }
+    async findProtocolModuleRootInDir(path, directory) {
+        const { files } = await this.filesystem.readdir({ path, directory });
+        const hasManifest = files.find((file) => file.type === 'file' && file.name === MANIFEST_FILENAME);
+        if (hasManifest) {
+            return path;
+        }
+        for (const file of files) {
+            if (file.type === 'directory') {
+                const root = await this.findProtocolModuleRootInDir(`${path}/${file.name}`, directory);
+                if (root !== undefined) {
+                    return root;
+                }
+            }
+        }
+        return undefined;
+    }
+    async installProtocolModule(identifier, files, symbols, currentLocation) {
+        const newPath = `${ISOLATED_MODULES_PATH}/${identifier}`;
+        const newDirectory = Directory.Data;
+        try {
+            for (const file of [MANIFEST_FILENAME, SIGNATURE_FILENAME, ...files]) {
+                const lastSegmentIndex = file.lastIndexOf('/');
+                const parent = file.substring(0, lastSegmentIndex).replace(/^\/+/, '');
+                await this.filesystem
+                    .mkdir({
+                    path: `${newPath}/${parent}`,
+                    directory: newDirectory,
+                    recursive: true
+                })
+                    .catch(() => {
+                    /* no action */
+                });
+                await this.filesystem.copy({
+                    from: `${currentLocation.path}/${currentLocation.root}/${file}`,
+                    directory: currentLocation.directory,
+                    to: `${newPath}/${file}`,
+                    toDirectory: newDirectory
+                });
+                const symbolsDir = `${ISOLATED_MODULES_PATH}/${ISOLATED_SYMBOLS_PATH}`;
+                await this.filesystem
+                    .mkdir({
+                    path: symbolsDir,
+                    directory: newDirectory,
+                    recursive: true
+                })
+                    .catch(() => {
+                    /* no action */
+                });
+                await Promise.all(Object.entries(symbols).map(async ([symbol, uri]) => {
+                    const path = `${symbolsDir}/${symbol.toLowerCase()}`;
+                    if (uri.startsWith('file://')) {
+                        const resPath = uri.replace(/^file:\/\//, '');
+                        const extension = uri.split('.').slice(-1)[0].toLocaleLowerCase();
+                        await this.filesystem.copy({
+                            from: `${currentLocation.path}/${currentLocation.root}/${resPath}`,
+                            directory: currentLocation.directory,
+                            to: path,
+                            toDirectory: newDirectory
+                        });
+                        await this.saveImageMetadata(path, {
+                            mediaType: `image/${extension === 'svg' ? 'svg+xml' : extension}`,
+                            isBinary: true
+                        });
+                    }
+                    else if (uri.startsWith('data:image')) {
+                        const splitData = this.uriService.splitDataUri(uri);
+                        await this.saveImageData(path, splitData.data, Encoding.UTF8, {
+                            mediaType: splitData.mediaType,
+                            isBinary: splitData.isBinary
+                        });
+                    }
+                }));
+            }
+        }
+        catch (error) {
+            await this.removeTempProtocolModule(newPath, newDirectory).catch(() => {
+                /* no action */
+            });
+            throw error;
+        }
+        finally {
+            await this.removeTempProtocolModule(currentLocation.path, currentLocation.directory).catch(() => {
+                /* no action */
+            });
+        }
+    }
+    async saveImageData(path, data, encoding, metadata) {
+        await this.writeDataFile({
+            path,
+            data,
+            encoding
+        });
+        if (metadata) {
+            await this.saveImageMetadata(path, metadata);
+        }
+    }
+    async saveImageMetadata(path, metadata) {
+        await this.writeDataFile({
+            path: this.getMetadataFilePath(path),
+            data: JSON.stringify(metadata),
+            encoding: Encoding.UTF8
+        });
+    }
+    async readImageMetadata(path) {
+        return this.readDataFile({
+            path: this.getMetadataFilePath(path),
+            encoding: Encoding.UTF8
+        }).then((result) => JSON.parse(result.data));
+    }
+    async readDataFile(options) {
+        return this.filesystem.readFile({
+            directory: Directory.Data,
+            ...options
+        });
+    }
+    async writeDataFile(options) {
+        return this.filesystem.writeFile({
+            directory: Directory.Data,
+            ...options,
+            recursive: true
+        });
+    }
+    async filesInDir(path, directory = Directory.Data) {
+        return this.filesystem
+            .readdir({
+            path,
+            directory
+        })
+            .then((result) => new Set(result.files.map((fileInfo) => fileInfo.uri)));
+    }
+    getLinkFilePath(path) {
+        return `${path}.link`;
+    }
+    getMetadataFilePath(path) {
+        return `${path}.metadata`;
+    }
+    splitPath(path) {
+        const dirEnd = path.lastIndexOf('/');
+        return dirEnd !== -1 ? { dir: path.slice(0, dirEnd), filename: path.slice(dirEnd + 1) } : { dir: '/', filename: path };
+    }
+    async createTempProtocolModuleDir(moduleName) {
+        const tempDir = `protocolmodule_${moduleName.replace(/\.zip$/, '')}_${Date.now()}`;
+        const directory = Directory.Cache;
+        await this.filesystem.mkdir({
+            path: tempDir,
+            directory
+        });
+        return { path: tempDir, directory };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FilesystemService, deps: [{ token: i1.UriService }, { token: i2.ImageService }, { token: FILESYSTEM_PLUGIN }, { token: ZIP_PLUGIN }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FilesystemService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FilesystemService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.UriService }, { type: i2.ImageService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FILESYSTEM_PLUGIN]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ZIP_PLUGIN]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filesystem.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/filesystem/filesystem.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\nimport {\n  Directory,\n  Encoding,\n  FileInfo,\n  FilesystemPlugin,\n  ReaddirResult,\n  ReadFileOptions,\n  ReadFileResult,\n  WriteFileOptions,\n  WriteFileResult\n} from '@capacitor/filesystem'\nimport { ZipPlugin } from '../../capacitor-plugins/definitions'\n\nimport { FILESYSTEM_PLUGIN, ZIP_PLUGIN } from '../../capacitor-plugins/injection-tokens'\nimport { ImageService } from '../image/image.service'\nimport { UriService } from '../uri/uri.service'\n\ninterface Metadata {\n  mediaType?: string\n  isBinary?: boolean\n}\n\nconst MANIFEST_FILENAME = 'manifest.json'\nconst SIGNATURE_FILENAME = 'module.sig'\n\nconst ISOLATED_MODULES_PATH = '__airgap_protocol_modules__'\nconst ISOLATED_SYMBOLS_PATH = '__symbols__'\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FilesystemService {\n  constructor(\n    private readonly uriService: UriService,\n    private readonly imageService: ImageService,\n    @Inject(FILESYSTEM_PLUGIN) private readonly filesystem: FilesystemPlugin,\n    @Inject(ZIP_PLUGIN) private readonly zip: ZipPlugin\n  ) {}\n\n  public async readLazyImage(path: string): Promise<string | undefined> {\n    try {\n      const { dir, filename } = this.splitPath(path)\n      const filesInDir = await this.filesInDir(dir)\n\n      if (filesInDir.has(filename)) {\n        const data: string = await this.readDataFile({ path }).then((result: ReadFileResult) => result.data as string)\n\n        const metadata: Metadata | undefined = filesInDir.has(this.getMetadataFilePath(filename))\n          ? await this.readImageMetadata(path)\n          : undefined\n\n        return this.uriService.data(data, metadata.mediaType, metadata.isBinary)\n      } else if (filesInDir.has(this.getLinkFilePath(filename))) {\n        return this.downloadRemoteImage(path)\n      } else {\n        return undefined\n      }\n    } catch (error) {\n      return undefined\n    }\n  }\n\n  public async writeLazyImage(path: string, uri: string): Promise<void> {\n    const dataEntry = this.createLazyDataEntry(path, uri)\n    await this.saveImageData(dataEntry.path, dataEntry.data, dataEntry.encoding, dataEntry.metadata)\n  }\n\n  private async downloadRemoteImage(path: string): Promise<string | undefined> {\n    const uri: string = await this.readDataFile({\n      path: this.getLinkFilePath(path),\n      encoding: Encoding.UTF8\n    }).then((result: ReadFileResult) => result.data as string)\n\n    const base64 = await this.imageService.fetch(uri)\n    if (!base64) {\n      return undefined\n    }\n\n    const splitData = this.uriService.splitDataUri(base64)\n\n    await this.saveImageData(path, splitData.data, Encoding.UTF8, { mediaType: splitData.mediaType, isBinary: splitData.isBinary })\n\n    return base64\n  }\n\n  private createLazyDataEntry(path: string, uri: string): { path: string; data: string; encoding?: Encoding; metadata?: Metadata } {\n    const uriType = this.uriService.resolveUriType(uri)\n    // eslint-disable-next-line default-case\n    switch (uriType) {\n      case 'remote':\n      case 'unsupported':\n        return {\n          path: this.getLinkFilePath(path),\n          data: uri,\n          encoding: Encoding.UTF8\n        }\n      case 'data':\n        const splitData = this.uriService.splitDataUri(uri)\n\n        return {\n          path,\n          data: splitData.data,\n          encoding: Encoding.UTF8,\n          metadata: splitData.mediaType ? { mediaType: splitData.mediaType, isBinary: splitData.isBinary } : undefined\n        }\n    }\n  }\n\n  public async readIsolatedSymbol(name: string): Promise<string | undefined> {\n    try {\n      const dir: string = `${ISOLATED_MODULES_PATH}/${ISOLATED_SYMBOLS_PATH}`\n      const path: string = `${dir}/${name.toLowerCase()}`\n\n      const { data }: ReadFileResult = await this.readDataFile({ path })\n\n      const metadata: Metadata = await this.readImageMetadata(path)\n\n      return this.uriService.data(data as string, metadata.mediaType, metadata.isBinary)\n    } catch (error) {\n      return undefined\n    }\n  }\n\n  public async createTempProtocolModule(name: string, path: string): Promise<{ path: string; directory: Directory }> {\n    const tempDir = await this.createTempProtocolModuleDir(name)\n\n    try {\n      await this.zip.unzip({\n        from: path,\n        to: tempDir.path,\n        toDirectory: tempDir.directory\n      })\n\n      return {\n        path: tempDir.path,\n        directory: tempDir.directory\n      }\n    } catch (error) {\n      await this.removeTempProtocolModule(tempDir.path, tempDir.directory).catch(() => {\n        /* no action */\n      })\n      throw error\n    }\n  }\n\n  public async removeTempProtocolModule(path: string, directory: Directory): Promise<void> {\n    return this.filesystem.rmdir({\n      path,\n      directory,\n      recursive: true\n    })\n  }\n\n  public async findProtocolModuleRoot(path: string, directory: Directory): Promise<string | undefined> {\n    const { type } = await this.filesystem.stat({ path, directory })\n    if (type === 'directory') {\n      const root = await this.findProtocolModuleRootInDir(path, directory)\n\n      return root?.replace(`${path}/`, '')\n    } else {\n      return undefined\n    }\n  }\n\n  private async findProtocolModuleRootInDir(path: string, directory: Directory): Promise<string | undefined> {\n    const { files }: ReaddirResult = await this.filesystem.readdir({ path, directory })\n    const hasManifest = files.find((file: FileInfo) => file.type === 'file' && file.name === MANIFEST_FILENAME)\n    if (hasManifest) {\n      return path\n    }\n\n    for (const file of files) {\n      if (file.type === 'directory') {\n        const root: string | undefined = await this.findProtocolModuleRootInDir(`${path}/${file.name}`, directory)\n        if (root !== undefined) {\n          return root\n        }\n      }\n    }\n\n    return undefined\n  }\n\n  public async installProtocolModule(\n    identifier: string,\n    files: string[],\n    symbols: Record<string, string>,\n    currentLocation: {\n      path: string\n      root: string\n      directory: Directory\n    }\n  ): Promise<void> {\n    const newPath: string = `${ISOLATED_MODULES_PATH}/${identifier}`\n    const newDirectory: Directory = Directory.Data\n\n    try {\n      for (const file of [MANIFEST_FILENAME, SIGNATURE_FILENAME, ...files]) {\n        const lastSegmentIndex: number = file.lastIndexOf('/')\n        const parent = file.substring(0, lastSegmentIndex).replace(/^\\/+/, '')\n\n        await this.filesystem\n          .mkdir({\n            path: `${newPath}/${parent}`,\n            directory: newDirectory,\n            recursive: true\n          })\n          .catch(() => {\n            /* no action */\n          })\n\n        await this.filesystem.copy({\n          from: `${currentLocation.path}/${currentLocation.root}/${file}`,\n          directory: currentLocation.directory,\n          to: `${newPath}/${file}`,\n          toDirectory: newDirectory\n        })\n\n        const symbolsDir: string = `${ISOLATED_MODULES_PATH}/${ISOLATED_SYMBOLS_PATH}`\n        await this.filesystem\n          .mkdir({\n            path: symbolsDir,\n            directory: newDirectory,\n            recursive: true\n          })\n          .catch(() => {\n            /* no action */\n          })\n\n        await Promise.all(\n          Object.entries(symbols).map(async ([symbol, uri]: [string, string]) => {\n            const path: string = `${symbolsDir}/${symbol.toLowerCase()}`\n\n            if (uri.startsWith('file://')) {\n              const resPath: string = uri.replace(/^file:\\/\\//, '')\n              const extension: string = uri.split('.').slice(-1)[0].toLocaleLowerCase()\n\n              await this.filesystem.copy({\n                from: `${currentLocation.path}/${currentLocation.root}/${resPath}`,\n                directory: currentLocation.directory,\n                to: path,\n                toDirectory: newDirectory\n              })\n\n              await this.saveImageMetadata(path, {\n                mediaType: `image/${extension === 'svg' ? 'svg+xml' : extension}`,\n                isBinary: true\n              })\n            } else if (uri.startsWith('data:image')) {\n              const splitData = this.uriService.splitDataUri(uri)\n              await this.saveImageData(path, splitData.data, Encoding.UTF8, {\n                mediaType: splitData.mediaType,\n                isBinary: splitData.isBinary\n              })\n            }\n          })\n        )\n      }\n    } catch (error) {\n      await this.removeTempProtocolModule(newPath, newDirectory).catch(() => {\n        /* no action */\n      })\n      throw error\n    } finally {\n      await this.removeTempProtocolModule(currentLocation.path, currentLocation.directory).catch(() => {\n        /* no action */\n      })\n    }\n  }\n\n  private async saveImageData(path: string, data: string, encoding?: Encoding, metadata?: Metadata): Promise<void> {\n    await this.writeDataFile({\n      path,\n      data,\n      encoding\n    })\n\n    if (metadata) {\n      await this.saveImageMetadata(path, metadata)\n    }\n  }\n\n  private async saveImageMetadata(path: string, metadata: Metadata): Promise<void> {\n    await this.writeDataFile({\n      path: this.getMetadataFilePath(path),\n      data: JSON.stringify(metadata),\n      encoding: Encoding.UTF8\n    })\n  }\n\n  private async readImageMetadata(path: string): Promise<Metadata> {\n    return this.readDataFile({\n      path: this.getMetadataFilePath(path),\n      encoding: Encoding.UTF8\n    }).then((result: ReadFileResult) => JSON.parse(result.data as string))\n  }\n\n  private async readDataFile(options: ReadFileOptions): Promise<ReadFileResult> {\n    return this.filesystem.readFile({\n      directory: Directory.Data,\n      ...options\n    })\n  }\n\n  private async writeDataFile(options: WriteFileOptions): Promise<WriteFileResult> {\n    return this.filesystem.writeFile({\n      directory: Directory.Data,\n      ...options,\n      recursive: true\n    })\n  }\n\n  private async filesInDir(path: string, directory: Directory = Directory.Data): Promise<Set<string>> {\n    return this.filesystem\n      .readdir({\n        path,\n        directory\n      })\n      .then((result: ReaddirResult) => new Set(result.files.map((fileInfo: FileInfo) => fileInfo.uri)))\n  }\n\n  private getLinkFilePath(path: string): string {\n    return `${path}.link`\n  }\n\n  private getMetadataFilePath(path: string): string {\n    return `${path}.metadata`\n  }\n\n  private splitPath(path: string): { dir: string; filename: string } {\n    const dirEnd = path.lastIndexOf('/')\n\n    return dirEnd !== -1 ? { dir: path.slice(0, dirEnd), filename: path.slice(dirEnd + 1) } : { dir: '/', filename: path }\n  }\n\n  private async createTempProtocolModuleDir(moduleName: string): Promise<{ path: string; directory: Directory }> {\n    const tempDir: string = `protocolmodule_${moduleName.replace(/\\.zip$/, '')}_${Date.now()}`\n    const directory: Directory = Directory.Cache\n\n    await this.filesystem.mkdir({\n      path: tempDir,\n      directory\n    })\n\n    return { path: tempDir, directory }\n  }\n}\n"]}

package/esm2022/lib/services/iac/base.iac.service.mjs

@@ -0,0 +1,155 @@
+import { IACMessageType } from '@wallfree-dev/serializer';
+import { Inject, Injectable } from '@angular/core';
+import { SerializerV3Generator } from '../qr/qr-generators/serializer-v3-generator';
+import { SerializerV3Handler } from '../qr/qr-handler/serializer-v3-handler';
+import { SerializerV2Handler } from '../qr/qr-handler/serializer-v2-handler';
+import { APP_CONFIG } from '../../config/app-config';
+import { IACHandlerStatus } from './message-handler';
+import * as i0 from "@angular/core";
+import * as i1 from "../ui-event-elements/ui-event-elements.service";
+import * as i2 from "../clipboard/clipboard.service";
+import * as i3 from "../deeplink/deeplink.service";
+export class BaseIACService {
+    constructor(uiEventElementService, clipboard, isReady, customHandlers, deeplinkService, appConfig) {
+        this.uiEventElementService = uiEventElementService;
+        this.clipboard = clipboard;
+        this.isReady = isReady;
+        this.customHandlers = customHandlers;
+        this.deeplinkService = deeplinkService;
+        this.appConfig = appConfig;
+        this.transport = undefined;
+        this.scanAgainCallback = undefined;
+        this.serializerMessageHandlers = {
+            [IACMessageType.AccountShareRequest]: this.syncTypeNotSupportedAlert.bind(this),
+            [IACMessageType.AccountShareResponse]: this.syncTypeNotSupportedAlert.bind(this),
+            [IACMessageType.TransactionSignRequest]: this.syncTypeNotSupportedAlert.bind(this),
+            [IACMessageType.TransactionSignResponse]: this.syncTypeNotSupportedAlert.bind(this),
+            [IACMessageType.MessageSignRequest]: this.syncTypeNotSupportedAlert.bind(this),
+            [IACMessageType.MessageSignResponse]: this.syncTypeNotSupportedAlert.bind(this)
+        };
+        this.handlers = [
+            new SerializerV3Handler((deserializedSync) => this.deserialize(deserializedSync)),
+            new SerializerV2Handler((deserializedSync) => this.deserialize(deserializedSync))
+        ];
+        this.handlers.push(...customHandlers);
+    }
+    async storeResult(message, status, transport) {
+        console.debug('STORE_RESULT', message, status, transport);
+        return status;
+    }
+    // check if we already have part, scanning same QR advances progress bar
+    async handleRequest(data, transport, scanAgainCallback = () => undefined) {
+        this.transport = transport;
+        this.scanAgainCallback = scanAgainCallback;
+        await this.isReady;
+        for (let i = 0; i < this.handlers.length; i++) {
+            const handler = this.handlers[i];
+            try {
+                const canHandle = await handler.canHandle(data);
+                if (canHandle) {
+                    const handlerStatus = await handler.receive(data);
+                    if (handlerStatus === IACHandlerStatus.SUCCESS) {
+                        try {
+                            const result = await handler.getResult();
+                            const status = IACHandlerStatus.SUCCESS;
+                            await handler.handleComplete();
+                            await this.resetHandlers();
+                            return this.storeResult(result, status, transport);
+                        }
+                        catch (e) {
+                            console.error('Error while handling result', e);
+                            const dataSingle = (await handler.getDataSingle()) ?? data;
+                            await this.messageUnknownAlert(dataSingle, this.scanAgainCallback);
+                            await this.resetHandlers();
+                            return this.storeResult({ result: undefined, data: dataSingle }, IACHandlerStatus.UNSUPPORTED, transport);
+                        }
+                    }
+                    else if (handlerStatus === IACHandlerStatus.PARTIAL) {
+                        scanAgainCallback(await handler.getProgress());
+                        return this.storeResult({ result: data, data: await handler.getDataSingle() }, IACHandlerStatus.PARTIAL, transport);
+                    }
+                }
+            }
+            catch (handlerError) {
+                console.log(`Error while handling message in ${handler.name}`, handlerError);
+            }
+        }
+        await this.resetHandlers();
+        await this.messageUnknownAlert(data, this.scanAgainCallback);
+        return this.storeResult({ result: undefined, data }, IACHandlerStatus.UNSUPPORTED, this.transport);
+    }
+    async resetHandlers() {
+        await Promise.all(this.handlers.map((handler) => {
+            handler.reset();
+        }));
+    }
+    async deserialize(deserializedSync) {
+        const data = deserializedSync.result;
+        if (data && data.length > 0) {
+            const groupedByType = data.reduce((grouped, message) => Object.assign(grouped, { [message.type]: (grouped[message.type] || []).concat(message) }), {});
+            for (const type in groupedByType) {
+                if (type in IACMessageType) {
+                    // TODO: Improve types
+                    const typedType = parseInt(type, 10);
+                    // eslint-disable-next-line no-console
+                    this.serializerMessageHandlers[typedType]({ result: groupedByType[typedType] ?? [], data: deserializedSync.data, context: deserializedSync.context }, this.transport, this.scanAgainCallback).catch(console.error);
+                }
+                else {
+                    // TODO: Improve types
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-console
+                    this.syncTypeNotSupportedAlert(deserializedSync, this.transport, this.scanAgainCallback).catch(console.error);
+                    return IACHandlerStatus.UNSUPPORTED;
+                }
+            }
+            return IACHandlerStatus.SUCCESS;
+        }
+        else {
+            throw new Error('Empty message received!');
+        }
+    }
+    async messageUnknownAlert(data, scanAgainCallback) {
+        const relayHandler = () => {
+            // eslint-disable-next-line no-console
+            this.relay(data).catch(console.error);
+        };
+        const copyHandler = () => {
+            // eslint-disable-next-line no-console
+            this.clipboard.copyAndShowToast(data).catch(console.error);
+        };
+        const cancelHandler = () => {
+            scanAgainCallback();
+        };
+        // eslint-disable-next-line no-console
+        this.uiEventElementService.showIACMessageUnknownAlert(relayHandler, copyHandler, cancelHandler).catch(console.error);
+    }
+    async syncTypeNotSupportedAlert(messageWrapper, _transport, scanAgainCallback) {
+        const relayHandler = () => {
+            // eslint-disable-next-line no-console
+            this.relay(messageWrapper.data).catch(console.error);
+        };
+        const copyHandler = () => {
+            // eslint-disable-next-line no-console
+            this.clipboard.copyAndShowToast(messageWrapper.data).catch(console.error);
+        };
+        const cancelHandler = () => {
+            scanAgainCallback();
+        };
+        // eslint-disable-next-line no-console
+        this.uiEventElementService.showIACMessageNotSupportedAlert(relayHandler, copyHandler, cancelHandler).catch(console.error);
+        return false;
+    }
+    async serialize(messageDefinitionObject, prefix) {
+        const generator = new SerializerV3Generator();
+        await generator.create(messageDefinitionObject, 100, 100);
+        return generator.getSingle(prefix);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseIACService, deps: "invalid", target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseIACService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BaseIACService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.UiEventElementsService }, { type: i2.ClipboardService }, { type: Promise }, { type: undefined }, { type: i3.DeeplinkService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.iac.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/iac/base.iac.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { IACMessageDefinitionObjectV3, IACMessageType } from '@wallfree-dev/serializer'\nimport { Inject, Injectable } from '@angular/core'\nimport { UiEventElementsService } from '../ui-event-elements/ui-event-elements.service'\nimport { ClipboardService } from '../clipboard/clipboard.service'\nimport { SerializerV3Generator } from '../qr/qr-generators/serializer-v3-generator'\nimport { SerializerV3Handler } from '../qr/qr-handler/serializer-v3-handler'\nimport { SerializerV2Handler } from '../qr/qr-handler/serializer-v2-handler'\nimport { DeeplinkService } from '../deeplink/deeplink.service'\nimport { AppConfig, APP_CONFIG } from '../../config/app-config'\nimport { IACMessageHandler, IACMessageTransport, IACHandlerStatus, IACMessageWrapper } from './message-handler'\n\nexport type ScanAgainCallback = (progress?: number) => void\n\nexport type RelayMessage = string\n\n@Injectable()\nexport abstract class BaseIACService {\n  protected readonly handlers: IACMessageHandler<unknown>[]\n  private transport: IACMessageTransport | undefined = undefined\n  private scanAgainCallback: ScanAgainCallback | undefined = undefined\n\n  protected readonly serializerMessageHandlers: {\n    [key in IACMessageType]: (\n      deserializedSync: IACMessageWrapper<IACMessageDefinitionObjectV3[]>,\n      transport: IACMessageTransport,\n      scanAgainCallback: ScanAgainCallback\n    ) => Promise<boolean>\n  }\n\n  constructor(\n    protected readonly uiEventElementService: UiEventElementsService,\n    protected readonly clipboard: ClipboardService,\n    protected readonly isReady: Promise<void>,\n    protected readonly customHandlers: IACMessageHandler<unknown>[],\n    protected readonly deeplinkService: DeeplinkService,\n    @Inject(APP_CONFIG) protected readonly appConfig: AppConfig\n  ) {\n    this.serializerMessageHandlers = {\n      [IACMessageType.AccountShareRequest]: this.syncTypeNotSupportedAlert.bind(this),\n      [IACMessageType.AccountShareResponse]: this.syncTypeNotSupportedAlert.bind(this),\n      [IACMessageType.TransactionSignRequest]: this.syncTypeNotSupportedAlert.bind(this),\n      [IACMessageType.TransactionSignResponse]: this.syncTypeNotSupportedAlert.bind(this),\n      [IACMessageType.MessageSignRequest]: this.syncTypeNotSupportedAlert.bind(this),\n      [IACMessageType.MessageSignResponse]: this.syncTypeNotSupportedAlert.bind(this)\n    }\n\n    this.handlers = [\n      new SerializerV3Handler((deserializedSync: IACMessageWrapper<IACMessageDefinitionObjectV3[]>) => this.deserialize(deserializedSync)),\n      new SerializerV2Handler((deserializedSync: IACMessageWrapper<IACMessageDefinitionObjectV3[]>) => this.deserialize(deserializedSync))\n    ]\n\n    this.handlers.push(...customHandlers)\n  }\n\n  public async storeResult(\n    message: IACMessageWrapper<unknown>,\n    status: IACHandlerStatus,\n    transport: IACMessageTransport\n  ): Promise<IACHandlerStatus> {\n    console.debug('STORE_RESULT', message, status, transport)\n\n    return status\n  }\n\n  // check if we already have part, scanning same QR advances progress bar\n\n  public async handleRequest(\n    data: string,\n    transport: IACMessageTransport,\n    scanAgainCallback: ScanAgainCallback = (): void => undefined\n  ): Promise<IACHandlerStatus> {\n    this.transport = transport\n    this.scanAgainCallback = scanAgainCallback\n    await this.isReady\n    for (let i = 0; i < this.handlers.length; i++) {\n      const handler = this.handlers[i]\n      try {\n        const canHandle = await handler.canHandle(data)\n        if (canHandle) {\n          const handlerStatus: IACHandlerStatus = await handler.receive(data)\n          if (handlerStatus === IACHandlerStatus.SUCCESS) {\n            try {\n              const result: IACMessageWrapper<unknown> = await handler.getResult()\n              const status: IACHandlerStatus = IACHandlerStatus.SUCCESS\n              await handler.handleComplete()\n              await this.resetHandlers()\n\n              return this.storeResult(result, status, transport)\n            } catch (e) {\n              console.error('Error while handling result', e)\n              const dataSingle: string = (await handler.getDataSingle()) ?? data\n\n              await this.messageUnknownAlert(dataSingle, this.scanAgainCallback)\n              await this.resetHandlers()\n\n              return this.storeResult({ result: undefined, data: dataSingle }, IACHandlerStatus.UNSUPPORTED, transport)\n            }\n          } else if (handlerStatus === IACHandlerStatus.PARTIAL) {\n            scanAgainCallback(await handler.getProgress())\n\n            return this.storeResult({ result: data, data: await handler.getDataSingle() }, IACHandlerStatus.PARTIAL, transport)\n          }\n        }\n      } catch (handlerError) {\n        console.log(`Error while handling message in ${handler.name}`, handlerError)\n      }\n    }\n    await this.resetHandlers()\n\n    await this.messageUnknownAlert(data, this.scanAgainCallback)\n\n    return this.storeResult({ result: undefined, data }, IACHandlerStatus.UNSUPPORTED, this.transport)\n  }\n\n  public async resetHandlers(): Promise<void> {\n    await Promise.all(\n      this.handlers.map((handler) => {\n        handler.reset()\n      })\n    )\n  }\n\n  private async deserialize(deserializedSync: IACMessageWrapper<IACMessageDefinitionObjectV3[]>): Promise<IACHandlerStatus> {\n    const data = deserializedSync.result\n    if (data && data.length > 0) {\n      const groupedByType: { [key in IACMessageType]?: IACMessageDefinitionObjectV3[] } = data.reduce(\n        (grouped, message) => Object.assign(grouped, { [message.type]: (grouped[message.type] || []).concat(message) }),\n        {} as { [key in IACMessageType]?: IACMessageDefinitionObjectV3[] }\n      )\n\n      for (const type in groupedByType) {\n        if (type in IACMessageType) {\n          // TODO: Improve types\n          const typedType: IACMessageType = parseInt(type, 10)\n          // eslint-disable-next-line no-console\n          this.serializerMessageHandlers[typedType](\n            { result: groupedByType[typedType] ?? [], data: deserializedSync.data, context: deserializedSync.context },\n            this.transport,\n            this.scanAgainCallback\n          ).catch(console.error)\n        } else {\n          // TODO: Improve types\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-console\n          this.syncTypeNotSupportedAlert(deserializedSync, this.transport, this.scanAgainCallback).catch(console.error)\n\n          return IACHandlerStatus.UNSUPPORTED\n        }\n      }\n\n      return IACHandlerStatus.SUCCESS\n    } else {\n      throw new Error('Empty message received!')\n    }\n  }\n\n  protected async messageUnknownAlert(data: string, scanAgainCallback: ScanAgainCallback): Promise<void> {\n    const relayHandler = () => {\n      // eslint-disable-next-line no-console\n      this.relay(data).catch(console.error)\n    }\n\n    const copyHandler = () => {\n      // eslint-disable-next-line no-console\n      this.clipboard.copyAndShowToast(data).catch(console.error)\n    }\n\n    const cancelHandler = () => {\n      scanAgainCallback()\n    }\n\n    // eslint-disable-next-line no-console\n    this.uiEventElementService.showIACMessageUnknownAlert(relayHandler, copyHandler, cancelHandler).catch(console.error)\n  }\n\n  protected async syncTypeNotSupportedAlert(\n    messageWrapper: IACMessageWrapper<IACMessageDefinitionObjectV3[]>,\n    _transport: IACMessageTransport,\n    scanAgainCallback: ScanAgainCallback\n  ): Promise<boolean> {\n    const relayHandler = () => {\n      // eslint-disable-next-line no-console\n      this.relay(messageWrapper.data).catch(console.error)\n    }\n\n    const copyHandler = () => {\n      // eslint-disable-next-line no-console\n      this.clipboard.copyAndShowToast(messageWrapper.data).catch(console.error)\n    }\n\n    const cancelHandler = () => {\n      scanAgainCallback()\n    }\n\n    // eslint-disable-next-line no-console\n    this.uiEventElementService.showIACMessageNotSupportedAlert(relayHandler, copyHandler, cancelHandler).catch(console.error)\n\n    return false\n  }\n\n  private async serialize(messageDefinitionObject: IACMessageDefinitionObjectV3[], prefix: string): Promise<string> {\n    const generator = new SerializerV3Generator()\n    await generator.create(messageDefinitionObject, 100, 100)\n\n    return generator.getSingle(prefix)\n  }\n\n  /**\n   * This method should relay the message to the other app. The app is responsibe\n   * for navigating away from the scanner because scanning will not be resumed.\n   *\n   * @param data The data that will be relayed\n   */\n  public abstract relay(data: RelayMessage): Promise<void>\n}\n"]}

package/esm2022/lib/services/iac/message-handler-single.mjs

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { IACHandlerStatus, IACMessageHandler } from './message-handler';
+import * as i0 from "@angular/core";
+/**
+ * Handles requests that can only be in a single QR
+ */
+export class IACSinglePartHandler extends IACMessageHandler {
+    constructor() {
+        super();
+    }
+    async canHandle(data) {
+        const processed = await this.processData(data);
+        if (processed) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    async receive(data) {
+        const processed = await this.processData(data);
+        if (!processed) {
+            return IACHandlerStatus.UNSUPPORTED;
+        }
+        this.rawData = data;
+        this.payload = processed;
+        return IACHandlerStatus.SUCCESS;
+    }
+    async getProgress() {
+        return 1;
+    }
+    async getResult() {
+        return { result: this.payload, data: await this.getDataSingle() };
+    }
+    async getDataSingle() {
+        return this.rawData;
+    }
+    async reset() {
+        this.payload = undefined;
+        return;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACSinglePartHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACSinglePartHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACSinglePartHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/iac/message-handler.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export var IACMessageTransport;
+(function (IACMessageTransport) {
+    IACMessageTransport["QR_SCANNER"] = "QR_SCANNER";
+    IACMessageTransport["DEEPLINK"] = "DEEPLINK";
+    IACMessageTransport["PASTE"] = "CLIPBOARD";
+})(IACMessageTransport || (IACMessageTransport = {}));
+export var IACHandlerStatus;
+(function (IACHandlerStatus) {
+    IACHandlerStatus[IACHandlerStatus["SUCCESS"] = 0] = "SUCCESS";
+    IACHandlerStatus[IACHandlerStatus["PARTIAL"] = 1] = "PARTIAL";
+    IACHandlerStatus[IACHandlerStatus["UNSUPPORTED"] = 2] = "UNSUPPORTED";
+})(IACHandlerStatus || (IACHandlerStatus = {}));
+export class IACMessageHandler {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACMessageHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACMessageHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACMessageHandler, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/iac/qr-generator.mjs

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import { serializedDataToUrlString } from '../../utils/utils';
+import * as i0 from "@angular/core";
+export class IACQrGenerator {
+    async prefixSingle(data, prefix, parameter) {
+        return serializedDataToUrlString(data, `${prefix}://`, parameter);
+    }
+    static async canHandle(_data) {
+        return true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACQrGenerator, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACQrGenerator }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: IACQrGenerator, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXItZ2VuZXJhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi9zZXJ2aWNlcy9pYWMvcXItZ2VuZXJhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDMUMsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sbUJBQW1CLENBQUE7O0FBRzdELE1BQU0sT0FBZ0IsY0FBYztJQU14QixLQUFLLENBQUMsWUFBWSxDQUFDLElBQVksRUFBRSxNQUFjLEVBQUUsU0FBaUI7UUFDMUUsT0FBTyx5QkFBeUIsQ0FBQyxJQUFJLEVBQUUsR0FBRyxNQUFNLEtBQUssRUFBRSxTQUFTLENBQUMsQ0FBQTtJQUNuRSxDQUFDO0lBRU0sTUFBTSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsS0FBcUM7UUFDakUsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDOytHQVptQixjQUFjO21IQUFkLGNBQWM7OzRGQUFkLGNBQWM7a0JBRG5DLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJQUNNZXNzYWdlRGVmaW5pdGlvbk9iamVjdFYzIH0gZnJvbSAnQHdhbGxmcmVlLWRldi9zZXJpYWxpemVyJ1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5pbXBvcnQgeyBzZXJpYWxpemVkRGF0YVRvVXJsU3RyaW5nIH0gZnJvbSAnLi4vLi4vdXRpbHMvdXRpbHMnXG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBJQUNRckdlbmVyYXRvciB7XG4gIGFic3RyYWN0IGNyZWF0ZShkYXRhOiBJQUNNZXNzYWdlRGVmaW5pdGlvbk9iamVjdFYzW10sIG11bHRpRnJhZ21lbnRMZW5ndGg/OiBudW1iZXIsIHNpbmdsZUZyYWdtZW50TGVuZ3RoPzogbnVtYmVyKTogUHJvbWlzZTx2b2lkPlxuICBhYnN0cmFjdCBuZXh0UGFydCgpOiBQcm9taXNlPHN0cmluZz4gLy8gaGFuZGxlIGNvbXBsZXRlXG4gIGFic3RyYWN0IGdldFNpbmdsZShwcmVmaXg6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nPlxuICBhYnN0cmFjdCBnZXROdW1iZXJPZlBhcnRzKCk6IFByb21pc2U8bnVtYmVyPlxuXG4gIHByb3RlY3RlZCBhc3luYyBwcmVmaXhTaW5nbGUoZGF0YTogc3RyaW5nLCBwcmVmaXg6IHN0cmluZywgcGFyYW1ldGVyOiBzdHJpbmcpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIHJldHVybiBzZXJpYWxpemVkRGF0YVRvVXJsU3RyaW5nKGRhdGEsIGAke3ByZWZpeH06Ly9gLCBwYXJhbWV0ZXIpXG4gIH1cblxuICBwdWJsaWMgc3RhdGljIGFzeW5jIGNhbkhhbmRsZShfZGF0YTogSUFDTWVzc2FnZURlZmluaXRpb25PYmplY3RWM1tdKTogUHJvbWlzZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIHRydWVcbiAgfVxufVxuIl19