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

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

@@ -0,0 +1,181 @@
+import { Injectable } from '@angular/core';
+import { generateId, IACMessageType, Serializer, SerializerV3 } from '@wallfree-dev/serializer';
+import { parseIACUrl } from '../../utils/utils';
+import { defaultValues, InternalStorageKey } from '../storage/storage.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../storage/storage.service";
+export const convertV2ToV3 = async (chunks) => {
+    return chunks.map((message) => {
+        let newPayload;
+        switch (message.type) {
+            case IACMessageType.AccountShareResponse:
+                newPayload = {
+                    ...message.payload,
+                    masterFingerprint: '',
+                    isActive: true,
+                    groupId: '',
+                    groupLabel: ''
+                };
+                break;
+            default:
+                newPayload = message.payload;
+                break;
+        }
+        return {
+            id: generateId(8),
+            type: message.type,
+            protocol: message.protocol,
+            payload: newPayload
+        };
+    });
+};
+export const convertV3ToV2 = async (chunks) => {
+    return chunks.map((message) => {
+        let newPayload;
+        switch (message.type) {
+            case IACMessageType.AccountShareResponse:
+                const { masterFingerprint, isActive, groupId, groupLabel, ...rest } = message.payload;
+                newPayload = {
+                    ...message.payload
+                };
+                newPayload = rest;
+                break;
+            default:
+                newPayload = message.payload;
+                break;
+        }
+        return {
+            id: message.id.toString().repeat(10).slice(0, 10), // We need to assume the id is "0", so we need to repeat it 10 times
+            type: message.type,
+            protocol: message.protocol,
+            payload: newPayload
+        };
+    });
+};
+export class SerializerService {
+    get useV3() {
+        return this._useV3;
+    }
+    set useV3(value) {
+        // eslint-disable-next-line no-console
+        this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_ENABLE_V3, value).catch(console.error);
+        this._useV3 = value;
+    }
+    get singleChunkSize() {
+        return this._singleChunkSize;
+    }
+    set singleChunkSize(value) {
+        // eslint-disable-next-line no-console
+        this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE, value).catch(console.error);
+        this._singleChunkSize = value;
+    }
+    get multiChunkSize() {
+        return this._multiChunkSize;
+    }
+    set multiChunkSize(value) {
+        // eslint-disable-next-line no-console
+        this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE, value).catch(console.error);
+        this._multiChunkSize = value;
+    }
+    get displayTimePerChunk() {
+        return this._displayTimePerChunk;
+    }
+    set displayTimePerChunk(value) {
+        // eslint-disable-next-line no-console
+        this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_CHUNK_TIME, value).catch(console.error);
+        this._displayTimePerChunk = value;
+    }
+    constructor(internalStorageService) {
+        this.internalStorageService = internalStorageService;
+        this._singleChunkSize = defaultValues.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE;
+        this._multiChunkSize = defaultValues.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE;
+        this.serializer = Serializer.getInstance();
+        this.serializerV3 = SerializerV3.getInstance();
+        this._useV3 = defaultValues.SETTINGS_SERIALIZER_ENABLE_V3;
+        this._displayTimePerChunk = defaultValues.SETTINGS_SERIALIZER_CHUNK_TIME;
+        // eslint-disable-next-line no-console
+        this.loadSettings().catch(console.error);
+    }
+    async resetSettings() {
+        this._useV3 = defaultValues.SETTINGS_SERIALIZER_ENABLE_V3;
+        this._singleChunkSize = defaultValues.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE;
+        this._multiChunkSize = defaultValues.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE;
+        this._displayTimePerChunk = defaultValues.SETTINGS_SERIALIZER_CHUNK_TIME;
+        await Promise.all([
+            this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_ENABLE_V3),
+            this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE),
+            this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE),
+            this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_CHUNK_TIME)
+        ]);
+    }
+    async serialize(chunks) {
+        if (this.useV3) {
+            return this.serializeV3(chunks);
+        }
+        else {
+            return this.serializeV2(chunks);
+        }
+    }
+    async deserialize(chunks) {
+        const parsedChunks = parseIACUrl(chunks, 'd');
+        try {
+            return this.deserializeV2(parsedChunks);
+        }
+        catch (error) {
+            if (error && error.availablePages && error.totalPages) {
+                throw error;
+            }
+            if (parsedChunks.length === 1) {
+                return this.deserializeV3(parsedChunks[0]);
+            }
+            else {
+                throw new Error('Could not deserialize input');
+            }
+        }
+    }
+    async loadSettings() {
+        this.internalStorageService
+            .get(InternalStorageKey.SETTINGS_SERIALIZER_ENABLE_V3)
+            .then((setting) => (this._useV3 = setting))
+            // eslint-disable-next-line no-console
+            .catch(console.error);
+        this.internalStorageService
+            .get(InternalStorageKey.SETTINGS_SERIALIZER_CHUNK_TIME)
+            .then((setting) => (this._displayTimePerChunk = setting))
+            // eslint-disable-next-line no-console
+            .catch(console.error);
+        this.internalStorageService
+            .get(InternalStorageKey.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE)
+            .then((setting) => (this._singleChunkSize = setting))
+            // eslint-disable-next-line no-console
+            .catch(console.error);
+        this.internalStorageService
+            .get(InternalStorageKey.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE)
+            .then((setting) => (this._multiChunkSize = setting))
+            // eslint-disable-next-line no-console
+            .catch(console.error);
+    }
+    async serializeV2(chunks) {
+        const dataV2 = await convertV3ToV2(chunks);
+        return this.serializer.serialize(dataV2, this.singleChunkSize, this.multiChunkSize);
+    }
+    async deserializeV2(chunks) {
+        const v2Data = await this.serializer.deserialize(chunks);
+        return convertV2ToV3(v2Data);
+    }
+    async serializeV3(chunks) {
+        return this.serializerV3.serialize(chunks);
+    }
+    async deserializeV3(chunks) {
+        return this.serializerV3.deserialize(chunks);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SerializerService, deps: [{ token: i1.InternalStorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SerializerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SerializerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.InternalStorageService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serializer.service.js","sourceRoot":"","sources":["../../../../../src/lib/services/serializer/serializer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core'\nimport {\n  AccountShareResponse as AccountShareResponseV3,\n  AccountShareResponseV2,\n  generateId,\n  IACMessageDefinitionObject,\n  IACMessageDefinitionObjectV3,\n  IACMessages as IACMessagesV3,\n  IACMessagesV2,\n  IACMessageType,\n  Serializer,\n  SerializerV3\n} from '@wallfree-dev/serializer'\n\nimport { parseIACUrl } from '../../utils/utils'\nimport { defaultValues, InternalStorageKey, InternalStorageService } from '../storage/storage.service'\n\nexport const convertV2ToV3 = async (chunks: IACMessageDefinitionObject[]): Promise<IACMessageDefinitionObjectV3[]> => {\n  return chunks.map((message: IACMessageDefinitionObject) => {\n    let newPayload: IACMessagesV3\n    switch (message.type) {\n      case IACMessageType.AccountShareResponse:\n        newPayload = {\n          ...message.payload,\n          masterFingerprint: '',\n          isActive: true,\n          groupId: '',\n          groupLabel: ''\n        }\n        break\n\n      default:\n        newPayload = message.payload as Exclude<IACMessagesV2, AccountShareResponseV2>\n        break\n    }\n\n    return {\n      id: generateId(8),\n      type: message.type,\n      protocol: message.protocol,\n      payload: newPayload\n    }\n  })\n}\n\nexport const convertV3ToV2 = async (chunks: IACMessageDefinitionObjectV3[]): Promise<IACMessageDefinitionObject[]> => {\n  return chunks.map((message: IACMessageDefinitionObjectV3) => {\n    let newPayload: IACMessagesV2\n    switch (message.type) {\n      case IACMessageType.AccountShareResponse:\n        const { masterFingerprint, isActive, groupId, groupLabel, ...rest } = message.payload as AccountShareResponseV3\n        newPayload = {\n          ...message.payload\n        } as any\n        newPayload = rest\n        break\n\n      default:\n        newPayload = message.payload as Exclude<IACMessagesV3, AccountShareResponseV3> as any\n        break\n    }\n\n    return {\n      id: message.id.toString().repeat(10).slice(0, 10), // We need to assume the id is \"0\", so we need to repeat it 10 times\n      type: message.type,\n      protocol: message.protocol,\n      payload: newPayload\n    }\n  })\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SerializerService {\n  public _singleChunkSize: number = defaultValues.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE\n  public _multiChunkSize: number = defaultValues.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE\n\n  private readonly serializer: Serializer = Serializer.getInstance()\n  private readonly serializerV3: SerializerV3 = SerializerV3.getInstance()\n\n  private _useV3: boolean = defaultValues.SETTINGS_SERIALIZER_ENABLE_V3\n  private _displayTimePerChunk: number = defaultValues.SETTINGS_SERIALIZER_CHUNK_TIME\n\n  public get useV3(): boolean {\n    return this._useV3\n  }\n\n  public set useV3(value: boolean) {\n    // eslint-disable-next-line no-console\n    this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_ENABLE_V3, value).catch(console.error)\n    this._useV3 = value\n  }\n\n  public get singleChunkSize(): number {\n    return this._singleChunkSize\n  }\n\n  public set singleChunkSize(value: number) {\n    // eslint-disable-next-line no-console\n    this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE, value).catch(console.error)\n    this._singleChunkSize = value\n  }\n\n  public get multiChunkSize(): number {\n    return this._multiChunkSize\n  }\n\n  public set multiChunkSize(value: number) {\n    // eslint-disable-next-line no-console\n    this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE, value).catch(console.error)\n    this._multiChunkSize = value\n  }\n\n  public get displayTimePerChunk(): number {\n    return this._displayTimePerChunk\n  }\n\n  public set displayTimePerChunk(value: number) {\n    // eslint-disable-next-line no-console\n    this.internalStorageService.set(InternalStorageKey.SETTINGS_SERIALIZER_CHUNK_TIME, value).catch(console.error)\n    this._displayTimePerChunk = value\n  }\n\n  constructor(private readonly internalStorageService: InternalStorageService) {\n    // eslint-disable-next-line no-console\n    this.loadSettings().catch(console.error)\n  }\n\n  public async resetSettings(): Promise<void> {\n    this._useV3 = defaultValues.SETTINGS_SERIALIZER_ENABLE_V3\n    this._singleChunkSize = defaultValues.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE\n    this._multiChunkSize = defaultValues.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE\n    this._displayTimePerChunk = defaultValues.SETTINGS_SERIALIZER_CHUNK_TIME\n\n    await Promise.all([\n      this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_ENABLE_V3),\n      this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE),\n      this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE),\n      this.internalStorageService.delete(InternalStorageKey.SETTINGS_SERIALIZER_CHUNK_TIME)\n    ])\n  }\n\n  public async serialize(chunks: IACMessageDefinitionObjectV3[]): Promise<string[] | string> {\n    if (this.useV3) {\n      return this.serializeV3(chunks)\n    } else {\n      return this.serializeV2(chunks)\n    }\n  }\n\n  public async deserialize(chunks: string | string[]): Promise<IACMessageDefinitionObjectV3[]> {\n    const parsedChunks: string[] = parseIACUrl(chunks, 'd')\n    try {\n      return this.deserializeV2(parsedChunks)\n    } catch (error) {\n      if (error && error.availablePages && error.totalPages) {\n        throw error\n      }\n\n      if (parsedChunks.length === 1) {\n        return this.deserializeV3(parsedChunks[0])\n      } else {\n        throw new Error('Could not deserialize input')\n      }\n    }\n  }\n\n  private async loadSettings() {\n    this.internalStorageService\n      .get(InternalStorageKey.SETTINGS_SERIALIZER_ENABLE_V3)\n      .then((setting) => (this._useV3 = setting))\n      // eslint-disable-next-line no-console\n      .catch(console.error)\n    this.internalStorageService\n      .get(InternalStorageKey.SETTINGS_SERIALIZER_CHUNK_TIME)\n      .then((setting) => (this._displayTimePerChunk = setting))\n      // eslint-disable-next-line no-console\n      .catch(console.error)\n    this.internalStorageService\n      .get(InternalStorageKey.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE)\n      .then((setting) => (this._singleChunkSize = setting))\n      // eslint-disable-next-line no-console\n      .catch(console.error)\n    this.internalStorageService\n      .get(InternalStorageKey.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE)\n      .then((setting) => (this._multiChunkSize = setting))\n      // eslint-disable-next-line no-console\n      .catch(console.error)\n  }\n\n  private async serializeV2(chunks: IACMessageDefinitionObjectV3[]): Promise<string[]> {\n    const dataV2 = await convertV3ToV2(chunks)\n\n    return this.serializer.serialize(dataV2, this.singleChunkSize, this.multiChunkSize)\n  }\n\n  private async deserializeV2(chunks: string[]): Promise<IACMessageDefinitionObjectV3[]> {\n    const v2Data = await this.serializer.deserialize(chunks)\n\n    return convertV2ToV3(v2Data)\n  }\n\n  private async serializeV3(chunks: IACMessageDefinitionObjectV3[]): Promise<string> {\n    return this.serializerV3.serialize(chunks)\n  }\n\n  private async deserializeV3(chunks: string): Promise<IACMessageDefinitionObjectV3[]> {\n    return this.serializerV3.deserialize(chunks)\n  }\n}\n"]}

package/esm2022/lib/services/storage/base.storage.mjs

@@ -0,0 +1,30 @@
+export class BaseStorage {
+    constructor(storage, defaultValues, drivers = []) {
+        this.defaultValues = defaultValues;
+        this.storage = Promise.all(drivers.map((driver) => storage.defineDriver(driver))).then(() => storage.create());
+    }
+    async getStorage() {
+        return this.storage;
+    }
+    async get(key) {
+        const storage = await this.getStorage();
+        const value = await storage.get(key);
+        const result = value !== null && value !== undefined ? value : this.defaultValues[key];
+        return result;
+    }
+    async set(key, value) {
+        const storage = await this.getStorage();
+        return storage.set(key, value);
+    }
+    async delete(key) {
+        try {
+            const storage = await this.getStorage();
+            await storage.remove(key);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { BaseStorage } from './base.storage';
+import * as i0 from "@angular/core";
+import * as i1 from "@ionic/storage-angular";
+export var InternalStorageKey;
+(function (InternalStorageKey) {
+    InternalStorageKey["SETTINGS_SERIALIZER_ENABLE_V3"] = "SETTINGS_SERIALIZER_ENABLE_V3";
+    InternalStorageKey["SETTINGS_SERIALIZER_CHUNK_TIME"] = "SETTINGS_SERIALIZER_CHUNK_TIME";
+    InternalStorageKey["SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE"] = "SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE";
+    InternalStorageKey["SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE"] = "SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE";
+    InternalStorageKey["SETTINGS_TRADING_USE_MTPELERIN"] = "SETTINGS_TRADING_USE_MTPELERIN";
+})(InternalStorageKey || (InternalStorageKey = {}));
+export const defaultValues = {
+    [InternalStorageKey.SETTINGS_SERIALIZER_ENABLE_V3]: true,
+    [InternalStorageKey.SETTINGS_SERIALIZER_CHUNK_TIME]: 200,
+    [InternalStorageKey.SETTINGS_SERIALIZER_SINGLE_CHUNK_SIZE]: 500,
+    [InternalStorageKey.SETTINGS_SERIALIZER_MULTI_CHUNK_SIZE]: 250,
+    [InternalStorageKey.SETTINGS_TRADING_USE_MTPELERIN]: true
+};
+export class InternalStorageService extends BaseStorage {
+    constructor(storage) {
+        super(storage, defaultValues);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InternalStorageService, deps: [{ token: i1.Storage }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InternalStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InternalStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.Storage }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,52 @@
+import { erc20Tokens } from '@wallfree-dev/ethereum';
+import { Injectable } from '@angular/core';
+import { createV0EthereumERC20Token } from '../../utils/protocol/protocol-v0-adapter';
+import * as i0 from "@angular/core";
+export class TokenService {
+    getRecipientToken(tx) {
+        // Guard against undefined tx.to[0] (e.g., Solana transactions may have empty to array)
+        if (!tx.to || !tx.to[0]) {
+            return undefined;
+        }
+        return Object.values(erc20Tokens).find((token) => token.contractAddress.toLowerCase() === tx.to[0].toLowerCase());
+    }
+    async getTokenTransferDetailsFromSigned(tx, signedTransaction, recipientToken) {
+        const token = recipientToken ?? this.getRecipientToken(tx);
+        if (token !== undefined) {
+            const genericErc20 = await createV0EthereumERC20Token(token);
+            try {
+                const transactions = await genericErc20.getTransactionDetailsFromSigned(signedTransaction);
+                if (transactions.length !== 1) {
+                    throw Error('`getTransactionDetailsFromSigned` returned more than 1 transaction!');
+                }
+                return transactions[0];
+            }
+            catch (error) { }
+        }
+        return tx;
+    }
+    async getTokenTransferDetails(tx, unsignedTransaction, recipientToken) {
+        const token = recipientToken ?? this.getRecipientToken(tx);
+        if (token !== undefined) {
+            const genericErc20 = await createV0EthereumERC20Token(token);
+            try {
+                const transactions = await genericErc20.getTransactionDetails(unsignedTransaction);
+                if (transactions.length !== 1) {
+                    throw Error('`getTransactionDetails` returned more than 1 transaction!');
+                }
+                return transactions[0];
+            }
+            catch (error) { }
+        }
+        return tx;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TokenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TokenService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TokenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4uc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvc2VydmljZXMvdG9rZW4vdG9rZW4uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQXNCLFdBQVcsRUFBRSxNQUFNLHdCQUF3QixDQUFBO0FBQ3hFLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFHMUMsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sMENBQTBDLENBQUE7O0FBS3JGLE1BQU0sT0FBTyxZQUFZO0lBQ2hCLGlCQUFpQixDQUFDLEVBQXNCO1FBQzdDLHVGQUF1RjtRQUN2RixJQUFJLENBQUMsRUFBRSxDQUFDLEVBQUUsSUFBSSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUN4QixPQUFPLFNBQVMsQ0FBQTtRQUNsQixDQUFDO1FBQ0QsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLEtBQXlCLEVBQUUsRUFBRSxDQUFDLEtBQUssQ0FBQyxlQUFlLENBQUMsV0FBVyxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQyxDQUFBO0lBQ3ZJLENBQUM7SUFFTSxLQUFLLENBQUMsaUNBQWlDLENBQzVDLEVBQXNCLEVBQ3RCLGlCQUFvQyxFQUNwQyxjQUFzQjtRQUV0QixNQUFNLEtBQUssR0FBc0IsY0FBYyxJQUFJLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLENBQUMsQ0FBQTtRQUM3RSxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztZQUN4QixNQUFNLFlBQVksR0FBa0IsTUFBTSwwQkFBMEIsQ0FBQyxLQUFLLENBQUMsQ0FBQTtZQUUzRSxJQUFJLENBQUM7Z0JBQ0gsTUFBTSxZQUFZLEdBQXlCLE1BQU0sWUFBWSxDQUFDLCtCQUErQixDQUFDLGlCQUFpQixDQUFDLENBQUE7Z0JBRWhILElBQUksWUFBWSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztvQkFDOUIsTUFBTSxLQUFLLENBQUMscUVBQXFFLENBQUMsQ0FBQTtnQkFDcEYsQ0FBQztnQkFFRCxPQUFPLFlBQVksQ0FBQyxDQUFDLENBQUMsQ0FBQTtZQUN4QixDQUFDO1lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQyxDQUFBLENBQUM7UUFDcEIsQ0FBQztRQUVELE9BQU8sRUFBRSxDQUFBO0lBQ1gsQ0FBQztJQUVNLEtBQUssQ0FBQyx1QkFBdUIsQ0FDbEMsRUFBc0IsRUFDdEIsbUJBQXdDLEVBQ3hDLGNBQXNCO1FBRXRCLE1BQU0sS0FBSyxHQUFzQixjQUFjLElBQUksSUFBSSxDQUFDLGlCQUFpQixDQUFDLEVBQUUsQ0FBQyxDQUFBO1FBQzdFLElBQUksS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ3hCLE1BQU0sWUFBWSxHQUFrQixNQUFNLDBCQUEwQixDQUFDLEtBQUssQ0FBQyxDQUFBO1lBRTNFLElBQUksQ0FBQztnQkFDSCxNQUFNLFlBQVksR0FBeUIsTUFBTSxZQUFZLENBQUMscUJBQXFCLENBQUMsbUJBQW1CLENBQUMsQ0FBQTtnQkFDeEcsSUFBSSxZQUFZLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO29CQUM5QixNQUFNLEtBQUssQ0FBQywyREFBMkQsQ0FBQyxDQUFBO2dCQUMxRSxDQUFDO2dCQUVELE9BQU8sWUFBWSxDQUFDLENBQUMsQ0FBQyxDQUFBO1lBQ3hCLENBQUM7WUFBQyxPQUFPLEtBQUssRUFBRSxDQUFDLENBQUEsQ0FBQztRQUNwQixDQUFDO1FBRUQsT0FBTyxFQUFFLENBQUE7SUFDWCxDQUFDOytHQXBEVSxZQUFZO21IQUFaLFlBQVksY0FGWCxNQUFNOzs0RkFFUCxZQUFZO2tCQUh4QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElBaXJHYXBUcmFuc2FjdGlvbiwgSUNvaW5Qcm90b2NvbCwgU2lnbmVkVHJhbnNhY3Rpb24sIFVuc2lnbmVkVHJhbnNhY3Rpb24gfSBmcm9tICdAd2FsbGZyZWUtZGV2L2NvaW5saWItY29yZSdcbmltcG9ydCB7IEVSQzIwVG9rZW5NZXRhZGF0YSwgZXJjMjBUb2tlbnMgfSBmcm9tICdAd2FsbGZyZWUtZGV2L2V0aGVyZXVtJ1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IFRva2VuIH0gZnJvbSAnLi4vLi4vdHlwZXMvVG9rZW4nXG5pbXBvcnQgeyBjcmVhdGVWMEV0aGVyZXVtRVJDMjBUb2tlbiB9IGZyb20gJy4uLy4uL3V0aWxzL3Byb3RvY29sL3Byb3RvY29sLXYwLWFkYXB0ZXInXG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIFRva2VuU2VydmljZSB7XG4gIHB1YmxpYyBnZXRSZWNpcGllbnRUb2tlbih0eDogSUFpckdhcFRyYW5zYWN0aW9uKTogVG9rZW4gfCB1bmRlZmluZWQge1xuICAgIC8vIEd1YXJkIGFnYWluc3QgdW5kZWZpbmVkIHR4LnRvWzBdIChlLmcuLCBTb2xhbmEgdHJhbnNhY3Rpb25zIG1heSBoYXZlIGVtcHR5IHRvIGFycmF5KVxuICAgIGlmICghdHgudG8gfHwgIXR4LnRvWzBdKSB7XG4gICAgICByZXR1cm4gdW5kZWZpbmVkXG4gICAgfVxuICAgIHJldHVybiBPYmplY3QudmFsdWVzKGVyYzIwVG9rZW5zKS5maW5kKCh0b2tlbjogRVJDMjBUb2tlbk1ldGFkYXRhKSA9PiB0b2tlbi5jb250cmFjdEFkZHJlc3MudG9Mb3dlckNhc2UoKSA9PT0gdHgudG9bMF0udG9Mb3dlckNhc2UoKSlcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBnZXRUb2tlblRyYW5zZmVyRGV0YWlsc0Zyb21TaWduZWQoXG4gICAgdHg6IElBaXJHYXBUcmFuc2FjdGlvbixcbiAgICBzaWduZWRUcmFuc2FjdGlvbjogU2lnbmVkVHJhbnNhY3Rpb24sXG4gICAgcmVjaXBpZW50VG9rZW4/OiBUb2tlblxuICApOiBQcm9taXNlPElBaXJHYXBUcmFuc2FjdGlvbj4ge1xuICAgIGNvbnN0IHRva2VuOiBUb2tlbiB8IHVuZGVmaW5lZCA9IHJlY2lwaWVudFRva2VuID8/IHRoaXMuZ2V0UmVjaXBpZW50VG9rZW4odHgpXG4gICAgaWYgKHRva2VuICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIGNvbnN0IGdlbmVyaWNFcmMyMDogSUNvaW5Qcm90b2NvbCA9IGF3YWl0IGNyZWF0ZVYwRXRoZXJldW1FUkMyMFRva2VuKHRva2VuKVxuXG4gICAgICB0cnkge1xuICAgICAgICBjb25zdCB0cmFuc2FjdGlvbnM6IElBaXJHYXBUcmFuc2FjdGlvbltdID0gYXdhaXQgZ2VuZXJpY0VyYzIwLmdldFRyYW5zYWN0aW9uRGV0YWlsc0Zyb21TaWduZWQoc2lnbmVkVHJhbnNhY3Rpb24pXG5cbiAgICAgICAgaWYgKHRyYW5zYWN0aW9ucy5sZW5ndGggIT09IDEpIHtcbiAgICAgICAgICB0aHJvdyBFcnJvcignYGdldFRyYW5zYWN0aW9uRGV0YWlsc0Zyb21TaWduZWRgIHJldHVybmVkIG1vcmUgdGhhbiAxIHRyYW5zYWN0aW9uIScpXG4gICAgICAgIH1cblxuICAgICAgICByZXR1cm4gdHJhbnNhY3Rpb25zWzBdXG4gICAgICB9IGNhdGNoIChlcnJvcikge31cbiAgICB9XG5cbiAgICByZXR1cm4gdHhcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBnZXRUb2tlblRyYW5zZmVyRGV0YWlscyhcbiAgICB0eDogSUFpckdhcFRyYW5zYWN0aW9uLFxuICAgIHVuc2lnbmVkVHJhbnNhY3Rpb246IFVuc2lnbmVkVHJhbnNhY3Rpb24sXG4gICAgcmVjaXBpZW50VG9rZW4/OiBUb2tlblxuICApOiBQcm9taXNlPElBaXJHYXBUcmFuc2FjdGlvbj4ge1xuICAgIGNvbnN0IHRva2VuOiBUb2tlbiB8IHVuZGVmaW5lZCA9IHJlY2lwaWVudFRva2VuID8/IHRoaXMuZ2V0UmVjaXBpZW50VG9rZW4odHgpXG4gICAgaWYgKHRva2VuICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIGNvbnN0IGdlbmVyaWNFcmMyMDogSUNvaW5Qcm90b2NvbCA9IGF3YWl0IGNyZWF0ZVYwRXRoZXJldW1FUkMyMFRva2VuKHRva2VuKVxuXG4gICAgICB0cnkge1xuICAgICAgICBjb25zdCB0cmFuc2FjdGlvbnM6IElBaXJHYXBUcmFuc2FjdGlvbltdID0gYXdhaXQgZ2VuZXJpY0VyYzIwLmdldFRyYW5zYWN0aW9uRGV0YWlscyh1bnNpZ25lZFRyYW5zYWN0aW9uKVxuICAgICAgICBpZiAodHJhbnNhY3Rpb25zLmxlbmd0aCAhPT0gMSkge1xuICAgICAgICAgIHRocm93IEVycm9yKCdgZ2V0VHJhbnNhY3Rpb25EZXRhaWxzYCByZXR1cm5lZCBtb3JlIHRoYW4gMSB0cmFuc2FjdGlvbiEnKVxuICAgICAgICB9XG5cbiAgICAgICAgcmV0dXJuIHRyYW5zYWN0aW9uc1swXVxuICAgICAgfSBjYXRjaCAoZXJyb3IpIHt9XG4gICAgfVxuXG4gICAgcmV0dXJuIHR4XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,67 @@
+import { IACMessageType } from '@wallfree-dev/serializer';
+import { Injectable } from '@angular/core';
+import { flattened } from '../../utils/array';
+import * as i0 from "@angular/core";
+import * as i1 from "../protocol/protocol.service";
+import * as i2 from "../token/token.service";
+export class TransactionService {
+    constructor(protocolService, tokenService) {
+        this.protocolService = protocolService;
+        this.tokenService = tokenService;
+    }
+    async getDetailsFromIACMessages(messages, config) {
+        const supportedMessageTypes = [IACMessageType.TransactionSignRequest, IACMessageType.TransactionSignResponse];
+        const details = await Promise.all(messages.map(async (message) => {
+            if (!supportedMessageTypes.includes(message.type)) {
+                return [];
+            }
+            const protocol = config?.overrideProtocol ?? (await this.protocolService.getProtocol(message.protocol));
+            switch (message.type) {
+                case IACMessageType.TransactionSignRequest:
+                    return this.getDetailsFromUnsigned(protocol, message.payload, config?.data);
+                case IACMessageType.TransactionSignResponse:
+                    return this.getDetailsFromSigned(protocol, message.payload, config?.data);
+                default:
+                    return [];
+            }
+        }));
+        return flattened(details);
+    }
+    async getDetailsFromUnsigned(protocol, unsignedTransaction, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data) {
+        const unsignedDetails = await protocol.getTransactionDetails(unsignedTransaction, data);
+        return Promise.all(unsignedDetails.map((details) => {
+            const token = this.tokenService.getRecipientToken(details);
+            if (token !== undefined) {
+                return this.tokenService.getTokenTransferDetails(details, unsignedTransaction, token);
+            }
+            else {
+                return details;
+            }
+        }));
+    }
+    async getDetailsFromSigned(protocol, signedTransaction, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    data) {
+        const unsignedDetails = await protocol.getTransactionDetailsFromSigned(signedTransaction, data);
+        return Promise.all(unsignedDetails.map((details) => {
+            const token = this.tokenService.getRecipientToken(details);
+            if (token !== undefined) {
+                return this.tokenService.getTokenTransferDetailsFromSigned(details, signedTransaction, token);
+            }
+            else {
+                return details;
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TransactionService, deps: [{ token: i1.ProtocolService }, { token: i2.TokenService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TransactionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TransactionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.ProtocolService }, { type: i2.TokenService }] });
+//# sourceMappingURL=data:application/json;base64,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