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

package/esm2022/lib/services/protocol/store/sub/sub-protocol-store.service.mjs

@@ -0,0 +1,174 @@
+import { Injectable } from '@angular/core';
+import { SubProtocolSymbols, MainProtocolSymbols, isNetworkEqual } from '@wallfree-dev/coinlib-core';
+import { erc20Tokens } from '@wallfree-dev/ethereum';
+import { getMainIdentifier } from '../../../../utils/protocol/protocol-identifier';
+import { splitProtocolNetworkIdentifier } from '../../../../utils/protocol/protocol-network-identifier';
+import { BaseProtocolStoreService } from '../base-protocol-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../environment/base-environment.service";
+import * as i2 from "../../../modules/controller/modules.controller";
+export class SubProtocolStoreService extends BaseProtocolStoreService {
+    constructor(environment, modulesController) {
+        super('SubProtocolService', environment, modulesController);
+    }
+    get ethTokenIdentifiers() {
+        if (this._ethTokenIdentifers === undefined) {
+            this._ethTokenIdentifers = new Set(Object.values(erc20Tokens).map((token) => token.identifier));
+        }
+        return this._ethTokenIdentifers;
+    }
+    async removeProtocols(identifiers) {
+        const identifiersSet = new Set(identifiers);
+        const mainIdentifiersSet = new Set(identifiers.map(getMainIdentifier));
+        const protocolKeys = Object.keys(await this.supportedProtocols)
+            .map((key) => {
+            const { protocol: protocolIdentifier } = splitProtocolNetworkIdentifier(key);
+            return identifiersSet.has(protocolIdentifier)
+                ? [key, 'fully']
+                : mainIdentifiersSet.has(protocolIdentifier)
+                    ? [key, 'partially']
+                    : undefined;
+        })
+            .filter((key) => key !== undefined);
+        protocolKeys.forEach(([key, mode]) => {
+            if (mode === 'fully') {
+                delete this._activeProtocols[key];
+                delete this._passiveProtocols[key];
+            }
+            else {
+                identifiers.forEach((identifier) => {
+                    // eslint-disable-next-line no-unused-expressions
+                    this._activeProtocols[key] && delete this._activeProtocols[key][identifier];
+                    // eslint-disable-next-line no-unused-expressions
+                    this._passiveProtocols[key] && delete this._passiveProtocols[key][identifier];
+                });
+            }
+        });
+        // reset supported protocols
+        this._supportedProtocols = undefined;
+    }
+    isIdentifierValid(identifier) {
+        const mainIdentifier = getMainIdentifier(identifier);
+        return (Object.values(SubProtocolSymbols).includes(identifier) ||
+            this.ethTokenIdentifiers.has(identifier) ||
+            (Object.values(MainProtocolSymbols).includes(mainIdentifier) && identifier !== mainIdentifier) ||
+            identifier.includes('-'));
+    }
+    async getProtocolByIdentifier(identifier, network, activeOnly = true, retry = true) {
+        try {
+            const mainIdentifier = getMainIdentifier(identifier);
+            const targetNetwork = await this.getTargetNetwork(mainIdentifier, network);
+            const protocolAndNetworkIdentifier = await this.getProtocolAndNetworkIdentifier(mainIdentifier, targetNetwork);
+            const subProtocolsMap = activeOnly ? this.activeProtocols : await this.supportedProtocols;
+            const found = (subProtocolsMap[protocolAndNetworkIdentifier] ?? {})[identifier];
+            if (!found && retry) {
+                const mainnetProtocol = await this.getProtocolByIdentifier(identifier, undefined, activeOnly, false);
+                if (mainnetProtocol === undefined) {
+                    const protocols = Object.values(subProtocolsMap).map((values) => values[identifier]);
+                    const filtered = await Promise.all(protocols.map(async (protocol) => {
+                        return protocol && (await protocol.getIdentifier()) === identifier ? protocol : undefined;
+                    }));
+                    return filtered.find((protocol) => protocol !== undefined);
+                }
+                return mainnetProtocol;
+            }
+            return found;
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.warn('[SubProtocolStore:getProtocolByIdentifer]', error);
+            return undefined;
+        }
+    }
+    async getNetworksForProtocol(identifier, activeOnly = true) {
+        const subProtocolsMap = activeOnly ? this.activeProtocols : await this.supportedProtocols;
+        const networks = await Promise.all(Object.values(subProtocolsMap).map(async (entry) => {
+            const protocol = entry[identifier];
+            return protocol ? (await protocol.getOptions()).network : undefined;
+        }));
+        return networks.filter((network) => network !== undefined);
+    }
+    async transformConfig(config) {
+        const [passiveProtocols, activeProtocols] = await Promise.all([
+            this.createSubProtocolMap(config.passiveSubProtocols),
+            this.createSubProtocolMap(config.activeSubProtocols)
+        ]);
+        return { ...config, passiveProtocols, activeProtocols };
+    }
+    async mergeProtocols(protocols1, protocols2) {
+        return this.mergeSubProtocolMaps(protocols1, protocols2);
+    }
+    async removeProtocolDuplicates() {
+        // if a sub protocol has been set as passive and active, it's considered active
+        const passiveEntries = Object.entries(this.passiveProtocols)
+            .map(([protocolAndNetworkIdentifier, subProtocols]) => Object.keys(subProtocols).map((subProtocol) => [protocolAndNetworkIdentifier, subProtocol]))
+            .reduce((flatten, toFlatten) => flatten.concat(toFlatten), []);
+        const filtered = {};
+        passiveEntries.forEach(([protocolAndNetworkIdentifier, subProtocolIdentifier]) => {
+            if (this.activeProtocols[protocolAndNetworkIdentifier] === undefined ||
+                this.activeProtocols[protocolAndNetworkIdentifier][subProtocolIdentifier] === undefined) {
+                if (filtered[protocolAndNetworkIdentifier] === undefined) {
+                    filtered[protocolAndNetworkIdentifier] = {};
+                }
+                filtered[protocolAndNetworkIdentifier][subProtocolIdentifier] =
+                    this.passiveProtocols[protocolAndNetworkIdentifier][subProtocolIdentifier];
+            }
+        });
+        this._passiveProtocols = filtered;
+    }
+    async createSubProtocolMap(protocols) {
+        const subProtocolMap = {};
+        for (const [protocol, subProtocol] of protocols) {
+            const [protocolIdentifier, protocolOptions, subProtocolIdentifier, subProtocolName, subProtocolOptions] = await Promise.all([
+                protocol.getIdentifier(),
+                protocol.getOptions(),
+                subProtocol.getIdentifier(),
+                subProtocol.getName(),
+                subProtocol.getOptions()
+            ]);
+            if (!subProtocolIdentifier.startsWith(protocolIdentifier)) {
+                throw new Error(`Sub protocol ${subProtocolName} is not supported for protocol ${protocolIdentifier}.`);
+            }
+            if (!isNetworkEqual(protocolOptions.network, subProtocolOptions.network)) {
+                throw new Error(`Sub protocol ${subProtocolName} must have the same network as the main protocol.`);
+            }
+            const protocolAndNetworkIdentifier = await this.getProtocolAndNetworkIdentifier(protocol);
+            if (subProtocolMap[protocolAndNetworkIdentifier] === undefined) {
+                subProtocolMap[protocolAndNetworkIdentifier] = {};
+            }
+            subProtocolMap[protocolAndNetworkIdentifier][subProtocolIdentifier] = subProtocol;
+        }
+        return subProtocolMap;
+    }
+    async mergeSubProtocolMaps(first, second) {
+        if (Array.isArray(first) && Array.isArray(second)) {
+            return this.createSubProtocolMap(first.concat(second));
+        }
+        const firstMap = Array.isArray(first) ? await this.createSubProtocolMap(first) : first;
+        const secondMap = Array.isArray(second) ? await this.createSubProtocolMap(second) : second;
+        const mergedMap = {};
+        Object.entries(firstMap)
+            .concat(Object.entries(secondMap))
+            .forEach(([protocolAndNetworkIdentifier, subProtocols]) => {
+            if (mergedMap[protocolAndNetworkIdentifier] === undefined) {
+                mergedMap[protocolAndNetworkIdentifier] = subProtocols;
+            }
+            else {
+                mergedMap[protocolAndNetworkIdentifier] = {
+                    ...mergedMap[protocolAndNetworkIdentifier],
+                    ...subProtocols
+                };
+            }
+        });
+        return mergedMap;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SubProtocolStoreService, deps: [{ token: i1.BaseEnvironmentService }, { token: i2.ModulesController }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SubProtocolStoreService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SubProtocolStoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.BaseEnvironmentService }, { type: i2.ModulesController }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sub-protocol-store.service.js","sourceRoot":"","sources":["../../../../../../../src/lib/services/protocol/store/sub/sub-protocol-store.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport {\n  ICoinProtocol,\n  ICoinSubProtocol,\n  ProtocolNetwork,\n  SubProtocolSymbols,\n  MainProtocolSymbols,\n  isNetworkEqual\n} from '@wallfree-dev/coinlib-core'\nimport { erc20Tokens } from '@wallfree-dev/ethereum'\nimport { getMainIdentifier } from '../../../../utils/protocol/protocol-identifier'\nimport { splitProtocolNetworkIdentifier } from '../../../../utils/protocol/protocol-network-identifier'\nimport { Token } from '../../../../types/Token'\nimport { BaseProtocolStoreService, BaseProtocolStoreConfig } from '../base-protocol-store.service'\nimport { ModulesController } from '../../../modules/controller/modules.controller'\nimport { BaseEnvironmentService } from '../../../environment/base-environment.service'\n\nexport interface SubProtocolsMap {\n  [key: string]: {\n    [subProtocolIdentifier in SubProtocolSymbols]?: ICoinSubProtocol\n  }\n}\n\nexport interface SubProtocolStoreConfig {\n  passiveSubProtocols: [ICoinProtocol, ICoinSubProtocol][]\n  activeSubProtocols: [ICoinProtocol, ICoinSubProtocol][]\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SubProtocolStoreService extends BaseProtocolStoreService<\n  ICoinSubProtocol,\n  SubProtocolSymbols,\n  SubProtocolsMap,\n  SubProtocolStoreConfig\n> {\n  private _ethTokenIdentifers: Set<string> | undefined\n\n  constructor(environment: BaseEnvironmentService, modulesController: ModulesController) {\n    super('SubProtocolService', environment, modulesController)\n  }\n\n  private get ethTokenIdentifiers(): Set<string> {\n    if (this._ethTokenIdentifers === undefined) {\n      this._ethTokenIdentifers = new Set(Object.values(erc20Tokens).map((token: Token) => token.identifier))\n    }\n\n    return this._ethTokenIdentifers\n  }\n\n  public async removeProtocols(identifiers: SubProtocolSymbols[]): Promise<void> {\n    const identifiersSet: Set<string> = new Set(identifiers)\n    const mainIdentifiersSet: Set<string> = new Set(identifiers.map(getMainIdentifier))\n    const protocolKeys = Object.keys(await this.supportedProtocols)\n      .map((key: string): [string, 'fully' | 'partially'] | undefined => {\n        const { protocol: protocolIdentifier } = splitProtocolNetworkIdentifier(key)\n\n        return identifiersSet.has(protocolIdentifier)\n          ? [key, 'fully']\n          : mainIdentifiersSet.has(protocolIdentifier)\n          ? [key, 'partially']\n          : undefined\n      })\n      .filter((key) => key !== undefined)\n\n    protocolKeys.forEach(([key, mode]) => {\n      if (mode === 'fully') {\n        delete this._activeProtocols[key]\n        delete this._passiveProtocols[key]\n      } else {\n        identifiers.forEach((identifier: SubProtocolSymbols) => {\n          // eslint-disable-next-line no-unused-expressions\n          this._activeProtocols[key] && delete this._activeProtocols[key][identifier]\n          // eslint-disable-next-line no-unused-expressions\n          this._passiveProtocols[key] && delete this._passiveProtocols[key][identifier]\n        })\n      }\n    })\n\n    // reset supported protocols\n    this._supportedProtocols = undefined\n  }\n\n  public isIdentifierValid(identifier: string): boolean {\n    const mainIdentifier = getMainIdentifier(identifier as SubProtocolSymbols)\n\n    return (\n      Object.values(SubProtocolSymbols).includes(identifier as SubProtocolSymbols) ||\n      this.ethTokenIdentifiers.has(identifier) ||\n      (Object.values(MainProtocolSymbols).includes(mainIdentifier) && identifier !== mainIdentifier) ||\n      identifier.includes('-')\n    )\n  }\n\n  public async getProtocolByIdentifier(\n    identifier: SubProtocolSymbols,\n    network?: ProtocolNetwork | string,\n    activeOnly: boolean = true,\n    retry: boolean = true\n  ): Promise<ICoinSubProtocol | undefined> {\n    try {\n      const mainIdentifier: MainProtocolSymbols = getMainIdentifier(identifier)\n      const targetNetwork: ProtocolNetwork | string | undefined = await this.getTargetNetwork(mainIdentifier, network)\n      const protocolAndNetworkIdentifier: string = await this.getProtocolAndNetworkIdentifier(mainIdentifier, targetNetwork)\n\n      const subProtocolsMap: SubProtocolsMap = activeOnly ? this.activeProtocols : await this.supportedProtocols\n      const found = (subProtocolsMap[protocolAndNetworkIdentifier] ?? {})[identifier]\n\n      if (!found && retry) {\n        const mainnetProtocol: ICoinSubProtocol | undefined = await this.getProtocolByIdentifier(identifier, undefined, activeOnly, false)\n        if (mainnetProtocol === undefined) {\n          const protocols: (ICoinSubProtocol | undefined)[] = Object.values(subProtocolsMap).map((values) => values[identifier])\n          const filtered: (ICoinSubProtocol | undefined)[] = await Promise.all(\n            protocols.map(async (protocol: ICoinSubProtocol | undefined) => {\n              return protocol && (await protocol.getIdentifier()) === identifier ? protocol : undefined\n            })\n          )\n\n          return filtered.find((protocol: ICoinSubProtocol | undefined) => protocol !== undefined)\n        }\n\n        return mainnetProtocol\n      }\n\n      return found\n    } catch (error) {\n      // eslint-disable-next-line no-console\n      console.warn('[SubProtocolStore:getProtocolByIdentifer]', error)\n\n      return undefined\n    }\n  }\n\n  public async getNetworksForProtocol(identifier: SubProtocolSymbols, activeOnly: boolean = true): Promise<ProtocolNetwork[]> {\n    const subProtocolsMap: SubProtocolsMap = activeOnly ? this.activeProtocols : await this.supportedProtocols\n    const networks: (ProtocolNetwork | undefined)[] = await Promise.all(\n      Object.values(subProtocolsMap).map(async (entry) => {\n        const protocol = entry[identifier]\n\n        return protocol ? (await protocol.getOptions()).network : undefined\n      })\n    )\n\n    return networks.filter((network: ProtocolNetwork | undefined) => network !== undefined)\n  }\n\n  protected async transformConfig(config: SubProtocolStoreConfig): Promise<BaseProtocolStoreConfig<SubProtocolsMap>> {\n    const [passiveProtocols, activeProtocols]: SubProtocolsMap[] = await Promise.all([\n      this.createSubProtocolMap(config.passiveSubProtocols),\n      this.createSubProtocolMap(config.activeSubProtocols)\n    ])\n\n    return { ...config, passiveProtocols, activeProtocols }\n  }\n\n  protected async mergeProtocols(protocols1: SubProtocolsMap, protocols2: SubProtocolsMap): Promise<SubProtocolsMap> {\n    return this.mergeSubProtocolMaps(protocols1, protocols2)\n  }\n\n  protected async removeProtocolDuplicates(): Promise<void> {\n    // if a sub protocol has been set as passive and active, it's considered active\n    const passiveEntries: [string, SubProtocolSymbols][] = Object.entries(this.passiveProtocols)\n      .map(([protocolAndNetworkIdentifier, subProtocols]: [string, { [subProtocolIdentifier in SubProtocolSymbols]?: ICoinSubProtocol }]) =>\n        Object.keys(subProtocols).map((subProtocol: string) => [protocolAndNetworkIdentifier, subProtocol] as [string, SubProtocolSymbols])\n      )\n      .reduce((flatten: [string, SubProtocolSymbols][], toFlatten: [string, SubProtocolSymbols][]) => flatten.concat(toFlatten), [])\n\n    const filtered: SubProtocolsMap = {}\n\n    passiveEntries.forEach(([protocolAndNetworkIdentifier, subProtocolIdentifier]: [string, SubProtocolSymbols]) => {\n      if (\n        this.activeProtocols[protocolAndNetworkIdentifier] === undefined ||\n        this.activeProtocols[protocolAndNetworkIdentifier][subProtocolIdentifier] === undefined\n      ) {\n        if (filtered[protocolAndNetworkIdentifier] === undefined) {\n          filtered[protocolAndNetworkIdentifier] = {}\n        }\n\n        filtered[protocolAndNetworkIdentifier][subProtocolIdentifier] =\n          this.passiveProtocols[protocolAndNetworkIdentifier][subProtocolIdentifier]\n      }\n    })\n\n    this._passiveProtocols = filtered\n  }\n\n  private async createSubProtocolMap(protocols: [ICoinProtocol, ICoinSubProtocol][]): Promise<SubProtocolsMap> {\n    const subProtocolMap: SubProtocolsMap = {}\n\n    for (const [protocol, subProtocol] of protocols) {\n      const [protocolIdentifier, protocolOptions, subProtocolIdentifier, subProtocolName, subProtocolOptions] = await Promise.all([\n        protocol.getIdentifier(),\n        protocol.getOptions(),\n        subProtocol.getIdentifier(),\n        subProtocol.getName(),\n        subProtocol.getOptions()\n      ])\n\n      if (!subProtocolIdentifier.startsWith(protocolIdentifier)) {\n        throw new Error(`Sub protocol ${subProtocolName} is not supported for protocol ${protocolIdentifier}.`)\n      }\n\n      if (!isNetworkEqual(protocolOptions.network, subProtocolOptions.network)) {\n        throw new Error(`Sub protocol ${subProtocolName} must have the same network as the main protocol.`)\n      }\n\n      const protocolAndNetworkIdentifier: string = await this.getProtocolAndNetworkIdentifier(protocol)\n\n      if (subProtocolMap[protocolAndNetworkIdentifier] === undefined) {\n        subProtocolMap[protocolAndNetworkIdentifier] = {}\n      }\n\n      subProtocolMap[protocolAndNetworkIdentifier][subProtocolIdentifier as SubProtocolSymbols] = subProtocol\n    }\n\n    return subProtocolMap\n  }\n\n  private async mergeSubProtocolMaps(\n    first: [ICoinProtocol, ICoinSubProtocol][] | SubProtocolsMap,\n    second: [ICoinProtocol, ICoinSubProtocol][] | SubProtocolsMap\n  ): Promise<SubProtocolsMap> {\n    if (Array.isArray(first) && Array.isArray(second)) {\n      return this.createSubProtocolMap(first.concat(second))\n    }\n\n    const firstMap: SubProtocolsMap = Array.isArray(first) ? await this.createSubProtocolMap(first) : first\n    const secondMap: SubProtocolsMap = Array.isArray(second) ? await this.createSubProtocolMap(second) : second\n\n    const mergedMap: SubProtocolsMap = {}\n\n    Object.entries(firstMap)\n      .concat(Object.entries(secondMap))\n      .forEach(\n        ([protocolAndNetworkIdentifier, subProtocols]: [string, { [subProtocolIdentifier in SubProtocolSymbols]?: ICoinSubProtocol }]) => {\n          if (mergedMap[protocolAndNetworkIdentifier] === undefined) {\n            mergedMap[protocolAndNetworkIdentifier] = subProtocols\n          } else {\n            mergedMap[protocolAndNetworkIdentifier] = {\n              ...mergedMap[protocolAndNetworkIdentifier],\n              ...subProtocols\n            }\n          }\n        }\n      )\n\n    return mergedMap\n  }\n}\n"]}

package/esm2022/lib/services/qr/qr-generators/bc-ur-generator.mjs

@@ -0,0 +1,127 @@
+import * as bs58check from 'bs58check';
+// import * as ecc from 'tiny-secp256k1'
+import * as ecc from '@bitcoinerlab/secp256k1';
+import { BIP32Factory } from 'bip32';
+// import ecc from 'tiny-secp256k1'
+import { CryptoKeypath, CryptoHDKey, CryptoOutput, ScriptExpressions, CryptoAccount, PathComponent, CryptoPSBT, patchTags } from '@keystonehq/bc-ur-registry';
+import { bufferFrom, MainProtocolSymbols } from '@wallfree-dev/coinlib-core';
+import { IACMessageType } from '@wallfree-dev/serializer';
+import { IACQrGenerator } from '../../iac/qr-generator';
+import { ScriptExpression } from '@keystonehq/bc-ur-registry/dist/ScriptExpression';
+class ExtendedPublicKey {
+    constructor(extendedPublicKey) {
+        this.rawKey = bs58check.decode(extendedPublicKey).slice(4);
+    }
+    toXpub() {
+        return this.addPrefix('0488b21e');
+    }
+    toYPub() {
+        return this.addPrefix('049d7cb2');
+    }
+    toZPub() {
+        return this.addPrefix('04b24746');
+    }
+    getRawKey() {
+        return this.rawKey;
+    }
+    addPrefix(prefix) {
+        const data = Buffer.concat([bufferFrom(prefix, 'hex'), this.rawKey]);
+        return bs58check.encode(data);
+    }
+}
+export class BCURTypesGenerator extends IACQrGenerator {
+    constructor() {
+        super();
+        this.bip32 = BIP32Factory(ecc);
+    }
+    async create(data, multiFragmentLength, singleFragmentLength) {
+        if (!(await BCURTypesGenerator.canHandle(data))) {
+            return;
+        }
+        const element = data[0];
+        if (element.type === IACMessageType.AccountShareResponse) {
+            this.data = await this.generateCryptoAccountMessage(element);
+        }
+        else if (element.type === IACMessageType.TransactionSignResponse) {
+            this.data = await this.generatePSBTMessage(element);
+        }
+        else {
+            throw new Error('Not Supported');
+        }
+        // We first try to create a larger "single chunk" fragment
+        this.encoder = this.data.toUREncoder(singleFragmentLength);
+        // If this is not possible, we use the multiFragmentLength
+        if (this.encoder.fragmentsLength !== 1) {
+            this.encoder = this.data.toUREncoder(multiFragmentLength);
+        }
+    }
+    static async canHandle(data) {
+        if (data.length === 1) {
+            const element = data[0];
+            return ((element.protocol === MainProtocolSymbols.BTC_SEGWIT || element.protocol === MainProtocolSymbols.BTC_TAPROOT) &&
+                [IACMessageType.AccountShareResponse, IACMessageType.TransactionSignResponse].includes(element.type));
+        }
+        return false;
+    }
+    async nextPart() {
+        if (this.encoder) {
+            return this.encoder.nextPart().toUpperCase();
+        }
+        else {
+            return '';
+        }
+    }
+    async getSingle() {
+        if (this.data) {
+            return this.data.toUREncoder(Number.MAX_SAFE_INTEGER).nextPart();
+        }
+        else {
+            return '';
+        }
+    }
+    async getNumberOfParts() {
+        return this.encoder?.fragmentsLength ?? 0;
+    }
+    async generateCryptoAccountMessage(data) {
+        const account = data.payload;
+        const extendedPublicKey = this.bip32.fromBase58(new ExtendedPublicKey(account.publicKey).toXpub());
+        const cryptoKeyPathComponents = [];
+        for (const component of account.derivationPath.split('/')) {
+            if (component === 'm')
+                continue;
+            const index = parseInt(component, 10);
+            const hardened = component.endsWith('h') || component.endsWith("'");
+            cryptoKeyPathComponents.push(new PathComponent({ index, hardened }));
+        }
+        const parentFingerprint = Buffer.alloc(4);
+        parentFingerprint.writeUInt32BE(extendedPublicKey.parentFingerprint, 0);
+        const isTaproot = data.protocol === MainProtocolSymbols.BTC_TAPROOT;
+        let scriptExpressions = [];
+        if (isTaproot) {
+            const TR = new ScriptExpression(409, 'tr');
+            patchTags([409]);
+            scriptExpressions = [TR];
+        }
+        else {
+            scriptExpressions = [ScriptExpressions.WITNESS_PUBLIC_KEY_HASH];
+        }
+        const cryptoAccount = new CryptoAccount(bufferFrom(account.masterFingerprint, 'hex'), [
+            new CryptoOutput(scriptExpressions, new CryptoHDKey({
+                isMaster: false,
+                key: Buffer.from(extendedPublicKey.publicKey),
+                chainCode: Buffer.from(extendedPublicKey.chainCode),
+                origin: new CryptoKeypath(cryptoKeyPathComponents, Buffer.from(extendedPublicKey.fingerprint), extendedPublicKey.depth),
+                parentFingerprint,
+                name: account.groupLabel
+            }))
+        ]);
+        return cryptoAccount;
+    }
+    async generatePSBTMessage(data) {
+        const transaction = data.payload;
+        const psbt = bufferFrom(transaction.transaction, 'hex');
+        const cryptoPSBT = new CryptoPSBT(psbt);
+        return cryptoPSBT;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bc-ur-generator.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr/qr-generators/bc-ur-generator.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-classes-per-file */\nimport { UREncoder } from '@ngraveio/bc-ur'\nimport * as bs58check from 'bs58check'\n// import * as ecc from 'tiny-secp256k1'\nimport * as ecc from '@bitcoinerlab/secp256k1'\n\nimport { BIP32Factory } from 'bip32'\n// import ecc from 'tiny-secp256k1'\n\nimport {\n  CryptoKeypath,\n  CryptoHDKey,\n  CryptoOutput,\n  ScriptExpressions,\n  CryptoAccount,\n  PathComponent,\n  CryptoPSBT,\n  patchTags\n} from '@keystonehq/bc-ur-registry'\nimport { BitcoinSegwitTransactionSignResponse } from '@wallfree-dev/bitcoin'\nimport { bufferFrom, MainProtocolSymbols } from '@wallfree-dev/coinlib-core'\nimport { AccountShareResponse, IACMessageDefinitionObjectV3, IACMessageType } from '@wallfree-dev/serializer'\n\nimport { IACQrGenerator } from '../../iac/qr-generator'\nimport { ScriptExpression } from '@keystonehq/bc-ur-registry/dist/ScriptExpression'\n\nclass ExtendedPublicKey {\n  private readonly rawKey: Buffer\n\n  constructor(extendedPublicKey: string) {\n    this.rawKey = bs58check.decode(extendedPublicKey).slice(4)\n  }\n\n  public toXpub() {\n    return this.addPrefix('0488b21e')\n  }\n\n  public toYPub() {\n    return this.addPrefix('049d7cb2')\n  }\n\n  public toZPub() {\n    return this.addPrefix('04b24746')\n  }\n\n  public getRawKey() {\n    return this.rawKey\n  }\n\n  private addPrefix(prefix: string) {\n    const data = Buffer.concat([bufferFrom(prefix, 'hex'), this.rawKey])\n\n    return bs58check.encode(data)\n  }\n}\n\nexport class BCURTypesGenerator extends IACQrGenerator {\n  private encoder: UREncoder | undefined\n\n  private data: CryptoAccount | CryptoPSBT | undefined\n  private readonly bip32 = BIP32Factory(ecc)\n\n  constructor() {\n    super()\n  }\n\n  public async create(data: IACMessageDefinitionObjectV3[], multiFragmentLength: number, singleFragmentLength: number): Promise<void> {\n    if (!(await BCURTypesGenerator.canHandle(data))) {\n      return\n    }\n\n    const element = data[0]\n\n    if (element.type === IACMessageType.AccountShareResponse) {\n      this.data = await this.generateCryptoAccountMessage(element)\n    } else if (element.type === IACMessageType.TransactionSignResponse) {\n      this.data = await this.generatePSBTMessage(element)\n    } else {\n      throw new Error('Not Supported')\n    }\n\n    // We first try to create a larger \"single chunk\" fragment\n    this.encoder = this.data.toUREncoder(singleFragmentLength)\n\n    // If this is not possible, we use the multiFragmentLength\n    if (this.encoder.fragmentsLength !== 1) {\n      this.encoder = this.data.toUREncoder(multiFragmentLength)\n    }\n  }\n\n  public static async canHandle(data: IACMessageDefinitionObjectV3[]): Promise<boolean> {\n    if (data.length === 1) {\n      const element = data[0]\n\n      return (\n        (element.protocol === MainProtocolSymbols.BTC_SEGWIT || element.protocol === MainProtocolSymbols.BTC_TAPROOT) &&\n        [IACMessageType.AccountShareResponse, IACMessageType.TransactionSignResponse].includes(element.type)\n      )\n    }\n\n    return false\n  }\n\n  public async nextPart(): Promise<string> {\n    if (this.encoder) {\n      return this.encoder.nextPart().toUpperCase()\n    } else {\n      return ''\n    }\n  }\n\n  public async getSingle(): Promise<string> {\n    if (this.data) {\n      return this.data.toUREncoder(Number.MAX_SAFE_INTEGER).nextPart()\n    } else {\n      return ''\n    }\n  }\n\n  public async getNumberOfParts(): Promise<number> {\n    return this.encoder?.fragmentsLength ?? 0\n  }\n\n  private async generateCryptoAccountMessage(data: IACMessageDefinitionObjectV3) {\n    const account = data.payload as AccountShareResponse\n\n    const extendedPublicKey = this.bip32.fromBase58(new ExtendedPublicKey(account.publicKey).toXpub())\n\n    const cryptoKeyPathComponents = []\n    for (const component of account.derivationPath.split('/')) {\n      if (component === 'm') continue\n      const index = parseInt(component, 10)\n      const hardened = component.endsWith('h') || component.endsWith(\"'\")\n      cryptoKeyPathComponents.push(new PathComponent({ index, hardened }))\n    }\n\n    const parentFingerprint = Buffer.alloc(4)\n    parentFingerprint.writeUInt32BE(extendedPublicKey.parentFingerprint, 0)\n\n    const isTaproot = data.protocol === MainProtocolSymbols.BTC_TAPROOT\n\n    let scriptExpressions: ScriptExpression[] = []\n\n    if (isTaproot) {\n      const TR = new ScriptExpression(409, 'tr')\n      patchTags([409])\n      scriptExpressions = [TR]\n    } else {\n      scriptExpressions = [ScriptExpressions.WITNESS_PUBLIC_KEY_HASH]\n    }\n\n    const cryptoAccount = new CryptoAccount(bufferFrom(account.masterFingerprint, 'hex'), [\n      new CryptoOutput(\n        scriptExpressions,\n        new CryptoHDKey({\n          isMaster: false,\n          key: Buffer.from(extendedPublicKey.publicKey),\n          chainCode: Buffer.from(extendedPublicKey.chainCode),\n          origin: new CryptoKeypath(cryptoKeyPathComponents, Buffer.from(extendedPublicKey.fingerprint), extendedPublicKey.depth),\n          parentFingerprint,\n          name: account.groupLabel\n        })\n      )\n    ])\n\n    return cryptoAccount\n  }\n\n  private async generatePSBTMessage(data: IACMessageDefinitionObjectV3): Promise<CryptoPSBT> {\n    const transaction = data.payload as BitcoinSegwitTransactionSignResponse\n\n    const psbt = bufferFrom(transaction.transaction, 'hex')\n\n    const cryptoPSBT = new CryptoPSBT(psbt)\n\n    return cryptoPSBT\n  }\n}\n"]}

package/esm2022/lib/services/qr/qr-generators/metamask-generator.mjs

@@ -0,0 +1,117 @@
+import * as uuid from 'uuid';
+import { CryptoKeypath, PathComponent, CryptoHDKey } from '@keystonehq/bc-ur-registry';
+import { ETHSignature } from '@keystonehq/bc-ur-registry-eth';
+import { TransactionFactory } from '@ethereumjs/tx';
+import { MainProtocolSymbols } from '@wallfree-dev/coinlib-core';
+import { IACMessageType } from '@wallfree-dev/serializer';
+// import * as ecc from 'tiny-secp256k1'
+import * as ecc from '@bitcoinerlab/secp256k1';
+import { BIP32Factory } from 'bip32';
+import { IACQrGenerator } from '../../iac/qr-generator';
+import { TEMP_MM_REQUEST_IDS } from '../../../utils/utils';
+export class MetamaskGenerator extends IACQrGenerator {
+    constructor() {
+        super();
+        this.bip32 = BIP32Factory(ecc);
+    }
+    async create(data, multiFragmentLength, singleFragmentLength) {
+        if (!(await MetamaskGenerator.canHandle(data))) {
+            return;
+        }
+        const element = data[0];
+        if (element.type === IACMessageType.AccountShareResponse) {
+            this.data = await this.generateCryptoAccountMessage(element);
+        }
+        else if (element.type === IACMessageType.TransactionSignResponse) {
+            this.data = await this.generateMessage(element);
+        }
+        else if (element.type === IACMessageType.MessageSignResponse) {
+            this.data = await this.generateMessage(element);
+        }
+        else {
+            throw new Error('Not Supported');
+        }
+        // We first try to create a larger "single chunk" fragment
+        this.encoder = this.data.toUREncoder(singleFragmentLength);
+        // If this is not possible, we use the multiFragmentLength
+        if (this.encoder.fragmentsLength !== 1) {
+            this.encoder = this.data.toUREncoder(multiFragmentLength);
+        }
+    }
+    static async canHandle(data) {
+        if (data.length === 1) {
+            const element = data[0];
+            return ((element.protocol === MainProtocolSymbols.ETH || element.protocol === MainProtocolSymbols.OPTIMISM) &&
+                [IACMessageType.AccountShareResponse, IACMessageType.TransactionSignResponse, IACMessageType.MessageSignResponse].includes(element.type));
+        }
+        return false;
+    }
+    async nextPart() {
+        if (this.encoder) {
+            return this.encoder.nextPart().toUpperCase();
+        }
+        else {
+            return '';
+        }
+    }
+    async getSingle() {
+        if (this.data) {
+            return this.data.toUREncoder(Number.MAX_SAFE_INTEGER).nextPart();
+        }
+        else {
+            return '';
+        }
+    }
+    async getNumberOfParts() {
+        return this.encoder?.fragmentsLength ?? 0;
+    }
+    async generateCryptoAccountMessage(data) {
+        const account = data.payload;
+        const extendedPublicKey = this.bip32.fromBase58(account.publicKey);
+        const cryptoKeyPathComponents = [];
+        for (const component of account.derivationPath.split('/')) {
+            if (component === 'm')
+                continue;
+            const index = parseInt(component, 10);
+            const hardened = component.endsWith('h') || component.endsWith("'");
+            cryptoKeyPathComponents.push(new PathComponent({ index, hardened }));
+        }
+        const cryptoHDKey = new CryptoHDKey({
+            isMaster: false,
+            key: Buffer.from(extendedPublicKey.publicKey),
+            chainCode: Buffer.from(extendedPublicKey.chainCode),
+            origin: new CryptoKeypath(cryptoKeyPathComponents, Buffer.from(extendedPublicKey.fingerprint)), // TODO: Define which FP we use
+            parentFingerprint: Buffer.from(account.masterFingerprint),
+            name: `AirGap - ${account.groupLabel}`
+        });
+        return cryptoHDKey;
+    }
+    async generateMessage(data) {
+        let rlpSignatureData;
+        if (data.payload.transaction) {
+            const transaction = data.payload;
+            const tx = TransactionFactory.fromSerializedData(Buffer.from(transaction.transaction, 'hex'));
+            const r = Buffer.from(tx.r?.toString(16, 32), 'hex');
+            const s = Buffer.from(tx.s?.toString(16, 32), 'hex');
+            const v = Buffer.from(tx.v?.toString(16, 2), 'hex');
+            rlpSignatureData = Buffer.concat([r, s, v]);
+        }
+        else {
+            const transaction = data.payload;
+            rlpSignatureData = Buffer.from(transaction.signature.slice(2), 'hex');
+        }
+        if (!rlpSignatureData) {
+            throw new Error('Empty signature');
+        }
+        // TODO: This should be moved to a higher level, probably the "iac.service", and properly store context for any kind of request.
+        const IDs = JSON.parse(localStorage.getItem(TEMP_MM_REQUEST_IDS) ?? '{}');
+        const id = IDs[data.id];
+        // TODO: We cannot immediately delete the ID because this method might be called multiple times
+        // delete IDs[data.id]
+        // localStorage.setItem('TEMP-MM-REQUEST-IDS', JSON.stringify(IDs))
+        const idBuffer = id ? Buffer.from(id, 'hex') : uuid.parse(uuid.v4());
+        const ethSignature = new ETHSignature(rlpSignatureData, Buffer.from(idBuffer));
+        return ethSignature;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metamask-generator.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr/qr-generators/metamask-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import { UREncoder } from '@ngraveio/bc-ur'\nimport * as uuid from 'uuid'\n\nimport { CryptoKeypath, PathComponent, CryptoHDKey } from '@keystonehq/bc-ur-registry'\nimport { ETHSignature } from '@keystonehq/bc-ur-registry-eth'\nimport { TransactionFactory } from '@ethereumjs/tx'\nimport { MainProtocolSymbols } from '@wallfree-dev/coinlib-core'\nimport { EthereumTransactionSignResponse } from '@wallfree-dev/ethereum'\nimport { AccountShareResponse, IACMessageDefinitionObjectV3, IACMessageType, MessageSignResponse } from '@wallfree-dev/serializer'\n\n// import * as ecc from 'tiny-secp256k1'\nimport * as ecc from '@bitcoinerlab/secp256k1'\n\nimport { BIP32Factory } from 'bip32'\n\nimport { IACQrGenerator } from '../../iac/qr-generator'\n\nimport { TEMP_MM_REQUEST_IDS } from '../../../utils/utils'\n\nexport class MetamaskGenerator extends IACQrGenerator {\n  private encoder: UREncoder | undefined\n\n  private data: CryptoHDKey | ETHSignature | undefined\n  private readonly bip32 = BIP32Factory(ecc)\n\n  constructor() {\n    super()\n  }\n\n  public async create(data: IACMessageDefinitionObjectV3[], multiFragmentLength: number, singleFragmentLength: number): Promise<void> {\n    if (!(await MetamaskGenerator.canHandle(data))) {\n      return\n    }\n\n    const element = data[0]\n\n    if (element.type === IACMessageType.AccountShareResponse) {\n      this.data = await this.generateCryptoAccountMessage(element)\n    } else if (element.type === IACMessageType.TransactionSignResponse) {\n      this.data = await this.generateMessage(element)\n    } else if (element.type === IACMessageType.MessageSignResponse) {\n      this.data = await this.generateMessage(element)\n    } else {\n      throw new Error('Not Supported')\n    }\n\n    // We first try to create a larger \"single chunk\" fragment\n    this.encoder = this.data.toUREncoder(singleFragmentLength)\n\n    // If this is not possible, we use the multiFragmentLength\n    if (this.encoder.fragmentsLength !== 1) {\n      this.encoder = this.data.toUREncoder(multiFragmentLength)\n    }\n  }\n\n  public static async canHandle(data: IACMessageDefinitionObjectV3[]): Promise<boolean> {\n    if (data.length === 1) {\n      const element = data[0]\n\n      return (\n        (element.protocol === MainProtocolSymbols.ETH || element.protocol === MainProtocolSymbols.OPTIMISM) &&\n        [IACMessageType.AccountShareResponse, IACMessageType.TransactionSignResponse, IACMessageType.MessageSignResponse].includes(\n          element.type\n        )\n      )\n    }\n\n    return false\n  }\n\n  public async nextPart(): Promise<string> {\n    if (this.encoder) {\n      return this.encoder.nextPart().toUpperCase()\n    } else {\n      return ''\n    }\n  }\n\n  public async getSingle(): Promise<string> {\n    if (this.data) {\n      return this.data.toUREncoder(Number.MAX_SAFE_INTEGER).nextPart()\n    } else {\n      return ''\n    }\n  }\n\n  public async getNumberOfParts(): Promise<number> {\n    return this.encoder?.fragmentsLength ?? 0\n  }\n\n  private async generateCryptoAccountMessage(data: IACMessageDefinitionObjectV3): Promise<CryptoHDKey> {\n    const account = data.payload as AccountShareResponse\n    const extendedPublicKey = this.bip32.fromBase58(account.publicKey)\n\n    const cryptoKeyPathComponents = []\n    for (const component of account.derivationPath.split('/')) {\n      if (component === 'm') continue\n      const index = parseInt(component, 10)\n      const hardened = component.endsWith('h') || component.endsWith(\"'\")\n      cryptoKeyPathComponents.push(new PathComponent({ index, hardened }))\n    }\n\n    const cryptoHDKey = new CryptoHDKey({\n      isMaster: false,\n      key: Buffer.from(extendedPublicKey.publicKey),\n      chainCode: Buffer.from(extendedPublicKey.chainCode),\n      origin: new CryptoKeypath(cryptoKeyPathComponents, Buffer.from(extendedPublicKey.fingerprint)), // TODO: Define which FP we use\n      parentFingerprint: Buffer.from(account.masterFingerprint),\n      name: `AirGap - ${account.groupLabel}`\n    })\n\n    return cryptoHDKey\n  }\n\n  private async generateMessage(data: IACMessageDefinitionObjectV3): Promise<ETHSignature> {\n    let rlpSignatureData: Buffer | undefined\n\n    if ((data.payload as any).transaction) {\n      const transaction = data.payload as EthereumTransactionSignResponse\n\n      const tx = TransactionFactory.fromSerializedData(Buffer.from(transaction.transaction, 'hex'))\n\n      const r = Buffer.from(tx.r?.toString(16, 32), 'hex')\n      const s = Buffer.from(tx.s?.toString(16, 32), 'hex')\n      const v = Buffer.from(tx.v?.toString(16, 2), 'hex')\n\n      rlpSignatureData = Buffer.concat([r, s, v])\n    } else {\n      const transaction = data.payload as MessageSignResponse\n\n      rlpSignatureData = Buffer.from(transaction.signature.slice(2), 'hex')\n    }\n\n    if (!rlpSignatureData) {\n      throw new Error('Empty signature')\n    }\n\n    // TODO: This should be moved to a higher level, probably the \"iac.service\", and properly store context for any kind of request.\n    const IDs = JSON.parse(localStorage.getItem(TEMP_MM_REQUEST_IDS) ?? '{}')\n    const id = IDs[data.id]\n\n    // TODO: We cannot immediately delete the ID because this method might be called multiple times\n    // delete IDs[data.id]\n    // localStorage.setItem('TEMP-MM-REQUEST-IDS', JSON.stringify(IDs))\n\n    const idBuffer = id ? Buffer.from(id, 'hex') : (uuid.parse(uuid.v4()) as Uint8Array)\n\n    const ethSignature = new ETHSignature(rlpSignatureData, Buffer.from(idBuffer))\n\n    return ethSignature\n  }\n}\n"]}

package/esm2022/lib/services/qr/qr-generators/output-descriptor-generator.mjs

@@ -0,0 +1,49 @@
+import { MainProtocolSymbols } from '@wallfree-dev/coinlib-core';
+import { IACMessageType } from '@wallfree-dev/serializer';
+import { IACQrGenerator } from '../../iac/qr-generator';
+export class OutputDescriptorGenerator extends IACQrGenerator {
+    constructor() {
+        super();
+    }
+    async create(data, _multiFragmentLength, _singleFragmentLength) {
+        if (!(await OutputDescriptorGenerator.canHandle(data))) {
+            return;
+        }
+        const element = data[0];
+        if (element.type === IACMessageType.AccountShareResponse) {
+            this.data = await this.generateOutputDescriptor(element);
+        }
+        else {
+            throw new Error('Not Supported');
+        }
+    }
+    static async canHandle(data) {
+        if (data.length === 1) {
+            const element = data[0];
+            return ((element.protocol === MainProtocolSymbols.BTC_SEGWIT || element.protocol === MainProtocolSymbols.BTC_TAPROOT) &&
+                [IACMessageType.AccountShareResponse].includes(element.type));
+        }
+        return false;
+    }
+    async nextPart() {
+        return this.data ?? '';
+    }
+    async getSingle() {
+        return this.data ?? '';
+    }
+    async getNumberOfParts() {
+        return this.data ? 1 : 0;
+    }
+    async generateOutputDescriptor(data) {
+        // EXAMPLE: DESC="wpkh([0f056943/84h/1h/0h]tpubDC7jGaaSE66Pn4dgtbAAstde4bCyhSUs4r3P8WhMVvPByvcRrzrwqSvpF9Ghx83Z1LfVugGRrSBko5UEKELCz9HoMv5qKmGq3fqnnbS5E9r/0/*)#erexmnep"
+        const account = data.payload;
+        const dpWithoutPrefix = account.derivationPath.slice(1);
+        const dpWithoutUnhardened = dpWithoutPrefix.slice(0, dpWithoutPrefix.lastIndexOf("'") + 1);
+        if (data.protocol === MainProtocolSymbols.BTC_TAPROOT) {
+            return `tr([${account.masterFingerprint}${dpWithoutUnhardened}]${account.publicKey}/0/*)`;
+        }
+        // Default to SegWit
+        return `wpkh([${account.masterFingerprint}${dpWithoutUnhardened}]${account.publicKey}/0/*)`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/qr/qr-generators/serializer-v2-generator.mjs

@@ -0,0 +1,30 @@
+import { Serializer } from '@wallfree-dev/serializer';
+import { IACQrGenerator } from '../../iac/qr-generator';
+import { convertV3ToV2 } from '../../serializer/serializer.service';
+const serializer = Serializer.getInstance();
+export class SerializerV2Generator extends IACQrGenerator {
+    constructor() {
+        super();
+        this.counter = 0;
+        this.parts = [];
+        this.data = [];
+    }
+    async create(data, multiFragmentLength, singleFragmentLength) {
+        this.counter = 0;
+        this.data = await convertV3ToV2(data);
+        this.parts = await serializer.serialize(this.data, singleFragmentLength, multiFragmentLength);
+    }
+    async nextPart() {
+        const next = this.parts[this.counter % this.parts.length];
+        this.counter += 1;
+        return next;
+    }
+    async getSingle(prefix) {
+        const part = this.parts.length === 1 ? this.parts[0] : (await serializer.serialize(this.data))[0];
+        return this.prefixSingle(part, prefix, 'd');
+    }
+    async getNumberOfParts() {
+        return this.parts.length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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