@airgap/ethereum 0.13.45-beta.3 → 0.13.45-beta.5

package/v1/protocol/EthereumBaseProtocol.js

@@ -1,4 +1,30 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -15,45 +41,71 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultEthereumBaseProtocolImpl = exports.EthereumBaseProtocolImpl = exports.DEFAULT_ETHEREUM_UNITS_METADATA = void 0;
 // tslint:disable: max-classes-per-file
-const coinlib_core_1 = require("@airgap/coinlib-core");
-const bignumber_1 = require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber");
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var bignumber_1 = require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber");
 // @ts-ignore
-const BitGo = __importStar(require("@airgap/coinlib-core/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src"));
-const errors_1 = require("@airgap/coinlib-core/errors");
-const hex_1 = require("@airgap/coinlib-core/utils/hex");
-const crypto_1 = require("@airgap/crypto");
-const module_kit_1 = require("@airgap/module-kit");
-const common_1 = __importDefault(require("@ethereumjs/common"));
+var BitGo = __importStar(require("@airgap/coinlib-core/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var crypto_1 = require("@airgap/crypto");
+var module_kit_1 = require("@airgap/module-kit");
+var common_1 = __importDefault(require("@ethereumjs/common"));
 // TODO: ETH TX and ethereumjs-util-5.2.0 removed
-const tx_1 = require("@ethereumjs/tx");
-const EthereumCryptoClient_1 = require("../clients/crypto/EthereumCryptoClient");
-const EthereumAddress_1 = require("../data/EthereumAddress");
-const EthereumUtils_1 = require("../utils/EthereumUtils");
-const key_1 = require("../utils/key");
-const EthereumChainIds_1 = require("./EthereumChainIds");
+var tx_1 = require("@ethereumjs/tx");
+var EthereumCryptoClient_1 = require("../clients/crypto/EthereumCryptoClient");
+var EthereumAddress_1 = require("../data/EthereumAddress");
+var EthereumUtils_1 = require("../utils/EthereumUtils");
+var key_1 = require("../utils/key");
+var EthereumChainIds_1 = require("./EthereumChainIds");
 // Implementation
 exports.DEFAULT_ETHEREUM_UNITS_METADATA = {
     ETH: {
@@ -69,10 +121,11 @@ exports.DEFAULT_ETHEREUM_UNITS_METADATA = {
         decimals: 0
     }
 };
-const MAX_GAS_ESTIMATE = 300000;
-const WALLET_CONNECT_NAMESPACE = 'eip155';
-class EthereumBaseProtocolImpl {
-    constructor(nodeClient, infoClient, options) {
+var MAX_GAS_ESTIMATE = 300000;
+var WALLET_CONNECT_NAMESPACE = 'eip155';
+var EthereumBaseProtocolImpl = /** @class */ (function () {
+    function EthereumBaseProtocolImpl(nodeClient, infoClient, options) {
+        var _a, _b;
         this.bitcoinJS = {
             lib: BitGo,
             config: { network: BitGo.networks.bitcoin }
@@ -87,7 +140,7 @@ class EthereumBaseProtocolImpl {
         this.infoClient = infoClient;
         this.cryptoClient = new EthereumCryptoClient_1.EthereumCryptoClient();
         this.units = options.units;
-        this.feeDefaults = options.feeDefaults ?? {
+        this.feeDefaults = (_a = options.feeDefaults) !== null && _a !== void 0 ? _a : {
             low: (0, module_kit_1.newAmount)(0.00021 /* 21000 GAS * 10 GWEI */, 'ETH').blockchain(this.feeUnits),
             medium: (0, module_kit_1.newAmount)(0.000315 /* 21000 GAS * 15 GWEI */, 'ETH').blockchain(this.feeUnits),
             high: (0, module_kit_1.newAmount)(0.00084 /* 21000 GAS * 40 GWEI */, 'ETH').blockchain(this.feeUnits)
@@ -103,7 +156,7 @@ class EthereumBaseProtocolImpl {
                 mainUnit: 'ETH'
             },
             account: {
-                standardDerivationPath: options.standardDerivationPath ?? `m/44'/60'/0'`,
+                standardDerivationPath: (_b = options.standardDerivationPath) !== null && _b !== void 0 ? _b : "m/44'/60'/0'",
                 address: {
                     isCaseSensitive: false,
                     placeholder: '0xabc...',
@@ -117,455 +170,723 @@ class EthereumBaseProtocolImpl {
             }
         };
     }
-    async getMetadata() {
-        return this.metadata;
-    }
-    async getAddressFromPublicKey(publicKey) {
-        return EthereumAddress_1.EthereumAddress.from(this.nonExtendedPublicKey(publicKey)).asString();
-    }
-    async deriveFromExtendedPublicKey(extendedPublicKey, visibilityIndex, addressIndex) {
-        return this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, visibilityIndex, addressIndex);
-    }
-    async getDetailsFromTransaction(transaction, publicKey) {
-        return publicKey.type === 'pub'
-            ? this.getDetailsFromTransactionWithPublicKey(transaction, publicKey)
-            : this.getDetailsFromTransactionWithExtendedPublicKey(transaction, publicKey);
-    }
-    async getDetailsFromTransactionWithPublicKey(transaction, publicKey) {
-        switch (transaction.type) {
-            case 'signed':
-                return this.getDetailsFromSignedTransaction(transaction);
-            case 'unsigned':
-                const ownAddress = await this.getAddressFromPublicKey(publicKey);
-                if (transaction.ethereumType === 'typed') {
-                    return this.getDetailsFromTypedUnsignedTransaction(transaction, ownAddress);
+    EthereumBaseProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, EthereumAddress_1.EthereumAddress.from(this.nonExtendedPublicKey(publicKey)).asString()];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.deriveFromExtendedPublicKey = function (extendedPublicKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, visibilityIndex, addressIndex)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, publicKey.type === 'pub'
+                        ? this.getDetailsFromTransactionWithPublicKey(transaction, publicKey)
+                        : this.getDetailsFromTransactionWithExtendedPublicKey(transaction, publicKey)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getDetailsFromTransactionWithPublicKey = function (transaction, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, ownAddress;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = transaction.type;
+                        switch (_a) {
+                            case 'signed': return [3 /*break*/, 1];
+                            case 'unsigned': return [3 /*break*/, 2];
+                        }
+                        return [3 /*break*/, 4];
+                    case 1: return [2 /*return*/, this.getDetailsFromSignedTransaction(transaction)];
+                    case 2: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 3:
+                        ownAddress = _b.sent();
+                        if (transaction.ethereumType === 'typed') {
+                            return [2 /*return*/, this.getDetailsFromTypedUnsignedTransaction(transaction, ownAddress)];
+                        }
+                        else {
+                            return [2 /*return*/, this.getDetailsFromRawUnsignedTransaction(transaction, ownAddress)];
+                        }
+                        _b.label = 4;
+                    case 4:
+                        (0, coinlib_core_1.assertNever)(transaction);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, 'Unsupported transaction type.');
                 }
-                else {
-                    return this.getDetailsFromRawUnsignedTransaction(transaction, ownAddress);
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getDetailsFromTransactionWithExtendedPublicKey = function (transaction, extendedPublicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, dps, derivedPublicKey, ownAddress, derivedPublicKey, ownAddress;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = transaction.type;
+                        switch (_a) {
+                            case 'signed': return [3 /*break*/, 1];
+                            case 'unsigned': return [3 /*break*/, 2];
+                        }
+                        return [3 /*break*/, 6];
+                    case 1: return [2 /*return*/, this.getDetailsFromSignedTransaction(transaction)];
+                    case 2:
+                        if (!(transaction.ethereumType === 'typed')) return [3 /*break*/, 4];
+                        dps = transaction.derivationPath.split('/');
+                        derivedPublicKey = this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, Number(dps[dps.length - 2]), Number(dps[dps.length - 1]));
+                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
+                    case 3:
+                        ownAddress = _b.sent();
+                        return [2 /*return*/, this.getDetailsFromTypedUnsignedTransaction(transaction, ownAddress)];
+                    case 4:
+                        derivedPublicKey = this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0);
+                        return [4 /*yield*/, this.getAddressFromPublicKey(derivedPublicKey)];
+                    case 5:
+                        ownAddress = _b.sent();
+                        return [2 /*return*/, this.getDetailsFromRawUnsignedTransaction(transaction, ownAddress)];
+                    case 6:
+                        (0, coinlib_core_1.assertNever)(transaction);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, 'Unsupported transaction type.');
                 }
-            default:
-                (0, coinlib_core_1.assertNever)(transaction);
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, 'Unsupported transaction type.');
-        }
-    }
-    async getDetailsFromTransactionWithExtendedPublicKey(transaction, extendedPublicKey) {
-        switch (transaction.type) {
-            case 'signed':
-                return this.getDetailsFromSignedTransaction(transaction);
-            case 'unsigned':
-                if (transaction.ethereumType === 'typed') {
-                    const dps = transaction.derivationPath.split('/');
-                    const derivedPublicKey = this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, Number(dps[dps.length - 2]), Number(dps[dps.length - 1]));
-                    const ownAddress = await this.getAddressFromPublicKey(derivedPublicKey);
-                    return this.getDetailsFromTypedUnsignedTransaction(transaction, ownAddress);
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getDetailsFromSignedTransaction = function (transaction) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var ethTx, tx, hexValue, hexGasPrice, hexGasLimit, hexNonce, chainId, to, feeTx;
+            return __generator(this, function (_c) {
+                ethTx = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
+                if (ethTx.type === 0) {
+                    tx = ethTx;
+                    hexValue = tx.value.toString('hex') || '0x0';
+                    hexGasPrice = tx.gasPrice.toString('hex') || '0x0';
+                    hexGasLimit = tx.gasLimit.toString('hex') || '0x0';
+                    hexNonce = tx.nonce.toString('hex') || '0x0';
+                    chainId = tx.common.chainIdBN().toString(10);
+                    to = tx.to;
+                    if (!to) {
+                        throw new Error('No "TO" address');
+                    }
+                    return [2 /*return*/, [
+                            {
+                                from: [tx.getSenderAddress().toString()],
+                                to: [to.toString()],
+                                isInbound: tx.toCreationAddress(),
+                                amount: (0, module_kit_1.newAmount)(parseInt(hexValue, 16), 'blockchain'),
+                                fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(parseInt(hexGasLimit, 16)).multipliedBy(parseInt(hexGasPrice, 16)), 'blockchain'),
+                                network: this.options.network,
+                                status: {
+                                    type: 'unknown',
+                                    hash: "0x".concat(tx.hash().toString('hex'))
+                                },
+                                arbitraryData: "0x".concat(tx.data.toString('hex')),
+                                extra: {
+                                    chainId: chainId,
+                                    nonce: parseInt(hexNonce, 16)
+                                }
+                            }
+                        ]];
                 }
-                else {
-                    const derivedPublicKey = this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0);
-                    const ownAddress = await this.getAddressFromPublicKey(derivedPublicKey);
-                    return this.getDetailsFromRawUnsignedTransaction(transaction, ownAddress);
+                try {
+                    feeTx = ethTx;
+                    return [2 /*return*/, [
+                            {
+                                from: [feeTx.getSenderAddress().toString()],
+                                to: [(_b = (_a = feeTx.to) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ''],
+                                isInbound: false,
+                                amount: (0, module_kit_1.newAmount)(feeTx.value.toString(10), 'blockchain'),
+                                fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(feeTx.gasLimit.toString(10)).multipliedBy(feeTx.maxFeePerGas.toString(10)), 'blockchain'),
+                                network: this.options.network,
+                                arbitraryData: feeTx.data.toString('hex'),
+                                extra: {
+                                    chainId: feeTx.chainId.toNumber(),
+                                    nonce: feeTx.nonce.toNumber()
+                                }
+                            }
+                        ]];
                 }
-            default:
-                (0, coinlib_core_1.assertNever)(transaction);
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, 'Unsupported transaction type.');
-        }
-    }
-    async getDetailsFromSignedTransaction(transaction) {
-        const ethTx = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
-        if (ethTx.type === 0) {
-            const tx = ethTx;
-            const hexValue = tx.value.toString('hex') || '0x0';
-            const hexGasPrice = tx.gasPrice.toString('hex') || '0x0';
-            const hexGasLimit = tx.gasLimit.toString('hex') || '0x0';
-            const hexNonce = tx.nonce.toString('hex') || '0x0';
-            const chainId = tx.common.chainIdBN().toString(10);
-            const to = tx.to;
-            if (!to) {
-                throw new Error('No "TO" address');
-            }
-            return [
-                {
-                    from: [tx.getSenderAddress().toString()],
-                    to: [to.toString()],
-                    isInbound: tx.toCreationAddress(),
-                    amount: (0, module_kit_1.newAmount)(parseInt(hexValue, 16), 'blockchain'),
-                    fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(parseInt(hexGasLimit, 16)).multipliedBy(parseInt(hexGasPrice, 16)), 'blockchain'),
-                    network: this.options.network,
-                    status: {
-                        type: 'unknown',
-                        hash: `0x${tx.hash().toString('hex')}`
-                    },
-                    arbitraryData: `0x${tx.data.toString('hex')}`,
-                    extra: {
-                        chainId,
-                        nonce: parseInt(hexNonce, 16)
-                    }
+                catch (e) {
+                    throw new Error("Transaction type \"".concat(ethTx.type, "\" not supported"));
                 }
-            ];
-        }
-        try {
-            const feeTx = ethTx;
-            return [
-                {
-                    from: [feeTx.getSenderAddress().toString()],
-                    to: [feeTx.to?.toString() ?? ''],
+                return [2 /*return*/];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getDetailsFromTypedUnsignedTransaction = function (transaction, ownAddress) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var typedTransaction, airGapTransaction;
+            return __generator(this, function (_d) {
+                typedTransaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
+                airGapTransaction = {
+                    from: [ownAddress],
+                    to: [(_b = (_a = typedTransaction.to) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ''],
                     isInbound: false,
-                    amount: (0, module_kit_1.newAmount)(feeTx.value.toString(10), 'blockchain'),
-                    fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(feeTx.gasLimit.toString(10)).multipliedBy(feeTx.maxFeePerGas.toString(10)), 'blockchain'),
+                    amount: (0, module_kit_1.newAmount)(typedTransaction.value.toString(10), 'blockchain'),
+                    fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(typedTransaction.gasLimit.toString(10)).multipliedBy(typedTransaction.maxFeePerGas.toString(10)), 'blockchain'),
                     network: this.options.network,
-                    arbitraryData: feeTx.data.toString('hex'),
-                    extra: {
-                        chainId: feeTx.chainId.toNumber(),
-                        nonce: feeTx.nonce.toNumber()
-                    }
+                    arbitraryData: typedTransaction.data.toString('hex'),
+                    uiAlerts: typedTransaction.chainId.toNumber() !== 1
+                        ? [
+                            (0, module_kit_1.newWarningUIAlert)({
+                                title: (0, module_kit_1.newPlainUIText)('Chain ID'),
+                                description: (0, module_kit_1.newPlainUIText)("Please note that this is not an Ethereum Mainnet transaction, it is from ".concat((_c = EthereumChainIds_1.ETHEREUM_CHAIN_IDS[typedTransaction.chainId.toNumber()]) !== null && _c !== void 0 ? _c : "Chain ID ".concat(typedTransaction.chainId.toNumber())))
+                            })
+                        ]
+                        : undefined
+                };
+                return [2 /*return*/, [airGapTransaction]];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getDetailsFromRawUnsignedTransaction = function (transaction, ownAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, [
+                        {
+                            from: [ownAddress],
+                            to: [transaction.to],
+                            isInbound: false,
+                            amount: (0, module_kit_1.newAmount)(transaction.value, 'blockchain'),
+                            fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(transaction.gasLimit).multipliedBy(transaction.gasPrice), 'blockchain'),
+                            network: this.options.network,
+                            arbitraryData: transaction.data
+                        }
+                    ]];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSignature, hexPublicKey;
+            return __generator(this, function (_a) {
+                hexSignature = signature;
+                hexPublicKey = (0, key_1.convertPublicKey)(this.nonExtendedPublicKey(publicKey), 'hex');
+                return [2 /*return*/, this.cryptoClient.verifyMessage(message, hexSignature.value, hexPublicKey.value)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexPublicKey;
+            return __generator(this, function (_a) {
+                hexPublicKey = (0, key_1.convertPublicKey)(this.nonExtendedPublicKey(publicKey), 'hex');
+                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoConfiguration];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node;
+            return __generator(this, function (_a) {
+                node = this.derivativeToBip32Node(derivative);
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newSecretKey)(node.keyPair.getPrivateKeyBuffer().toString('hex'), 'hex'),
+                        publicKey: (0, module_kit_1.newPublicKey)(node.neutered().keyPair.getPublicKeyBuffer().toString('hex'), 'hex')
+                    }];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getExtendedKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node;
+            return __generator(this, function (_a) {
+                node = this.derivativeToBip32Node(derivative);
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newExtendedSecretKey)(node.toBase58(), 'encoded'),
+                        publicKey: (0, module_kit_1.newExtendedPublicKey)(node.neutered().toBase58(), 'encoded')
+                    }];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.deriveFromExtendedSecretKey = function (extendedSecretKey, visibilityIndex, addressIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getSecretKeyFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, transaction.ethereumType === 'typed'
+                        ? this.signTypedUnsignedTransactionWithSecretKey(transaction, this.nonExtendedSecretKey(secretKey))
+                        : this.signRawUnsignedTransactionWithSecretKey(transaction, this.nonExtendedSecretKey(secretKey))];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.signTypedUnsignedTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var typedTransaction;
+            return __generator(this, function (_a) {
+                typedTransaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
+                return [2 /*return*/, this.signTypedTransactionWithSecretKey(typedTransaction, secretKey)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.signRawUnsignedTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var txData, common, typedTransaction;
+            return __generator(this, function (_a) {
+                txData = {
+                    nonce: transaction.nonce,
+                    gasPrice: transaction.gasPrice,
+                    gasLimit: transaction.gasLimit,
+                    to: transaction.to,
+                    value: transaction.value.startsWith('0x') ? transaction.value : EthereumUtils_1.EthereumUtils.toHex(parseInt(transaction.value, 10)),
+                    data: transaction.data
+                };
+                try {
+                    common = new common_1.default({ chain: transaction.chainId });
                 }
-            ];
-        }
-        catch (e) {
-            throw new Error(`Transaction type "${ethTx.type}" not supported`);
-        }
-    }
-    async getDetailsFromTypedUnsignedTransaction(transaction, ownAddress) {
-        const typedTransaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
-        const airGapTransaction = {
-            from: [ownAddress],
-            to: [typedTransaction.to?.toString() ?? ''],
-            isInbound: false,
-            amount: (0, module_kit_1.newAmount)(typedTransaction.value.toString(10), 'blockchain'),
-            fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(typedTransaction.gasLimit.toString(10)).multipliedBy(typedTransaction.maxFeePerGas.toString(10)), 'blockchain'),
-            network: this.options.network,
-            arbitraryData: typedTransaction.data.toString('hex'),
-            uiAlerts: typedTransaction.chainId.toNumber() !== 1
-                ? [
-                    (0, module_kit_1.newWarningUIAlert)({
-                        title: (0, module_kit_1.newPlainUIText)('Chain ID'),
-                        description: (0, module_kit_1.newPlainUIText)(`Please note that this is not an Ethereum Mainnet transaction, it is from ${EthereumChainIds_1.ETHEREUM_CHAIN_IDS[typedTransaction.chainId.toNumber()] ?? `Chain ID ${typedTransaction.chainId.toNumber()}`}`)
-                    })
-                ]
-                : undefined
-        };
-        return [airGapTransaction];
-    }
-    async getDetailsFromRawUnsignedTransaction(transaction, ownAddress) {
-        return [
-            {
-                from: [ownAddress],
-                to: [transaction.to],
-                isInbound: false,
-                amount: (0, module_kit_1.newAmount)(transaction.value, 'blockchain'),
-                fee: (0, module_kit_1.newAmount)(new bignumber_1.BigNumber(transaction.gasLimit).multipliedBy(transaction.gasPrice), 'blockchain'),
-                network: this.options.network,
-                arbitraryData: transaction.data
-            }
-        ];
-    }
-    async verifyMessageWithPublicKey(message, signature, publicKey) {
-        const hexSignature = signature;
-        const hexPublicKey = (0, key_1.convertPublicKey)(this.nonExtendedPublicKey(publicKey), 'hex');
-        return this.cryptoClient.verifyMessage(message, hexSignature.value, hexPublicKey.value);
-    }
-    async encryptAsymmetricWithPublicKey(payload, publicKey) {
-        const hexPublicKey = (0, key_1.convertPublicKey)(this.nonExtendedPublicKey(publicKey), 'hex');
-        return this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value);
-    }
-    async getCryptoConfiguration() {
-        return this.cryptoConfiguration;
-    }
-    async getKeyPairFromDerivative(derivative) {
-        const node = this.derivativeToBip32Node(derivative);
-        return {
-            secretKey: (0, module_kit_1.newSecretKey)(node.keyPair.getPrivateKeyBuffer().toString('hex'), 'hex'),
-            publicKey: (0, module_kit_1.newPublicKey)(node.neutered().keyPair.getPublicKeyBuffer().toString('hex'), 'hex')
-        };
-    }
-    async getExtendedKeyPairFromDerivative(derivative) {
-        const node = this.derivativeToBip32Node(derivative);
-        return {
-            secretKey: (0, module_kit_1.newExtendedSecretKey)(node.toBase58(), 'encoded'),
-            publicKey: (0, module_kit_1.newExtendedPublicKey)(node.neutered().toBase58(), 'encoded')
-        };
-    }
-    async deriveFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex) {
-        return this.getSecretKeyFromExtendedSecretKey(extendedSecretKey, visibilityIndex, addressIndex);
-    }
-    async signTransactionWithSecretKey(transaction, secretKey) {
-        return transaction.ethereumType === 'typed'
-            ? this.signTypedUnsignedTransactionWithSecretKey(transaction, this.nonExtendedSecretKey(secretKey))
-            : this.signRawUnsignedTransactionWithSecretKey(transaction, this.nonExtendedSecretKey(secretKey));
-    }
-    async signTypedUnsignedTransactionWithSecretKey(transaction, secretKey) {
-        const typedTransaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
-        return this.signTypedTransactionWithSecretKey(typedTransaction, secretKey);
-    }
-    async signRawUnsignedTransactionWithSecretKey(transaction, secretKey) {
-        const txData = {
-            nonce: transaction.nonce,
-            gasPrice: transaction.gasPrice,
-            gasLimit: transaction.gasLimit,
-            to: transaction.to,
-            value: transaction.value.startsWith('0x') ? transaction.value : EthereumUtils_1.EthereumUtils.toHex(parseInt(transaction.value, 10)),
-            data: transaction.data
-        };
-        let common;
-        try {
-            common = new common_1.default({ chain: transaction.chainId });
-        }
-        catch {
-            common = common_1.default.custom({ chainId: transaction.chainId });
-        }
-        const typedTransaction = tx_1.TransactionFactory.fromTxData(txData, { common });
-        return this.signTypedTransactionWithSecretKey(typedTransaction, secretKey);
-    }
-    async signTypedTransactionWithSecretKey(transaction, secretKey) {
-        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-        const signedTransaction = transaction.sign(Buffer.from(hexSecretKey.value, 'hex'));
-        return (0, module_kit_1.newSignedTransaction)({
-            serialized: signedTransaction.serialize().toString('hex')
+                catch (_b) {
+                    common = common_1.default.custom({ chainId: transaction.chainId });
+                }
+                typedTransaction = tx_1.TransactionFactory.fromTxData(txData, { common: common });
+                return [2 /*return*/, this.signTypedTransactionWithSecretKey(typedTransaction, secretKey)];
+            });
         });
-    }
-    async signMessageWithKeyPair(message, keyPair) {
-        const hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(keyPair.secretKey), 'hex');
-        const signature = await this.cryptoClient.signMessage(message, { privateKey: hexSecretKey.value });
-        return (0, module_kit_1.newSignature)(signature, 'hex');
-    }
-    async decryptAsymmetricWithKeyPair(payload, keyPair) {
-        const hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(keyPair.secretKey), 'hex');
-        const hexPublicKey = (0, key_1.convertPublicKey)(this.nonExtendedPublicKey(keyPair.publicKey), 'hex');
-        return this.cryptoClient.decryptAsymmetric(payload, { privateKey: hexSecretKey.value, publicKey: hexPublicKey.value });
-    }
-    async encryptAESWithSecretKey(payload, secretKey) {
-        const hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(secretKey), 'hex');
-        return this.cryptoClient.encryptAES(payload, hexSecretKey.value);
-    }
-    async decryptAESWithSecretKey(payload, secretKey) {
-        const hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(secretKey), 'hex');
-        return this.cryptoClient.decryptAES(payload, hexSecretKey.value);
-    }
+    };
+    EthereumBaseProtocolImpl.prototype.signTypedTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, signedTransaction;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+                signedTransaction = transaction.sign(Buffer.from(hexSecretKey.value, 'hex'));
+                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({
+                        serialized: signedTransaction.serialize().toString('hex')
+                    })];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, signature;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(keyPair.secretKey), 'hex');
+                        return [4 /*yield*/, this.cryptoClient.signMessage(message, { privateKey: hexSecretKey.value })];
+                    case 1:
+                        signature = _a.sent();
+                        return [2 /*return*/, (0, module_kit_1.newSignature)(signature, 'hex')];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, hexPublicKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(keyPair.secretKey), 'hex');
+                hexPublicKey = (0, key_1.convertPublicKey)(this.nonExtendedPublicKey(keyPair.publicKey), 'hex');
+                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(payload, { privateKey: hexSecretKey.value, publicKey: hexPublicKey.value })];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(secretKey), 'hex');
+                return [2 /*return*/, this.cryptoClient.encryptAES(payload, hexSecretKey.value)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(this.nonExtendedSecretKey(secretKey), 'hex');
+                return [2 /*return*/, this.cryptoClient.decryptAES(payload, hexSecretKey.value)];
+            });
+        });
+    };
     // Online
-    async getNetwork() {
-        return this.options.network;
-    }
-    async getTransactionsForPublicKey(publicKey, limit, cursor) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getTransactionsForAddress(address, limit, cursor);
-    }
-    async getTransactionsForAddress(address, limit, cursor) {
-        return this.getTransactionsForAddresses([address], limit, cursor);
-    }
-    async getTransactionsForAddresses(addresses, limit, cursor) {
-        return new Promise((overallResolve, overallReject) => {
-            const promises = [];
-            for (const address of addresses) {
-                promises.push(this.infoClient.fetchTransactions(address, limit, cursor));
-            }
-            Promise.all(promises)
-                .then((values) => {
-                const page = Math.max(...values.map((txResult) => txResult.cursor.page));
-                const transactions = values.reduce((acc, current) => {
-                    return acc.concat(current.transactions.map((tx) => ({
-                        ...tx,
-                        amount: (0, module_kit_1.newAmount)(tx.amount.value, 'blockchain'),
-                        fee: (0, module_kit_1.newAmount)(tx.fee.value, 'blockchain'),
-                        network: this.options.network
-                    })));
-                }, []);
-                const hasNext = transactions.length >= limit;
-                overallResolve({
-                    transactions,
-                    cursor: {
-                        hasNext,
-                        page: hasNext ? page : undefined
-                    }
-                });
-            })
-                .catch(overallReject);
+    EthereumBaseProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
         });
-    }
-    async getTransactionStatus(transactionIds) {
-        const statuses = await Promise.all(transactionIds.map(async (txHash) => {
-            return [txHash, await this.nodeClient.getTransactionStatus(txHash)];
-        }));
-        return statuses.reduce((obj, next) => Object.assign(obj, { [next[0]]: next[1] }), {});
-    }
-    async getBalanceOfPublicKey(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getBalanceOfAddress(address);
-    }
-    async getBalanceOfAddress(address) {
-        return this.getBalanceOfAddresses([address]);
-    }
-    async getBalanceOfAddresses(addresses) {
-        const balances = await Promise.all(addresses.map((address) => {
-            return this.nodeClient.fetchBalance(address);
-        }));
-        return {
-            total: (0, module_kit_1.newAmount)(balances.reduce((a, b) => a.plus(b)), 'blockchain')
-        };
-    }
-    async getTokenBalancesOfPublicKey(publicKey, tokens) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        const contractAddresses = tokens.map((token) => token.contractAddress);
-        const balances = await this.nodeClient.callBalanceOfOnContracts(contractAddresses, address);
-        return tokens.reduce((obj, next) => {
-            const balance = balances[next.contractAddress];
-            if (balance === undefined) {
-                return obj;
-            }
-            return Object.assign(obj, { [next.identifier]: (0, module_kit_1.newAmount)(balance, 'blockchain') });
-        }, {});
-    }
-    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
-        const { total, transferable } = await this.getBalanceOfPublicKey(publicKey);
-        const balance = new bignumber_1.BigNumber((0, module_kit_1.newAmount)(transferable ?? total).blockchain(this.units).value);
-        let fee;
-        if (configuration?.fee !== undefined) {
-            fee = configuration.fee;
-        }
-        else {
-            const estimatedFee = await this.getTransactionFeeWithPublicKey(publicKey, to.map((recipient) => ({
-                to: recipient,
-                amount: (0, module_kit_1.newAmount)(balance.div(to.length).decimalPlaces(0, bignumber_1.BigNumber.ROUND_CEIL), 'blockchain')
-            })));
-            fee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(this.feeUnits);
-            if (balance.lte(fee.value)) {
-                fee = (0, module_kit_1.newAmount)(0, 'blockchain');
-            }
-        }
-        let amountWithoutFees = balance.minus(fee.value);
-        if (amountWithoutFees.isNegative()) {
-            amountWithoutFees = new bignumber_1.BigNumber(0);
-        }
-        return (0, module_kit_1.newAmount)(amountWithoutFees, 'blockchain');
-    }
-    async getTransactionFeeWithPublicKey(publicKey, details, configuration) {
-        if (details.length !== 1) {
-            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ETHEREUM, 'you cannot have 0 transaction details');
-        }
-        const address = await this.getAddressFromPublicKey(publicKey);
-        const estimatedGas = await this.estimateGas(address, details[0].to, (0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units));
-        const gasPrice = await this.nodeClient.getGasPrice();
-        const feeStepFactor = new bignumber_1.BigNumber(0.5);
-        const estimatedFee = estimatedGas.times(gasPrice);
-        const lowFee = estimatedFee.minus(estimatedFee.times(feeStepFactor).integerValue(bignumber_1.BigNumber.ROUND_FLOOR));
-        const mediumFee = estimatedFee;
-        const highFee = mediumFee.plus(mediumFee.times(feeStepFactor).integerValue(bignumber_1.BigNumber.ROUND_FLOOR));
-        return {
-            low: (0, module_kit_1.newAmount)(lowFee, 'blockchain'),
-            medium: (0, module_kit_1.newAmount)(mediumFee, 'blockchain'),
-            high: (0, module_kit_1.newAmount)(highFee, 'blockchain')
-        };
-    }
-    async prepareTransactionWithPublicKey(publicKey, details, configuration) {
-        if (details.length !== 1) {
-            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ETHEREUM, 'you cannot have 0 transaction details');
-        }
-        let fee;
-        if (configuration?.fee !== undefined) {
-            fee = configuration.fee;
-        }
-        else {
-            const estimatedFee = await this.getTransactionFeeWithPublicKey(publicKey, details);
-            fee = estimatedFee.medium;
-        }
-        const wrappedFee = new bignumber_1.BigNumber((0, module_kit_1.newAmount)(fee).blockchain(this.feeUnits).value);
-        const wrappedAmount = new bignumber_1.BigNumber((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
-        const address = await this.getAddressFromPublicKey(publicKey);
-        const hexAmount = EthereumUtils_1.EthereumUtils.toHex(wrappedAmount.toFixed());
-        const balance = await this.getBalanceOfPublicKey(publicKey);
-        const availableBalance = (0, module_kit_1.newAmount)(balance.transferable ?? balance.total).blockchain(this.units);
-        const gasLimit = await this.estimateGas(address, details[0].to, hexAmount);
-        const gasPrice = wrappedFee.div(gasLimit).integerValue(bignumber_1.BigNumber.ROUND_CEIL);
-        if (new bignumber_1.BigNumber(availableBalance.value).gte(wrappedAmount.plus(wrappedFee))) {
-            const txCount = await this.nodeClient.fetchTransactionCount(address);
-            const transaction = (0, module_kit_1.newUnsignedTransaction)({
-                ethereumType: 'raw',
-                nonce: EthereumUtils_1.EthereumUtils.toHex(txCount),
-                gasLimit: EthereumUtils_1.EthereumUtils.toHex(gasLimit.toFixed()),
-                gasPrice: EthereumUtils_1.EthereumUtils.toHex(gasPrice.toFixed()), // 10 Gwei
-                to: details[0].to,
-                value: hexAmount,
-                chainId: this.options.network.chainId,
-                data: '0x'
-            });
-            return transaction;
-        }
-        else {
-            throw new errors_1.BalanceError(coinlib_core_1.Domain.ETHEREUM, 'not enough balance');
-        }
-    }
-    async getWalletConnectChain() {
-        return `${WALLET_CONNECT_NAMESPACE}:${this.options.network.chainId}`;
-    }
-    async prepareWalletConnectTransactionWithPublicKey(publicKey, request) {
-        const gasPricePromise = request.gasPrice
-            ? Promise.resolve(request.gasPrice)
-            : this.nodeClient.getGasPrice().then((gasPrice) => `0x${gasPrice.toString(16)}`);
-        const noncePromise = request.nonce
-            ? Promise.resolve(request.nonce)
-            : this.getAddressFromPublicKey(publicKey)
-                .then((address) => this.nodeClient.fetchTransactionCount(address))
-                .then((transactionCount) => `0x${new bignumber_1.BigNumber(transactionCount).toString(16)}`);
-        const [gasPrice, nonce] = await Promise.all([gasPricePromise, noncePromise]);
-        return (0, module_kit_1.newUnsignedTransaction)({
-            ethereumType: 'raw',
-            nonce,
-            gasLimit: `0x${(300000).toString(16)}`,
-            gasPrice,
-            to: request.to ?? '',
-            value: request.value ?? '0x00',
-            chainId: this.options.network.chainId,
-            data: request.data ?? '0x'
+    };
+    EthereumBaseProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getTransactionsForAddress(address, limit, cursor)];
+                }
+            });
         });
-    }
-    async broadcastTransaction(transaction) {
-        return this.nodeClient.sendSignedTransaction(`0x${transaction.serialized.replace(/^0x/, '')}`);
-    }
+    };
+    EthereumBaseProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getTransactionsForAddresses([address], limit, cursor)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getTransactionsForAddresses = function (addresses, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (overallResolve, overallReject) {
+                        var promises = [];
+                        for (var _i = 0, addresses_1 = addresses; _i < addresses_1.length; _i++) {
+                            var address = addresses_1[_i];
+                            promises.push(_this.infoClient.fetchTransactions(address, limit, cursor));
+                        }
+                        Promise.all(promises)
+                            .then(function (values) {
+                            var page = Math.max.apply(Math, values.map(function (txResult) { return txResult.cursor.page; }));
+                            var transactions = values.reduce(function (acc, current) {
+                                return acc.concat(current.transactions.map(function (tx) { return (__assign(__assign({}, tx), { amount: (0, module_kit_1.newAmount)(tx.amount.value, 'blockchain'), fee: (0, module_kit_1.newAmount)(tx.fee.value, 'blockchain'), network: _this.options.network })); }));
+                            }, []);
+                            var hasNext = transactions.length >= limit;
+                            overallResolve({
+                                transactions: transactions,
+                                cursor: {
+                                    hasNext: hasNext,
+                                    page: hasNext ? page : undefined
+                                }
+                            });
+                        })
+                            .catch(overallReject);
+                    })];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getTransactionStatus = function (transactionIds) {
+        return __awaiter(this, void 0, void 0, function () {
+            var statuses;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(transactionIds.map(function (txHash) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _a = [txHash];
+                                        return [4 /*yield*/, this.nodeClient.getTransactionStatus(txHash)];
+                                    case 1: return [2 /*return*/, _a.concat([_b.sent()])];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        statuses = _a.sent();
+                        return [2 /*return*/, statuses.reduce(function (obj, next) {
+                                var _a;
+                                return Object.assign(obj, (_a = {}, _a[next[0]] = next[1], _a));
+                            }, {})];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getBalanceOfAddress(address)];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getBalanceOfAddresses([address])];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balances;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(addresses.map(function (address) {
+                            return _this.nodeClient.fetchBalance(address);
+                        }))];
+                    case 1:
+                        balances = _a.sent();
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(balances.reduce(function (a, b) { return a.plus(b); }), 'blockchain')
+                            }];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getTokenBalancesOfPublicKey = function (publicKey, tokens) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address, contractAddresses, balances;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        contractAddresses = tokens.map(function (token) { return token.contractAddress; });
+                        return [4 /*yield*/, this.nodeClient.callBalanceOfOnContracts(contractAddresses, address)];
+                    case 2:
+                        balances = _a.sent();
+                        return [2 /*return*/, tokens.reduce(function (obj, next) {
+                                var _a;
+                                var balance = balances[next.contractAddress];
+                                if (balance === undefined) {
+                                    return obj;
+                                }
+                                return Object.assign(obj, (_a = {}, _a[next.identifier] = (0, module_kit_1.newAmount)(balance, 'blockchain'), _a));
+                            }, {})];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, total, transferable, balance, fee, estimatedFee, amountWithoutFees;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        _a = _b.sent(), total = _a.total, transferable = _a.transferable;
+                        balance = new bignumber_1.BigNumber((0, module_kit_1.newAmount)(transferable !== null && transferable !== void 0 ? transferable : total).blockchain(this.units).value);
+                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 2];
+                        fee = configuration.fee;
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, to.map(function (recipient) { return ({
+                            to: recipient,
+                            amount: (0, module_kit_1.newAmount)(balance.div(to.length).decimalPlaces(0, bignumber_1.BigNumber.ROUND_CEIL), 'blockchain')
+                        }); }))];
+                    case 3:
+                        estimatedFee = _b.sent();
+                        fee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(this.feeUnits);
+                        if (balance.lte(fee.value)) {
+                            fee = (0, module_kit_1.newAmount)(0, 'blockchain');
+                        }
+                        _b.label = 4;
+                    case 4:
+                        amountWithoutFees = balance.minus(fee.value);
+                        if (amountWithoutFees.isNegative()) {
+                            amountWithoutFees = new bignumber_1.BigNumber(0);
+                        }
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(amountWithoutFees, 'blockchain')];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address, estimatedGas, gasPrice, feeStepFactor, estimatedFee, lowFee, mediumFee, highFee;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (details.length !== 1) {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ETHEREUM, 'you cannot have 0 transaction details');
+                        }
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [4 /*yield*/, this.estimateGas(address, details[0].to, (0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units))];
+                    case 2:
+                        estimatedGas = _a.sent();
+                        return [4 /*yield*/, this.nodeClient.getGasPrice()];
+                    case 3:
+                        gasPrice = _a.sent();
+                        feeStepFactor = new bignumber_1.BigNumber(0.5);
+                        estimatedFee = estimatedGas.times(gasPrice);
+                        lowFee = estimatedFee.minus(estimatedFee.times(feeStepFactor).integerValue(bignumber_1.BigNumber.ROUND_FLOOR));
+                        mediumFee = estimatedFee;
+                        highFee = mediumFee.plus(mediumFee.times(feeStepFactor).integerValue(bignumber_1.BigNumber.ROUND_FLOOR));
+                        return [2 /*return*/, {
+                                low: (0, module_kit_1.newAmount)(lowFee, 'blockchain'),
+                                medium: (0, module_kit_1.newAmount)(mediumFee, 'blockchain'),
+                                high: (0, module_kit_1.newAmount)(highFee, 'blockchain')
+                            }];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var fee, estimatedFee, wrappedFee, wrappedAmount, address, hexAmount, balance, availableBalance, gasLimit, gasPrice, txCount, transaction;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (details.length !== 1) {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ETHEREUM, 'you cannot have 0 transaction details');
+                        }
+                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 1];
+                        fee = configuration.fee;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, details)];
+                    case 2:
+                        estimatedFee = _b.sent();
+                        fee = estimatedFee.medium;
+                        _b.label = 3;
+                    case 3:
+                        wrappedFee = new bignumber_1.BigNumber((0, module_kit_1.newAmount)(fee).blockchain(this.feeUnits).value);
+                        wrappedAmount = new bignumber_1.BigNumber((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 4:
+                        address = _b.sent();
+                        hexAmount = EthereumUtils_1.EthereumUtils.toHex(wrappedAmount.toFixed());
+                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 5:
+                        balance = _b.sent();
+                        availableBalance = (0, module_kit_1.newAmount)((_a = balance.transferable) !== null && _a !== void 0 ? _a : balance.total).blockchain(this.units);
+                        return [4 /*yield*/, this.estimateGas(address, details[0].to, hexAmount)];
+                    case 6:
+                        gasLimit = _b.sent();
+                        gasPrice = wrappedFee.div(gasLimit).integerValue(bignumber_1.BigNumber.ROUND_CEIL);
+                        if (!new bignumber_1.BigNumber(availableBalance.value).gte(wrappedAmount.plus(wrappedFee))) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.nodeClient.fetchTransactionCount(address)];
+                    case 7:
+                        txCount = _b.sent();
+                        transaction = (0, module_kit_1.newUnsignedTransaction)({
+                            ethereumType: 'raw',
+                            nonce: EthereumUtils_1.EthereumUtils.toHex(txCount),
+                            gasLimit: EthereumUtils_1.EthereumUtils.toHex(gasLimit.toFixed()),
+                            gasPrice: EthereumUtils_1.EthereumUtils.toHex(gasPrice.toFixed()),
+                            to: details[0].to,
+                            value: hexAmount,
+                            chainId: this.options.network.chainId,
+                            data: '0x'
+                        });
+                        return [2 /*return*/, transaction];
+                    case 8: throw new errors_1.BalanceError(coinlib_core_1.Domain.ETHEREUM, 'not enough balance');
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.getWalletConnectChain = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, "".concat(WALLET_CONNECT_NAMESPACE, ":").concat(this.options.network.chainId)];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.prepareWalletConnectTransactionWithPublicKey = function (publicKey, request) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
+            var gasPricePromise, noncePromise, _d, gasPrice, nonce;
+            var _this = this;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        gasPricePromise = request.gasPrice
+                            ? Promise.resolve(request.gasPrice)
+                            : this.nodeClient.getGasPrice().then(function (gasPrice) { return "0x".concat(gasPrice.toString(16)); });
+                        noncePromise = request.nonce
+                            ? Promise.resolve(request.nonce)
+                            : this.getAddressFromPublicKey(publicKey)
+                                .then(function (address) { return _this.nodeClient.fetchTransactionCount(address); })
+                                .then(function (transactionCount) { return "0x".concat(new bignumber_1.BigNumber(transactionCount).toString(16)); });
+                        return [4 /*yield*/, Promise.all([gasPricePromise, noncePromise])];
+                    case 1:
+                        _d = _e.sent(), gasPrice = _d[0], nonce = _d[1];
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
+                                ethereumType: 'raw',
+                                nonce: nonce,
+                                gasLimit: "0x".concat((300000).toString(16)),
+                                gasPrice: gasPrice,
+                                to: (_a = request.to) !== null && _a !== void 0 ? _a : '',
+                                value: (_b = request.value) !== null && _b !== void 0 ? _b : '0x00',
+                                chainId: this.options.network.chainId,
+                                data: (_c = request.data) !== null && _c !== void 0 ? _c : '0x'
+                            })];
+                }
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.nodeClient.sendSignedTransaction("0x".concat(transaction.serialized.replace(/^0x/, '')))];
+            });
+        });
+    };
     // Custom
-    nonExtendedPublicKey(publicKey) {
+    EthereumBaseProtocolImpl.prototype.nonExtendedPublicKey = function (publicKey) {
         return publicKey.type === 'pub' ? publicKey : this.getPublicKeyFromExtendedPublicKey(publicKey);
-    }
-    nonExtendedSecretKey(secretKey) {
+    };
+    EthereumBaseProtocolImpl.prototype.nonExtendedSecretKey = function (secretKey) {
         return secretKey.type === 'priv' ? secretKey : this.getSecretKeyFromExtendedSecretKey(secretKey);
-    }
-    getPublicKeyFromExtendedPublicKey(extendedPublicKey, visibilityIndex = 0, addressIndex = 0) {
-        const encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, 'encoded');
-        const derivedNode = this.deriveNode(encodedExtendedPublicKey.value, visibilityIndex, addressIndex);
+    };
+    EthereumBaseProtocolImpl.prototype.getPublicKeyFromExtendedPublicKey = function (extendedPublicKey, visibilityIndex, addressIndex) {
+        if (visibilityIndex === void 0) { visibilityIndex = 0; }
+        if (addressIndex === void 0) { addressIndex = 0; }
+        var encodedExtendedPublicKey = (0, key_1.convertExtendedPublicKey)(extendedPublicKey, 'encoded');
+        var derivedNode = this.deriveNode(encodedExtendedPublicKey.value, visibilityIndex, addressIndex);
         return (0, module_kit_1.newPublicKey)(derivedNode.neutered().keyPair.getPublicKeyBuffer().toString('hex'), 'hex');
-    }
-    getSecretKeyFromExtendedSecretKey(extendedSecretKey, visibilityIndex = 0, addressIndex = 0) {
-        const encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, 'encoded');
-        const derivedNode = this.deriveNode(encodedExtendedSecretKey.value, visibilityIndex, addressIndex);
+    };
+    EthereumBaseProtocolImpl.prototype.getSecretKeyFromExtendedSecretKey = function (extendedSecretKey, visibilityIndex, addressIndex) {
+        if (visibilityIndex === void 0) { visibilityIndex = 0; }
+        if (addressIndex === void 0) { addressIndex = 0; }
+        var encodedExtendedSecretKey = (0, key_1.convertExtendedSecretKey)(extendedSecretKey, 'encoded');
+        var derivedNode = this.deriveNode(encodedExtendedSecretKey.value, visibilityIndex, addressIndex);
         return (0, module_kit_1.newSecretKey)(derivedNode.keyPair.getPrivateKeyBuffer().toString('hex'), 'hex');
-    }
-    deriveNode(base58, visibilityIndex, addressIndex) {
-        return [visibilityIndex, addressIndex].reduce((node, index) => node.derive(index), this.bitcoinJS.lib.HDNode.fromBase58(base58, this.bitcoinJS.config.network));
-    }
-    async estimateGas(fromAddress, toAddress, amount, data) {
-        let hexAmount;
-        if (typeof amount === 'string' && (0, hex_1.isHex)(amount)) {
-            hexAmount = amount;
-        }
-        else {
-            const blockchainAmount = (0, module_kit_1.isAmount)(amount) ? (0, module_kit_1.newAmount)(amount).blockchain(this.units) : (0, module_kit_1.newAmount)(amount, 'blockchain');
-            hexAmount = EthereumUtils_1.EthereumUtils.toHex(blockchainAmount.value);
-        }
-        return this.nodeClient.estimateTransactionGas(fromAddress, toAddress, hexAmount, data, EthereumUtils_1.EthereumUtils.toHex(MAX_GAS_ESTIMATE));
-    }
-    derivativeToBip32Node(derivative) {
-        const bip32Node = (0, crypto_1.encodeDerivative)('bip32', derivative);
+    };
+    EthereumBaseProtocolImpl.prototype.deriveNode = function (base58, visibilityIndex, addressIndex) {
+        return [visibilityIndex, addressIndex].reduce(function (node, index) { return node.derive(index); }, this.bitcoinJS.lib.HDNode.fromBase58(base58, this.bitcoinJS.config.network));
+    };
+    EthereumBaseProtocolImpl.prototype.estimateGas = function (fromAddress, toAddress, amount, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexAmount, blockchainAmount;
+            return __generator(this, function (_a) {
+                if (typeof amount === 'string' && (0, hex_1.isHex)(amount)) {
+                    hexAmount = amount;
+                }
+                else {
+                    blockchainAmount = (0, module_kit_1.isAmount)(amount) ? (0, module_kit_1.newAmount)(amount).blockchain(this.units) : (0, module_kit_1.newAmount)(amount, 'blockchain');
+                    hexAmount = EthereumUtils_1.EthereumUtils.toHex(blockchainAmount.value);
+                }
+                return [2 /*return*/, this.nodeClient.estimateTransactionGas(fromAddress, toAddress, hexAmount, data, EthereumUtils_1.EthereumUtils.toHex(MAX_GAS_ESTIMATE))];
+            });
+        });
+    };
+    EthereumBaseProtocolImpl.prototype.derivativeToBip32Node = function (derivative) {
+        var bip32Node = (0, crypto_1.encodeDerivative)('bip32', derivative);
         return this.bitcoinJS.lib.HDNode.fromBase58(bip32Node.secretKey, this.bitcoinJS.config.network);
-    }
-}
+    };
+    return EthereumBaseProtocolImpl;
+}());
 exports.EthereumBaseProtocolImpl = EthereumBaseProtocolImpl;
-class DefaultEthereumBaseProtocolImpl extends EthereumBaseProtocolImpl {
-    constructor(nodeClient, infoClient, options) {
-        super(nodeClient, infoClient, {
-            ...options,
-            identifier: coinlib_core_1.MainProtocolSymbols.ETH,
-            name: 'Ethereum',
-            units: exports.DEFAULT_ETHEREUM_UNITS_METADATA,
-            mainUnit: 'ETH'
-        });
+var DefaultEthereumBaseProtocolImpl = /** @class */ (function (_super) {
+    __extends(DefaultEthereumBaseProtocolImpl, _super);
+    function DefaultEthereumBaseProtocolImpl(nodeClient, infoClient, options) {
+        return _super.call(this, nodeClient, infoClient, __assign(__assign({}, options), { identifier: coinlib_core_1.MainProtocolSymbols.ETH, name: 'Ethereum', units: exports.DEFAULT_ETHEREUM_UNITS_METADATA, mainUnit: 'ETH' })) || this;
     }
-}
+    return DefaultEthereumBaseProtocolImpl;
+}(EthereumBaseProtocolImpl));
 exports.DefaultEthereumBaseProtocolImpl = DefaultEthereumBaseProtocolImpl;
 //# sourceMappingURL=EthereumBaseProtocol.js.map