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

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

@@ -0,0 +1,880 @@
+/* eslint-disable max-lines */
+/* eslint-disable max-classes-per-file */
+import { NetworkType as NetworkTypeV0, ProtocolBlockExplorer as ProtocolBlockExplorerV0, ProtocolNetwork as ProtocolNetworkV0, SubProtocolSymbols, SubProtocolType as SubProtocolTypeV0 } from '@wallfree-dev/coinlib-core';
+import { derive, mnemonicToSeed } from '@wallfree-dev/crypto';
+import { canEncryptAES, canEncryptAsymmetric, canFetchDataForAddress, canFetchDataForMultipleAddresses, canSignMessage, hasConfigurableContract, hasMultiAddressPublicKeys, implementsInterface, isAmount, isBip32Protocol, isMultiTokenSubProtocol, isOfflineProtocol, isOnlineProtocol, isTransactionStatusChecker, newAmount, newExtendedPublicKey, newExtendedSecretKey, newPublicKey, newSecretKey, newSignature } from '@wallfree-dev/module-kit';
+import BigNumber from 'bignumber.js';
+import { isTezosSaplingProtocol } from '@wallfree-dev/tezos';
+import { isBitcoinSegwitProtocol, isBitcoinTaprootProtocol } from '@wallfree-dev/bitcoin';
+import { getProtocolOptionsByIdentifierLegacy } from '../../utils/protocol/protocol-options';
+import { supportsV1Delegation } from '../../utils/protocol/delegation';
+import { convertFeeDefaultsV1ToV0, convertNetworkTypeV1ToV0, convertTransactionDetailsV1ToV0, convertTransactionStatusV1ToV0, getBytesFormatV1FromV0, getPublicKeyType, getSecretKeyType } from '../../utils/protocol/protocol-v0-adapter';
+// ProtocolBlockExplorer
+export class ProtocolBlockExplorerAdapter extends ProtocolBlockExplorerV0 {
+    constructor(blockExplorerV1, url) {
+        super(url);
+        this.blockExplorerV1 = blockExplorerV1;
+    }
+    async getAddressLink(address) {
+        return this.blockExplorerV1.createAddressUrl(address);
+    }
+    async getTransactionLink(transactionId) {
+        return this.blockExplorerV1.createTransactionUrl(transactionId);
+    }
+    toJSON() {
+        return {
+            blockExplorer: this.blockExplorer
+        };
+    }
+}
+// ProtocolNetwork
+export class ProtocolNetworkAdapter extends ProtocolNetworkV0 {
+    constructor(name, type, rpcUrl, blockExplorer, extras = {}) {
+        const networkType = Object.values(NetworkTypeV0).includes(type)
+            ? type
+            : convertNetworkTypeV1ToV0(type);
+        super(name, networkType, rpcUrl, blockExplorer, extras);
+    }
+}
+// ProtocolOptions
+export class ProtocolOptionsAdapter {
+    constructor(network, config = {}) {
+        this.network = network;
+        this.config = config;
+    }
+}
+// TransactionValidator
+export class TransactionValidatorAdapter {
+    constructor(protocolIdentifier, serializerCompanion) {
+        this.protocolIdentifier = protocolIdentifier;
+        this.serializerCompanion = serializerCompanion;
+    }
+    async validateUnsignedTransaction(transaction) {
+        return this.serializerCompanion.validateTransactionSignRequest(this.protocolIdentifier, transaction);
+    }
+    async validateSignedTransaction(transaction) {
+        return this.serializerCompanion.validateTransactionSignResponse(this.protocolIdentifier, transaction);
+    }
+}
+// ICoinProtocol
+export class ICoinProtocolAdapter {
+    constructor(protocolV1, protocolMetadata, crypto, network, blockExplorerV1, blockExplorerMetadata, v3SerializerCompanion) {
+        this.protocolV1 = protocolV1;
+        this.protocolMetadata = protocolMetadata;
+        this.crypto = crypto;
+        this.network = network;
+        this.v3SerializerCompanion = v3SerializerCompanion;
+        const units = this.protocolMetadata.units;
+        const mainUnit = this.protocolMetadata.mainUnit;
+        const symbol = units[mainUnit].symbol;
+        const feeUnits = protocolMetadata.fee?.units ?? protocolMetadata.units;
+        const mainFeeUnit = protocolMetadata.fee?.mainUnit ?? protocolMetadata.mainUnit;
+        const feeSymbol = feeUnits[mainFeeUnit].symbol;
+        const feeDefaults = protocolMetadata.fee?.defaults ?? {
+            low: newAmount('0', 'blockchain'),
+            medium: newAmount('0', 'blockchain'),
+            high: newAmount('0', 'blockchain')
+        };
+        const maxDecimals = Math.max(...Object.values(protocolMetadata.units).map((unit) => unit.decimals));
+        this.name = this.protocolMetadata.name;
+        this.identifier = this.protocolMetadata.identifier;
+        this.symbol = symbol.value;
+        this.marketSymbol = symbol.market ?? symbol.value;
+        this.assetSymbol = symbol.asset;
+        this.decimals = units[mainUnit].decimals;
+        this.feeSymbol = feeSymbol.value;
+        this.feeDefaults = this.convertFeeDefaultsV1ToV0(feeDefaults);
+        this.feeDecimals = feeUnits[mainFeeUnit].decimals;
+        this.units = Object.entries(protocolMetadata.units).map((entry) => {
+            const unitSymbol = entry[0];
+            const factor = new BigNumber(1).shiftedBy(-(maxDecimals - entry[1].decimals)).toFixed();
+            return { unitSymbol, factor };
+        });
+        this.supportsHD = isBip32Protocol(this.protocolV1);
+        this.standardDerivationPath = this.protocolMetadata.account?.standardDerivationPath ?? 'm/';
+        this.addressIsCaseSensitive = this.protocolMetadata.account.address?.isCaseSensitive ?? false;
+        this.addressValidationPattern = this.protocolMetadata.account?.address?.regex ?? '*+';
+        this.addressPlaceholder = this.protocolMetadata.account?.address?.placeholder ?? '';
+        let knownOptions;
+        try {
+            knownOptions = getProtocolOptionsByIdentifierLegacy(this.protocolMetadata.identifier);
+            // eslint-disable-next-line no-empty
+        }
+        catch { }
+        this.blockExplorerV0 =
+            blockExplorerV1 && blockExplorerMetadata ? new ProtocolBlockExplorerAdapter(blockExplorerV1, blockExplorerMetadata.url) : undefined;
+        this.networkV0 = this.getNetwork(knownOptions);
+        this.options = new ProtocolOptionsAdapter(this.networkV0, knownOptions?.config ?? {});
+    }
+    async getSymbol() {
+        return this.symbol;
+    }
+    async getName() {
+        return this.name;
+    }
+    async getMarketSymbol() {
+        return this.marketSymbol;
+    }
+    async getAssetSymbol() {
+        return this.assetSymbol;
+    }
+    async getFeeSymbol() {
+        return this.feeSymbol;
+    }
+    async getFeeDefaults() {
+        return this.feeDefaults;
+    }
+    async getDecimals() {
+        return this.decimals;
+    }
+    async getFeeDecimals() {
+        return this.feeDecimals;
+    }
+    async getIdentifier() {
+        return this.identifier;
+    }
+    async getUnits() {
+        return this.units;
+    }
+    async getSupportsHD() {
+        return this.supportsHD;
+    }
+    async getStandardDerivationPath() {
+        return this.standardDerivationPath;
+    }
+    async getAddressIsCaseSensitive() {
+        return this.addressIsCaseSensitive;
+    }
+    async getAddressValidationPattern() {
+        return this.addressValidationPattern;
+    }
+    async getAddressPlaceholder() {
+        return this.addressPlaceholder;
+    }
+    async getOptions() {
+        return this.options;
+    }
+    async getBlockExplorerLinkForAddress(address) {
+        if (this.blockExplorerV0 === undefined) {
+            throw new Error('Method not supported, BlockExplorer not found.');
+        }
+        return this.blockExplorerV0.getAddressLink(address);
+    }
+    async getBlockExplorerLinkForTxId(txId) {
+        if (this.blockExplorerV0 === undefined) {
+            throw new Error('Method not supported, BlockExplorer not found.');
+        }
+        return this.blockExplorerV0.getTransactionLink(txId);
+    }
+    async getTransactionsFromPublicKey(publicKey, limit, cursor) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required interface: Online.');
+        }
+        const transactions = await this.protocolV1.getTransactionsForPublicKey(newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)), limit, cursor);
+        return {
+            transactions: await this.convertTransactionDetailsV1ToV0(transactions.transactions),
+            cursor
+        };
+    }
+    async getTransactionsFromExtendedPublicKey(extendedPublicKey, limit, cursor) {
+        if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required interface: Online, Bip32.');
+        }
+        const transactions = await this.protocolV1.getTransactionsForPublicKey(newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)), limit, cursor);
+        return {
+            transactions: await this.convertTransactionDetailsV1ToV0(transactions.transactions),
+            cursor
+        };
+    }
+    async getTransactionsFromAddresses(addresses, limit, cursor) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.');
+        }
+        let transactions;
+        if (addresses.length === 1 && canFetchDataForAddress(this.protocolV1)) {
+            transactions = await this.protocolV1.getTransactionsForAddress(addresses[0], limit, cursor);
+        }
+        else if (canFetchDataForMultipleAddresses(this.protocolV1)) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            transactions = await this.protocolV1.getTransactionsForAddresses(addresses, limit, cursor);
+        }
+        else {
+            throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.');
+        }
+        return {
+            transactions: await this.convertTransactionDetailsV1ToV0(transactions.transactions),
+            cursor: transactions.cursor ? transactions.cursor : cursor
+        };
+    }
+    async getBalanceOfAddresses(addresses, _data) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.');
+        }
+        let balance;
+        if (addresses.length === 1 && canFetchDataForAddress(this.protocolV1)) {
+            balance = await this.protocolV1.getBalanceOfAddress(addresses[0]);
+        }
+        else if (canFetchDataForMultipleAddresses(this.protocolV1)) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            balance = await this.protocolV1.getBalanceOfAddresses(addresses);
+        }
+        else {
+            throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.');
+        }
+        return newAmount(balance.total).blockchain(this.protocolMetadata.units).value;
+    }
+    async getBalanceOfPublicKey(publicKey, data) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online.');
+        }
+        const publicKeyV1 = newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey));
+        const balance = data?.assetID && isMultiTokenSubProtocol(this.protocolV1)
+            ? await this.protocolV1.getBalanceOfPublicKey(publicKeyV1, { tokenId: data.assetID })
+            : await this.protocolV1.getBalanceOfPublicKey(publicKeyV1);
+        return newAmount(balance.total).blockchain(this.protocolMetadata.units).value;
+    }
+    async getBalanceOfExtendedPublicKey(extendedPublicKey, _offset, data) {
+        if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online, Bip32.');
+        }
+        const extendedPublicKeyV1 = newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey));
+        const balance = data?.assetID && isMultiTokenSubProtocol(this.protocolV1)
+            ? await this.protocolV1.getBalanceOfPublicKey(extendedPublicKeyV1, { tokenId: data.assetID })
+            : await this.protocolV1.getBalanceOfPublicKey(extendedPublicKeyV1);
+        return newAmount(balance.total).blockchain(this.protocolMetadata.units).value;
+    }
+    async getAvailableBalanceOfAddresses(addresses, _data) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.');
+        }
+        let balance;
+        if (addresses.length === 1 && canFetchDataForAddress(this.protocolV1)) {
+            balance = await this.protocolV1.getBalanceOfAddress(addresses[0]);
+        }
+        else if (canFetchDataForMultipleAddresses(this.protocolV1)) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            balance = await this.protocolV1.getBalanceOfAddresses(addresses);
+        }
+        else {
+            throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.');
+        }
+        return newAmount(balance.transferable ?? balance.total).blockchain(this.protocolMetadata.units).value;
+    }
+    async getTransactionStatuses(transactionHash) {
+        if (!isOnlineProtocol(this.protocolV1) || !isTransactionStatusChecker(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online, TransactionStatusChecker.');
+        }
+        const statuses = await this.protocolV1.getTransactionStatus(transactionHash);
+        return transactionHash.map((hash) => {
+            const status = statuses[hash];
+            return convertTransactionStatusV1ToV0(status);
+        });
+    }
+    async getBalanceOfPublicKeyForSubProtocols(_publicKey, _subProtocols) {
+        throw new Error('Method not supported.');
+    }
+    async estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey, recipients, fee, data) {
+        if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online, Bip32.');
+        }
+        const maxAmount = await this.protocolV1.getTransactionMaxAmountWithPublicKey(newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)), recipients, {
+            arbitraryData: this.getArbitraryData(data),
+            fee: fee ? newAmount(fee, 'blockchain') : undefined
+        });
+        return newAmount(maxAmount).blockchain(this.protocolMetadata.units).value;
+    }
+    async estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee, data) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online.');
+        }
+        const maxAmount = await this.protocolV1.getTransactionMaxAmountWithPublicKey(newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)), recipients, {
+            fee: fee ? newAmount(fee, 'blockchain') : undefined,
+            arbitraryData: this.getArbitraryData(data)
+        });
+        return newAmount(maxAmount).blockchain(this.protocolMetadata.units).value;
+    }
+    async estimateFeeDefaultsFromExtendedPublicKey(publicKey, recipients, values, data) {
+        if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online, Bip32.');
+        }
+        const feeEstimation = await this.protocolV1.getTransactionFeeWithPublicKey(newExtendedPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)), this.combineTransactionDetails(recipients, values), {
+            arbitraryData: this.getArbitraryData(data),
+            assetId: data?.assetID ? parseInt(data.assetID, 10) : undefined
+        });
+        if (feeEstimation === undefined) {
+            throw new Error('Method `estimateFeeDefaultsFromExtendedPublicKey` not supported.');
+        }
+        const feeDefaults = isAmount(feeEstimation)
+            ? { low: feeEstimation, medium: feeEstimation, high: feeEstimation }
+            : feeEstimation;
+        return this.convertFeeDefaultsV1ToV0(feeDefaults);
+    }
+    async estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online.');
+        }
+        if (recipients.length !== values.length) {
+            throw new Error('Recipients length must match values length.');
+        }
+        const transactionDetails = recipients.map((recipient, index) => ({
+            to: recipient,
+            amount: newAmount(values[index], 'blockchain')
+        }));
+        const feeEstimation = await this.protocolV1.getTransactionFeeWithPublicKey(newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)), transactionDetails, {
+            arbitraryData: this.getArbitraryData(data),
+            assetId: data?.assetID ? parseInt(data.assetID, 10) : undefined
+        });
+        if (feeEstimation === undefined) {
+            throw new Error('Method `estimateFeeDefaultsFromPublicKey` not supported.');
+        }
+        const feeDefaults = isAmount(feeEstimation)
+            ? { low: feeEstimation, medium: feeEstimation, high: feeEstimation }
+            : feeEstimation;
+        return this.convertFeeDefaultsV1ToV0(feeDefaults);
+    }
+    async prepareTransactionFromExtendedPublicKey(extendedPublicKey, _offset, recipients, values, fee, extras) {
+        if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online.');
+        }
+        const isSegwit = isBitcoinSegwitProtocol(this.protocolV1);
+        const isTaproot = isBitcoinTaprootProtocol(this.protocolV1);
+        let transaction;
+        if (isSegwit || isTaproot) {
+            transaction = await (isSegwit
+                ? this.protocolV1
+                : this.protocolV1).prepareTransactionWithPublicKey(newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)), this.combineTransactionDetails(recipients, values), {
+                fee: newAmount(fee, 'blockchain'),
+                arbitraryData: this.getArbitraryData(extras),
+                masterFingerprint: {
+                    format: 'hex',
+                    value: extras?.masterFingerprint
+                },
+                replaceByFee: extras?.replaceByFee
+            });
+        }
+        else {
+            transaction = await this.protocolV1.prepareTransactionWithPublicKey(newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)), this.combineTransactionDetails(recipients, values), {
+                fee: newAmount(fee, 'blockchain'),
+                assetId: extras?.assetID ? parseInt(extras.assetID, 10) : undefined,
+                arbitraryData: this.getArbitraryData(extras)
+            });
+        }
+        const transactionV0 = await this.convertUnsignedTransactionV1ToV0(transaction, extendedPublicKey);
+        return transactionV0.transaction;
+    }
+    async prepareTransactionFromPublicKey(publicKey, recipients, values, fee, extras) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online.');
+        }
+        const transaction = await this.protocolV1.prepareTransactionWithPublicKey(newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)), this.combineTransactionDetails(recipients, values), {
+            fee: newAmount(fee, 'blockchain'),
+            arbitraryData: this.getArbitraryData(extras),
+            assetId: extras?.assetID ? parseInt(extras.assetID, 10) : undefined
+        });
+        const transactionV0 = await this.convertUnsignedTransactionV1ToV0(transaction, publicKey);
+        return transactionV0.transaction;
+    }
+    async broadcastTransaction(rawTransaction) {
+        if (!isOnlineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Online.');
+        }
+        const transaction = { transaction: rawTransaction, accountIdentifier: '' };
+        const signed = await this.convertSignedTransactionV0ToV1(transaction);
+        return this.protocolV1.broadcastTransaction(signed);
+    }
+    async getAddressFromPublicKey(publicKey, _cursor) {
+        const address = await this.protocolV1.getAddressFromPublicKey(newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)));
+        return {
+            address: typeof address === 'string' ? address : address.address,
+            cursor: typeof address === 'object' ? address.cursor : { hasNext: false }
+        };
+    }
+    async getAddressesFromPublicKey(publicKey, _cursor) {
+        if (hasMultiAddressPublicKeys(this.protocolV1)) {
+            const pk = newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey));
+            const addresses = await this.protocolV1.getInitialAddressesFromPublicKey(pk);
+            return addresses;
+        }
+        else {
+            return [await this.getAddressFromPublicKey(publicKey)];
+        }
+    }
+    async getAddressFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
+        if (!isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Bip32.');
+        }
+        const derivedPublicKey = await this.protocolV1.deriveFromExtendedPublicKey(newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)), visibilityDerivationIndex, addressDerivationIndex);
+        return this.getAddressFromPublicKey(derivedPublicKey.value);
+    }
+    async getAddressesFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
+        if (!isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Bip32.');
+        }
+        const generatorArray = Array.from(new Array(addressCount), (_, i) => i + offset);
+        return Promise.all(generatorArray.map((addressDerivationIndex) => this.getAddressFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex)));
+    }
+    async getTransactionDetails(transaction, data) {
+        const unsigned = await this.convertUnsignedTransactionV0ToV1(transaction, data?.transactionOwner);
+        let transactions;
+        if (this.isExtendedPublicKey(transaction.publicKey)) {
+            if (!isBip32Protocol(this.protocolV1)) {
+                throw new Error('Method not supported, required inferface: Bip32.');
+            }
+            transactions = await this.protocolV1.getDetailsFromTransaction(unsigned, newExtendedPublicKey(transaction.publicKey, getBytesFormatV1FromV0(transaction.publicKey)));
+        }
+        else {
+            const publicKey = newPublicKey(transaction.publicKey, getBytesFormatV1FromV0(transaction.publicKey));
+            transactions =
+                data?.knownViewingKeys && isTezosSaplingProtocol(this.protocolV1)
+                    ? await this.protocolV1.getDetailsFromTransaction(unsigned, publicKey, data.knownViewingKeys)
+                    : await this.protocolV1.getDetailsFromTransaction(unsigned, publicKey);
+        }
+        const transactionsV0 = await this.convertTransactionDetailsV1ToV0(transactions);
+        return transactionsV0.map((tx) => ({
+            ...tx,
+            transactionDetails: tx.transactionDetails ?? transaction.transaction
+        }));
+    }
+    async getTransactionDetailsFromSigned(transaction, data) {
+        const signed = await this.convertSignedTransactionV0ToV1(transaction, data?.transactionOwner);
+        let transactions;
+        if (this.isExtendedPublicKey(transaction.accountIdentifier)) {
+            if (!isBip32Protocol(this.protocolV1)) {
+                throw new Error('Method not supported, required inferface: Bip32.');
+            }
+            transactions = await this.protocolV1.getDetailsFromTransaction(signed, newExtendedPublicKey(transaction.accountIdentifier, getBytesFormatV1FromV0(transaction.accountIdentifier)));
+        }
+        else {
+            const publicKey = newPublicKey(transaction.accountIdentifier, getBytesFormatV1FromV0(transaction.accountIdentifier));
+            transactions =
+                data?.knownViewingKeys && isTezosSaplingProtocol(this.protocolV1)
+                    ? await this.protocolV1.getDetailsFromTransaction(signed, publicKey, data.knownViewingKeys)
+                    : await this.protocolV1.getDetailsFromTransaction(signed, publicKey);
+        }
+        const transactionsV0 = await this.convertTransactionDetailsV1ToV0(transactions);
+        return transactionsV0.map((tx) => ({
+            ...tx,
+            transactionDetails: tx.transactionDetails ?? transaction.transaction
+        }));
+    }
+    async verifyMessage(message, signature, publicKey) {
+        if (!isOfflineProtocol(this.protocolV1) || !canSignMessage(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, SignMessage.');
+        }
+        return this.protocolV1.verifyMessageWithPublicKey(message, newSignature(signature, getBytesFormatV1FromV0(signature)), newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)));
+    }
+    async encryptAsymmetric(payload, publicKey) {
+        if (!isOfflineProtocol(this.protocolV1) || !canEncryptAsymmetric(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, AsymmetricEncryption.');
+        }
+        return this.protocolV1.encryptAsymmetricWithPublicKey(payload, newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)));
+    }
+    async getPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
+        if (!isOfflineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const seed = await mnemonicToSeed(crypto, mnemonic, password);
+        return this.getPublicKeyFromHexSecret(seed.toString('hex'), derivationPath);
+    }
+    async getPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
+        if (!isOfflineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const seed = await mnemonicToSeed(crypto, mnemonic, password);
+        return this.getPrivateKeyFromHexSecret(seed.toString('hex'), derivationPath);
+    }
+    async getExtendedPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
+        if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, Bip32.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const seed = await mnemonicToSeed(crypto, mnemonic, password);
+        return this.getExtendedPublicKeyFromHexSecret(seed.toString('hex'), derivationPath);
+    }
+    async getExtendedPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
+        if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, Bip32.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const seed = await mnemonicToSeed(crypto, mnemonic, password);
+        return this.getExtendedPrivateKeyFromHexSecret(seed.toString('hex'), derivationPath);
+    }
+    async getPublicKeyFromHexSecret(secret, derivationPath) {
+        if (!isOfflineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, Bip32.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const derivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath);
+        const keyPair = await this.protocolV1.getKeyPairFromDerivative(derivative);
+        return keyPair.publicKey.value;
+    }
+    async getPrivateKeyFromHexSecret(secret, derivationPath) {
+        if (!isOfflineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const derivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath);
+        const keyPair = await this.protocolV1.getKeyPairFromDerivative(derivative);
+        return keyPair.secretKey.value;
+    }
+    async getExtendedPublicKeyFromHexSecret(secret, derivationPath) {
+        if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, Bip32.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const derivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath);
+        const keyPair = await this.protocolV1.getExtendedKeyPairFromDerivative(derivative);
+        return keyPair.publicKey.value;
+    }
+    async getExtendedPrivateKeyFromHexSecret(secret, derivationPath) {
+        if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, Bip32.');
+        }
+        const crypto = this.crypto ?? (await this.protocolV1.getCryptoConfiguration());
+        const derivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath);
+        const keyPair = await this.protocolV1.getExtendedKeyPairFromDerivative(derivative);
+        return keyPair.secretKey.value;
+    }
+    async signWithExtendedPrivateKey(extendedPrivateKey, transaction, childDerivationPath) {
+        if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, Bip32.');
+        }
+        const unsigned = await this.convertUnsignedTransactionV0ToV1({
+            transaction,
+            publicKey: ''
+        });
+        const extendedSecretKey = newExtendedSecretKey(extendedPrivateKey, getBytesFormatV1FromV0(extendedPrivateKey));
+        const secretKey = childDerivationPath
+            ? await this.deriveSecretKey(extendedSecretKey, childDerivationPath)
+            : extendedSecretKey;
+        const signed = await this.protocolV1.signTransactionWithSecretKey(unsigned, secretKey);
+        const signedV0 = await this.convertSignedTransactionV1ToV0(signed, '');
+        return signedV0.transaction;
+    }
+    async signWithPrivateKey(privateKey, transaction) {
+        if (!isOfflineProtocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline.');
+        }
+        const unsigned = await this.convertUnsignedTransactionV0ToV1({
+            transaction,
+            publicKey: ''
+        });
+        const signed = await this.protocolV1.signTransactionWithSecretKey(unsigned, newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)));
+        const signedV0 = await this.convertSignedTransactionV1ToV0(signed, '');
+        return signedV0.transaction;
+    }
+    async signMessage(message, keypair) {
+        if (!isOfflineProtocol(this.protocolV1) || !canSignMessage(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, SignMessage.');
+        }
+        const privateKey = getSecretKeyType(keypair.privateKey) === 'xpriv'
+            ? await this.getPrivateKeyFromExtendedPrivateKey(keypair.privateKey)
+            : keypair.privateKey;
+        const publicKey = keypair.publicKey
+            ? getPublicKeyType(keypair.publicKey) === 'xpub'
+                ? await this.getPublicKeyFromExtendedPrivateKey(keypair.publicKey)
+                : keypair.publicKey
+            : '';
+        const signature = await this.protocolV1.signMessageWithKeyPair(message, {
+            secretKey: newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)),
+            publicKey: newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))
+        });
+        return signature.value;
+    }
+    async decryptAsymmetric(encryptedPayload, keypair) {
+        if (!isOfflineProtocol(this.protocolV1) || !canEncryptAsymmetric(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, AsymmetricEncryption.');
+        }
+        const privateKey = getSecretKeyType(keypair.privateKey) === 'xpriv'
+            ? await this.getPrivateKeyFromExtendedPrivateKey(keypair.privateKey)
+            : keypair.privateKey;
+        const publicKey = keypair.publicKey
+            ? getPublicKeyType(keypair.publicKey) === 'xpub'
+                ? await this.getPublicKeyFromExtendedPrivateKey(keypair.publicKey)
+                : keypair.publicKey
+            : '';
+        return this.protocolV1.decryptAsymmetricWithKeyPair(encryptedPayload, {
+            secretKey: newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)),
+            publicKey: newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))
+        });
+    }
+    async encryptAES(payload, privateKey) {
+        if (!isOfflineProtocol(this.protocolV1) || !canEncryptAES(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, AES.');
+        }
+        // eslint-disable-next-line no-param-reassign
+        privateKey = getSecretKeyType(privateKey) === 'xpriv' ? await this.getPrivateKeyFromExtendedPrivateKey(privateKey) : privateKey;
+        return this.protocolV1.encryptAESWithSecretKey(payload, newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)));
+    }
+    async decryptAES(encryptedPayload, privateKey) {
+        if (!isOfflineProtocol(this.protocolV1) || !canEncryptAES(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, AES.');
+        }
+        // eslint-disable-next-line no-param-reassign
+        privateKey = getSecretKeyType(privateKey) === 'xpriv' ? await this.getPrivateKeyFromExtendedPrivateKey(privateKey) : privateKey;
+        return this.protocolV1.decryptAESWithSecretKey(encryptedPayload, newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)));
+    }
+    async getPrivateKeyFromExtendedPrivateKey(extendedPrivateKey, childDerivationPath) {
+        if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Offline, Bip32.');
+        }
+        const secretKey = await this.deriveSecretKey(newExtendedSecretKey(extendedPrivateKey, getBytesFormatV1FromV0(extendedPrivateKey)), childDerivationPath);
+        return secretKey.value;
+    }
+    async getPublicKeyFromExtendedPrivateKey(extendedPublicKey, childDerivationPath) {
+        if (!isBip32Protocol(this.protocolV1)) {
+            throw new Error('Method not supported, required inferface: Bip32.');
+        }
+        const publicKey = await this.derivePublicKey(newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)), childDerivationPath);
+        return publicKey.value;
+    }
+    getNetwork(protocolOptions) {
+        let knownOptions;
+        try {
+            knownOptions = protocolOptions ?? getProtocolOptionsByIdentifierLegacy(this.identifier);
+            // eslint-disable-next-line no-empty
+        }
+        catch { }
+        const { name, type, rpcUrl, ...rest } = this.network ?? {};
+        return new ProtocolNetworkAdapter(name ?? knownOptions?.network.name ?? '', type ?? knownOptions?.network.type ?? 'mainnet', rpcUrl ?? knownOptions?.network.rpcUrl ?? '', this.blockExplorerV0, rest || (knownOptions?.network.extras ?? {}));
+    }
+    async deriveSecretKey(extendedSecretKey, childDerivationPath = '0/0') {
+        if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {
+            throw new Error(`Protocol doesn't support secret key derivation, missing inferface: Offline, Bip32.`);
+        }
+        if (childDerivationPath.startsWith('m')) {
+            throw new Error('Received full derivation path, expected child derivation path');
+        }
+        if (childDerivationPath.toLowerCase().includes('h') || childDerivationPath.includes(`'`)) {
+            throw new Error('Child derivation path cannot include hardened children');
+        }
+        const [visibilityIndex, addressIndex] = childDerivationPath.split('/').map((index) => parseInt(index, 10));
+        return this.protocolV1.deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex);
+    }
+    async derivePublicKey(extendedPublicKey, childDerivationPath = '0/0') {
+        if (!isBip32Protocol(this.protocolV1)) {
+            throw new Error(`Protocol doesn't support public key derivation, missing inferface: Bip32.`);
+        }
+        if (childDerivationPath.startsWith('m')) {
+            throw new Error('Received full derivation path, expected child derivation path');
+        }
+        if (childDerivationPath.toLowerCase().includes('h') || childDerivationPath.includes(`'`)) {
+            throw new Error('Child derivation path cannot include hardened children');
+        }
+        const [visibilityIndex, addressIndex] = childDerivationPath.split('/').map((index) => parseInt(index, 10));
+        return this.protocolV1.deriveFromExtendedPublicKey(extendedPublicKey, visibilityIndex, addressIndex);
+    }
+    async getSerializerIdentifier(base) {
+        const identifier = base ?? (await this.getIdentifier());
+        return identifier.startsWith(SubProtocolSymbols.ETH_ERC20)
+            ? SubProtocolSymbols.ETH_ERC20
+            : identifier.startsWith(SubProtocolSymbols.OPTIMISM_ERC20)
+                ? SubProtocolSymbols.OPTIMISM_ERC20
+                : identifier;
+    }
+    async convertUnsignedTransactionV0ToV1(transaction, owner) {
+        const identifier = await this.getSerializerIdentifier(owner);
+        return this.v3SerializerCompanion.fromTransactionSignRequest(identifier, transaction);
+    }
+    async convertUnsignedTransactionV1ToV0(transaction, publicKey, callbackUrl, owner) {
+        const identifier = await this.getSerializerIdentifier(owner);
+        return this.v3SerializerCompanion.toTransactionSignRequest(identifier, transaction, publicKey, callbackUrl);
+    }
+    async convertSignedTransactionV0ToV1(transaction, owner) {
+        const identifier = await this.getSerializerIdentifier(owner);
+        return this.v3SerializerCompanion.fromTransactionSignResponse(identifier, transaction);
+    }
+    async convertSignedTransactionV1ToV0(transaction, accountIdentifier, owner) {
+        const identifier = await this.getSerializerIdentifier(owner);
+        return this.v3SerializerCompanion.toTransactionSignResponse(identifier, transaction, accountIdentifier);
+    }
+    convertFeeDefaultsV1ToV0(feeDefaults) {
+        return convertFeeDefaultsV1ToV0(feeDefaults, this.protocolMetadata);
+    }
+    async convertTransactionDetailsV1ToV0(txs) {
+        return convertTransactionDetailsV1ToV0(txs, this.protocolMetadata, this.networkV0);
+    }
+    combineTransactionDetails(recipients, values) {
+        if (recipients.length !== values.length) {
+            throw new Error('Recipients length must match values length.');
+        }
+        return recipients.map((recipient, index) => ({
+            to: recipient,
+            amount: newAmount(values[index], 'blockchain')
+        }));
+    }
+    isExtendedPublicKey(publicKey) {
+        return publicKey.startsWith('xpub') || publicKey.startsWith('ypub') || publicKey.startsWith('zpub');
+    }
+    getArbitraryData(data) {
+        const simpleArbitraryDataMetadataSchema = {
+            name: 'required',
+            maxLength: 'optional',
+            regex: 'optional'
+        };
+        return this.protocolMetadata.transaction?.arbitraryData
+            ? implementsInterface(this.protocolMetadata.transaction?.arbitraryData, simpleArbitraryDataMetadataSchema)
+                ? data[this.protocolMetadata.transaction.arbitraryData.name]
+                : data[this.protocolMetadata.transaction.arbitraryData.root?.name ?? this.protocolMetadata.transaction.arbitraryData.inner?.name]
+            : undefined;
+    }
+}
+// ICoinDelegateProtocol
+export class ICoinDelegateProtocolAdapter extends ICoinProtocolAdapter {
+    async getDefaultDelegatee() {
+        return this.protocolV1.getDefaultDelegatee();
+    }
+    async getCurrentDelegateesForPublicKey(publicKey, data) {
+        return this.protocolV1.getCurrentDelegateesForPublicKey({ type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) }, data);
+    }
+    async getCurrentDelegateesForAddress(address, data) {
+        return this.protocolV1.getCurrentDelegateesForAddress(address, data);
+    }
+    async getDelegateeDetails(address, data) {
+        return this.protocolV1.getDelegateeDetails(address, data);
+    }
+    async isPublicKeyDelegating(publicKey, data) {
+        return this.protocolV1.isPublicKeyDelegating({ type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) }, data);
+    }
+    async isAddressDelegating(address, data) {
+        return this.protocolV1.isAddressDelegating(address, data);
+    }
+    async getDelegatorDetailsFromPublicKey(publicKey, data) {
+        return this.protocolV1.getDelegatorDetailsFromPublicKey({ type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) }, data);
+    }
+    async getDelegatorDetailsFromAddress(address, data) {
+        return this.protocolV1.getDelegatorDetailsFromAddress(address, data);
+    }
+    async getDelegationDetailsFromPublicKey(publicKey, delegatees, data) {
+        return this.protocolV1.getDelegationDetailsFromPublicKey({ type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) }, delegatees, data);
+    }
+    async getDelegationDetailsFromAddress(address, delegatees, data) {
+        return this.protocolV1.getDelegationDetailsFromAddress(address, delegatees, data);
+    }
+    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
+        const transactions = await this.protocolV1.prepareDelegatorActionFromPublicKey({ type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) }, type, data);
+        const transactionsV0 = await Promise.all(transactions.map((transaction) => this.convertUnsignedTransactionV1ToV0(transaction, publicKey)));
+        return transactionsV0.map((transaction) => transaction.transaction);
+    }
+}
+// ICoinSubProtocol
+export class ICoinSubProtocolAdapter extends ICoinProtocolAdapter {
+    constructor(protocolV1, protocolMetadata, crypto, network, v1BlockExplorer, blockExplorerMetadata, v3SerializerCompanion, type, contractAddress) {
+        super(protocolV1, protocolMetadata, crypto, network, v1BlockExplorer, blockExplorerMetadata, v3SerializerCompanion);
+        this.isSubProtocol = true;
+        this.subProtocolType = type === 'account' ? SubProtocolTypeV0.ACCOUNT : SubProtocolTypeV0.TOKEN;
+        this.contractAddress = contractAddress;
+    }
+    async getIsSubProtocol() {
+        return this.isSubProtocol;
+    }
+    async getSubProtocolType() {
+        return this.subProtocolType;
+    }
+    async getContractAddress() {
+        return this.contractAddress;
+    }
+}
+export class ICoinDelegateSubProtocolAdapter extends ICoinSubProtocolAdapter {
+    constructor(protocolV1, protocolMetadata, crypto, network, v1BlockExplorer, blockExplorerMetadata, v3SerializerCompanion, type, contractAddress) {
+        super(protocolV1, protocolMetadata, crypto, network, v1BlockExplorer, blockExplorerMetadata, v3SerializerCompanion, type, contractAddress);
+        this.delegateProtocolAdapter = new ICoinDelegateProtocolAdapter(protocolV1, protocolMetadata, crypto, network, v1BlockExplorer, blockExplorerMetadata, v3SerializerCompanion);
+    }
+    async getDefaultDelegatee() {
+        return this.delegateProtocolAdapter.getDefaultDelegatee();
+    }
+    async getCurrentDelegateesForPublicKey(publicKey, data) {
+        return this.delegateProtocolAdapter.getCurrentDelegateesForPublicKey(publicKey, data);
+    }
+    async getCurrentDelegateesForAddress(address, data) {
+        return this.delegateProtocolAdapter.getCurrentDelegateesForAddress(address, data);
+    }
+    async getDelegateeDetails(address, data) {
+        return this.delegateProtocolAdapter.getDelegateeDetails(address, data);
+    }
+    async isPublicKeyDelegating(publicKey, data) {
+        return this.delegateProtocolAdapter.isPublicKeyDelegating(publicKey, data);
+    }
+    async isAddressDelegating(address, data) {
+        return this.delegateProtocolAdapter.isAddressDelegating(address, data);
+    }
+    async getDelegatorDetailsFromPublicKey(publicKey, data) {
+        return this.delegateProtocolAdapter.getDelegatorDetailsFromPublicKey(publicKey, data);
+    }
+    async getDelegatorDetailsFromAddress(address, data) {
+        return this.delegateProtocolAdapter.getDelegatorDetailsFromAddress(address, data);
+    }
+    async getDelegationDetailsFromPublicKey(publicKey, delegatees, data) {
+        return this.delegateProtocolAdapter.getDelegationDetailsFromPublicKey(publicKey, delegatees, data);
+    }
+    async getDelegationDetailsFromAddress(address, delegatees, data) {
+        return this.delegateProtocolAdapter.getDelegationDetailsFromAddress(address, delegatees, data);
+    }
+    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
+        return this.delegateProtocolAdapter.prepareDelegatorActionFromPublicKey(publicKey, type, data);
+    }
+}
+// Factories
+export async function createICoinProtocolAdapter(protocolV1, blockExplorerV1, v3SerializerCompanion, extra = {}) {
+    const [protocolMetadata, crypto, network, blockExplorerMetadata] = await Promise.all([
+        extra.protocolMetadata ? Promise.resolve(extra.protocolMetadata) : protocolV1.getMetadata(),
+        extra.crypto
+            ? Promise.resolve(extra.crypto)
+            : extra.crypto === null || !isOfflineProtocol(protocolV1) || (extra.type !== 'offline' && extra.type !== 'full')
+                ? Promise.resolve(undefined)
+                : protocolV1.getCryptoConfiguration(),
+        extra.network
+            ? Promise.resolve(extra.network)
+            : extra.network === null || !isOnlineProtocol(protocolV1) || (extra.type !== 'online' && extra.type !== 'full')
+                ? Promise.resolve(undefined)
+                : protocolV1.getNetwork(),
+        extra.blockExplorerMetadata
+            ? Promise.resolve(extra.blockExplorerMetadata)
+            : extra.blockExplorerMetadata === null || blockExplorerV1 === undefined || (extra.type !== 'online' && extra.type !== 'full')
+                ? Promise.resolve(undefined)
+                : blockExplorerV1.getMetadata()
+    ]);
+    if (supportsV1Delegation(protocolV1)) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new ICoinDelegateProtocolAdapter(protocolV1, protocolMetadata, crypto, network, blockExplorerV1, blockExplorerMetadata, v3SerializerCompanion);
+    }
+    else {
+        return new ICoinProtocolAdapter(protocolV1, protocolMetadata, crypto, network, blockExplorerV1, blockExplorerMetadata, v3SerializerCompanion);
+    }
+}
+// eslint-disable-next-line complexity
+export async function createICoinSubProtocolAdapter(protocolV1, blockExplorerV1, v3SerializerCompanion, extra = {}) {
+    const [protocolMetadata, crypto, network, blockExplorerMetadata, type, contractAddress] = await Promise.all([
+        extra.protocolMetadata ? Promise.resolve(extra.protocolMetadata) : protocolV1.getMetadata(),
+        extra.crypto
+            ? Promise.resolve(extra.crypto)
+            : extra.crypto === null || !isOfflineProtocol(protocolV1) || (extra?.type !== 'offline' && extra?.type !== 'full')
+                ? Promise.resolve(undefined)
+                : protocolV1.getCryptoConfiguration(),
+        extra.network
+            ? Promise.resolve(extra.network)
+            : extra.network === null || !isOnlineProtocol(protocolV1) || (extra?.type !== 'online' && extra?.type !== 'full')
+                ? Promise.resolve(undefined)
+                : protocolV1.getNetwork(),
+        extra.blockExplorerMetadata
+            ? Promise.resolve(extra.blockExplorerMetadata)
+            : extra.blockExplorerMetadata === null || blockExplorerV1 === undefined || (extra?.type !== 'online' && extra?.type !== 'full')
+                ? Promise.resolve(undefined)
+                : blockExplorerV1.getMetadata(),
+        extra.subType ? Promise.resolve(extra.subType) : protocolV1.getType(),
+        extra.contractAddress
+            ? Promise.resolve(extra.contractAddress)
+            : extra.contractAddress === null || !hasConfigurableContract(protocolV1)
+                ? Promise.resolve(undefined)
+                : protocolV1.getContractAddress()
+    ]);
+    if (supportsV1Delegation(protocolV1)) {
+        return new ICoinDelegateSubProtocolAdapter(protocolV1, protocolMetadata, crypto, network, blockExplorerV1, blockExplorerMetadata, v3SerializerCompanion, type, contractAddress);
+    }
+    else {
+        return new ICoinSubProtocolAdapter(protocolV1, protocolMetadata, crypto, network, blockExplorerV1, blockExplorerMetadata, v3SerializerCompanion, type, contractAddress);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol-v0-adapter.js","sourceRoot":"","sources":["../../../../../src/lib/protocol/adapter/protocol-v0-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-lines */\n/* eslint-disable max-classes-per-file */\nimport {\n  CryptoClient,\n  DelegateeDetails,\n  DelegationDetails,\n  DelegatorDetails,\n  FeeDefaults as FeeDefaultsV0,\n  IAirGapTransaction,\n  IAirGapTransactionResult,\n  ICoinDelegateProtocol,\n  ICoinProtocol,\n  ICoinSubProtocol,\n  IProtocolTransactionCursor,\n  NetworkType as NetworkTypeV0,\n  ProtocolBlockExplorer as ProtocolBlockExplorerV0,\n  ProtocolNetwork as ProtocolNetworkV0,\n  ProtocolSymbols,\n  SignedTransaction as SignedTransactionV0,\n  SubProtocolSymbols,\n  SubProtocolType as SubProtocolTypeV0,\n  UnsignedTransaction as UnsignedTransactionV0\n} from '@wallfree-dev/coinlib-core'\nimport { IProtocolAddressCursor, IAirGapAddressResult } from '@wallfree-dev/coinlib-core/interfaces/IAirGapAddress'\nimport { AirGapTransactionStatus as AirGapTransactionStatusV0 } from '@wallfree-dev/coinlib-core/interfaces/IAirGapTransaction'\nimport { ProtocolOptions as ProtocolOptionsV0 } from '@wallfree-dev/coinlib-core/utils/ProtocolOptions'\nimport { derive, mnemonicToSeed } from '@wallfree-dev/crypto'\nimport {\n  AddressWithCursor,\n  AirGapAnyProtocol,\n  AirGapBlockExplorer,\n  AirGapTransaction,\n  AirGapTransactionStatus,\n  AirGapTransactionsWithCursor,\n  AirGapV3SerializerCompanion,\n  Amount,\n  Balance,\n  BlockExplorerMetadata,\n  canEncryptAES,\n  canEncryptAsymmetric,\n  canFetchDataForAddress,\n  canFetchDataForMultipleAddresses,\n  canSignMessage,\n  CryptoConfiguration,\n  CryptoDerivative,\n  ExtendedKeyPair,\n  ExtendedPublicKey,\n  ExtendedSecretKey,\n  FeeDefaults,\n  FeeEstimation,\n  hasConfigurableContract,\n  hasMultiAddressPublicKeys,\n  implementsInterface,\n  isAmount,\n  isBip32Protocol,\n  isMultiTokenSubProtocol,\n  isOfflineProtocol,\n  isOnlineProtocol,\n  isTransactionStatusChecker,\n  KeyPair,\n  newAmount,\n  newExtendedPublicKey,\n  newExtendedSecretKey,\n  newPublicKey,\n  newSecretKey,\n  newSignature,\n  ProtocolConfiguration,\n  ProtocolMetadata,\n  ProtocolNetwork,\n  ProtocolNetworkType,\n  ProtocolSymbol,\n  ProtocolTransactionArbitraryDataMetadata,\n  ProtocolUnitsMetadata,\n  PublicKey,\n  Schema,\n  SecretKey,\n  Signature,\n  SignedTransaction,\n  SubProtocol,\n  SubProtocolType,\n  TransactionCursor,\n  TransactionDetails,\n  UnsignedTransaction\n} from '@wallfree-dev/module-kit'\nimport BigNumber from 'bignumber.js'\nimport { TransactionSignRequest, TransactionSignResponse, TransactionValidator } from '@wallfree-dev/serializer'\nimport { AirGapDelegateProtocol } from '@wallfree-dev/module-kit/internal'\nimport { isTezosSaplingProtocol } from '@wallfree-dev/tezos'\nimport { BitcoinSegwitProtocol, BitcoinTaprootProtocol, isBitcoinSegwitProtocol, isBitcoinTaprootProtocol } from '@wallfree-dev/bitcoin'\nimport { getProtocolOptionsByIdentifierLegacy } from '../../utils/protocol/protocol-options'\nimport { supportsV1Delegation } from '../../utils/protocol/delegation'\nimport {\n  convertFeeDefaultsV1ToV0,\n  convertNetworkTypeV1ToV0,\n  convertTransactionDetailsV1ToV0,\n  convertTransactionStatusV1ToV0,\n  getBytesFormatV1FromV0,\n  getPublicKeyType,\n  getSecretKeyType\n} from '../../utils/protocol/protocol-v0-adapter'\n\n// ProtocolBlockExplorer\n\nexport class ProtocolBlockExplorerAdapter extends ProtocolBlockExplorerV0 {\n  constructor(private readonly blockExplorerV1: AirGapBlockExplorer, url: string) {\n    super(url)\n  }\n\n  public async getAddressLink(address: string): Promise<string> {\n    return this.blockExplorerV1.createAddressUrl(address)\n  }\n\n  public async getTransactionLink(transactionId: string): Promise<string> {\n    return this.blockExplorerV1.createTransactionUrl(transactionId)\n  }\n\n  public toJSON(): any {\n    return {\n      blockExplorer: this.blockExplorer\n    }\n  }\n}\n\n// ProtocolNetwork\n\nexport class ProtocolNetworkAdapter extends ProtocolNetworkV0 {\n  constructor(\n    name: string,\n    type: ProtocolNetworkType | NetworkTypeV0,\n    rpcUrl: string,\n    blockExplorer: ProtocolBlockExplorerV0 | undefined,\n    extras: unknown = {}\n  ) {\n    const networkType: NetworkTypeV0 = Object.values(NetworkTypeV0).includes(type as NetworkTypeV0)\n      ? (type as NetworkTypeV0)\n      : convertNetworkTypeV1ToV0(type as ProtocolNetworkType)\n\n    super(name, networkType, rpcUrl, blockExplorer, extras)\n  }\n}\n\n// ProtocolOptions\n\nexport class ProtocolOptionsAdapter implements ProtocolOptionsV0 {\n  constructor(public readonly network: ProtocolNetworkV0, public readonly config: unknown = {}) {}\n}\n\n// TransactionValidator\n\nexport class TransactionValidatorAdapter implements TransactionValidator {\n  constructor(private readonly protocolIdentifier: string, private readonly serializerCompanion: AirGapV3SerializerCompanion) {}\n\n  public async validateUnsignedTransaction(transaction: TransactionSignRequest): Promise<any> {\n    return this.serializerCompanion.validateTransactionSignRequest(this.protocolIdentifier, transaction)\n  }\n\n  public async validateSignedTransaction(transaction: TransactionSignResponse): Promise<any> {\n    return this.serializerCompanion.validateTransactionSignResponse(this.protocolIdentifier, transaction)\n  }\n}\n\n// ICoinProtocol\n\nexport class ICoinProtocolAdapter<T extends AirGapAnyProtocol = AirGapAnyProtocol> implements ICoinProtocol {\n  public readonly symbol: string\n  public readonly name: string\n  public readonly marketSymbol: string\n  public readonly assetSymbol: string | undefined\n  public readonly feeSymbol: string\n  public readonly feeDefaults: FeeDefaultsV0\n  public readonly decimals: number\n  public readonly feeDecimals: number\n  public readonly identifier: ProtocolSymbols\n  public readonly units: { unitSymbol: string; factor: string }[]\n  public readonly supportsHD: boolean\n  public readonly standardDerivationPath: string\n  public readonly addressIsCaseSensitive: boolean\n  public readonly addressValidationPattern: string\n  public readonly addressPlaceholder: string\n  public readonly options: ProtocolOptionsV0\n  public readonly cryptoClient: CryptoClient\n\n  private readonly networkV0: ProtocolNetworkV0\n  private readonly blockExplorerV0: ProtocolBlockExplorerAdapter | undefined\n\n  constructor(\n    public readonly protocolV1: T,\n    private readonly protocolMetadata: ProtocolMetadata,\n    private readonly crypto: CryptoConfiguration | undefined,\n    private readonly network: ProtocolNetwork | undefined,\n    blockExplorerV1: AirGapBlockExplorer | undefined,\n    blockExplorerMetadata: BlockExplorerMetadata | undefined,\n    private readonly v3SerializerCompanion: AirGapV3SerializerCompanion\n  ) {\n    const units: ProtocolUnitsMetadata = this.protocolMetadata.units\n    const mainUnit: string = this.protocolMetadata.mainUnit\n    const symbol: ProtocolSymbol = units[mainUnit].symbol\n\n    const feeUnits: ProtocolUnitsMetadata = protocolMetadata.fee?.units ?? protocolMetadata.units\n    const mainFeeUnit: string = protocolMetadata.fee?.mainUnit ?? protocolMetadata.mainUnit\n    const feeSymbol: ProtocolSymbol = feeUnits[mainFeeUnit].symbol\n\n    const feeDefaults: FeeDefaults = protocolMetadata.fee?.defaults ?? {\n      low: newAmount('0', 'blockchain'),\n      medium: newAmount('0', 'blockchain'),\n      high: newAmount('0', 'blockchain')\n    }\n\n    const maxDecimals: number = Math.max(...Object.values(protocolMetadata.units).map((unit) => unit.decimals))\n\n    this.name = this.protocolMetadata.name\n    this.identifier = this.protocolMetadata.identifier as ProtocolSymbols\n\n    this.symbol = symbol.value\n    this.marketSymbol = symbol.market ?? symbol.value\n    this.assetSymbol = symbol.asset\n    this.decimals = units[mainUnit].decimals\n\n    this.feeSymbol = feeSymbol.value\n    this.feeDefaults = this.convertFeeDefaultsV1ToV0(feeDefaults)\n    this.feeDecimals = feeUnits[mainFeeUnit].decimals\n\n    this.units = Object.entries(protocolMetadata.units).map((entry) => {\n      const unitSymbol: string = entry[0]\n      const factor: string = new BigNumber(1).shiftedBy(-(maxDecimals - entry[1].decimals)).toFixed()\n\n      return { unitSymbol, factor }\n    })\n\n    this.supportsHD = isBip32Protocol(this.protocolV1)\n\n    this.standardDerivationPath = this.protocolMetadata.account?.standardDerivationPath ?? 'm/'\n    this.addressIsCaseSensitive = this.protocolMetadata.account.address?.isCaseSensitive ?? false\n    this.addressValidationPattern = this.protocolMetadata.account?.address?.regex ?? '*+'\n    this.addressPlaceholder = this.protocolMetadata.account?.address?.placeholder ?? ''\n\n    let knownOptions: ProtocolOptionsV0 | undefined\n    try {\n      knownOptions = getProtocolOptionsByIdentifierLegacy(this.protocolMetadata.identifier as ProtocolSymbols)\n      // eslint-disable-next-line no-empty\n    } catch {}\n\n    this.blockExplorerV0 =\n      blockExplorerV1 && blockExplorerMetadata ? new ProtocolBlockExplorerAdapter(blockExplorerV1, blockExplorerMetadata.url) : undefined\n    this.networkV0 = this.getNetwork(knownOptions)\n    this.options = new ProtocolOptionsAdapter(this.networkV0, knownOptions?.config ?? {})\n  }\n\n  public async getSymbol(): Promise<string> {\n    return this.symbol\n  }\n\n  public async getName(): Promise<string> {\n    return this.name\n  }\n\n  public async getMarketSymbol(): Promise<string> {\n    return this.marketSymbol\n  }\n\n  public async getAssetSymbol(): Promise<string | undefined> {\n    return this.assetSymbol\n  }\n\n  public async getFeeSymbol(): Promise<string> {\n    return this.feeSymbol\n  }\n\n  public async getFeeDefaults(): Promise<FeeDefaultsV0> {\n    return this.feeDefaults\n  }\n\n  public async getDecimals(): Promise<number> {\n    return this.decimals\n  }\n\n  public async getFeeDecimals(): Promise<number> {\n    return this.feeDecimals\n  }\n\n  public async getIdentifier(): Promise<ProtocolSymbols> {\n    return this.identifier\n  }\n\n  public async getUnits(): Promise<{ unitSymbol: string; factor: string }[]> {\n    return this.units\n  }\n\n  public async getSupportsHD(): Promise<boolean> {\n    return this.supportsHD\n  }\n\n  public async getStandardDerivationPath(): Promise<string> {\n    return this.standardDerivationPath\n  }\n\n  public async getAddressIsCaseSensitive(): Promise<boolean> {\n    return this.addressIsCaseSensitive\n  }\n\n  public async getAddressValidationPattern(): Promise<string> {\n    return this.addressValidationPattern\n  }\n\n  public async getAddressPlaceholder(): Promise<string> {\n    return this.addressPlaceholder\n  }\n\n  public async getOptions(): Promise<ProtocolOptionsV0> {\n    return this.options\n  }\n\n  public async getBlockExplorerLinkForAddress(address: string): Promise<string> {\n    if (this.blockExplorerV0 === undefined) {\n      throw new Error('Method not supported, BlockExplorer not found.')\n    }\n\n    return this.blockExplorerV0.getAddressLink(address)\n  }\n\n  public async getBlockExplorerLinkForTxId(txId: string): Promise<string> {\n    if (this.blockExplorerV0 === undefined) {\n      throw new Error('Method not supported, BlockExplorer not found.')\n    }\n\n    return this.blockExplorerV0.getTransactionLink(txId)\n  }\n\n  public async getTransactionsFromPublicKey(\n    publicKey: string,\n    limit: number,\n    cursor?: IProtocolTransactionCursor\n  ): Promise<IAirGapTransactionResult> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required interface: Online.')\n    }\n\n    const transactions: AirGapTransactionsWithCursor = await this.protocolV1.getTransactionsForPublicKey(\n      newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)),\n      limit,\n      cursor as TransactionCursor\n    )\n\n    return {\n      transactions: await this.convertTransactionDetailsV1ToV0(transactions.transactions),\n      cursor\n    }\n  }\n\n  public async getTransactionsFromExtendedPublicKey(\n    extendedPublicKey: string,\n    limit: number,\n    cursor?: IProtocolTransactionCursor\n  ): Promise<IAirGapTransactionResult> {\n    if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required interface: Online, Bip32.')\n    }\n\n    const transactions: AirGapTransactionsWithCursor = await this.protocolV1.getTransactionsForPublicKey(\n      newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)),\n      limit,\n      cursor as TransactionCursor\n    )\n\n    return {\n      transactions: await this.convertTransactionDetailsV1ToV0(transactions.transactions),\n      cursor\n    }\n  }\n\n  public async getTransactionsFromAddresses(\n    addresses: string[],\n    limit: number,\n    cursor?: IProtocolTransactionCursor\n  ): Promise<IAirGapTransactionResult> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.')\n    }\n\n    let transactions: AirGapTransactionsWithCursor\n    if (addresses.length === 1 && canFetchDataForAddress(this.protocolV1)) {\n      transactions = await this.protocolV1.getTransactionsForAddress(addresses[0], limit, cursor as TransactionCursor)\n    } else if (canFetchDataForMultipleAddresses(this.protocolV1)) {\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      transactions = await this.protocolV1.getTransactionsForAddresses(addresses, limit, cursor as TransactionCursor)\n    } else {\n      throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.')\n    }\n\n    return {\n      transactions: await this.convertTransactionDetailsV1ToV0(transactions.transactions),\n      cursor: transactions.cursor ? transactions.cursor : cursor\n    }\n  }\n\n  public async getBalanceOfAddresses(addresses: string[], _data?: { [key: string]: unknown }): Promise<string> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.')\n    }\n\n    let balance: Balance\n    if (addresses.length === 1 && canFetchDataForAddress(this.protocolV1)) {\n      balance = await this.protocolV1.getBalanceOfAddress(addresses[0])\n    } else if (canFetchDataForMultipleAddresses(this.protocolV1)) {\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      balance = await this.protocolV1.getBalanceOfAddresses(addresses)\n    } else {\n      throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.')\n    }\n\n    return newAmount(balance.total).blockchain(this.protocolMetadata.units).value\n  }\n\n  public async getBalanceOfPublicKey(\n    publicKey: string,\n    data?: { [key: string]: unknown; addressIndex?: number; assetID?: string }\n  ): Promise<string> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online.')\n    }\n\n    const publicKeyV1: PublicKey = newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))\n\n    const balance: Balance =\n      data?.assetID && isMultiTokenSubProtocol(this.protocolV1)\n        ? await this.protocolV1.getBalanceOfPublicKey(publicKeyV1, { tokenId: data.assetID })\n        : await this.protocolV1.getBalanceOfPublicKey(publicKeyV1)\n\n    return newAmount(balance.total).blockchain(this.protocolMetadata.units).value\n  }\n\n  public async getBalanceOfExtendedPublicKey(\n    extendedPublicKey: string,\n    _offset: number,\n    data?: { [key: string]: unknown; assetID?: string }\n  ): Promise<string> {\n    if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online, Bip32.')\n    }\n\n    const extendedPublicKeyV1: ExtendedPublicKey = newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey))\n\n    const balance: Balance =\n      data?.assetID && isMultiTokenSubProtocol(this.protocolV1)\n        ? await this.protocolV1.getBalanceOfPublicKey(extendedPublicKeyV1, { tokenId: data.assetID })\n        : await this.protocolV1.getBalanceOfPublicKey(extendedPublicKeyV1)\n\n    return newAmount(balance.total).blockchain(this.protocolMetadata.units).value\n  }\n\n  public async getAvailableBalanceOfAddresses(addresses: string[], _data?: { [key: string]: unknown }): Promise<string> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.')\n    }\n\n    let balance: Balance\n    if (addresses.length === 1 && canFetchDataForAddress(this.protocolV1)) {\n      balance = await this.protocolV1.getBalanceOfAddress(addresses[0])\n    } else if (canFetchDataForMultipleAddresses(this.protocolV1)) {\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      balance = await this.protocolV1.getBalanceOfAddresses(addresses)\n    } else {\n      throw new Error('Method not supported, required interface: Online, FetchDataForAddress/FetchDataForMultipleAddresses.')\n    }\n\n    return newAmount(balance.transferable ?? balance.total).blockchain(this.protocolMetadata.units).value\n  }\n\n  public async getTransactionStatuses(transactionHash: string[]): Promise<AirGapTransactionStatusV0[]> {\n    if (!isOnlineProtocol(this.protocolV1) || !isTransactionStatusChecker(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online, TransactionStatusChecker.')\n    }\n\n    const statuses: Record<string, AirGapTransactionStatus> = await this.protocolV1.getTransactionStatus(transactionHash)\n\n    return transactionHash.map((hash: string) => {\n      const status: AirGapTransactionStatus = statuses[hash]\n\n      return convertTransactionStatusV1ToV0(status)\n    })\n  }\n\n  public async getBalanceOfPublicKeyForSubProtocols(_publicKey: string, _subProtocols: ICoinSubProtocol[]): Promise<string[]> {\n    throw new Error('Method not supported.')\n  }\n\n  public async estimateMaxTransactionValueFromExtendedPublicKey(\n    extendedPublicKey: string,\n    recipients: string[],\n    fee?: string,\n    data?: { [key: string]: unknown }\n  ): Promise<string> {\n    if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online, Bip32.')\n    }\n\n    const maxAmount: Amount = await this.protocolV1.getTransactionMaxAmountWithPublicKey(\n      newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)),\n      recipients,\n      {\n        arbitraryData: this.getArbitraryData(data),\n        fee: fee ? newAmount(fee, 'blockchain') : undefined\n      }\n    )\n\n    return newAmount(maxAmount).blockchain(this.protocolMetadata.units).value\n  }\n\n  public async estimateMaxTransactionValueFromPublicKey(\n    publicKey: string,\n    recipients: string[],\n    fee?: string,\n    data?: { [key: string]: unknown; addressIndex?: number }\n  ): Promise<string> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online.')\n    }\n\n    const maxAmount: Amount = await this.protocolV1.getTransactionMaxAmountWithPublicKey(\n      newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)),\n      recipients,\n      {\n        fee: fee ? newAmount(fee, 'blockchain') : undefined,\n        arbitraryData: this.getArbitraryData(data)\n      }\n    )\n\n    return newAmount(maxAmount).blockchain(this.protocolMetadata.units).value\n  }\n\n  public async estimateFeeDefaultsFromExtendedPublicKey(\n    publicKey: string,\n    recipients: string[],\n    values: string[],\n    data?: {\n      [key: string]: unknown\n\n      // Tezos FA2\n      assetID?: string\n    }\n  ): Promise<FeeDefaultsV0> {\n    if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online, Bip32.')\n    }\n\n    const feeEstimation: FeeEstimation | undefined = await this.protocolV1.getTransactionFeeWithPublicKey(\n      newExtendedPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)),\n      this.combineTransactionDetails(recipients, values),\n      {\n        arbitraryData: this.getArbitraryData(data),\n        assetId: data?.assetID ? parseInt(data.assetID, 10) : undefined\n      }\n    )\n\n    if (feeEstimation === undefined) {\n      throw new Error('Method `estimateFeeDefaultsFromExtendedPublicKey` not supported.')\n    }\n\n    const feeDefaults: FeeDefaults = isAmount(feeEstimation)\n      ? { low: feeEstimation, medium: feeEstimation, high: feeEstimation }\n      : feeEstimation\n\n    return this.convertFeeDefaultsV1ToV0(feeDefaults)\n  }\n\n  public async estimateFeeDefaultsFromPublicKey(\n    publicKey: string,\n    recipients: string[],\n    values: string[],\n    data?: {\n      [key: string]: unknown\n\n      // Tezos FA2\n      assetID?: string\n    }\n  ): Promise<FeeDefaultsV0> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online.')\n    }\n\n    if (recipients.length !== values.length) {\n      throw new Error('Recipients length must match values length.')\n    }\n\n    const transactionDetails: TransactionDetails[] = recipients.map((recipient: string, index: number) => ({\n      to: recipient,\n      amount: newAmount(values[index], 'blockchain')\n    }))\n\n    const feeEstimation: FeeEstimation | undefined = await this.protocolV1.getTransactionFeeWithPublicKey(\n      newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)),\n      transactionDetails,\n      {\n        arbitraryData: this.getArbitraryData(data),\n        assetId: data?.assetID ? parseInt(data.assetID, 10) : undefined\n      }\n    )\n\n    if (feeEstimation === undefined) {\n      throw new Error('Method `estimateFeeDefaultsFromPublicKey` not supported.')\n    }\n\n    const feeDefaults: FeeDefaults = isAmount(feeEstimation)\n      ? { low: feeEstimation, medium: feeEstimation, high: feeEstimation }\n      : feeEstimation\n\n    return this.convertFeeDefaultsV1ToV0(feeDefaults)\n  }\n\n  public async prepareTransactionFromExtendedPublicKey(\n    extendedPublicKey: string,\n    _offset: number,\n    recipients: string[],\n    values: string[],\n    fee: string,\n    extras?: {\n      [key: string]: unknown\n\n      // Bitcoin\n      masterFingerprint: string\n      replaceByFee: boolean\n\n      // Tezos FA2\n      assetID?: string\n    }\n  ): Promise<any> {\n    if (!isOnlineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online.')\n    }\n\n    const isSegwit = isBitcoinSegwitProtocol(this.protocolV1)\n    const isTaproot = isBitcoinTaprootProtocol(this.protocolV1)\n\n    let transaction: UnsignedTransaction\n    if (isSegwit || isTaproot) {\n      transaction = await (isSegwit\n        ? (this.protocolV1 as BitcoinSegwitProtocol)\n        : (this.protocolV1 as BitcoinTaprootProtocol)\n      ).prepareTransactionWithPublicKey(\n        newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)),\n        this.combineTransactionDetails(recipients, values),\n        {\n          fee: newAmount(fee, 'blockchain'),\n          arbitraryData: this.getArbitraryData(extras),\n          masterFingerprint: {\n            format: 'hex',\n            value: extras?.masterFingerprint\n          },\n          replaceByFee: extras?.replaceByFee\n        }\n      )\n    } else {\n      transaction = await this.protocolV1.prepareTransactionWithPublicKey(\n        newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)),\n        this.combineTransactionDetails(recipients, values),\n        {\n          fee: newAmount(fee, 'blockchain'),\n          assetId: extras?.assetID ? parseInt(extras.assetID, 10) : undefined,\n          arbitraryData: this.getArbitraryData(extras)\n        }\n      )\n    }\n\n    const transactionV0 = await this.convertUnsignedTransactionV1ToV0(transaction, extendedPublicKey)\n\n    return transactionV0.transaction\n  }\n\n  public async prepareTransactionFromPublicKey(\n    publicKey: string,\n    recipients: string[],\n    values: string[],\n    fee: string,\n    extras?: {\n      [key: string]: unknown\n\n      // Tezos FA2\n      assetID?: string\n    }\n  ): Promise<any> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online.')\n    }\n\n    const transaction: UnsignedTransaction = await this.protocolV1.prepareTransactionWithPublicKey(\n      newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)),\n      this.combineTransactionDetails(recipients, values),\n      {\n        fee: newAmount(fee, 'blockchain'),\n        arbitraryData: this.getArbitraryData(extras),\n        assetId: extras?.assetID ? parseInt(extras.assetID, 10) : undefined\n      }\n    )\n\n    const transactionV0 = await this.convertUnsignedTransactionV1ToV0(transaction, publicKey)\n\n    return transactionV0.transaction\n  }\n\n  public async broadcastTransaction(rawTransaction: any): Promise<string> {\n    if (!isOnlineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Online.')\n    }\n\n    const transaction = { transaction: rawTransaction, accountIdentifier: '' }\n    const signed: SignedTransaction = await this.convertSignedTransactionV0ToV1(transaction)\n\n    return this.protocolV1.broadcastTransaction(signed)\n  }\n\n  public async getAddressFromPublicKey(publicKey: string, _cursor?: IProtocolAddressCursor): Promise<IAirGapAddressResult> {\n    const address: AddressWithCursor | string = await this.protocolV1.getAddressFromPublicKey(\n      newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))\n    )\n\n    return {\n      address: typeof address === 'string' ? address : address.address,\n      cursor: typeof address === 'object' ? address.cursor : { hasNext: false }\n    }\n  }\n\n  public async getAddressesFromPublicKey(publicKey: string, _cursor?: IProtocolAddressCursor): Promise<IAirGapAddressResult[]> {\n    if (hasMultiAddressPublicKeys(this.protocolV1)) {\n      const pk: PublicKey = newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))\n      const addresses: AddressWithCursor[] = await this.protocolV1.getInitialAddressesFromPublicKey(pk)\n\n      return addresses\n    } else {\n      return [await this.getAddressFromPublicKey(publicKey)]\n    }\n  }\n\n  public async getAddressFromExtendedPublicKey(\n    extendedPublicKey: string,\n    visibilityDerivationIndex: number,\n    addressDerivationIndex: number\n  ): Promise<IAirGapAddressResult> {\n    if (!isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Bip32.')\n    }\n\n    const derivedPublicKey: PublicKey = await this.protocolV1.deriveFromExtendedPublicKey(\n      newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)),\n      visibilityDerivationIndex,\n      addressDerivationIndex\n    )\n\n    return this.getAddressFromPublicKey(derivedPublicKey.value)\n  }\n\n  public async getAddressesFromExtendedPublicKey(\n    extendedPublicKey: string,\n    visibilityDerivationIndex: number,\n    addressCount: number,\n    offset: number\n  ): Promise<IAirGapAddressResult[]> {\n    if (!isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Bip32.')\n    }\n\n    const generatorArray = Array.from(new Array(addressCount), (_, i) => i + offset)\n\n    return Promise.all(\n      generatorArray.map((addressDerivationIndex: number) =>\n        this.getAddressFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex)\n      )\n    )\n  }\n\n  public async getTransactionDetails(\n    transaction: UnsignedTransactionV0,\n    data?: {\n      [key: string]: unknown\n      transactionOwner?: string\n\n      // TezosSapling\n      knownViewingKeys?: string[]\n    }\n  ): Promise<IAirGapTransaction[]> {\n    const unsigned: UnsignedTransaction = await this.convertUnsignedTransactionV0ToV1(transaction, data?.transactionOwner)\n\n    let transactions: AirGapTransaction[]\n    if (this.isExtendedPublicKey(transaction.publicKey)) {\n      if (!isBip32Protocol(this.protocolV1)) {\n        throw new Error('Method not supported, required inferface: Bip32.')\n      }\n\n      transactions = await this.protocolV1.getDetailsFromTransaction(\n        unsigned,\n        newExtendedPublicKey(transaction.publicKey, getBytesFormatV1FromV0(transaction.publicKey))\n      )\n    } else {\n      const publicKey: PublicKey = newPublicKey(transaction.publicKey, getBytesFormatV1FromV0(transaction.publicKey))\n      transactions =\n        data?.knownViewingKeys && isTezosSaplingProtocol(this.protocolV1)\n          ? await this.protocolV1.getDetailsFromTransaction(unsigned as any, publicKey, data.knownViewingKeys)\n          : await this.protocolV1.getDetailsFromTransaction(unsigned, publicKey)\n    }\n\n    const transactionsV0: IAirGapTransaction[] = await this.convertTransactionDetailsV1ToV0(transactions)\n\n    return transactionsV0.map(\n      (tx: IAirGapTransaction): IAirGapTransaction => ({\n        ...tx,\n        transactionDetails: tx.transactionDetails ?? transaction.transaction\n      })\n    )\n  }\n\n  public async getTransactionDetailsFromSigned(\n    transaction: SignedTransactionV0,\n    data?: {\n      [key: string]: unknown\n      transactionOwner?: string\n\n      // TezosSapling\n      knownViewingKeys?: string[]\n    }\n  ): Promise<IAirGapTransaction[]> {\n    const signed: SignedTransaction = await this.convertSignedTransactionV0ToV1(transaction, data?.transactionOwner)\n\n    let transactions: AirGapTransaction[]\n    if (this.isExtendedPublicKey(transaction.accountIdentifier)) {\n      if (!isBip32Protocol(this.protocolV1)) {\n        throw new Error('Method not supported, required inferface: Bip32.')\n      }\n\n      transactions = await this.protocolV1.getDetailsFromTransaction(\n        signed,\n        newExtendedPublicKey(transaction.accountIdentifier, getBytesFormatV1FromV0(transaction.accountIdentifier))\n      )\n    } else {\n      const publicKey: PublicKey = newPublicKey(transaction.accountIdentifier, getBytesFormatV1FromV0(transaction.accountIdentifier))\n      transactions =\n        data?.knownViewingKeys && isTezosSaplingProtocol(this.protocolV1)\n          ? await this.protocolV1.getDetailsFromTransaction(signed as any, publicKey, data.knownViewingKeys)\n          : await this.protocolV1.getDetailsFromTransaction(signed, publicKey)\n    }\n\n    const transactionsV0: IAirGapTransaction[] = await this.convertTransactionDetailsV1ToV0(transactions)\n\n    return transactionsV0.map(\n      (tx: IAirGapTransaction): IAirGapTransaction => ({\n        ...tx,\n        transactionDetails: tx.transactionDetails ?? transaction.transaction\n      })\n    )\n  }\n\n  public async verifyMessage(message: string, signature: string, publicKey: string): Promise<boolean> {\n    if (!isOfflineProtocol(this.protocolV1) || !canSignMessage(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, SignMessage.')\n    }\n\n    return this.protocolV1.verifyMessageWithPublicKey(\n      message,\n      newSignature(signature, getBytesFormatV1FromV0(signature)),\n      newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))\n    )\n  }\n\n  public async encryptAsymmetric(payload: string, publicKey: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !canEncryptAsymmetric(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, AsymmetricEncryption.')\n    }\n\n    return this.protocolV1.encryptAsymmetricWithPublicKey(payload, newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey)))\n  }\n\n  public async getPublicKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const seed: Buffer = await mnemonicToSeed(crypto, mnemonic, password)\n\n    return this.getPublicKeyFromHexSecret(seed.toString('hex'), derivationPath)\n  }\n\n  public async getPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const seed: Buffer = await mnemonicToSeed(crypto, mnemonic, password)\n\n    return this.getPrivateKeyFromHexSecret(seed.toString('hex'), derivationPath)\n  }\n\n  public async getExtendedPublicKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, Bip32.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const seed: Buffer = await mnemonicToSeed(crypto, mnemonic, password)\n\n    return this.getExtendedPublicKeyFromHexSecret(seed.toString('hex'), derivationPath)\n  }\n\n  public async getExtendedPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, Bip32.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const seed: Buffer = await mnemonicToSeed(crypto, mnemonic, password)\n\n    return this.getExtendedPrivateKeyFromHexSecret(seed.toString('hex'), derivationPath)\n  }\n\n  public async getPublicKeyFromHexSecret(secret: string, derivationPath: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, Bip32.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const derivative: CryptoDerivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath)\n    const keyPair: KeyPair = await this.protocolV1.getKeyPairFromDerivative(derivative)\n\n    return keyPair.publicKey.value\n  }\n\n  public async getPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const derivative: CryptoDerivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath)\n    const keyPair: KeyPair = await this.protocolV1.getKeyPairFromDerivative(derivative)\n\n    return keyPair.secretKey.value\n  }\n\n  public async getExtendedPublicKeyFromHexSecret(secret: string, derivationPath: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, Bip32.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const derivative: CryptoDerivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath)\n    const keyPair: ExtendedKeyPair = await this.protocolV1.getExtendedKeyPairFromDerivative(derivative)\n\n    return keyPair.publicKey.value\n  }\n\n  public async getExtendedPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, Bip32.')\n    }\n\n    const crypto: CryptoConfiguration = this.crypto ?? (await this.protocolV1.getCryptoConfiguration())\n    const derivative: CryptoDerivative = await derive(crypto, Buffer.from(secret, 'hex'), derivationPath)\n    const keyPair: ExtendedKeyPair = await this.protocolV1.getExtendedKeyPairFromDerivative(derivative)\n\n    return keyPair.secretKey.value\n  }\n\n  public async signWithExtendedPrivateKey(extendedPrivateKey: string, transaction: any, childDerivationPath?: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, Bip32.')\n    }\n\n    const unsigned: UnsignedTransaction = await this.convertUnsignedTransactionV0ToV1({\n      transaction,\n      publicKey: ''\n    })\n\n    const extendedSecretKey: ExtendedSecretKey = newExtendedSecretKey(extendedPrivateKey, getBytesFormatV1FromV0(extendedPrivateKey))\n\n    const secretKey: ExtendedSecretKey | SecretKey = childDerivationPath\n      ? await this.deriveSecretKey(extendedSecretKey, childDerivationPath)\n      : extendedSecretKey\n\n    const signed: SignedTransaction = await this.protocolV1.signTransactionWithSecretKey(unsigned, secretKey)\n    const signedV0: TransactionSignResponse = await this.convertSignedTransactionV1ToV0(signed, '')\n\n    return signedV0.transaction\n  }\n\n  public async signWithPrivateKey(privateKey: string, transaction: any): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline.')\n    }\n\n    const unsigned: UnsignedTransaction = await this.convertUnsignedTransactionV0ToV1({\n      transaction,\n      publicKey: ''\n    })\n\n    const signed: SignedTransaction = await this.protocolV1.signTransactionWithSecretKey(\n      unsigned,\n      newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey))\n    )\n    const signedV0: TransactionSignResponse = await this.convertSignedTransactionV1ToV0(signed, '')\n\n    return signedV0.transaction\n  }\n\n  public async signMessage(message: string, keypair: { publicKey?: string; privateKey: string }): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !canSignMessage(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, SignMessage.')\n    }\n\n    const privateKey =\n      getSecretKeyType(keypair.privateKey) === 'xpriv'\n        ? await this.getPrivateKeyFromExtendedPrivateKey(keypair.privateKey)\n        : keypair.privateKey\n\n    const publicKey = keypair.publicKey\n      ? getPublicKeyType(keypair.publicKey) === 'xpub'\n        ? await this.getPublicKeyFromExtendedPrivateKey(keypair.publicKey)\n        : keypair.publicKey\n      : ''\n\n    const signature: Signature = await this.protocolV1.signMessageWithKeyPair(message, {\n      secretKey: newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)),\n      publicKey: newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))\n    })\n\n    return signature.value\n  }\n\n  public async decryptAsymmetric(encryptedPayload: string, keypair: { publicKey?: string; privateKey: string }): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !canEncryptAsymmetric(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, AsymmetricEncryption.')\n    }\n\n    const privateKey =\n      getSecretKeyType(keypair.privateKey) === 'xpriv'\n        ? await this.getPrivateKeyFromExtendedPrivateKey(keypair.privateKey)\n        : keypair.privateKey\n\n    const publicKey = keypair.publicKey\n      ? getPublicKeyType(keypair.publicKey) === 'xpub'\n        ? await this.getPublicKeyFromExtendedPrivateKey(keypair.publicKey)\n        : keypair.publicKey\n      : ''\n\n    return this.protocolV1.decryptAsymmetricWithKeyPair(encryptedPayload, {\n      secretKey: newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)),\n      publicKey: newPublicKey(publicKey, getBytesFormatV1FromV0(publicKey))\n    })\n  }\n\n  public async encryptAES(payload: string, privateKey: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !canEncryptAES(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, AES.')\n    }\n\n    // eslint-disable-next-line no-param-reassign\n    privateKey = getSecretKeyType(privateKey) === 'xpriv' ? await this.getPrivateKeyFromExtendedPrivateKey(privateKey) : privateKey\n\n    return this.protocolV1.encryptAESWithSecretKey(payload, newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)))\n  }\n\n  public async decryptAES(encryptedPayload: string, privateKey: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !canEncryptAES(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, AES.')\n    }\n\n    // eslint-disable-next-line no-param-reassign\n    privateKey = getSecretKeyType(privateKey) === 'xpriv' ? await this.getPrivateKeyFromExtendedPrivateKey(privateKey) : privateKey\n\n    return this.protocolV1.decryptAESWithSecretKey(encryptedPayload, newSecretKey(privateKey, getBytesFormatV1FromV0(privateKey)))\n  }\n\n  public async getPrivateKeyFromExtendedPrivateKey(extendedPrivateKey: string, childDerivationPath?: string): Promise<string> {\n    if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Offline, Bip32.')\n    }\n\n    const secretKey: SecretKey = await this.deriveSecretKey(\n      newExtendedSecretKey(extendedPrivateKey, getBytesFormatV1FromV0(extendedPrivateKey)),\n      childDerivationPath\n    )\n\n    return secretKey.value\n  }\n\n  public async getPublicKeyFromExtendedPrivateKey(extendedPublicKey: string, childDerivationPath?: string): Promise<string> {\n    if (!isBip32Protocol(this.protocolV1)) {\n      throw new Error('Method not supported, required inferface: Bip32.')\n    }\n\n    const publicKey: PublicKey = await this.derivePublicKey(\n      newExtendedPublicKey(extendedPublicKey, getBytesFormatV1FromV0(extendedPublicKey)),\n      childDerivationPath\n    )\n\n    return publicKey.value\n  }\n\n  protected getNetwork(protocolOptions?: ProtocolOptionsV0): ProtocolNetworkV0 {\n    let knownOptions: ProtocolOptionsV0 | undefined\n    try {\n      knownOptions = protocolOptions ?? getProtocolOptionsByIdentifierLegacy(this.identifier)\n      // eslint-disable-next-line no-empty\n    } catch {}\n\n    const { name, type, rpcUrl, ...rest } = this.network ?? {}\n\n    return new ProtocolNetworkAdapter(\n      name ?? knownOptions?.network.name ?? '',\n      type ?? knownOptions?.network.type ?? 'mainnet',\n      rpcUrl ?? knownOptions?.network.rpcUrl ?? '',\n      this.blockExplorerV0,\n      rest || (knownOptions?.network.extras ?? {})\n    )\n  }\n\n  protected async deriveSecretKey(extendedSecretKey: ExtendedSecretKey, childDerivationPath: string = '0/0'): Promise<SecretKey> {\n    if (!isOfflineProtocol(this.protocolV1) || !isBip32Protocol(this.protocolV1)) {\n      throw new Error(`Protocol doesn't support secret key derivation, missing inferface: Offline, Bip32.`)\n    }\n\n    if (childDerivationPath.startsWith('m')) {\n      throw new Error('Received full derivation path, expected child derivation path')\n    }\n\n    if (childDerivationPath.toLowerCase().includes('h') || childDerivationPath.includes(`'`)) {\n      throw new Error('Child derivation path cannot include hardened children')\n    }\n\n    const [visibilityIndex, addressIndex]: number[] = childDerivationPath.split('/').map((index: string) => parseInt(index, 10))\n\n    return this.protocolV1.deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex)\n  }\n\n  protected async derivePublicKey(extendedPublicKey: ExtendedPublicKey, childDerivationPath: string = '0/0'): Promise<PublicKey> {\n    if (!isBip32Protocol(this.protocolV1)) {\n      throw new Error(`Protocol doesn't support public key derivation, missing inferface: Bip32.`)\n    }\n\n    if (childDerivationPath.startsWith('m')) {\n      throw new Error('Received full derivation path, expected child derivation path')\n    }\n\n    if (childDerivationPath.toLowerCase().includes('h') || childDerivationPath.includes(`'`)) {\n      throw new Error('Child derivation path cannot include hardened children')\n    }\n\n    const [visibilityIndex, addressIndex]: number[] = childDerivationPath.split('/').map((index: string) => parseInt(index, 10))\n\n    return this.protocolV1.deriveFromExtendedPublicKey(extendedPublicKey, visibilityIndex, addressIndex)\n  }\n\n  protected async getSerializerIdentifier(base?: string): Promise<string> {\n    const identifier: string = base ?? (await this.getIdentifier())\n\n    return identifier.startsWith(SubProtocolSymbols.ETH_ERC20)\n      ? SubProtocolSymbols.ETH_ERC20\n      : identifier.startsWith(SubProtocolSymbols.OPTIMISM_ERC20)\n      ? SubProtocolSymbols.OPTIMISM_ERC20\n      : identifier\n  }\n\n  public async convertUnsignedTransactionV0ToV1(transaction: TransactionSignRequest, owner?: string): Promise<UnsignedTransaction> {\n    const identifier: string = await this.getSerializerIdentifier(owner)\n\n    return this.v3SerializerCompanion.fromTransactionSignRequest(identifier, transaction)\n  }\n\n  public async convertUnsignedTransactionV1ToV0(\n    transaction: UnsignedTransaction,\n    publicKey: string,\n    callbackUrl?: string,\n    owner?: string\n  ): Promise<TransactionSignRequest> {\n    const identifier: string = await this.getSerializerIdentifier(owner)\n\n    return this.v3SerializerCompanion.toTransactionSignRequest(identifier, transaction, publicKey, callbackUrl)\n  }\n\n  public async convertSignedTransactionV0ToV1(transaction: TransactionSignResponse, owner?: string): Promise<SignedTransaction> {\n    const identifier: string = await this.getSerializerIdentifier(owner)\n\n    return this.v3SerializerCompanion.fromTransactionSignResponse(identifier, transaction)\n  }\n\n  public async convertSignedTransactionV1ToV0(\n    transaction: SignedTransaction,\n    accountIdentifier: string,\n    owner?: string\n  ): Promise<TransactionSignResponse> {\n    const identifier: string = await this.getSerializerIdentifier(owner)\n\n    return this.v3SerializerCompanion.toTransactionSignResponse(identifier, transaction, accountIdentifier)\n  }\n\n  public convertFeeDefaultsV1ToV0(feeDefaults: FeeDefaults): FeeDefaultsV0 {\n    return convertFeeDefaultsV1ToV0(feeDefaults, this.protocolMetadata)\n  }\n\n  public async convertTransactionDetailsV1ToV0(txs: AirGapTransaction[]): Promise<IAirGapTransaction[]> {\n    return convertTransactionDetailsV1ToV0(txs, this.protocolMetadata, this.networkV0)\n  }\n\n  protected combineTransactionDetails<_Units extends string>(recipients: string[], values: string[]): TransactionDetails<_Units>[] {\n    if (recipients.length !== values.length) {\n      throw new Error('Recipients length must match values length.')\n    }\n\n    return recipients.map((recipient: string, index: number) => ({\n      to: recipient,\n      amount: newAmount(values[index], 'blockchain')\n    }))\n  }\n\n  protected isExtendedPublicKey(publicKey: string): boolean {\n    return publicKey.startsWith('xpub') || publicKey.startsWith('ypub') || publicKey.startsWith('zpub')\n  }\n\n  protected getArbitraryData(data: any): string | undefined {\n    const simpleArbitraryDataMetadataSchema: Schema<ProtocolTransactionArbitraryDataMetadata> = {\n      name: 'required',\n      maxLength: 'optional',\n      regex: 'optional'\n    }\n\n    return this.protocolMetadata.transaction?.arbitraryData\n      ? implementsInterface<ProtocolTransactionArbitraryDataMetadata>(\n          this.protocolMetadata.transaction?.arbitraryData,\n          simpleArbitraryDataMetadataSchema\n        )\n        ? data[this.protocolMetadata.transaction.arbitraryData.name]\n        : data[this.protocolMetadata.transaction.arbitraryData.root?.name ?? this.protocolMetadata.transaction.arbitraryData.inner?.name]\n      : undefined\n  }\n}\n\n// ICoinDelegateProtocol\n\nexport class ICoinDelegateProtocolAdapter<T extends AirGapAnyProtocol & AirGapDelegateProtocol>\n  extends ICoinProtocolAdapter<T>\n  implements ICoinDelegateProtocol\n{\n  public async getDefaultDelegatee(): Promise<string> {\n    return this.protocolV1.getDefaultDelegatee()\n  }\n\n  public async getCurrentDelegateesForPublicKey(publicKey: string, data?: any): Promise<string[]> {\n    return this.protocolV1.getCurrentDelegateesForPublicKey(\n      { type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) },\n      data\n    )\n  }\n\n  public async getCurrentDelegateesForAddress(address: string, data?: any): Promise<string[]> {\n    return this.protocolV1.getCurrentDelegateesForAddress(address, data)\n  }\n\n  public async getDelegateeDetails(address: string, data?: any): Promise<DelegateeDetails> {\n    return this.protocolV1.getDelegateeDetails(address, data)\n  }\n\n  public async isPublicKeyDelegating(publicKey: string, data?: any): Promise<boolean> {\n    return this.protocolV1.isPublicKeyDelegating({ type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) }, data)\n  }\n\n  public async isAddressDelegating(address: string, data?: any): Promise<boolean> {\n    return this.protocolV1.isAddressDelegating(address, data)\n  }\n\n  public async getDelegatorDetailsFromPublicKey(publicKey: string, data?: any): Promise<DelegatorDetails> {\n    return this.protocolV1.getDelegatorDetailsFromPublicKey(\n      { type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) },\n      data\n    )\n  }\n\n  public async getDelegatorDetailsFromAddress(address: string, data?: any): Promise<DelegatorDetails> {\n    return this.protocolV1.getDelegatorDetailsFromAddress(address, data)\n  }\n\n  public async getDelegationDetailsFromPublicKey(publicKey: string, delegatees: string[], data?: any): Promise<DelegationDetails> {\n    return this.protocolV1.getDelegationDetailsFromPublicKey(\n      { type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) },\n      delegatees,\n      data\n    )\n  }\n\n  public async getDelegationDetailsFromAddress(address: string, delegatees: string[], data?: any): Promise<DelegationDetails> {\n    return this.protocolV1.getDelegationDetailsFromAddress(address, delegatees, data)\n  }\n\n  public async prepareDelegatorActionFromPublicKey(publicKey: string, type: any, data?: any): Promise<any[]> {\n    const transactions = await this.protocolV1.prepareDelegatorActionFromPublicKey(\n      { type: 'pub', value: publicKey, format: getBytesFormatV1FromV0(publicKey) },\n      type,\n      data\n    )\n\n    const transactionsV0 = await Promise.all(\n      transactions.map((transaction) => this.convertUnsignedTransactionV1ToV0(transaction, publicKey))\n    )\n\n    return transactionsV0.map((transaction) => transaction.transaction)\n  }\n}\n\n// ICoinSubProtocol\n\nexport class ICoinSubProtocolAdapter<T extends AirGapAnyProtocol & SubProtocol = AirGapAnyProtocol & SubProtocol>\n  extends ICoinProtocolAdapter<T>\n  implements ICoinSubProtocol\n{\n  public readonly isSubProtocol: boolean = true\n  public readonly subProtocolType: SubProtocolTypeV0\n  public readonly contractAddress?: string\n\n  constructor(\n    protocolV1: T,\n    protocolMetadata: ProtocolMetadata,\n    crypto: CryptoConfiguration | undefined,\n    network: ProtocolNetwork | undefined,\n    v1BlockExplorer: AirGapBlockExplorer | undefined,\n    blockExplorerMetadata: BlockExplorerMetadata | undefined,\n    v3SerializerCompanion: AirGapV3SerializerCompanion,\n    type: SubProtocolType,\n    contractAddress: string | undefined\n  ) {\n    super(protocolV1, protocolMetadata, crypto, network, v1BlockExplorer, blockExplorerMetadata, v3SerializerCompanion)\n\n    this.subProtocolType = type === 'account' ? SubProtocolTypeV0.ACCOUNT : SubProtocolTypeV0.TOKEN\n    this.contractAddress = contractAddress\n  }\n\n  public async getIsSubProtocol(): Promise<boolean> {\n    return this.isSubProtocol\n  }\n\n  public async getSubProtocolType(): Promise<SubProtocolTypeV0> {\n    return this.subProtocolType\n  }\n\n  public async getContractAddress(): Promise<string | undefined> {\n    return this.contractAddress\n  }\n}\n\nexport class ICoinDelegateSubProtocolAdapter<\n    T extends AirGapAnyProtocol & AirGapDelegateProtocol & SubProtocol = AirGapAnyProtocol & AirGapDelegateProtocol & SubProtocol\n  >\n  extends ICoinSubProtocolAdapter<T>\n  implements ICoinSubProtocol, ICoinDelegateProtocol\n{\n  private readonly delegateProtocolAdapter: ICoinDelegateProtocolAdapter<T>\n\n  constructor(\n    protocolV1: T,\n    protocolMetadata: ProtocolMetadata,\n    crypto: CryptoConfiguration | undefined,\n    network: ProtocolNetwork | undefined,\n    v1BlockExplorer: AirGapBlockExplorer | undefined,\n    blockExplorerMetadata: BlockExplorerMetadata | undefined,\n    v3SerializerCompanion: AirGapV3SerializerCompanion,\n    type: SubProtocolType,\n    contractAddress: string | undefined\n  ) {\n    super(\n      protocolV1,\n      protocolMetadata,\n      crypto,\n      network,\n      v1BlockExplorer,\n      blockExplorerMetadata,\n      v3SerializerCompanion,\n      type,\n      contractAddress\n    )\n\n    this.delegateProtocolAdapter = new ICoinDelegateProtocolAdapter(\n      protocolV1,\n      protocolMetadata,\n      crypto,\n      network,\n      v1BlockExplorer,\n      blockExplorerMetadata,\n      v3SerializerCompanion\n    )\n  }\n\n  public async getDefaultDelegatee(): Promise<string> {\n    return this.delegateProtocolAdapter.getDefaultDelegatee()\n  }\n\n  public async getCurrentDelegateesForPublicKey(publicKey: string, data?: any): Promise<string[]> {\n    return this.delegateProtocolAdapter.getCurrentDelegateesForPublicKey(publicKey, data)\n  }\n\n  public async getCurrentDelegateesForAddress(address: string, data?: any): Promise<string[]> {\n    return this.delegateProtocolAdapter.getCurrentDelegateesForAddress(address, data)\n  }\n\n  public async getDelegateeDetails(address: string, data?: any): Promise<DelegateeDetails> {\n    return this.delegateProtocolAdapter.getDelegateeDetails(address, data)\n  }\n\n  public async isPublicKeyDelegating(publicKey: string, data?: any): Promise<boolean> {\n    return this.delegateProtocolAdapter.isPublicKeyDelegating(publicKey, data)\n  }\n\n  public async isAddressDelegating(address: string, data?: any): Promise<boolean> {\n    return this.delegateProtocolAdapter.isAddressDelegating(address, data)\n  }\n\n  public async getDelegatorDetailsFromPublicKey(publicKey: string, data?: any): Promise<DelegatorDetails> {\n    return this.delegateProtocolAdapter.getDelegatorDetailsFromPublicKey(publicKey, data)\n  }\n\n  public async getDelegatorDetailsFromAddress(address: string, data?: any): Promise<DelegatorDetails> {\n    return this.delegateProtocolAdapter.getDelegatorDetailsFromAddress(address, data)\n  }\n\n  public async getDelegationDetailsFromPublicKey(publicKey: string, delegatees: string[], data?: any): Promise<DelegationDetails> {\n    return this.delegateProtocolAdapter.getDelegationDetailsFromPublicKey(publicKey, delegatees, data)\n  }\n\n  public async getDelegationDetailsFromAddress(address: string, delegatees: string[], data?: any): Promise<DelegationDetails> {\n    return this.delegateProtocolAdapter.getDelegationDetailsFromAddress(address, delegatees, data)\n  }\n\n  public async prepareDelegatorActionFromPublicKey(publicKey: string, type: any, data?: any): Promise<any[]> {\n    return this.delegateProtocolAdapter.prepareDelegatorActionFromPublicKey(publicKey, type, data)\n  }\n}\n\n// Factories\n\nexport async function createICoinProtocolAdapter<T extends AirGapAnyProtocol>(\n  protocolV1: T,\n  blockExplorerV1: AirGapBlockExplorer | undefined,\n  v3SerializerCompanion: AirGapV3SerializerCompanion,\n  extra: {\n    type?: ProtocolConfiguration['type']\n    protocolMetadata?: ProtocolMetadata\n    crypto?: CryptoConfiguration | null\n    network?: ProtocolNetwork | null\n    blockExplorerMetadata?: BlockExplorerMetadata | null\n  } = {}\n): Promise<ICoinProtocolAdapter<T>> {\n  const [protocolMetadata, crypto, network, blockExplorerMetadata]: [\n    ProtocolMetadata,\n    CryptoConfiguration | undefined,\n    ProtocolNetwork | undefined,\n    BlockExplorerMetadata | undefined\n  ] = await Promise.all([\n    extra.protocolMetadata ? Promise.resolve(extra.protocolMetadata) : protocolV1.getMetadata(),\n    extra.crypto\n      ? Promise.resolve(extra.crypto)\n      : extra.crypto === null || !isOfflineProtocol(protocolV1) || (extra.type !== 'offline' && extra.type !== 'full')\n      ? Promise.resolve(undefined)\n      : protocolV1.getCryptoConfiguration(),\n    extra.network\n      ? Promise.resolve(extra.network)\n      : extra.network === null || !isOnlineProtocol(protocolV1) || (extra.type !== 'online' && extra.type !== 'full')\n      ? Promise.resolve(undefined)\n      : protocolV1.getNetwork(),\n    extra.blockExplorerMetadata\n      ? Promise.resolve(extra.blockExplorerMetadata)\n      : extra.blockExplorerMetadata === null || blockExplorerV1 === undefined || (extra.type !== 'online' && extra.type !== 'full')\n      ? Promise.resolve(undefined)\n      : blockExplorerV1.getMetadata()\n  ])\n\n  if (supportsV1Delegation(protocolV1)) {\n    // eslint-disable-next-line @typescript-eslint/no-use-before-define\n    return new ICoinDelegateProtocolAdapter(\n      protocolV1,\n      protocolMetadata,\n      crypto,\n      network,\n      blockExplorerV1,\n      blockExplorerMetadata,\n      v3SerializerCompanion\n    )\n  } else {\n    return new ICoinProtocolAdapter(\n      protocolV1,\n      protocolMetadata,\n      crypto,\n      network,\n      blockExplorerV1,\n      blockExplorerMetadata,\n      v3SerializerCompanion\n    )\n  }\n}\n\n// eslint-disable-next-line complexity\nexport async function createICoinSubProtocolAdapter<T extends AirGapAnyProtocol & SubProtocol>(\n  protocolV1: T,\n  blockExplorerV1: AirGapBlockExplorer | undefined,\n  v3SerializerCompanion: AirGapV3SerializerCompanion,\n  extra: {\n    type?: ProtocolConfiguration['type']\n    protocolMetadata?: ProtocolMetadata\n    crypto?: CryptoConfiguration | null\n    network?: ProtocolNetwork | null\n    blockExplorerMetadata?: BlockExplorerMetadata | null\n    subType?: SubProtocolType\n    contractAddress?: string | null\n  } = {}\n): Promise<ICoinSubProtocolAdapter<T>> {\n  const [protocolMetadata, crypto, network, blockExplorerMetadata, type, contractAddress]: [\n    ProtocolMetadata,\n    CryptoConfiguration | undefined,\n    ProtocolNetwork | undefined,\n    BlockExplorerMetadata | undefined,\n    SubProtocolType,\n    string | undefined\n  ] = await Promise.all([\n    extra.protocolMetadata ? Promise.resolve(extra.protocolMetadata) : protocolV1.getMetadata(),\n    extra.crypto\n      ? Promise.resolve(extra.crypto)\n      : extra.crypto === null || !isOfflineProtocol(protocolV1) || (extra?.type !== 'offline' && extra?.type !== 'full')\n      ? Promise.resolve(undefined)\n      : protocolV1.getCryptoConfiguration(),\n    extra.network\n      ? Promise.resolve(extra.network)\n      : extra.network === null || !isOnlineProtocol(protocolV1) || (extra?.type !== 'online' && extra?.type !== 'full')\n      ? Promise.resolve(undefined)\n      : protocolV1.getNetwork(),\n    extra.blockExplorerMetadata\n      ? Promise.resolve(extra.blockExplorerMetadata)\n      : extra.blockExplorerMetadata === null || blockExplorerV1 === undefined || (extra?.type !== 'online' && extra?.type !== 'full')\n      ? Promise.resolve(undefined)\n      : blockExplorerV1.getMetadata(),\n    extra.subType ? Promise.resolve(extra.subType) : protocolV1.getType(),\n    extra.contractAddress\n      ? Promise.resolve(extra.contractAddress)\n      : extra.contractAddress === null || !hasConfigurableContract(protocolV1)\n      ? Promise.resolve(undefined)\n      : protocolV1.getContractAddress()\n  ])\n\n  if (supportsV1Delegation(protocolV1)) {\n    return new ICoinDelegateSubProtocolAdapter(\n      protocolV1,\n      protocolMetadata,\n      crypto,\n      network,\n      blockExplorerV1,\n      blockExplorerMetadata,\n      v3SerializerCompanion,\n      type,\n      contractAddress\n    )\n  } else {\n    return new ICoinSubProtocolAdapter(\n      protocolV1,\n      protocolMetadata,\n      crypto,\n      network,\n      blockExplorerV1,\n      blockExplorerMetadata,\n      v3SerializerCompanion,\n      type,\n      contractAddress\n    )\n  }\n}\n"]}