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

package/esm2022/lib/utils/protocol/protocol-v0-adapter.mjs

@@ -0,0 +1,390 @@
+/* eslint-disable max-lines */
+import { AeternityModule, createAeternityProtocol } from '@wallfree-dev/aeternity';
+import { AstarModule, createAstarProtocol, createShidenProtocol } from '@wallfree-dev/astar';
+import { ProtocolNetwork as ProtocolNetworkV0, NetworkType as ProtocolNetworkTypeV0 } from '@wallfree-dev/coinlib-core';
+import { createERC20Token as createEthereumERC20Token, createEthereumProtocol, EthereumModule } from '@wallfree-dev/ethereum';
+import { isOnlineProtocol, newAmount } from '@wallfree-dev/module-kit';
+import { BitcoinModule, createBitcoinProtocol, createBitcoinSegwitProtocol } from '@wallfree-dev/bitcoin';
+import { CoreumModule, createCoreumProtocol } from '@wallfree-dev/coreum';
+import { CosmosModule, createCosmosProtocol } from '@wallfree-dev/cosmos';
+import { createGroestlcoinProtocol, GroestlcoinModule } from '@wallfree-dev/groestlcoin';
+import { createICPProtocol, ICPModule } from '@wallfree-dev/icp';
+import { createMoonbaseProtocol, createMoonbeamProtocol, createMoonriverProtocol, MoonbeamModule } from '@wallfree-dev/moonbeam';
+import { createERC20Token as createOptimismERC20Token, createOptimismProtocol, OptimismModule } from '@wallfree-dev/optimism';
+import { createKusamaProtocol, createPolkadotProtocol, PolkadotModule } from '@wallfree-dev/polkadot';
+import { createSolanaProtocol, SolanaModule } from '@wallfree-dev/solana';
+import { createBTCTezProtocol, createCTezProtocol, createDogamiProtocol, createETHTezProtocol, createKolibriUSDProtocol, createPlentyProtocol, createQuipuswapProtocol, createSiriusProtocol, createStakerProtocol, createTetherUSDProtocol, createTezosFA1p2Protocol, createTezosFA2Protocol, createTezosKtProtocol, createTezosProtocol, createTezosShieldedTezProtocol, createTzBTCProtocol, createUBTCProtocol, createUDEFIProtocol, createUSDTezProtocol, createUUSDProtocol, createWrappedTezosProtocol, createWrapProtocol, createYouProtocol, TezosModule } from '@wallfree-dev/tezos';
+import BigNumber from '@wallfree-dev/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber';
+import { AirGapTransactionStatus as AirGapTransactionStatusV0, AirGapTransactionWarningType } from '@wallfree-dev/coinlib-core/interfaces/IAirGapTransaction';
+import { isHex } from '@wallfree-dev/coinlib-core/utils/hex';
+import { createICoinProtocolAdapter, createICoinSubProtocolAdapter, ProtocolBlockExplorerAdapter, ProtocolNetworkAdapter } from '../../protocol/adapter/protocol-v0-adapter';
+// Network
+export function convertNetworkTypeV0ToV1(type) {
+    return type === ProtocolNetworkTypeV0.MAINNET ? 'mainnet' : type === ProtocolNetworkTypeV0.TESTNET ? 'testnet' : 'custom';
+}
+export function convertNetworkTypeV1ToV0(type) {
+    return type === 'mainnet'
+        ? ProtocolNetworkTypeV0.MAINNET
+        : type === 'testnet'
+            ? ProtocolNetworkTypeV0.TESTNET
+            : ProtocolNetworkTypeV0.CUSTOM;
+}
+export function convertNetworkV0ToV1(network) {
+    return {
+        name: network.name,
+        type: convertNetworkTypeV0ToV1(network.type),
+        rpcUrl: network.rpcUrl,
+        blockExplorerUrl: network.blockExplorer.blockExplorer,
+        ...(typeof network.extras === 'object' ? network.extras : {})
+    };
+}
+export function convertNetworkV1ToV0(network, blockExplorer) {
+    const { name, type, rpcUrl, ...rest } = network;
+    const blockExplorerV0 = new ProtocolBlockExplorerAdapter(blockExplorer, network.blockExplorerUrl);
+    return new ProtocolNetworkAdapter(name, convertNetworkTypeV1ToV0(type), rpcUrl, blockExplorerV0, rest);
+}
+// Protocol
+async function createAdapterSupplementsFromIdentifierAndNetwork(module, identifier, network) {
+    const [blockExplorer, v3SerializerCompanion] = await Promise.all([
+        module.createBlockExplorer(identifier, network),
+        module.createV3SerializerCompanion()
+    ]);
+    return [blockExplorer, v3SerializerCompanion];
+}
+async function createAdapterSupplementsFromProtocol(protocol, module) {
+    const [metadata, network] = await Promise.all([
+        protocol.getMetadata(),
+        isOnlineProtocol(protocol) ? protocol.getNetwork() : Promise.resolve(undefined)
+    ]);
+    return createAdapterSupplementsFromIdentifierAndNetwork(module, metadata.identifier, network);
+}
+export async function createV0Protocol(protocol, module, type = 'full') {
+    const [blockExplorer, v3SerializerCompanion] = await createAdapterSupplementsFromProtocol(protocol, module);
+    return createICoinProtocolAdapter(protocol, blockExplorer, v3SerializerCompanion, { type });
+}
+export async function createV0SubProtocol(protocol, module, type = 'full') {
+    const [blockExplorer, v3SerializerCompanion] = await createAdapterSupplementsFromProtocol(protocol, module);
+    return createICoinSubProtocolAdapter(protocol, blockExplorer, v3SerializerCompanion, { type });
+}
+export async function createV0ERC20Token(erc20Token, protocol, module, type = 'full') {
+    const [metadata, network] = await Promise.all([
+        protocol.getMetadata(),
+        isOnlineProtocol(erc20Token) ? erc20Token.getNetwork() : Promise.resolve(undefined)
+    ]);
+    const [blockExplorer, v3SerializerCompanion] = await createAdapterSupplementsFromIdentifierAndNetwork(module, metadata.identifier, network);
+    return createICoinSubProtocolAdapter(erc20Token, blockExplorer, v3SerializerCompanion, { type });
+}
+export async function createV0AeternityProtocol(...args) {
+    const protocol = createAeternityProtocol(...args);
+    const module = new AeternityModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0AstarProtocol(...args) {
+    const protocol = createAstarProtocol(...args);
+    const module = new AstarModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0ShidenProtocol(...args) {
+    const protocol = createShidenProtocol(...args);
+    const module = new AstarModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0BitcoinProtocol(...args) {
+    const protocol = createBitcoinProtocol(...args);
+    const module = new BitcoinModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0BitcoinSegwitProtocol(...args) {
+    const protocol = createBitcoinSegwitProtocol(...args);
+    const module = new BitcoinModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0CoreumProtocol(...args) {
+    const protocol = createCoreumProtocol(...args);
+    const module = new CoreumModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0CosmosProtocol(...args) {
+    const protocol = createCosmosProtocol(...args);
+    const module = new CosmosModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0EthereumProtocol(...args) {
+    const protocol = createEthereumProtocol(...args);
+    const module = new EthereumModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0EthereumERC20Token(...args) {
+    const erc20Token = createEthereumERC20Token(...args);
+    const ethereumProtocol = createEthereumProtocol(args[1]);
+    const module = new EthereumModule();
+    return createV0ERC20Token(erc20Token, ethereumProtocol, module);
+}
+export async function createV0GroestlcoinProtocol(...args) {
+    const protocol = createGroestlcoinProtocol(...args);
+    const module = new GroestlcoinModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0ICPProtocol(...args) {
+    const protocol = createICPProtocol(...args);
+    const module = new ICPModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0MoonbeamProtocol(...args) {
+    const protocol = createMoonbeamProtocol(...args);
+    const module = new MoonbeamModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0MoonriverProtocol(...args) {
+    const protocol = createMoonriverProtocol(...args);
+    const module = new MoonbeamModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0MoonbaseProtocol(...args) {
+    const protocol = createMoonbaseProtocol(...args);
+    const module = new MoonbeamModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0OptimismProtocol(...args) {
+    const protocol = createOptimismProtocol(...args);
+    const module = new OptimismModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0OptimismERC20Token(...args) {
+    const erc20Token = createOptimismERC20Token(...args);
+    const optimismProtocol = createOptimismProtocol(args[1]);
+    const module = new OptimismModule();
+    return createV0ERC20Token(erc20Token, optimismProtocol, module);
+}
+export async function createV0PolkadotProtocol(...args) {
+    const protocol = createPolkadotProtocol(...args);
+    const module = new PolkadotModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0KusamaProtocol(...args) {
+    const protocol = createKusamaProtocol(...args);
+    const module = new PolkadotModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0SolanaProtocol(...args) {
+    const protocol = createSolanaProtocol(...args);
+    const module = new SolanaModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0TezosProtocol(...args) {
+    const protocol = createTezosProtocol(...args);
+    const module = new TezosModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0TezosShieldedTezProtocol(...args) {
+    const protocol = createTezosShieldedTezProtocol(...args);
+    const module = new TezosModule();
+    return createV0Protocol(protocol, module);
+}
+export async function createV0TezosKtProtocol(...args) {
+    const protocol = createTezosKtProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+async function createV0TezosFAProtocol(faProtocol, tezosNetwork, type = 'full') {
+    const tezosProtocol = createTezosProtocol({ network: tezosNetwork });
+    const module = new TezosModule();
+    const [metadata, network] = await Promise.all([
+        tezosProtocol.getMetadata(),
+        isOnlineProtocol(faProtocol) ? faProtocol.getNetwork() : Promise.resolve(undefined)
+    ]);
+    const [blockExplorer, v3SerializerCompanion] = await createAdapterSupplementsFromIdentifierAndNetwork(module, metadata.identifier, network);
+    return createICoinSubProtocolAdapter(faProtocol, blockExplorer, v3SerializerCompanion, { type });
+}
+export async function createV0TezosFA1p2Protocol(...args) {
+    const fa1p2Protocol = createTezosFA1p2Protocol(...args);
+    return createV0TezosFAProtocol(fa1p2Protocol, args[0].network);
+}
+export async function createV0TezosFA2Protocol(...args) {
+    const fa2Protocol = createTezosFA2Protocol(...args);
+    return createV0TezosFAProtocol(fa2Protocol, args[0].network);
+}
+export async function createV0TezosBTCTezProtocol(...args) {
+    const protocol = createBTCTezProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosCTezProtocol(...args) {
+    const protocol = createCTezProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosDogamiProtocol(...args) {
+    const protocol = createDogamiProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosETHTezProtocol(...args) {
+    const protocol = createETHTezProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosKolibriUSDProtocol(...args) {
+    const protocol = createKolibriUSDProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosPlentyProtocol(...args) {
+    const protocol = createPlentyProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosQuipuswapProtocol(...args) {
+    const protocol = createQuipuswapProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosSiriusProtocol(...args) {
+    const protocol = createSiriusProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosStakerProtocol(...args) {
+    const protocol = createStakerProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosTetherUSDProtocol(...args) {
+    const protocol = createTetherUSDProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosTzBTCProtocol(...args) {
+    const protocol = createTzBTCProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosUBTCProtocol(...args) {
+    const protocol = createUBTCProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosUDEFIProtocol(...args) {
+    const protocol = createUDEFIProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosUSDTezProtocol(...args) {
+    const protocol = createUSDTezProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosUUSDProtocol(...args) {
+    const protocol = createUUSDProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosWrappedProtocol(...args) {
+    const protocol = createWrappedTezosProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosWrapProtocol(...args) {
+    const protocol = createWrapProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+export async function createV0TezosYouProtocol(...args) {
+    const protocol = createYouProtocol(...args);
+    const module = new TezosModule();
+    return createV0SubProtocol(protocol, module);
+}
+// Transaction
+export function convertTransactionStatusV1ToV0(status) {
+    return status.type === 'applied'
+        ? AirGapTransactionStatusV0.APPLIED
+        : status.type === 'failed'
+            ? AirGapTransactionStatusV0.FAILED
+            : undefined;
+}
+function convertUIActionsV1ToV0(actions) {
+    return actions.map((action) => ({
+        text: action.text.value,
+        link: ''
+    }));
+}
+function convertUIAlertsV1ToV0(alerts) {
+    return alerts.map((alert) => ({
+        type: alert.type === 'success'
+            ? AirGapTransactionWarningType.SUCCESS
+            : alert.type === 'info'
+                ? AirGapTransactionWarningType.NOTE
+                : alert.type === 'warning'
+                    ? AirGapTransactionWarningType.WARNING
+                    : AirGapTransactionWarningType.ERROR,
+        title: alert.title.value,
+        description: alert.description.value,
+        icon: alert.icon,
+        actions: alert.actions ? convertUIActionsV1ToV0(alert.actions) : undefined
+    }));
+}
+// eslint-disable-next-line no-redeclare
+export async function convertTransactionDetailsV1ToV0(txs, protocolOrMetadata, networkOrUndefined) {
+    const protocolMetadata = isOnlineProtocol(protocolOrMetadata)
+        ? await protocolOrMetadata.getMetadata()
+        : protocolOrMetadata;
+    const networkV0 = isOnlineProtocol(protocolOrMetadata)
+        ? convertNetworkV1ToV0(await protocolOrMetadata.getNetwork())
+        : networkOrUndefined instanceof ProtocolNetworkV0
+            ? networkOrUndefined
+            : convertNetworkV1ToV0(networkOrUndefined);
+    const units = protocolMetadata.units;
+    const feeUnits = protocolMetadata.fee?.units ?? units;
+    return txs.map((tx) => {
+        return {
+            from: tx.from,
+            to: tx.to,
+            isInbound: tx.isInbound,
+            amount: newAmount(tx.amount).blockchain(units).value,
+            fee: newAmount(tx.fee).blockchain(feeUnits).value,
+            timestamp: tx.timestamp,
+            changeAddressInfo: tx.changeAddressInfo,
+            displayFromTo: tx.displayFromTo,
+            protocolIdentifier: protocolMetadata.identifier,
+            network: networkV0,
+            data: typeof tx.arbitraryData === 'string' ? tx.arbitraryData : tx.arbitraryData?.[1],
+            hash: tx.status?.hash,
+            blockHeight: tx.status?.block,
+            status: tx.status ? convertTransactionStatusV1ToV0(tx.status) : undefined,
+            warnings: tx.uiAlerts ? convertUIAlertsV1ToV0(tx.uiAlerts) : undefined,
+            extra: {
+                ...tx.extra,
+                type: tx.type
+            },
+            transactionDetails: tx.json
+        };
+    });
+}
+// FeeDefaults
+export function convertFeeDefaultsV0ToV1(feeDefaults, decimals) {
+    return {
+        low: newAmount(new BigNumber(feeDefaults.low).shiftedBy(decimals), 'blockchain'),
+        medium: newAmount(new BigNumber(feeDefaults.medium).shiftedBy(decimals), 'blockchain'),
+        high: newAmount(new BigNumber(feeDefaults.high).shiftedBy(decimals), 'blockchain')
+    };
+}
+export function convertFeeDefaultsV1ToV0(feeDefaults, protocolMetadata) {
+    const feeUnits = protocolMetadata.fee?.units ?? protocolMetadata.units;
+    const feeUnit = protocolMetadata.fee?.mainUnit ?? protocolMetadata.mainUnit;
+    return {
+        low: new BigNumber(newAmount(feeDefaults.low).convert(feeUnit, feeUnits).value).toFixed(),
+        medium: new BigNumber(newAmount(feeDefaults.medium).convert(feeUnit, feeUnits).value).toFixed(),
+        high: new BigNumber(newAmount(feeDefaults.high).convert(feeUnit, feeUnits).value).toFixed()
+    };
+}
+// Bytes
+export function getBytesFormatV1FromV0(bytes) {
+    return isHex(bytes) ? 'hex' : 'encoded';
+}
+export function getSecretKeyType(secretKey) {
+    return secretKey.startsWith('xprv') ? 'xpriv' : 'priv';
+}
+export function getPublicKeyType(publicKey) {
+    return publicKey.startsWith('xpub') ? 'xpub' : 'pub';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol-v0-adapter.js","sourceRoot":"","sources":["../../../../../src/lib/utils/protocol/protocol-v0-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-lines */\nimport { AeternityModule, AeternityProtocol, createAeternityProtocol } from '@wallfree-dev/aeternity'\nimport { AstarModule, AstarProtocol, createAstarProtocol, createShidenProtocol, ShidenProtocol } from '@wallfree-dev/astar'\nimport {\n  ProtocolNetwork as ProtocolNetworkV0,\n  NetworkType as ProtocolNetworkTypeV0,\n  ProtocolBlockExplorer as ProtocolBlockExplorerV0,\n  FeeDefaults as FeeDefaultsV0,\n  IAirGapTransaction as AirGapTransactionV0,\n  ProtocolSymbols\n} from '@wallfree-dev/coinlib-core'\nimport {\n  createERC20Token as createEthereumERC20Token,\n  createEthereumProtocol,\n  ERC20Token as EthereumERC20Token,\n  EthereumModule,\n  EthereumProtocol\n} from '@wallfree-dev/ethereum'\nimport {\n  AirGapAnyProtocol,\n  AirGapBlockExplorer as ProtocolBlockExplorerV1,\n  AirGapModule,\n  AirGapOnlineProtocol,\n  AirGapTransaction as AirGapTransactionV1,\n  AirGapTransactionStatus as AirGapTransactionStatusV1,\n  AirGapUIAction as AirGapUIActionV1,\n  AirGapUIAlert as AirGapUIAlertV1,\n  AirGapV3SerializerCompanion,\n  BytesStringFormat,\n  ExtendedPublicKey,\n  ExtendedSecretKey,\n  FeeDefaults as FeeDefaultsV1,\n  isOnlineProtocol,\n  newAmount,\n  ProtocolConfiguration,\n  ProtocolMetadata,\n  ProtocolNetwork as ProtocolNetworkV1,\n  ProtocolNetworkType as ProtocolNetworkTypeV1,\n  ProtocolUnitsMetadata,\n  PublicKey,\n  RecursivePartial,\n  SecretKey,\n  SubProtocol\n} from '@wallfree-dev/module-kit'\nimport { BitcoinModule, BitcoinProtocol, BitcoinSegwitProtocol, createBitcoinProtocol, createBitcoinSegwitProtocol } from '@wallfree-dev/bitcoin'\nimport { CoreumModule, CoreumProtocol, createCoreumProtocol } from '@wallfree-dev/coreum'\nimport { CosmosModule, CosmosProtocol, createCosmosProtocol } from '@wallfree-dev/cosmos'\nimport { createGroestlcoinProtocol, GroestlcoinModule, GroestlcoinProtocol } from '@wallfree-dev/groestlcoin'\nimport { createICPProtocol, ICPModule, ICPProtocol } from '@wallfree-dev/icp'\nimport {\n  createMoonbaseProtocol,\n  createMoonbeamProtocol,\n  createMoonriverProtocol,\n  MoonbaseProtocol,\n  MoonbeamModule,\n  MoonbeamProtocol,\n  MoonriverProtocol\n} from '@wallfree-dev/moonbeam'\nimport {\n  createERC20Token as createOptimismERC20Token,\n  createOptimismProtocol,\n  ERC20Token as OptimismERC20Token,\n  OptimismModule,\n  OptimismProtocol\n} from '@wallfree-dev/optimism'\nimport { createKusamaProtocol, createPolkadotProtocol, KusamaProtocol, PolkadotModule, PolkadotProtocol } from '@wallfree-dev/polkadot'\nimport { createSolanaProtocol, SolanaModule, SolanaProtocol } from '@wallfree-dev/solana'\nimport {\n  BTCTezProtocol,\n  createBTCTezProtocol,\n  createCTezProtocol,\n  createDogamiProtocol,\n  createETHTezProtocol,\n  createKolibriUSDProtocol,\n  createPlentyProtocol,\n  createQuipuswapProtocol,\n  createSiriusProtocol,\n  createStakerProtocol,\n  createTetherUSDProtocol,\n  createTezosFA1p2Protocol,\n  createTezosFA2Protocol,\n  createTezosKtProtocol,\n  createTezosProtocol,\n  createTezosShieldedTezProtocol,\n  createTzBTCProtocol,\n  createUBTCProtocol,\n  createUDEFIProtocol,\n  createUSDTezProtocol,\n  createUUSDProtocol,\n  createWrappedTezosProtocol,\n  createWrapProtocol,\n  createYouProtocol,\n  CTezProtocol,\n  DogamiProtocol,\n  ETHTezProtocol,\n  KolibriUSDProtocol,\n  PlentyProtocol,\n  QuipuswapProtocol,\n  SiriusProtocol,\n  StakerProtocol,\n  TetherUSDProtocol,\n  TezosFA1p2Protocol,\n  TezosFA2Protocol,\n  TezosFAProtocol,\n  TezosKtProtocol,\n  TezosModule,\n  TezosProtocol,\n  TezosProtocolNetwork,\n  TezosShieldedTezProtocol,\n  TzBTCProtocol,\n  UBTCProtocol,\n  UDEFIProtocol,\n  USDTezProtocol,\n  UUSDProtocol,\n  WrappedTezosProtocol,\n  WrapProtocol,\n  YouProtocol\n} from '@wallfree-dev/tezos'\nimport BigNumber from '@wallfree-dev/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber'\n\nimport {\n  AirGapTransactionStatus as AirGapTransactionStatusV0,\n  AirGapTransactionWarning as AirGapUIAlertV0,\n  AirGapTransactionWarningType\n} from '@wallfree-dev/coinlib-core/interfaces/IAirGapTransaction'\nimport { isHex } from '@wallfree-dev/coinlib-core/utils/hex'\n\nimport {\n  createICoinProtocolAdapter,\n  createICoinSubProtocolAdapter,\n  ICoinProtocolAdapter,\n  ICoinSubProtocolAdapter,\n  ProtocolBlockExplorerAdapter,\n  ProtocolNetworkAdapter\n} from '../../protocol/adapter/protocol-v0-adapter'\n\n// Network\n\nexport function convertNetworkTypeV0ToV1(type: ProtocolNetworkTypeV0): ProtocolNetworkTypeV1 {\n  return type === ProtocolNetworkTypeV0.MAINNET ? 'mainnet' : type === ProtocolNetworkTypeV0.TESTNET ? 'testnet' : 'custom'\n}\n\nexport function convertNetworkTypeV1ToV0(type: ProtocolNetworkTypeV1): ProtocolNetworkTypeV0 {\n  return type === 'mainnet'\n    ? ProtocolNetworkTypeV0.MAINNET\n    : type === 'testnet'\n    ? ProtocolNetworkTypeV0.TESTNET\n    : ProtocolNetworkTypeV0.CUSTOM\n}\n\nexport function convertNetworkV0ToV1(network: ProtocolNetworkV0): ProtocolNetworkV1 {\n  return {\n    name: network.name,\n    type: convertNetworkTypeV0ToV1(network.type),\n    rpcUrl: network.rpcUrl,\n    blockExplorerUrl: network.blockExplorer.blockExplorer,\n    ...(typeof network.extras === 'object' ? network.extras : {})\n  }\n}\n\nexport function convertNetworkV1ToV0(network: ProtocolNetworkV1, blockExplorer?: ProtocolBlockExplorerV1): ProtocolNetworkV0 {\n  const { name, type, rpcUrl, ...rest } = network\n  const blockExplorerV0: ProtocolBlockExplorerV0 = new ProtocolBlockExplorerAdapter(blockExplorer, network.blockExplorerUrl)\n\n  return new ProtocolNetworkAdapter(name, convertNetworkTypeV1ToV0(type), rpcUrl, blockExplorerV0, rest)\n}\n\n// Protocol\n\nasync function createAdapterSupplementsFromIdentifierAndNetwork(\n  module: AirGapModule,\n  identifier: string,\n  network: ProtocolNetworkV1 | undefined\n): Promise<[ProtocolBlockExplorerV1, AirGapV3SerializerCompanion]> {\n  const [blockExplorer, v3SerializerCompanion] = await Promise.all([\n    module.createBlockExplorer(identifier, network),\n    module.createV3SerializerCompanion()\n  ])\n\n  return [blockExplorer, v3SerializerCompanion]\n}\n\nasync function createAdapterSupplementsFromProtocol<T extends AirGapAnyProtocol>(\n  protocol: T,\n  module: AirGapModule\n): Promise<[ProtocolBlockExplorerV1, AirGapV3SerializerCompanion]> {\n  const [metadata, network]: [ProtocolMetadata, ProtocolNetworkV1 | undefined] = await Promise.all([\n    protocol.getMetadata(),\n    isOnlineProtocol(protocol) ? protocol.getNetwork() : Promise.resolve(undefined)\n  ])\n\n  return createAdapterSupplementsFromIdentifierAndNetwork(module, metadata.identifier, network)\n}\n\nexport async function createV0Protocol<T extends AirGapAnyProtocol>(\n  protocol: T,\n  module: AirGapModule,\n  type: ProtocolConfiguration['type'] = 'full'\n): Promise<ICoinProtocolAdapter<T>> {\n  const [blockExplorer, v3SerializerCompanion]: [ProtocolBlockExplorerV1, AirGapV3SerializerCompanion] =\n    await createAdapterSupplementsFromProtocol(protocol, module)\n\n  return createICoinProtocolAdapter(protocol, blockExplorer, v3SerializerCompanion, { type })\n}\n\nexport async function createV0SubProtocol<T extends AirGapAnyProtocol & SubProtocol>(\n  protocol: T,\n  module: AirGapModule,\n  type: ProtocolConfiguration['type'] = 'full'\n): Promise<ICoinSubProtocolAdapter<T>> {\n  const [blockExplorer, v3SerializerCompanion]: [ProtocolBlockExplorerV1, AirGapV3SerializerCompanion] =\n    await createAdapterSupplementsFromProtocol(protocol, module)\n\n  return createICoinSubProtocolAdapter(protocol, blockExplorer, v3SerializerCompanion, { type })\n}\n\nexport async function createV0ERC20Token<T extends AirGapAnyProtocol & SubProtocol>(\n  erc20Token: T,\n  protocol: AirGapAnyProtocol,\n  module: AirGapModule,\n  type: ProtocolConfiguration['type'] = 'full'\n): Promise<ICoinSubProtocolAdapter<T>> {\n  const [metadata, network]: [ProtocolMetadata, ProtocolNetworkV1 | undefined] = await Promise.all([\n    protocol.getMetadata(),\n    isOnlineProtocol(erc20Token) ? erc20Token.getNetwork() : Promise.resolve(undefined)\n  ])\n\n  const [blockExplorer, v3SerializerCompanion] = await createAdapterSupplementsFromIdentifierAndNetwork(\n    module,\n    metadata.identifier,\n    network\n  )\n\n  return createICoinSubProtocolAdapter(erc20Token, blockExplorer, v3SerializerCompanion, { type })\n}\n\nexport async function createV0AeternityProtocol(\n  ...args: Parameters<typeof createAeternityProtocol>\n): Promise<ICoinProtocolAdapter<AeternityProtocol>> {\n  const protocol: AeternityProtocol = createAeternityProtocol(...args)\n  const module: AeternityModule = new AeternityModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0AstarProtocol(...args: Parameters<typeof createAstarProtocol>): Promise<ICoinProtocolAdapter<AstarProtocol>> {\n  const protocol: AstarProtocol = createAstarProtocol(...args)\n  const module: AstarModule = new AstarModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0ShidenProtocol(\n  ...args: Parameters<typeof createShidenProtocol>\n): Promise<ICoinProtocolAdapter<ShidenProtocol>> {\n  const protocol: ShidenProtocol = createShidenProtocol(...args)\n  const module: AstarModule = new AstarModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0BitcoinProtocol(\n  ...args: Parameters<typeof createBitcoinProtocol>\n): Promise<ICoinProtocolAdapter<BitcoinProtocol>> {\n  const protocol: BitcoinProtocol = createBitcoinProtocol(...args)\n  const module: BitcoinModule = new BitcoinModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0BitcoinSegwitProtocol(\n  ...args: Parameters<typeof createBitcoinSegwitProtocol>\n): Promise<ICoinProtocolAdapter<BitcoinSegwitProtocol>> {\n  const protocol: BitcoinSegwitProtocol = createBitcoinSegwitProtocol(...args)\n  const module: BitcoinModule = new BitcoinModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0CoreumProtocol(\n  ...args: Parameters<typeof createCoreumProtocol>\n): Promise<ICoinProtocolAdapter<CoreumProtocol>> {\n  const protocol: CoreumProtocol = createCoreumProtocol(...args)\n  const module: CoreumModule = new CoreumModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0CosmosProtocol(\n  ...args: Parameters<typeof createCosmosProtocol>\n): Promise<ICoinProtocolAdapter<CosmosProtocol>> {\n  const protocol: CosmosProtocol = createCosmosProtocol(...args)\n  const module: CosmosModule = new CosmosModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0EthereumProtocol(\n  ...args: Parameters<typeof createEthereumProtocol>\n): Promise<ICoinProtocolAdapter<EthereumProtocol>> {\n  const protocol: EthereumProtocol = createEthereumProtocol(...args)\n  const module: EthereumModule = new EthereumModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0EthereumERC20Token(\n  ...args: Parameters<typeof createEthereumERC20Token>\n): Promise<ICoinSubProtocolAdapter<EthereumERC20Token>> {\n  const erc20Token: EthereumERC20Token = createEthereumERC20Token(...args)\n  const ethereumProtocol: EthereumProtocol = createEthereumProtocol(args[1])\n  const module: EthereumModule = new EthereumModule()\n\n  return createV0ERC20Token(erc20Token, ethereumProtocol, module)\n}\n\nexport async function createV0GroestlcoinProtocol(\n  ...args: Parameters<typeof createGroestlcoinProtocol>\n): Promise<ICoinProtocolAdapter<GroestlcoinProtocol>> {\n  const protocol: GroestlcoinProtocol = createGroestlcoinProtocol(...args)\n  const module: GroestlcoinModule = new GroestlcoinModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0ICPProtocol(...args: Parameters<typeof createICPProtocol>): Promise<ICoinProtocolAdapter<ICPProtocol>> {\n  const protocol: ICPProtocol = createICPProtocol(...args)\n  const module: ICPModule = new ICPModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0MoonbeamProtocol(\n  ...args: Parameters<typeof createMoonbeamProtocol>\n): Promise<ICoinProtocolAdapter<MoonbeamProtocol>> {\n  const protocol: MoonbeamProtocol = createMoonbeamProtocol(...args)\n  const module: MoonbeamModule = new MoonbeamModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0MoonriverProtocol(\n  ...args: Parameters<typeof createMoonriverProtocol>\n): Promise<ICoinProtocolAdapter<MoonriverProtocol>> {\n  const protocol: MoonriverProtocol = createMoonriverProtocol(...args)\n  const module: MoonbeamModule = new MoonbeamModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0MoonbaseProtocol(\n  ...args: Parameters<typeof createMoonbaseProtocol>\n): Promise<ICoinProtocolAdapter<MoonbaseProtocol>> {\n  const protocol: MoonbaseProtocol = createMoonbaseProtocol(...args)\n  const module: MoonbeamModule = new MoonbeamModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0OptimismProtocol(\n  ...args: Parameters<typeof createOptimismProtocol>\n): Promise<ICoinProtocolAdapter<OptimismProtocol>> {\n  const protocol: OptimismProtocol = createOptimismProtocol(...args)\n  const module: OptimismModule = new OptimismModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0OptimismERC20Token(\n  ...args: Parameters<typeof createOptimismERC20Token>\n): Promise<ICoinSubProtocolAdapter<OptimismERC20Token>> {\n  const erc20Token: OptimismERC20Token = createOptimismERC20Token(...args)\n  const optimismProtocol: OptimismProtocol = createOptimismProtocol(args[1])\n  const module: OptimismModule = new OptimismModule()\n\n  return createV0ERC20Token(erc20Token, optimismProtocol, module)\n}\n\nexport async function createV0PolkadotProtocol(\n  ...args: Parameters<typeof createPolkadotProtocol>\n): Promise<ICoinProtocolAdapter<PolkadotProtocol>> {\n  const protocol: PolkadotProtocol = createPolkadotProtocol(...args)\n  const module: PolkadotModule = new PolkadotModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0KusamaProtocol(\n  ...args: Parameters<typeof createKusamaProtocol>\n): Promise<ICoinProtocolAdapter<KusamaProtocol>> {\n  const protocol: KusamaProtocol = createKusamaProtocol(...args)\n  const module: PolkadotModule = new PolkadotModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0SolanaProtocol(\n  ...args: Parameters<typeof createSolanaProtocol>\n): Promise<ICoinProtocolAdapter<SolanaProtocol>> {\n  const protocol: SolanaProtocol = createSolanaProtocol(...args)\n  const module: any = new SolanaModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0TezosProtocol(...args: Parameters<typeof createTezosProtocol>): Promise<ICoinProtocolAdapter<TezosProtocol>> {\n  const protocol: TezosProtocol = createTezosProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0TezosShieldedTezProtocol(\n  ...args: Parameters<typeof createTezosShieldedTezProtocol>\n): Promise<ICoinProtocolAdapter<TezosShieldedTezProtocol>> {\n  const protocol: TezosShieldedTezProtocol = createTezosShieldedTezProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0Protocol(protocol, module)\n}\n\nexport async function createV0TezosKtProtocol(\n  ...args: Parameters<typeof createTezosKtProtocol>\n): Promise<ICoinSubProtocolAdapter<TezosKtProtocol>> {\n  const protocol: TezosKtProtocol = createTezosKtProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nasync function createV0TezosFAProtocol<T extends TezosFAProtocol>(\n  faProtocol: T,\n  tezosNetwork?: RecursivePartial<TezosProtocolNetwork>,\n  type: ProtocolConfiguration['type'] = 'full'\n): Promise<ICoinSubProtocolAdapter<T>> {\n  const tezosProtocol: TezosProtocol = createTezosProtocol({ network: tezosNetwork })\n  const module: TezosModule = new TezosModule()\n\n  const [metadata, network]: [ProtocolMetadata, ProtocolNetworkV1 | undefined] = await Promise.all([\n    tezosProtocol.getMetadata(),\n    isOnlineProtocol(faProtocol) ? faProtocol.getNetwork() : Promise.resolve(undefined)\n  ])\n\n  const [blockExplorer, v3SerializerCompanion] = await createAdapterSupplementsFromIdentifierAndNetwork(\n    module,\n    metadata.identifier,\n    network\n  )\n\n  return createICoinSubProtocolAdapter(faProtocol, blockExplorer, v3SerializerCompanion, { type })\n}\n\nexport async function createV0TezosFA1p2Protocol(\n  ...args: Parameters<typeof createTezosFA1p2Protocol>\n): Promise<ICoinSubProtocolAdapter<TezosFA1p2Protocol>> {\n  const fa1p2Protocol: TezosFA1p2Protocol = createTezosFA1p2Protocol(...args)\n\n  return createV0TezosFAProtocol(fa1p2Protocol, args[0].network)\n}\n\nexport async function createV0TezosFA2Protocol(\n  ...args: Parameters<typeof createTezosFA2Protocol>\n): Promise<ICoinSubProtocolAdapter<TezosFA2Protocol>> {\n  const fa2Protocol: TezosFA2Protocol = createTezosFA2Protocol(...args)\n\n  return createV0TezosFAProtocol(fa2Protocol, args[0].network)\n}\n\nexport async function createV0TezosBTCTezProtocol(\n  ...args: Parameters<typeof createBTCTezProtocol>\n): Promise<ICoinSubProtocolAdapter<BTCTezProtocol>> {\n  const protocol: BTCTezProtocol = createBTCTezProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosCTezProtocol(\n  ...args: Parameters<typeof createCTezProtocol>\n): Promise<ICoinSubProtocolAdapter<CTezProtocol>> {\n  const protocol: CTezProtocol = createCTezProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosDogamiProtocol(\n  ...args: Parameters<typeof createDogamiProtocol>\n): Promise<ICoinSubProtocolAdapter<DogamiProtocol>> {\n  const protocol: DogamiProtocol = createDogamiProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosETHTezProtocol(\n  ...args: Parameters<typeof createETHTezProtocol>\n): Promise<ICoinSubProtocolAdapter<ETHTezProtocol>> {\n  const protocol: ETHTezProtocol = createETHTezProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosKolibriUSDProtocol(\n  ...args: Parameters<typeof createKolibriUSDProtocol>\n): Promise<ICoinSubProtocolAdapter<KolibriUSDProtocol>> {\n  const protocol: KolibriUSDProtocol = createKolibriUSDProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosPlentyProtocol(\n  ...args: Parameters<typeof createPlentyProtocol>\n): Promise<ICoinSubProtocolAdapter<PlentyProtocol>> {\n  const protocol: PlentyProtocol = createPlentyProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosQuipuswapProtocol(\n  ...args: Parameters<typeof createQuipuswapProtocol>\n): Promise<ICoinSubProtocolAdapter<QuipuswapProtocol>> {\n  const protocol: QuipuswapProtocol = createQuipuswapProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosSiriusProtocol(\n  ...args: Parameters<typeof createSiriusProtocol>\n): Promise<ICoinSubProtocolAdapter<SiriusProtocol>> {\n  const protocol: SiriusProtocol = createSiriusProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosStakerProtocol(\n  ...args: Parameters<typeof createStakerProtocol>\n): Promise<ICoinSubProtocolAdapter<StakerProtocol>> {\n  const protocol: StakerProtocol = createStakerProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosTetherUSDProtocol(\n  ...args: Parameters<typeof createTetherUSDProtocol>\n): Promise<ICoinSubProtocolAdapter<TetherUSDProtocol>> {\n  const protocol: TetherUSDProtocol = createTetherUSDProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosTzBTCProtocol(\n  ...args: Parameters<typeof createTzBTCProtocol>\n): Promise<ICoinSubProtocolAdapter<TzBTCProtocol>> {\n  const protocol: TzBTCProtocol = createTzBTCProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosUBTCProtocol(\n  ...args: Parameters<typeof createUBTCProtocol>\n): Promise<ICoinSubProtocolAdapter<UBTCProtocol>> {\n  const protocol: UBTCProtocol = createUBTCProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosUDEFIProtocol(\n  ...args: Parameters<typeof createUDEFIProtocol>\n): Promise<ICoinSubProtocolAdapter<UDEFIProtocol>> {\n  const protocol: UDEFIProtocol = createUDEFIProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosUSDTezProtocol(\n  ...args: Parameters<typeof createUSDTezProtocol>\n): Promise<ICoinSubProtocolAdapter<USDTezProtocol>> {\n  const protocol: USDTezProtocol = createUSDTezProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosUUSDProtocol(\n  ...args: Parameters<typeof createUUSDProtocol>\n): Promise<ICoinSubProtocolAdapter<UUSDProtocol>> {\n  const protocol: UUSDProtocol = createUUSDProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosWrappedProtocol(\n  ...args: Parameters<typeof createWrappedTezosProtocol>\n): Promise<ICoinSubProtocolAdapter<WrappedTezosProtocol>> {\n  const protocol: WrappedTezosProtocol = createWrappedTezosProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosWrapProtocol(\n  ...args: Parameters<typeof createWrapProtocol>\n): Promise<ICoinSubProtocolAdapter<WrapProtocol>> {\n  const protocol: WrapProtocol = createWrapProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\nexport async function createV0TezosYouProtocol(\n  ...args: Parameters<typeof createYouProtocol>\n): Promise<ICoinSubProtocolAdapter<YouProtocol>> {\n  const protocol: YouProtocol = createYouProtocol(...args)\n  const module: TezosModule = new TezosModule()\n\n  return createV0SubProtocol(protocol, module)\n}\n\n// Transaction\n\nexport function convertTransactionStatusV1ToV0(status: AirGapTransactionStatusV1): AirGapTransactionStatusV0 {\n  return status.type === 'applied'\n    ? AirGapTransactionStatusV0.APPLIED\n    : status.type === 'failed'\n    ? AirGapTransactionStatusV0.FAILED\n    : undefined\n}\n\nfunction convertUIActionsV1ToV0(actions: AirGapUIActionV1[]): AirGapUIAlertV0['actions'] {\n  return actions.map((action: AirGapUIActionV1) => ({\n    text: action.text.value,\n    link: ''\n  }))\n}\n\nfunction convertUIAlertsV1ToV0(alerts: AirGapUIAlertV1[]): AirGapUIAlertV0[] {\n  return alerts.map((alert: AirGapUIAlertV1) => ({\n    type:\n      alert.type === 'success'\n        ? AirGapTransactionWarningType.SUCCESS\n        : alert.type === 'info'\n        ? AirGapTransactionWarningType.NOTE\n        : alert.type === 'warning'\n        ? AirGapTransactionWarningType.WARNING\n        : AirGapTransactionWarningType.ERROR,\n    title: alert.title.value,\n    description: alert.description.value,\n    icon: alert.icon,\n    actions: alert.actions ? convertUIActionsV1ToV0(alert.actions) : undefined\n  }))\n}\n\nexport async function convertTransactionDetailsV1ToV0(\n  txs: AirGapTransactionV1[],\n  protocol: AirGapOnlineProtocol\n): Promise<AirGapTransactionV0[]>\n// eslint-disable-next-line no-redeclare\nexport async function convertTransactionDetailsV1ToV0(\n  txs: AirGapTransactionV1[],\n  metadata: ProtocolMetadata,\n  network: ProtocolNetworkV1 | ProtocolNetworkV0\n): Promise<AirGapTransactionV0[]>\n// eslint-disable-next-line no-redeclare\nexport async function convertTransactionDetailsV1ToV0(\n  txs: AirGapTransactionV1[],\n  protocolOrMetadata: AirGapOnlineProtocol | ProtocolMetadata,\n  networkOrUndefined?: ProtocolNetworkV1 | ProtocolNetworkV0\n): Promise<AirGapTransactionV0[]> {\n  const protocolMetadata: ProtocolMetadata = isOnlineProtocol(protocolOrMetadata)\n    ? await protocolOrMetadata.getMetadata()\n    : protocolOrMetadata\n\n  const networkV0: ProtocolNetworkV0 = isOnlineProtocol(protocolOrMetadata)\n    ? convertNetworkV1ToV0(await protocolOrMetadata.getNetwork())\n    : networkOrUndefined instanceof ProtocolNetworkV0\n    ? networkOrUndefined\n    : convertNetworkV1ToV0(networkOrUndefined)\n\n  const units: ProtocolUnitsMetadata = protocolMetadata.units\n  const feeUnits: ProtocolUnitsMetadata = protocolMetadata.fee?.units ?? units\n\n  return txs.map((tx: AirGapTransactionV1): AirGapTransactionV0 => {\n    return {\n      from: tx.from,\n      to: tx.to,\n      isInbound: tx.isInbound,\n\n      amount: newAmount(tx.amount).blockchain(units).value,\n      fee: newAmount(tx.fee).blockchain(feeUnits).value,\n\n      timestamp: tx.timestamp,\n      changeAddressInfo: tx.changeAddressInfo,\n      displayFromTo: tx.displayFromTo,\n\n      protocolIdentifier: protocolMetadata.identifier as ProtocolSymbols,\n      network: networkV0,\n\n      data: typeof tx.arbitraryData === 'string' ? tx.arbitraryData : tx.arbitraryData?.[1],\n\n      hash: tx.status?.hash,\n      blockHeight: tx.status?.block,\n      status: tx.status ? convertTransactionStatusV1ToV0(tx.status) : undefined,\n\n      warnings: tx.uiAlerts ? convertUIAlertsV1ToV0(tx.uiAlerts) : undefined,\n\n      extra: {\n        ...tx.extra,\n        type: tx.type\n      },\n      transactionDetails: tx.json\n    }\n  })\n}\n\n// FeeDefaults\n\nexport function convertFeeDefaultsV0ToV1<_FeeUnits extends string>(feeDefaults: FeeDefaultsV0, decimals: number): FeeDefaultsV1<_FeeUnits> {\n  return {\n    low: newAmount(new BigNumber(feeDefaults.low).shiftedBy(decimals), 'blockchain'),\n    medium: newAmount(new BigNumber(feeDefaults.medium).shiftedBy(decimals), 'blockchain'),\n    high: newAmount(new BigNumber(feeDefaults.high).shiftedBy(decimals), 'blockchain')\n  }\n}\n\nexport function convertFeeDefaultsV1ToV0(feeDefaults: FeeDefaultsV1, protocolMetadata: ProtocolMetadata): FeeDefaultsV0 {\n  const feeUnits: ProtocolUnitsMetadata = protocolMetadata.fee?.units ?? protocolMetadata.units\n  const feeUnit: string = protocolMetadata.fee?.mainUnit ?? protocolMetadata.mainUnit\n\n  return {\n    low: new BigNumber(newAmount(feeDefaults.low).convert(feeUnit, feeUnits).value).toFixed(),\n    medium: new BigNumber(newAmount(feeDefaults.medium).convert(feeUnit, feeUnits).value).toFixed(),\n    high: new BigNumber(newAmount(feeDefaults.high).convert(feeUnit, feeUnits).value).toFixed()\n  }\n}\n\n// Bytes\n\nexport function getBytesFormatV1FromV0(bytes: string): BytesStringFormat {\n  return isHex(bytes) ? 'hex' : 'encoded'\n}\n\nexport function getSecretKeyType(secretKey: string): SecretKey['type'] | ExtendedSecretKey['type'] {\n  return secretKey.startsWith('xprv') ? 'xpriv' : 'priv'\n}\n\nexport function getPublicKeyType(publicKey: string): PublicKey['type'] | ExtendedPublicKey['type'] {\n  return publicKey.startsWith('xpub') ? 'xpub' : 'pub'\n}\n"]}

package/esm2022/lib/utils/utils.mjs

@@ -0,0 +1,80 @@
+// TODO: Split up into individual files
+// https://stackoverflow.com/a/8472700/4790610
+export function generateGUID() {
+    // tslint:disable
+    if (typeof window.crypto !== 'undefined' && typeof window.crypto.getRandomValues !== 'undefined') {
+        // If we have a cryptographically secure PRNG, use that
+        // https://stackoverflow.com/questions/6906916/collisions-when-generating-uuids-in-javascript
+        const buf = new Uint16Array(8);
+        window.crypto.getRandomValues(buf);
+        const S4 = function (num) {
+            let ret = num.toString(16);
+            while (ret.length < 4) {
+                ret = `0${ret}`;
+            }
+            return ret;
+        };
+        return `${S4(buf[0]) + S4(buf[1])}-${S4(buf[2])}-${S4(buf[3])}-${S4(buf[4])}-${S4(buf[5])}${S4(buf[6])}${S4(buf[7])}`;
+    }
+    else {
+        // Otherwise, just use Math.random
+        // https://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            // eslint-disable-next-line no-bitwise
+            const r = (Math.random() * 16) | 0;
+            // eslint-disable-next-line no-bitwise
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    // tslint:enable
+}
+export async function to(promise, errorExt) {
+    return promise
+        .then((data) => [null, data])
+        .catch((rejectionError) => {
+        if (errorExt) {
+            Object.assign(rejectionError, errorExt);
+        }
+        return [rejectionError, undefined];
+    });
+}
+function readParameterFromUrl(url, parameter) {
+    try {
+        const parsedUrl = new URL(url);
+        return parsedUrl.searchParams.get(parameter) || '';
+    }
+    catch (error) {
+        return url;
+    }
+}
+export function parseIACUrl(url, parameter) {
+    let parseResult;
+    if (Array.isArray(url)) {
+        parseResult = url.map((chunk) => readParameterFromUrl(chunk, parameter));
+    }
+    else {
+        try {
+            parseResult = readParameterFromUrl(url, parameter).split(',');
+        }
+        catch (error) {
+            parseResult = url.split(',');
+        }
+    }
+    // In case one of the elements contains a chunked string, we have to flatten it.
+    parseResult = parseResult.reduce((pv, cv) => [...pv, ...cv.split(',')], []);
+    return parseResult.filter((el) => el !== '');
+}
+export function serializedDataToUrlString(data, host, parameter = 'd') {
+    return `${host}?${parameter}=${data}`;
+}
+export function toBoolean(value) {
+    // All falsy and truthy values can be converted to a real boolean by using a double negative (!!)
+    return Boolean(value);
+}
+export function assertNever(name, arg) {
+    throw new Error(`${name} ${arg}`);
+}
+export const TEMP_BTC_REQUEST_IDS = 'TEMP-BTC-REQUEST-IDS';
+export const TEMP_MM_REQUEST_IDS = 'TEMP-MM-REQUEST-IDS';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/utils/utils.ts"],"names":[],"mappings":"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","sourcesContent":["// TODO: Split up into individual files\n\n// https://stackoverflow.com/a/8472700/4790610\nexport function generateGUID(): string {\n  // tslint:disable\n  if (typeof window.crypto !== 'undefined' && typeof window.crypto.getRandomValues !== 'undefined') {\n    // If we have a cryptographically secure PRNG, use that\n    // https://stackoverflow.com/questions/6906916/collisions-when-generating-uuids-in-javascript\n    const buf = new Uint16Array(8)\n    window.crypto.getRandomValues(buf)\n    const S4 = function (num: number): string {\n      let ret = num.toString(16)\n      while (ret.length < 4) {\n        ret = `0${ret}`\n      }\n\n      return ret\n    }\n\n    return `${S4(buf[0]) + S4(buf[1])}-${S4(buf[2])}-${S4(buf[3])}-${S4(buf[4])}-${S4(buf[5])}${S4(buf[6])}${S4(buf[7])}`\n  } else {\n    // Otherwise, just use Math.random\n    // https://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {\n      // eslint-disable-next-line no-bitwise\n      const r = (Math.random() * 16) | 0\n      // eslint-disable-next-line no-bitwise\n      const v = c === 'x' ? r : (r & 0x3) | 0x8\n\n      return v.toString(16)\n    })\n  }\n  // tslint:enable\n}\n\nexport async function to<T, U = Error>(promise: Promise<T>, errorExt?: unknown): Promise<[U | null, T | undefined]> {\n  return promise\n    .then<[null, T]>((data: T) => [null, data])\n    .catch<[U, undefined]>((rejectionError: U) => {\n      if (errorExt) {\n        Object.assign(rejectionError, errorExt)\n      }\n\n      return [rejectionError, undefined]\n    })\n}\n\nfunction readParameterFromUrl(url: string, parameter: string): string {\n  try {\n    const parsedUrl: URL = new URL(url)\n\n    return parsedUrl.searchParams.get(parameter) || ''\n  } catch (error) {\n    return url\n  }\n}\n\nexport function parseIACUrl(url: string | string[], parameter: string): string[] {\n  let parseResult: string[] | undefined\n  if (Array.isArray(url)) {\n    parseResult = url.map((chunk: string) => readParameterFromUrl(chunk, parameter))\n  } else {\n    try {\n      parseResult = readParameterFromUrl(url, parameter).split(',')\n    } catch (error) {\n      parseResult = url.split(',')\n    }\n  }\n\n  // In case one of the elements contains a chunked string, we have to flatten it.\n  parseResult = parseResult.reduce((pv: string[], cv: string) => [...pv, ...cv.split(',')], [])\n\n  return parseResult.filter((el: string) => el !== '')\n}\n\nexport function serializedDataToUrlString(data: string, host: string, parameter: string = 'd'): string {\n  return `${host}?${parameter}=${data}`\n}\n\nexport function toBoolean(value: unknown): boolean {\n  // All falsy and truthy values can be converted to a real boolean by using a double negative (!!)\n  return Boolean(value)\n}\n\nexport function assertNever(name: string, arg: never): never {\n  throw new Error(`${name} ${arg}`)\n}\n\nexport const TEMP_BTC_REQUEST_IDS = 'TEMP-BTC-REQUEST-IDS'\nexport const TEMP_MM_REQUEST_IDS = 'TEMP-MM-REQUEST-IDS'\n"]}