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

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

@@ -0,0 +1,45 @@
+import * as bs58check from '@wallfree-dev/coinlib-core/dependencies/src/bs58check-2.1.2/index';
+import { SerializerV3 } from '@wallfree-dev/serializer';
+import { UR, UREncoder } from '@ngraveio/bc-ur';
+import { IACQrGenerator } from '../../iac/qr-generator';
+export class SerializerV3Generator extends IACQrGenerator {
+    constructor() {
+        super();
+    }
+    async create(data, multiFragmentLength, singleFragmentLength) {
+        const serializer = SerializerV3.getInstance();
+        const serialized = await serializer.serialize(data);
+        const buffer = bs58check.decode(serialized);
+        this.ur = UR.fromBuffer(buffer);
+        // We first try to create a larger "single chunk" fragment
+        this.encoder = new UREncoder(this.ur, singleFragmentLength);
+        // If this is not possible, we use the multiFragmentLength
+        if (this.encoder.fragmentsLength !== 1) {
+            this.encoder = new UREncoder(this.ur, multiFragmentLength);
+        }
+    }
+    async nextPart() {
+        if (this.encoder) {
+            return this.encoder.nextPart().toUpperCase();
+        }
+        else {
+            return '';
+        }
+    }
+    async getSingle(prefix) {
+        if (this.ur) {
+            const part = new UREncoder(this.ur, Number.MAX_SAFE_INTEGER).nextPart();
+            const regex = /([^/]+$)/g;
+            const match = part.match(regex);
+            const data = match && match[0] ? match[0] : part;
+            return this.prefixSingle(data.toUpperCase(), prefix, 'ur');
+        }
+        else {
+            return '';
+        }
+    }
+    async getNumberOfParts() {
+        return this.encoder?.fragmentsLength ?? 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,38 @@
+import { MainProtocolSymbols } from '@wallfree-dev/coinlib-core';
+import { IACMessageType } from '@wallfree-dev/serializer';
+import { IACQrGenerator } from '../../iac/qr-generator';
+export class XPubGenerator extends IACQrGenerator {
+    constructor() {
+        super();
+    }
+    async create(data, _multiFragmentLength, _singleFragmentLength) {
+        if (!(await XPubGenerator.canHandle(data))) {
+            return;
+        }
+        const element = data[0];
+        if (element.type === IACMessageType.AccountShareResponse) {
+            this.data = element.payload.publicKey;
+        }
+        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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/qr/qr-handler/serializer-v2-handler.mjs

@@ -0,0 +1,114 @@
+import { Serializer } from '@wallfree-dev/serializer';
+import { IACHandlerStatus } from '../../iac/message-handler';
+import { convertV2ToV3 } from '../../serializer/serializer.service';
+export class SerializerV2Handler {
+    constructor(callback = () => undefined) {
+        this.name = 'SerializerV2Handler';
+        this.callback = () => undefined;
+        this.progress = 0;
+        this.parts = new Set();
+        this.serializer = Serializer.getInstance();
+        this.callback = callback;
+    }
+    async canHandle(_part) {
+        const part = this.getParsedData(_part);
+        try {
+            await this.serializer.deserialize([part]);
+            return true;
+        }
+        catch (error) {
+            try {
+                await this.serializer.deserialize(part.split(','));
+                return true;
+            }
+            catch (error) {
+                if (error.availablePages && error.totalPages) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+    }
+    getParsedData(data) {
+        if (!data.includes('://')) {
+            return data;
+        }
+        let parsedData = data;
+        try {
+            const url = new URL(data);
+            parsedData = url.searchParams.get('d');
+        }
+        catch (e) { }
+        return parsedData ?? '';
+    }
+    async receive(data) {
+        const parsedData = await this.getParsedData(data);
+        if (!parsedData) {
+            return IACHandlerStatus.UNSUPPORTED;
+        }
+        // Handle multiple parts
+        const splits = parsedData.split(',');
+        if (splits.length > 1) {
+            for (const split of splits) {
+                if (this.parts.has(split)) {
+                    return IACHandlerStatus.PARTIAL;
+                }
+                const valid = await this.canHandle(split);
+                if (valid) {
+                    this.parts.add(split);
+                }
+                else {
+                    return IACHandlerStatus.UNSUPPORTED;
+                }
+            }
+            // End multiple parts
+        }
+        else {
+            const canHandle = await this.canHandle(parsedData);
+            if (!canHandle) {
+                return IACHandlerStatus.UNSUPPORTED;
+            }
+            this.parts.add(parsedData);
+        }
+        try {
+            const deserialized = await this.serializer.deserialize(Array.from(this.parts));
+            if (deserialized) {
+                this.completeDeserialized = deserialized;
+                return IACHandlerStatus.SUCCESS;
+            }
+        }
+        catch (error) {
+            if (error.availablePages && error.totalPages) {
+                this.progress = error.availablePages.length / error.totalPages;
+            }
+        }
+        return IACHandlerStatus.PARTIAL;
+    }
+    async getProgress() {
+        return Number(this.progress.toFixed(2));
+    }
+    async handleComplete() {
+        const result = await this.getResult();
+        if (!result) {
+            throw new Error('Data not complete!');
+        }
+        this.callback(result);
+        return result;
+    }
+    async getDataSingle() {
+        return Array.from(this.parts.values()).join(','); // Serializer V2 used commas to separate parts
+    }
+    async getResult() {
+        return this.completeDeserialized
+            ? { result: await convertV2ToV3(this.completeDeserialized), data: await this.getDataSingle() }
+            : undefined;
+    }
+    async reset() {
+        this.parts = new Set();
+        this.progress = 0;
+        this.completeDeserialized = undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serializer-v2-handler.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr/qr-handler/serializer-v2-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { IACMessageDefinitionObjectV3, IACMessageDefinitionObject, Serializer } from '@wallfree-dev/serializer'\nimport { IACHandlerStatus, IACMessageHandler, IACMessageWrapper } from '../../iac/message-handler'\nimport { convertV2ToV3 } from '../../serializer/serializer.service'\n\nexport class SerializerV2Handler implements IACMessageHandler<IACMessageDefinitionObjectV3[]> {\n  public readonly name: string = 'SerializerV2Handler'\n  private readonly serializer: Serializer\n\n  private readonly callback: (data: IACMessageWrapper<IACMessageDefinitionObjectV3[]>) => void = (): void => undefined\n\n  private progress: number = 0\n  private parts: Set<string> = new Set<string>()\n  private completeDeserialized: IACMessageDefinitionObject[] | undefined\n\n  constructor(callback: (data: IACMessageWrapper<IACMessageDefinitionObjectV3[]>) => void = (): void => undefined) {\n    this.serializer = Serializer.getInstance()\n    this.callback = callback\n  }\n\n  public async canHandle(_part: string): Promise<boolean> {\n    const part = this.getParsedData(_part)\n    try {\n      await this.serializer.deserialize([part])\n\n      return true\n    } catch (error) {\n      try {\n        await this.serializer.deserialize(part.split(','))\n\n        return true\n      } catch (error) {\n        if (error.availablePages && error.totalPages) {\n          return true\n        } else {\n          return false\n        }\n      }\n    }\n  }\n\n  public getParsedData(data: string): string {\n    if (!data.includes('://')) {\n      return data\n    }\n    let parsedData: string | null = data\n    try {\n      const url = new URL(data)\n      parsedData = url.searchParams.get('d')\n    } catch (e) {}\n\n    return parsedData ?? ''\n  }\n\n  public async receive(data: string): Promise<IACHandlerStatus> {\n    const parsedData = await this.getParsedData(data)\n    if (!parsedData) {\n      return IACHandlerStatus.UNSUPPORTED\n    }\n\n    // Handle multiple parts\n    const splits = parsedData.split(',')\n    if (splits.length > 1) {\n      for (const split of splits) {\n        if (this.parts.has(split)) {\n          return IACHandlerStatus.PARTIAL\n        }\n\n        const valid = await this.canHandle(split)\n\n        if (valid) {\n          this.parts.add(split)\n        } else {\n          return IACHandlerStatus.UNSUPPORTED\n        }\n      }\n      // End multiple parts\n    } else {\n      const canHandle = await this.canHandle(parsedData)\n      if (!canHandle) {\n        return IACHandlerStatus.UNSUPPORTED\n      }\n      this.parts.add(parsedData)\n    }\n\n    try {\n      const deserialized = await this.serializer.deserialize(Array.from(this.parts))\n      if (deserialized) {\n        this.completeDeserialized = deserialized\n\n        return IACHandlerStatus.SUCCESS\n      }\n    } catch (error) {\n      if (error.availablePages && error.totalPages) {\n        this.progress = error.availablePages.length / error.totalPages\n      }\n    }\n\n    return IACHandlerStatus.PARTIAL\n  }\n\n  public async getProgress(): Promise<number> {\n    return Number(this.progress.toFixed(2))\n  }\n\n  public async handleComplete(): Promise<IACMessageWrapper<IACMessageDefinitionObjectV3[]>> {\n    const result = await this.getResult()\n    if (!result) {\n      throw new Error('Data not complete!')\n    }\n    this.callback(result)\n\n    return result\n  }\n\n  public async getDataSingle(): Promise<string | undefined> {\n    return Array.from(this.parts.values()).join(',') // Serializer V2 used commas to separate parts\n  }\n\n  public async getResult(): Promise<IACMessageWrapper<IACMessageDefinitionObjectV3[]> | undefined> {\n    return this.completeDeserialized\n      ? { result: await convertV2ToV3(this.completeDeserialized), data: await this.getDataSingle() }\n      : undefined\n  }\n\n  public async reset(): Promise<void> {\n    this.parts = new Set()\n    this.progress = 0\n    this.completeDeserialized = undefined\n  }\n}\n"]}

package/esm2022/lib/services/qr/qr-handler/serializer-v3-handler.mjs

@@ -0,0 +1,274 @@
+import { UR, URDecoder, UREncoder } from '@ngraveio/bc-ur';
+import * as bs58check from '@wallfree-dev/coinlib-core/dependencies/src/bs58check-2.1.2/index';
+import { CryptoPSBT } from '@keystonehq/bc-ur-registry';
+import { EthSignRequest, DataType } from '@keystonehq/bc-ur-registry-eth';
+import * as rlp from '@ethereumjs/rlp';
+import { TransactionFactory } from '@ethereumjs/tx';
+import { MainProtocolSymbols } from '@wallfree-dev/coinlib-core';
+import { SerializerV3, generateId, IACMessageType } from '@wallfree-dev/serializer';
+import { IACHandlerStatus } from '../../iac/message-handler';
+import { QRType } from '../../../../public-api';
+import { TEMP_BTC_REQUEST_IDS, TEMP_MM_REQUEST_IDS } from '../../../utils/utils';
+import * as bitcoinJS from 'bitcoinjs-lib';
+export class SerializerV3Handler {
+    constructor(callback = () => undefined) {
+        this.name = 'SerializerV3Handler';
+        this.decoder = new URDecoder();
+        this.callback = () => undefined;
+        this.parts = new Set();
+        this.serializer = SerializerV3.getInstance();
+        this.callback = callback;
+        // completion callback
+    }
+    async canHandle(data) {
+        if (data.toUpperCase().startsWith('UR:')) {
+            return true;
+        }
+        else {
+            try {
+                const ur = this.getParsedData(data);
+                return ur && ur.length > 0 ? true : false;
+            }
+            catch (e) {
+                return false;
+            }
+        }
+    }
+    getParsedData(data) {
+        if (data.toUpperCase().startsWith('UR:')) {
+            return data;
+        }
+        let ur = data;
+        try {
+            const url = new URL(data);
+            ur = `UR:BYTES/${url.searchParams.get('ur')}`;
+        }
+        catch (e) { }
+        return ur ?? '';
+    }
+    async receive(_data) {
+        const data = this.getParsedData(_data);
+        if (this.parts.has(data)) {
+            return IACHandlerStatus.PARTIAL;
+        }
+        this.parts.add(data);
+        const canHandle = await this.canHandle(data);
+        if (!canHandle) {
+            return IACHandlerStatus.UNSUPPORTED;
+        }
+        try {
+            const res = this.decoder.receivePart(data);
+            if (!res) {
+                // If we already have progress, but the scanner scans a "new set of QRs", it should reset itself and handle the part.
+                this.reset();
+                return this.receive(_data);
+            }
+        }
+        catch (e) {
+            return IACHandlerStatus.UNSUPPORTED;
+        }
+        if (this.decoder.isComplete() && this.decoder.isSuccess()) {
+            return IACHandlerStatus.SUCCESS;
+        }
+        return IACHandlerStatus.PARTIAL;
+    }
+    async handleComplete() {
+        const result = await this.getResult();
+        if (!result) {
+            throw new Error('Data not complete!');
+        }
+        this.callback(result);
+        return result;
+    }
+    async getProgress() {
+        return Number(this.decoder.estimatedPercentComplete().toFixed(2));
+    }
+    async getResult() {
+        if (this.resultCache) {
+            return this.resultCache;
+        }
+        if (this.decoder.isComplete() && this.decoder.isSuccess()) {
+            const decoded = this.decoder.resultUR();
+            this.combinedData = decoded.decodeCBOR();
+            if (decoded.type === 'crypto-psbt') {
+                const cryptoPsbt = CryptoPSBT.fromCBOR(decoded.cbor);
+                const psbt = cryptoPsbt.getPSBT().toString('hex');
+                return this.convertPSBT(psbt);
+            }
+            if (decoded.type === 'eth-sign-request') {
+                const signRequest = EthSignRequest.fromCBOR(decoded.cbor);
+                return this.convertMetaMaskSignRequest(signRequest);
+            }
+            const resultUr = bs58check.encode(this.combinedData);
+            return { result: await this.serializer.deserialize(resultUr), data: await this.getDataSingle() };
+        }
+        return undefined;
+    }
+    /*
+     * If we scan an animated QR, but the result is not a serializer message we get the result back
+     */
+    async getDataSingle() {
+        if (!this.combinedData) {
+            return undefined;
+        }
+        const ur = UR.fromBuffer(this.combinedData);
+        const part = new UREncoder(ur, Number.MAX_SAFE_INTEGER).nextPart();
+        return part.toUpperCase();
+    }
+    async reset() {
+        this.decoder = new URDecoder();
+        this.parts = new Set();
+        return;
+    }
+    async convertPSBT(psbt) {
+        const decodedPSBT = bitcoinJS.Psbt.fromHex(psbt);
+        const isTaproot = decodedPSBT.data.inputs.some((input) => input.tapBip32Derivation);
+        const payload = {
+            transaction: { psbt },
+            publicKey: ''
+        };
+        if (isTaproot) {
+            payload;
+        }
+        else {
+            payload;
+        }
+        const ownRequestId = generateId(8);
+        const IDs = JSON.parse(localStorage.getItem(TEMP_BTC_REQUEST_IDS) ?? '{}');
+        IDs[ownRequestId] = { qrType: QRType.BC_UR };
+        localStorage.setItem(TEMP_BTC_REQUEST_IDS, JSON.stringify(IDs));
+        return {
+            result: [
+                {
+                    id: ownRequestId,
+                    protocol: isTaproot ? MainProtocolSymbols.BTC_TAPROOT : MainProtocolSymbols.BTC_SEGWIT,
+                    type: IACMessageType.TransactionSignRequest,
+                    payload
+                }
+            ],
+            data: await this.getDataSingle()
+        };
+    }
+    async convertMetaMaskSignRequest(request) {
+        const signData = request.getSignData();
+        const sourceFingerprint = request.derivationPath.getSourceFingerprint().toString('hex');
+        const ownRequestId = generateId(8);
+        const metamaskRequestId = request.getRequestId().toString('hex');
+        // 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) ?? '{}');
+        IDs[ownRequestId] = metamaskRequestId;
+        localStorage.setItem(TEMP_MM_REQUEST_IDS, JSON.stringify(IDs));
+        const context = { requestId: metamaskRequestId, derivationPath: request.getDerivationPath(), sourceFingerprint };
+        const chainId = request.getChainId();
+        const protocol = chainId === 10 /* Optimism Mainnet */ || chainId === 420 /* Optimism Goerli */
+            ? MainProtocolSymbols.OPTIMISM
+            : MainProtocolSymbols.ETH;
+        switch (request.getDataType()) {
+            case DataType.transaction: {
+                // Metamask uses `Transaction#getMessageToSign` to get the transaction bytes which will be later encoded with RLP.
+                // This method returns data that is already prepared to be hashed and signed,
+                // for EIP-155 compliant transactions it means there's `chainId` put where the `v` component is usually placed.
+                // However, the data prepared in that way is not meant to be used to recreate the `Transaction` object.
+                // To construct the `Transaction` object on our side we have to use the transaction data to replicate the
+                // output we would get with `Transaction#serialized`. This means that we first have to decode the data,
+                // drop the EIP-155 compliant parts and finally encode the reduced array of bytes again.
+                const rawTx = rlp.decode(signData);
+                const [nonce, gasPrice, gasLimit, to, value, data] = rawTx;
+                const serializedTx = rlp.encode([
+                    nonce,
+                    gasPrice,
+                    gasLimit,
+                    to,
+                    value,
+                    data,
+                    Buffer.from([]) /* v */,
+                    Buffer.from([]) /* r */,
+                    Buffer.from([]) /* s */
+                ]);
+                const ethTx = TransactionFactory.fromSerializedData(Buffer.from(serializedTx));
+                const tx = ethTx;
+                return {
+                    result: [
+                        {
+                            id: ownRequestId,
+                            protocol,
+                            type: IACMessageType.TransactionSignRequest,
+                            payload: {
+                                transaction: {
+                                    nonce: `0x${tx.nonce.toString(16)}`,
+                                    gasPrice: `0x${tx.gasPrice.toString(16)}`,
+                                    gasLimit: `0x${tx.gasLimit.toString(16)}`,
+                                    to: tx.to.toString(),
+                                    value: `0x${tx.value.toString(16)}`,
+                                    chainId: request.getChainId(),
+                                    data: `0x${tx.data.toString('hex')}`
+                                },
+                                publicKey: ''
+                            }
+                        }
+                    ],
+                    data: await this.getDataSingle(),
+                    context
+                };
+            }
+            case DataType.typedData:
+                const typedDataSignRequest = {
+                    message: signData.toString(),
+                    publicKey: ''
+                };
+                return {
+                    result: [
+                        {
+                            id: ownRequestId,
+                            protocol,
+                            type: IACMessageType.MessageSignRequest,
+                            payload: typedDataSignRequest
+                        }
+                    ],
+                    data: await this.getDataSingle(),
+                    context
+                };
+            case DataType.personalMessage:
+                const signRequest = {
+                    message: `0x${signData.toString('hex')}`,
+                    publicKey: ''
+                };
+                return {
+                    result: [
+                        {
+                            id: ownRequestId,
+                            protocol,
+                            type: IACMessageType.MessageSignRequest,
+                            payload: signRequest
+                        }
+                    ],
+                    data: await this.getDataSingle(),
+                    context
+                };
+            case DataType.typedTransaction: {
+                return {
+                    result: [
+                        {
+                            id: ownRequestId,
+                            protocol,
+                            type: IACMessageType.TransactionSignRequest,
+                            payload: {
+                                transaction: {
+                                    serialized: signData.toString('hex'),
+                                    derivationPath: request.getDerivationPath(),
+                                    masterFingerprint: sourceFingerprint
+                                },
+                                publicKey: ''
+                            }
+                        }
+                    ],
+                    data: await this.getDataSingle(),
+                    context
+                };
+            }
+            default:
+                throw new Error(`Unable to handle data type "${request.getDataType()}"`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serializer-v3-handler.js","sourceRoot":"","sources":["../../../../../../src/lib/services/qr/qr-handler/serializer-v3-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { UR, URDecoder, UREncoder } from '@ngraveio/bc-ur'\nimport * as bs58check from '@wallfree-dev/coinlib-core/dependencies/src/bs58check-2.1.2/index'\nimport { CryptoKeypath, CryptoPSBT } from '@keystonehq/bc-ur-registry'\nimport { EthSignRequest, DataType } from '@keystonehq/bc-ur-registry-eth'\nimport * as rlp from '@ethereumjs/rlp'\nimport { Transaction, TransactionFactory } from '@ethereumjs/tx'\nimport { BitcoinSegwitTransactionSignRequest, BitcoinTaprootTransactionSignRequest } from '@wallfree-dev/bitcoin'\nimport { MainProtocolSymbols } from '@wallfree-dev/coinlib-core'\nimport { IACMessageDefinitionObjectV3, SerializerV3, generateId, IACMessageType, MessageSignRequest } from '@wallfree-dev/serializer'\nimport { IACHandlerStatus, IACMessageHandler, IACMessageWrapper } from '../../iac/message-handler'\nimport { QRType } from '../../../../public-api'\nimport { TEMP_BTC_REQUEST_IDS, TEMP_MM_REQUEST_IDS } from '../../../utils/utils'\nimport * as bitcoinJS from 'bitcoinjs-lib'\n\nexport class SerializerV3Handler implements IACMessageHandler<IACMessageDefinitionObjectV3[]> {\n  public readonly name: string = 'SerializerV3Handler'\n  private readonly serializer: SerializerV3\n  private decoder: URDecoder = new URDecoder()\n\n  private readonly callback: (data: IACMessageWrapper<IACMessageDefinitionObjectV3[]>) => void = (): void => undefined\n\n  private parts: Set<string> = new Set()\n\n  private combinedData: Buffer | undefined\n\n  private resultCache: IACMessageWrapper<IACMessageDefinitionObjectV3[]> | undefined\n\n  constructor(callback: (data: IACMessageWrapper<IACMessageDefinitionObjectV3[]>) => void = (): void => undefined) {\n    this.serializer = SerializerV3.getInstance()\n    this.callback = callback\n    // completion callback\n  }\n\n  public async canHandle(data: string): Promise<boolean> {\n    if (data.toUpperCase().startsWith('UR:')) {\n      return true\n    } else {\n      try {\n        const ur = this.getParsedData(data)\n\n        return ur && ur.length > 0 ? true : false\n      } catch (e) {\n        return false\n      }\n    }\n  }\n\n  public getParsedData(data: string): string {\n    if (data.toUpperCase().startsWith('UR:')) {\n      return data\n    }\n    let ur: string | null = data\n    try {\n      const url = new URL(data)\n      ur = `UR:BYTES/${url.searchParams.get('ur')}`\n    } catch (e) {}\n\n    return ur ?? ''\n  }\n\n  public async receive(_data: string): Promise<IACHandlerStatus> {\n    const data = this.getParsedData(_data)\n    if (this.parts.has(data)) {\n      return IACHandlerStatus.PARTIAL\n    }\n    this.parts.add(data)\n    const canHandle = await this.canHandle(data)\n    if (!canHandle) {\n      return IACHandlerStatus.UNSUPPORTED\n    }\n\n    try {\n      const res = this.decoder.receivePart(data)\n      if (!res) {\n        // If we already have progress, but the scanner scans a \"new set of QRs\", it should reset itself and handle the part.\n        this.reset()\n\n        return this.receive(_data)\n      }\n    } catch (e) {\n      return IACHandlerStatus.UNSUPPORTED\n    }\n\n    if (this.decoder.isComplete() && this.decoder.isSuccess()) {\n      return IACHandlerStatus.SUCCESS\n    }\n\n    return IACHandlerStatus.PARTIAL\n  }\n\n  public async handleComplete(): Promise<IACMessageWrapper<IACMessageDefinitionObjectV3[]>> {\n    const result = await this.getResult()\n    if (!result) {\n      throw new Error('Data not complete!')\n    }\n    this.callback(result)\n\n    return result\n  }\n\n  public async getProgress(): Promise<number> {\n    return Number(this.decoder.estimatedPercentComplete().toFixed(2))\n  }\n\n  public async getResult(): Promise<IACMessageWrapper<IACMessageDefinitionObjectV3[]> | undefined> {\n    if (this.resultCache) {\n      return this.resultCache\n    }\n\n    if (this.decoder.isComplete() && this.decoder.isSuccess()) {\n      const decoded = this.decoder.resultUR()\n      this.combinedData = decoded.decodeCBOR()\n\n      if (decoded.type === 'crypto-psbt') {\n        const cryptoPsbt = CryptoPSBT.fromCBOR(decoded.cbor)\n        const psbt = cryptoPsbt.getPSBT().toString('hex')\n\n        return this.convertPSBT(psbt)\n      }\n\n      if (decoded.type === 'eth-sign-request') {\n        const signRequest = EthSignRequest.fromCBOR(decoded.cbor)\n\n        return this.convertMetaMaskSignRequest(signRequest)\n      }\n\n      const resultUr = bs58check.encode(this.combinedData)\n\n      return { result: await this.serializer.deserialize(resultUr), data: await this.getDataSingle() }\n    }\n\n    return undefined\n  }\n\n  /*\n   * If we scan an animated QR, but the result is not a serializer message we get the result back\n   */\n  public async getDataSingle(): Promise<string | undefined> {\n    if (!this.combinedData) {\n      return undefined\n    }\n    const ur = UR.fromBuffer(this.combinedData)\n    const part = new UREncoder(ur, Number.MAX_SAFE_INTEGER).nextPart()\n\n    return part.toUpperCase()\n  }\n\n  public async reset(): Promise<void> {\n    this.decoder = new URDecoder()\n    this.parts = new Set()\n\n    return\n  }\n\n  private async convertPSBT(psbt: string): Promise<IACMessageWrapper<IACMessageDefinitionObjectV3[]>> {\n    const decodedPSBT = bitcoinJS.Psbt.fromHex(psbt)\n    const isTaproot = decodedPSBT.data.inputs.some((input) => input.tapBip32Derivation)\n\n    const payload = {\n      transaction: { psbt },\n      publicKey: ''\n    }\n\n    if (isTaproot) {\n      payload as BitcoinTaprootTransactionSignRequest\n    } else {\n      payload as BitcoinSegwitTransactionSignRequest\n    }\n\n    const ownRequestId: number = generateId(8)\n    const IDs = JSON.parse(localStorage.getItem(TEMP_BTC_REQUEST_IDS) ?? '{}')\n    IDs[ownRequestId] = { qrType: QRType.BC_UR }\n    localStorage.setItem(TEMP_BTC_REQUEST_IDS, JSON.stringify(IDs))\n\n    return {\n      result: [\n        {\n          id: ownRequestId,\n          protocol: isTaproot ? MainProtocolSymbols.BTC_TAPROOT : MainProtocolSymbols.BTC_SEGWIT,\n          type: IACMessageType.TransactionSignRequest,\n          payload\n        }\n      ],\n      data: await this.getDataSingle()\n    }\n  }\n\n  private async convertMetaMaskSignRequest(request: EthSignRequest): Promise<IACMessageWrapper<IACMessageDefinitionObjectV3[]>> {\n    const signData = request.getSignData()\n\n    const sourceFingerprint = ((request as any).derivationPath as CryptoKeypath).getSourceFingerprint().toString('hex')\n\n    const ownRequestId: number = generateId(8)\n\n    const metamaskRequestId: string = request.getRequestId().toString('hex')\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    IDs[ownRequestId] = metamaskRequestId\n    localStorage.setItem(TEMP_MM_REQUEST_IDS, JSON.stringify(IDs))\n\n    const context = { requestId: metamaskRequestId, derivationPath: request.getDerivationPath(), sourceFingerprint }\n\n    const chainId = request.getChainId()\n\n    const protocol =\n      chainId === 10 /* Optimism Mainnet */ || chainId === 420 /* Optimism Goerli */\n        ? MainProtocolSymbols.OPTIMISM\n        : MainProtocolSymbols.ETH\n\n    switch (request.getDataType()) {\n      case DataType.transaction: {\n        // Metamask uses `Transaction#getMessageToSign` to get the transaction bytes which will be later encoded with RLP.\n        // This method returns data that is already prepared to be hashed and signed,\n        // for EIP-155 compliant transactions it means there's `chainId` put where the `v` component is usually placed.\n        // However, the data prepared in that way is not meant to be used to recreate the `Transaction` object.\n        // To construct the `Transaction` object on our side we have to use the transaction data to replicate the\n        // output we would get with `Transaction#serialized`. This means that we first have to decode the data,\n        // drop the EIP-155 compliant parts and finally encode the reduced array of bytes again.\n        const rawTx = rlp.decode(signData)\n        const [nonce, gasPrice, gasLimit, to, value, data] = rawTx\n        const serializedTx = rlp.encode([\n          nonce,\n          gasPrice,\n          gasLimit,\n          to,\n          value,\n          data,\n          Buffer.from([]) /* v */,\n          Buffer.from([]) /* r */,\n          Buffer.from([]) /* s */\n        ])\n\n        const ethTx = TransactionFactory.fromSerializedData(Buffer.from(serializedTx))\n        const tx: Transaction = ethTx as Transaction\n\n        return {\n          result: [\n            {\n              id: ownRequestId,\n              protocol,\n              type: IACMessageType.TransactionSignRequest,\n              payload: {\n                transaction: {\n                  nonce: `0x${tx.nonce.toString(16)}`,\n                  gasPrice: `0x${tx.gasPrice.toString(16)}`,\n                  gasLimit: `0x${tx.gasLimit.toString(16)}`,\n                  to: tx.to.toString(),\n                  value: `0x${tx.value.toString(16)}`,\n                  chainId: request.getChainId(),\n                  data: `0x${tx.data.toString('hex')}`\n                },\n                publicKey: ''\n              }\n            }\n          ],\n          data: await this.getDataSingle(),\n          context\n        }\n      }\n\n      case DataType.typedData:\n        const typedDataSignRequest: MessageSignRequest = {\n          message: signData.toString(),\n          publicKey: ''\n        }\n\n        return {\n          result: [\n            {\n              id: ownRequestId,\n              protocol,\n              type: IACMessageType.MessageSignRequest,\n              payload: typedDataSignRequest\n            }\n          ],\n          data: await this.getDataSingle(),\n          context\n        }\n      case DataType.personalMessage:\n        const signRequest: MessageSignRequest = {\n          message: `0x${signData.toString('hex')}`,\n          publicKey: ''\n        }\n\n        return {\n          result: [\n            {\n              id: ownRequestId,\n              protocol,\n              type: IACMessageType.MessageSignRequest,\n              payload: signRequest\n            }\n          ],\n          data: await this.getDataSingle(),\n          context\n        }\n\n      case DataType.typedTransaction: {\n        return {\n          result: [\n            {\n              id: ownRequestId,\n              protocol,\n              type: IACMessageType.TransactionSignRequest,\n              payload: {\n                transaction: {\n                  serialized: signData.toString('hex'),\n                  derivationPath: request.getDerivationPath(),\n                  masterFingerprint: sourceFingerprint\n                },\n                publicKey: ''\n              }\n            }\n          ],\n          data: await this.getDataSingle(),\n          context\n        }\n      }\n\n      default:\n        throw new Error(`Unable to handle data type \"${request.getDataType()}\"`)\n    }\n  }\n}\n"]}

package/esm2022/lib/services/qr-scanner/qr-scanner.service.mjs

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/angular";
+export class QrScannerService {
+    constructor(platform) {
+        this.platform = platform;
+        /**
+         * Shows if the scanner is currently active (scanning) or not
+         */
+        this.isActive = false;
+        this.isMobile = this.platform.is('hybrid');
+    }
+    /**
+     * Start the QR scanner. It will make the background of the page transparent and scan until a QR is detected.
+     *
+     * @param successCallback
+     * @param errorCallback
+     */
+    scan(successCallback, errorCallback = null) {
+        this.show();
+        const scanCallback = (scanError, text) => {
+            if (scanError) {
+                // eslint-disable-next-line no-console
+                console.error('Scanner scan error', scanError);
+                if (errorCallback) {
+                    // TODO: Check type
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    errorCallback(scanError);
+                }
+            }
+            // eslint-disable-next-line no-console
+            console.log('Scanner scan success', text);
+            successCallback(text);
+        };
+        QRScanner.scan(scanCallback);
+    }
+    destroy() {
+        if (this.isMobile) {
+            this.isActive = false;
+            QRScanner.destroy();
+        }
+    }
+    show() {
+        if (this.isMobile) {
+            if (this.isActive) {
+                return;
+            }
+            this.isActive = true;
+            QRScanner.show();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: QrScannerService, deps: [{ token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: QrScannerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: QrScannerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Platform }] });
+//# sourceMappingURL=data:application/json;base64,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