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

package/v0/protocol/BaseEthereumProtocol.js

@@ -1,15 +1,4 @@
 "use strict";
-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);
@@ -26,83 +15,56 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEthereumProtocol = void 0;
-var bignumber_1 = require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber");
+const bignumber_1 = require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber");
 // @ts-ignore
-var bip39_2_5_0_1 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0");
+const bip39_2_5_0_1 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0");
 // @ts-ignore
-var bitcoinJS = __importStar(require("@airgap/coinlib-core/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src"));
-var errors_1 = require("@airgap/coinlib-core/errors");
-var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
-var IAirGapTransaction_1 = require("@airgap/coinlib-core/interfaces/IAirGapTransaction");
-var ICoinSubProtocol_1 = require("@airgap/coinlib-core/protocols/ICoinSubProtocol");
-var ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
-var common_1 = __importDefault(require("@ethereumjs/common"));
+const bitcoinJS = __importStar(require("@airgap/coinlib-core/dependencies/src/bitgo-utxo-lib-5d91049fd7a988382df81c8260e244ee56d57aac/src"));
+const errors_1 = require("@airgap/coinlib-core/errors");
+const coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+const IAirGapTransaction_1 = require("@airgap/coinlib-core/interfaces/IAirGapTransaction");
+const ICoinSubProtocol_1 = require("@airgap/coinlib-core/protocols/ICoinSubProtocol");
+const ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
+const common_1 = __importDefault(require("@ethereumjs/common"));
 // TODO: ETH TX and ethereumjs-util-5.2.0 removed
-var tx_1 = require("@ethereumjs/tx");
-var EthereumAddress_1 = require("./EthereumAddress");
-var EthereumChainIDs_1 = require("./EthereumChainIDs");
-var EthereumCryptoClient_1 = require("./EthereumCryptoClient");
-var EthereumProtocolOptions_1 = require("./EthereumProtocolOptions");
-var utils_1 = require("./utils/utils");
-var BaseEthereumProtocol = /** @class */ (function () {
-    function BaseEthereumProtocol(options) {
-        if (options === void 0) { options = new EthereumProtocolOptions_1.EthereumProtocolOptions(); }
+const tx_1 = require("@ethereumjs/tx");
+const EthereumAddress_1 = require("./EthereumAddress");
+const EthereumChainIDs_1 = require("./EthereumChainIDs");
+const EthereumCryptoClient_1 = require("./EthereumCryptoClient");
+const EthereumProtocolOptions_1 = require("./EthereumProtocolOptions");
+const utils_1 = require("./utils/utils");
+class BaseEthereumProtocol {
+    constructor(options = new EthereumProtocolOptions_1.EthereumProtocolOptions()) {
         this.options = options;
         this.symbol = 'ETH';
         this.name = 'Ethereum';
         this.marketSymbol = 'eth';
         this.feeSymbol = 'eth';
         this.feeDefaults = {
-            low: '0.00021',
-            medium: '0.000315',
+            low: '0.00021', // 21000 Gas * 10 Gwei
+            medium: '0.000315', // 21000 Gas * 15 Gwei
             high: '0.00084' // 21000 Gas * 40 Gwei
         };
         this.decimals = 18;
@@ -124,823 +86,449 @@ var BaseEthereumProtocol = /** @class */ (function () {
             }
         ];
         this.supportsHD = false;
-        this.standardDerivationPath = "m/44'/60'/0'/0/0";
+        this.standardDerivationPath = `m/44'/60'/0'/0/0`;
         this.addressIsCaseSensitive = false;
         this.addressValidationPattern = '^0x[a-fA-F0-9]{40}$';
         this.addressPlaceholder = '0xabc...';
         this.cryptoClient = new EthereumCryptoClient_1.EthereumCryptoClient(this);
         this.network = bitcoinJS.networks.bitcoin;
     }
-    BaseEthereumProtocol.prototype.getSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.symbol];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getName = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.name];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getMarketSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.marketSymbol];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAssetSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, undefined];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getFeeSymbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.feeSymbol];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getFeeDefaults = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.feeDefaults];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getDecimals = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.decimals];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getFeeDecimals = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.feeDecimals];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getIdentifier = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.identifier];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getUnits = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.units];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getSupportsHD = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.supportsHD];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getStandardDerivationPath = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.standardDerivationPath];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAddressIsCaseSensitive = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.addressIsCaseSensitive];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAddressValidationPattern = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.addressValidationPattern];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAddressPlaceholder = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.addressPlaceholder];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getOptions = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getBlockExplorerLinkForAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network.blockExplorer.getAddressLink(address)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getBlockExplorerLinkForTxId = function (txId) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network.blockExplorer.getTransactionLink(txId)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getPublicKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getPrivateKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getExtendedPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getExtendedPrivateKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getExtendedPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
-        return __awaiter(this, void 0, void 0, function () {
-            var secret;
-            return __generator(this, function (_a) {
-                secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
-                return [2 /*return*/, this.getExtendedPublicKeyFromHexSecret(secret, derivationPath)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getPublicKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ethereumNode;
-            return __generator(this, function (_a) {
-                ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
-                return [2 /*return*/, ethereumNode.derivePath(derivationPath).neutered().getPublicKeyBuffer().toString('hex')];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getExtendedPublicKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ethereumNode;
-            return __generator(this, function (_a) {
-                ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
-                return [2 /*return*/, ethereumNode.derivePath(derivationPath).neutered().toBase58()];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getPrivateKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ethereumNode;
-            return __generator(this, function (_a) {
-                ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
-                return [2 /*return*/, ethereumNode.derivePath(derivationPath).keyPair.d.toBuffer(32).toString('hex')];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getExtendedPrivateKeyFromHexSecret = function (secret, derivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ethereumNode;
-            return __generator(this, function (_a) {
-                ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
-                return [2 /*return*/, ethereumNode.derivePath(derivationPath).toBase58()];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAddressFromPublicKey = function (publicKey, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address;
-            return __generator(this, function (_a) {
-                address = EthereumAddress_1.EthereumAddress.from(publicKey);
-                return [2 /*return*/, {
-                        address: address.asString(),
-                        cursor: { hasNext: false }
-                    }];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAddressesFromPublicKey = function (publicKey, 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, cursor)];
-                    case 1:
-                        address = _a.sent();
-                        return [2 /*return*/, [address]];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getPublicKeyFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, bitcoinJS.HDNode.fromBase58(extendedPublicKey, this.network)
-                        .derive(visibilityDerivationIndex)
-                        .derive(addressDerivationIndex)
-                        .getPublicKeyBuffer()
-                        .toString('hex')];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this.getAddressFromPublicKey;
-                        return [4 /*yield*/, this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex)];
-                    case 1: return [2 /*return*/, _a.apply(this, [_b.sent()])];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAddressesFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
-        var _this = this;
-        var node = bitcoinJS.HDNode.fromBase58(extendedPublicKey, this.network);
-        var generatorArray = [addressCount].map(function (x, i) { return i + offset; });
-        return Promise.all(generatorArray.map(function (x) {
-            return _this.getAddressFromPublicKey(node.derive(visibilityDerivationIndex).derive(x).getPublicKeyBuffer().toString('hex'));
-        }));
-    };
-    BaseEthereumProtocol.prototype.getPrivateKeyFromExtendedPrivateKey = function (extendedPrivateKey, childDerivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var dp;
-            return __generator(this, function (_a) {
-                dp = childDerivationPath !== null && childDerivationPath !== void 0 ? childDerivationPath : '0/0' // This is the default
-                ;
-                if (dp.startsWith('m')) {
-                    throw new Error('Received full derivation path, expected child derivation path');
-                }
-                if (dp.toLowerCase().includes('h') || dp.includes("'")) {
-                    throw new Error('Child derivation path cannot include hardened children');
-                }
-                return [2 /*return*/, dp
-                        .split('/')
-                        .reduce(function (pv, cv) { return pv.derive(Number(cv)); }, bitcoinJS.HDNode.fromBase58(extendedPrivateKey, this.network))
-                        .keyPair.d.toBuffer(32)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.signWithExtendedPrivateKey = function (extendedPrivateKey, untypedTransaction, childDerivationPath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var privateKey, transaction, tx;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPrivateKeyFromExtendedPrivateKey(extendedPrivateKey, childDerivationPath)];
-                    case 1:
-                        privateKey = _a.sent();
-                        if (untypedTransaction.serialized &&
-                            untypedTransaction.derivationPath) {
-                            transaction = untypedTransaction;
-                            tx = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
-                            tx = tx.sign(privateKey);
-                            return [2 /*return*/, tx.serialize().toString('hex')];
-                        }
-                        else {
-                            return [2 /*return*/, this.signWithPrivateKey(privateKey.toString('hex'), untypedTransaction)];
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.signWithPrivateKey = function (privateKey, transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var common, tx;
-            return __generator(this, function (_a) {
-                if (!transaction.value.startsWith('0x')) {
-                    transaction.value = utils_1.EthereumUtils.toHex(parseInt(transaction.value, 10));
-                }
-                try {
-                    common = new common_1.default({ chain: transaction.chainId });
-                }
-                catch (_b) {
-                    common = common_1.default.custom({ chainId: transaction.chainId });
-                }
-                tx = tx_1.TransactionFactory.fromTxData(transaction, { common: common });
-                tx = tx.sign(Buffer.from(privateKey, 'hex'));
-                return [2 /*return*/, tx.serialize().toString('hex')];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getTransactionDetails = function (unsignedTx) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var typedTransaction, transaction, dps, ownAddress, _d, airGapTransaction, transaction, ownAddress, _e;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        if (!unsignedTx.transaction.serialized) return [3 /*break*/, 5];
-                        typedTransaction = unsignedTx.transaction;
-                        transaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(typedTransaction.serialized, 'hex'));
-                        dps = typedTransaction.derivationPath.split('/');
-                        if (!unsignedTx.publicKey.startsWith('x') // xPub
-                        ) return [3 /*break*/, 2]; // xPub
-                        return [4 /*yield*/, this.getAddressFromExtendedPublicKey(unsignedTx.publicKey, Number(dps[dps.length - 2]), Number(dps[dps.length - 1]))];
-                    case 1:
-                        _d = _f.sent();
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.getAddressFromPublicKey(unsignedTx.publicKey)];
-                    case 3:
-                        _d = _f.sent();
-                        _f.label = 4;
-                    case 4:
-                        ownAddress = _d;
-                        airGapTransaction = {
-                            from: [ownAddress.address],
-                            to: [(_b = (_a = transaction.to) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ''],
-                            amount: new bignumber_1.BigNumber(transaction.value.toString(10)).toString(10),
-                            fee: new bignumber_1.BigNumber(transaction.gasLimit.toString(10))
-                                .multipliedBy(new bignumber_1.BigNumber(transaction.maxFeePerGas.toString(10)))
-                                .toString(10),
-                            protocolIdentifier: this.identifier,
-                            network: this.options.network,
-                            isInbound: false,
-                            data: transaction.data.toString('hex'),
-                            transactionDetails: unsignedTx
-                        };
-                        return [2 /*return*/, [
-                                __assign(__assign({}, airGapTransaction), (transaction.chainId.toNumber() !== 1
-                                    ? {
-                                        warnings: [
-                                            {
-                                                type: IAirGapTransaction_1.AirGapTransactionWarningType.WARNING,
-                                                title: 'Chain ID',
-                                                description: "Please note that this is not an Ethereum Mainnet transaction, it is from ".concat((_c = EthereumChainIDs_1.EthereumChainIDs.get(transaction.chainId.toNumber())) !== null && _c !== void 0 ? _c : "Chain ID ".concat(transaction.chainId.toNumber()))
-                                            }
-                                        ]
-                                    }
-                                    : {}))
-                            ]];
-                    case 5:
-                        transaction = unsignedTx.transaction;
-                        if (!unsignedTx.publicKey.startsWith('x') // xPub
-                        ) return [3 /*break*/, 7]; // xPub
-                        return [4 /*yield*/, this.getAddressFromExtendedPublicKey(unsignedTx.publicKey, 0, 0)];
-                    case 6:
-                        _e = _f.sent();
-                        return [3 /*break*/, 9];
-                    case 7: return [4 /*yield*/, this.getAddressFromPublicKey(unsignedTx.publicKey)];
-                    case 8:
-                        _e = _f.sent();
-                        _f.label = 9;
-                    case 9:
-                        ownAddress = _e;
-                        return [2 /*return*/, [
+    async getSymbol() {
+        return this.symbol;
+    }
+    async getName() {
+        return this.name;
+    }
+    async getMarketSymbol() {
+        return this.marketSymbol;
+    }
+    async getAssetSymbol() {
+        return undefined;
+    }
+    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) {
+        return this.options.network.blockExplorer.getAddressLink(address);
+    }
+    async getBlockExplorerLinkForTxId(txId) {
+        return this.options.network.blockExplorer.getTransactionLink(txId);
+    }
+    async getPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
+        return this.getPublicKeyFromHexSecret(secret, derivationPath);
+    }
+    async getPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
+        return this.getPrivateKeyFromHexSecret(secret, derivationPath);
+    }
+    async getExtendedPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
+        return this.getExtendedPrivateKeyFromHexSecret(secret, derivationPath);
+    }
+    async getExtendedPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
+        const secret = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
+        return this.getExtendedPublicKeyFromHexSecret(secret, derivationPath);
+    }
+    async getPublicKeyFromHexSecret(secret, derivationPath) {
+        const ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
+        return ethereumNode.derivePath(derivationPath).neutered().getPublicKeyBuffer().toString('hex');
+    }
+    async getExtendedPublicKeyFromHexSecret(secret, derivationPath) {
+        const ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
+        return ethereumNode.derivePath(derivationPath).neutered().toBase58();
+    }
+    async getPrivateKeyFromHexSecret(secret, derivationPath) {
+        const ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
+        return ethereumNode.derivePath(derivationPath).keyPair.d.toBuffer(32).toString('hex');
+    }
+    async getExtendedPrivateKeyFromHexSecret(secret, derivationPath) {
+        const ethereumNode = bitcoinJS.HDNode.fromSeedHex(secret, this.network);
+        return ethereumNode.derivePath(derivationPath).toBase58();
+    }
+    async getAddressFromPublicKey(publicKey, cursor) {
+        const address = EthereumAddress_1.EthereumAddress.from(publicKey);
+        return {
+            address: address.asString(),
+            cursor: { hasNext: false }
+        };
+    }
+    async getAddressesFromPublicKey(publicKey, cursor) {
+        const address = await this.getAddressFromPublicKey(publicKey, cursor);
+        return [address];
+    }
+    async getPublicKeyFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
+        return bitcoinJS.HDNode.fromBase58(extendedPublicKey, this.network)
+            .derive(visibilityDerivationIndex)
+            .derive(addressDerivationIndex)
+            .getPublicKeyBuffer()
+            .toString('hex');
+    }
+    async getAddressFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
+        return this.getAddressFromPublicKey(await this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex));
+    }
+    getAddressesFromExtendedPublicKey(extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
+        const node = bitcoinJS.HDNode.fromBase58(extendedPublicKey, this.network);
+        const generatorArray = [addressCount].map((x, i) => i + offset);
+        return Promise.all(generatorArray.map((x) => this.getAddressFromPublicKey(node.derive(visibilityDerivationIndex).derive(x).getPublicKeyBuffer().toString('hex'))));
+    }
+    async getPrivateKeyFromExtendedPrivateKey(extendedPrivateKey, childDerivationPath) {
+        const dp = childDerivationPath ?? '0/0'; // This is the default
+        if (dp.startsWith('m')) {
+            throw new Error('Received full derivation path, expected child derivation path');
+        }
+        if (dp.toLowerCase().includes('h') || dp.includes(`'`)) {
+            throw new Error('Child derivation path cannot include hardened children');
+        }
+        return dp
+            .split('/')
+            .reduce((pv, cv) => pv.derive(Number(cv)), bitcoinJS.HDNode.fromBase58(extendedPrivateKey, this.network))
+            .keyPair.d.toBuffer(32);
+    }
+    async signWithExtendedPrivateKey(extendedPrivateKey, untypedTransaction, childDerivationPath) {
+        const privateKey = await this.getPrivateKeyFromExtendedPrivateKey(extendedPrivateKey, childDerivationPath);
+        if (untypedTransaction.serialized &&
+            untypedTransaction.derivationPath) {
+            const transaction = untypedTransaction;
+            let tx = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
+            tx = tx.sign(privateKey);
+            return tx.serialize().toString('hex');
+        }
+        else {
+            return this.signWithPrivateKey(privateKey.toString('hex'), untypedTransaction);
+        }
+    }
+    async signWithPrivateKey(privateKey, transaction) {
+        if (!transaction.value.startsWith('0x')) {
+            transaction.value = utils_1.EthereumUtils.toHex(parseInt(transaction.value, 10));
+        }
+        let common;
+        try {
+            common = new common_1.default({ chain: transaction.chainId });
+        }
+        catch {
+            common = common_1.default.custom({ chainId: transaction.chainId });
+        }
+        let tx = tx_1.TransactionFactory.fromTxData(transaction, { common });
+        tx = tx.sign(Buffer.from(privateKey, 'hex'));
+        return tx.serialize().toString('hex');
+    }
+    async getTransactionDetails(unsignedTx) {
+        if (unsignedTx.transaction.serialized) {
+            const typedTransaction = unsignedTx.transaction;
+            const transaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(typedTransaction.serialized, 'hex'));
+            const dps = typedTransaction.derivationPath.split('/');
+            const ownAddress = unsignedTx.publicKey.startsWith('x') // xPub
+                ? await this.getAddressFromExtendedPublicKey(unsignedTx.publicKey, Number(dps[dps.length - 2]), Number(dps[dps.length - 1]))
+                : await this.getAddressFromPublicKey(unsignedTx.publicKey);
+            const airGapTransaction = {
+                from: [ownAddress.address],
+                to: [transaction.to?.toString() ?? ''],
+                amount: new bignumber_1.BigNumber(transaction.value.toString(10)).toString(10),
+                fee: new bignumber_1.BigNumber(transaction.gasLimit.toString(10))
+                    .multipliedBy(new bignumber_1.BigNumber(transaction.maxFeePerGas.toString(10)))
+                    .toString(10),
+                protocolIdentifier: this.identifier,
+                network: this.options.network,
+                isInbound: false,
+                data: transaction.data.toString('hex'),
+                transactionDetails: unsignedTx
+            };
+            return [
+                {
+                    ...airGapTransaction,
+                    ...(transaction.chainId.toNumber() !== 1
+                        ? {
+                            warnings: [
                                 {
-                                    from: [ownAddress.address],
-                                    to: [transaction.to],
-                                    amount: new bignumber_1.BigNumber(transaction.value).toString(10),
-                                    fee: new bignumber_1.BigNumber(transaction.gasLimit).multipliedBy(new bignumber_1.BigNumber(transaction.gasPrice)).toString(10),
-                                    protocolIdentifier: this.identifier,
-                                    network: this.options.network,
-                                    isInbound: false,
-                                    data: transaction.data,
-                                    transactionDetails: unsignedTx
+                                    type: IAirGapTransaction_1.AirGapTransactionWarningType.WARNING,
+                                    title: 'Chain ID',
+                                    description: `Please note that this is not an Ethereum Mainnet transaction, it is from ${EthereumChainIDs_1.EthereumChainIDs.get(transaction.chainId.toNumber()) ?? `Chain ID ${transaction.chainId.toNumber()}`}`
                                 }
-                            ]];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getTransactionDetailsFromSigned = 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.transaction, '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()],
-                                amount: new bignumber_1.BigNumber(parseInt(hexValue, 16)).toString(10),
-                                fee: new bignumber_1.BigNumber(parseInt(hexGasLimit, 16)).multipliedBy(new bignumber_1.BigNumber(parseInt(hexGasPrice, 16))).toString(10),
-                                protocolIdentifier: this.identifier,
-                                network: this.options.network,
-                                isInbound: tx.toCreationAddress(),
-                                hash: "0x".concat(tx.hash().toString('hex')),
-                                data: "0x".concat(tx.data.toString('hex')),
-                                extra: {
-                                    chainId: chainId,
-                                    nonce: parseInt(hexNonce, 16)
-                                },
-                                transactionDetails: { raw: transaction.transaction }
-                            }
-                        ]];
-                }
-                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 : ''],
-                                amount: new bignumber_1.BigNumber(feeTx.value.toString(10)).toString(10),
-                                fee: new bignumber_1.BigNumber(feeTx.gasLimit.toString(10)).multipliedBy(new bignumber_1.BigNumber(feeTx.maxFeePerGas.toString(10))).toString(10),
-                                protocolIdentifier: this.identifier,
-                                network: this.options.network,
-                                isInbound: false,
-                                data: feeTx.data.toString('hex'),
-                                extra: {
-                                    chainId: feeTx.chainId.toString(10),
-                                    nonce: feeTx.nonce.toString(10)
-                                },
-                                transactionDetails: { raw: transaction.transaction }
-                            }
-                        ]];
-                }
-                catch (e) {
-                    throw new Error("Transaction type \"".concat(ethTx.type, "\" not supported"));
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    BaseEthereumProtocol.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.getBalanceOfAddresses([address.address])];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.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.options.nodeClient.fetchBalance(address);
-                        }))];
-                    case 1:
-                        balances = _a.sent();
-                        return [2 /*return*/, balances.reduce(function (a, b) { return a.plus(b); }).toString(10)];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getBalanceOfPublicKeyForSubProtocols = function (publicKey, subProtocols) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address, contractAddresses, balances;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)
-                            .then(function (address) { return address.address; })
-                            .catch(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, this.getAddressFromExtendedPublicKey(publicKey, 0, 0).then(function (address) { return address.address; })];
-                                case 1: return [2 /*return*/, _a.sent()];
-                            }
-                        }); }); })];
-                    case 1:
-                        address = _a.sent();
-                        return [4 /*yield*/, Promise.all(subProtocols.map(function (subProtocol) { return __awaiter(_this, void 0, void 0, function () {
-                                var subProtocolType, subProtocolContractAddress;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0: return [4 /*yield*/, subProtocol.getSubProtocolType()];
-                                        case 1:
-                                            subProtocolType = _a.sent();
-                                            return [4 /*yield*/, subProtocol.getContractAddress()];
-                                        case 2:
-                                            subProtocolContractAddress = _a.sent();
-                                            if (subProtocolType === ICoinSubProtocol_1.SubProtocolType.TOKEN && subProtocolContractAddress) {
-                                                return [2 /*return*/, subProtocolContractAddress];
-                                            }
-                                            else {
-                                                throw new errors_1.UnsupportedError(coinlib_error_1.Domain.ETHEREUM, 'can only retrieve balance of ERC20 tokens');
-                                            }
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }))];
-                    case 2:
-                        contractAddresses = _a.sent();
-                        return [4 /*yield*/, this.options.nodeClient.callBalanceOfOnContracts(contractAddresses, address)];
-                    case 3:
-                        balances = _a.sent();
-                        return [2 /*return*/, contractAddresses.map(function (contractAddresse) { var _a, _b; return (_b = (_a = balances[contractAddresse]) === null || _a === void 0 ? void 0 : _a.toFixed()) !== null && _b !== void 0 ? _b : '0'; })];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getBalanceOfExtendedPublicKey = function (extendedPublicKey, offset) {
-        if (offset === void 0) { offset = 0; }
-        return __awaiter(this, void 0, void 0, function () {
-            var publicKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0)];
-                    case 1:
-                        publicKey = _a.sent();
-                        return [2 /*return*/, this.getBalanceOfPublicKey(publicKey)];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getAvailableBalanceOfAddresses = function (addresses) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getBalanceOfAddresses(addresses)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.estimateMaxTransactionValueFromExtendedPublicKey = function (extendedPublicKey, recipients, fee) {
-        return __awaiter(this, void 0, void 0, function () {
-            var publicKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0)];
-                    case 1:
-                        publicKey = _a.sent();
-                        return [2 /*return*/, this.estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee)];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.estimateFeeDefaultsFromExtendedPublicKey = function (extendedPublicKey, recipients, values, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var publicKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0)];
-                    case 1:
-                        publicKey = _a.sent();
-                        return [2 /*return*/, this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data)];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.prepareTransactionFromExtendedPublicKey = function (extendedPublicKey, _offset, recipients, values, fee, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var publicKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0)];
-                    case 1:
-                        publicKey = _a.sent();
-                        return [2 /*return*/, this.prepareTransactionFromPublicKey(publicKey, recipients, values, fee, data)];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.estimateMaxTransactionValueFromPublicKey = function (publicKey, recipients, fee) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance, balanceWrapper, maxFee, estimatedFeeDefaults, amountWithoutFees;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        balanceWrapper = new bignumber_1.BigNumber(balance);
-                        if (!(fee !== undefined)) return [3 /*break*/, 2];
-                        maxFee = new bignumber_1.BigNumber(fee);
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, [balance])];
-                    case 3:
-                        estimatedFeeDefaults = _a.sent();
-                        maxFee = new bignumber_1.BigNumber(estimatedFeeDefaults.medium).shiftedBy(this.decimals);
-                        if (maxFee.gte(balanceWrapper)) {
-                            maxFee = new bignumber_1.BigNumber(0);
-                        }
-                        _a.label = 4;
-                    case 4:
-                        amountWithoutFees = balanceWrapper.minus(maxFee);
-                        if (amountWithoutFees.isNegative()) {
-                            amountWithoutFees = new bignumber_1.BigNumber(0);
-                        }
-                        return [2 /*return*/, amountWithoutFees.toFixed()];
-                }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.estimateFeeDefaultsFromPublicKey = function (publicKey, recipients, values, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address, estimatedGas, gasPrise, feeStepFactor, estimatedFee, lowFee, mediumFee, highFee;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (recipients.length !== values.length) {
-                            return [2 /*return*/, Promise.reject('recipients length does not match with values')];
+                            ]
                         }
-                        if (recipients.length !== 1) {
-                            return [2 /*return*/, Promise.reject('you cannot have 0 recipients')];
-                        }
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey).then(function (address) { return address.address; })];
-                    case 1:
-                        address = _a.sent();
-                        return [4 /*yield*/, this.options.nodeClient.estimateTransactionGas(address, recipients[0], utils_1.EthereumUtils.toHex(values[0]), undefined, utils_1.EthereumUtils.toHex(this.MAX_GAS_ESTIMATE))];
-                    case 2:
-                        estimatedGas = _a.sent();
-                        return [4 /*yield*/, this.options.nodeClient.getGasPrice()];
-                    case 3:
-                        gasPrise = _a.sent();
-                        feeStepFactor = new bignumber_1.BigNumber(0.5);
-                        estimatedFee = estimatedGas.times(gasPrise);
-                        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: lowFee.shiftedBy(-this.feeDecimals).toFixed(),
-                                medium: mediumFee.shiftedBy(-this.feeDecimals).toFixed(),
-                                high: highFee.shiftedBy(-this.feeDecimals).toFixed()
-                            }];
+                        : {})
                 }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.prepareTransactionFromPublicKey = function (publicKey, recipients, values, fee, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var wrappedValues, wrappedFee, address, amount, balance, gasLimit, gasPrice, txCount, transaction;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        wrappedValues = values.map(function (value) { return new bignumber_1.BigNumber(value); });
-                        wrappedFee = new bignumber_1.BigNumber(fee);
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey).then(function (address) { return address.address; })];
-                    case 1:
-                        address = _a.sent();
-                        if (recipients.length !== values.length) {
-                            return [2 /*return*/, Promise.reject('recipients length does not match with values')];
-                        }
-                        if (recipients.length !== 1) {
-                            return [2 /*return*/, Promise.reject('you cannot have 0 recipients')];
-                        }
-                        amount = utils_1.EthereumUtils.toHex(wrappedValues[0].toFixed());
-                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 2:
-                        balance = _a.sent();
-                        return [4 /*yield*/, this.options.nodeClient.estimateTransactionGas(address, recipients[0], amount, undefined, utils_1.EthereumUtils.toHex(this.MAX_GAS_ESTIMATE))];
-                    case 3:
-                        gasLimit = _a.sent();
-                        gasPrice = wrappedFee.div(gasLimit).integerValue(bignumber_1.BigNumber.ROUND_CEIL);
-                        if (!new bignumber_1.BigNumber(balance).gte(new bignumber_1.BigNumber(wrappedValues[0].plus(wrappedFee)))) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.options.nodeClient.fetchTransactionCount(address)];
-                    case 4:
-                        txCount = _a.sent();
-                        transaction = {
-                            nonce: utils_1.EthereumUtils.toHex(txCount),
-                            gasLimit: utils_1.EthereumUtils.toHex(gasLimit.toFixed()),
-                            gasPrice: utils_1.EthereumUtils.toHex(gasPrice.toFixed()),
-                            to: recipients[0],
-                            value: amount,
-                            chainId: this.options.network.extras.chainID,
-                            data: '0x'
-                        };
-                        return [2 /*return*/, transaction];
-                    case 5: throw new errors_1.BalanceError(coinlib_error_1.Domain.ETHEREUM, 'not enough balance');
+            ];
+        }
+        else {
+            const transaction = unsignedTx.transaction;
+            const ownAddress = unsignedTx.publicKey.startsWith('x') // xPub
+                ? await this.getAddressFromExtendedPublicKey(unsignedTx.publicKey, 0, 0)
+                : await this.getAddressFromPublicKey(unsignedTx.publicKey);
+            return [
+                {
+                    from: [ownAddress.address],
+                    to: [transaction.to],
+                    amount: new bignumber_1.BigNumber(transaction.value).toString(10),
+                    fee: new bignumber_1.BigNumber(transaction.gasLimit).multipliedBy(new bignumber_1.BigNumber(transaction.gasPrice)).toString(10),
+                    protocolIdentifier: this.identifier,
+                    network: this.options.network,
+                    isInbound: false,
+                    data: transaction.data,
+                    transactionDetails: unsignedTx
                 }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.broadcastTransaction = function (rawTransaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.nodeClient.sendSignedTransaction("0x".concat(rawTransaction))];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getTransactionsFromExtendedPublicKey = function (extendedPublicKey, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var publicKey;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0)];
-                    case 1:
-                        publicKey = _a.sent();
-                        return [2 /*return*/, this.getTransactionsFromPublicKey(publicKey, limit, cursor)];
+            ];
+        }
+    }
+    async getTransactionDetailsFromSigned(transaction) {
+        const ethTx = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.transaction, '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()],
+                    amount: new bignumber_1.BigNumber(parseInt(hexValue, 16)).toString(10),
+                    fee: new bignumber_1.BigNumber(parseInt(hexGasLimit, 16)).multipliedBy(new bignumber_1.BigNumber(parseInt(hexGasPrice, 16))).toString(10),
+                    protocolIdentifier: this.identifier,
+                    network: this.options.network,
+                    isInbound: tx.toCreationAddress(),
+                    hash: `0x${tx.hash().toString('hex')}`,
+                    data: `0x${tx.data.toString('hex')}`,
+                    extra: {
+                        chainId,
+                        nonce: parseInt(hexNonce, 16)
+                    },
+                    transactionDetails: { raw: transaction.transaction }
                 }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getTransactionsFromPublicKey = function (publicKey, limit, cursor) {
-        if (limit === void 0) { limit = 50; }
-        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.getTransactionsFromAddresses([address.address], limit, cursor)];
+            ];
+        }
+        try {
+            const feeTx = ethTx;
+            return [
+                {
+                    from: [feeTx.getSenderAddress().toString()],
+                    to: [feeTx.to?.toString() ?? ''],
+                    amount: new bignumber_1.BigNumber(feeTx.value.toString(10)).toString(10),
+                    fee: new bignumber_1.BigNumber(feeTx.gasLimit.toString(10)).multipliedBy(new bignumber_1.BigNumber(feeTx.maxFeePerGas.toString(10))).toString(10),
+                    protocolIdentifier: this.identifier,
+                    network: this.options.network,
+                    isInbound: false,
+                    data: feeTx.data.toString('hex'),
+                    extra: {
+                        chainId: feeTx.chainId.toString(10),
+                        nonce: feeTx.nonce.toString(10)
+                    },
+                    transactionDetails: { raw: transaction.transaction }
                 }
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getTransactionsFromAddresses = function (addresses, limit, cursor) {
-        var _this = this;
-        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.options.infoClient.fetchTransactions(_this, address, limit, cursor));
+            ];
+        }
+        catch (e) {
+            throw new Error(`Transaction type "${ethTx.type}" not supported`);
+        }
+    }
+    async getBalanceOfPublicKey(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getBalanceOfAddresses([address.address]);
+    }
+    async getBalanceOfAddresses(addresses) {
+        const balances = await Promise.all(addresses.map((address) => {
+            return this.options.nodeClient.fetchBalance(address);
+        }));
+        return balances.reduce((a, b) => a.plus(b)).toString(10);
+    }
+    async getBalanceOfPublicKeyForSubProtocols(publicKey, subProtocols) {
+        const address = await this.getAddressFromPublicKey(publicKey)
+            .then((address) => address.address)
+            .catch(async () => await this.getAddressFromExtendedPublicKey(publicKey, 0, 0).then((address) => address.address));
+        const contractAddresses = await Promise.all(subProtocols.map(async (subProtocol) => {
+            const subProtocolType = await subProtocol.getSubProtocolType();
+            const subProtocolContractAddress = await subProtocol.getContractAddress();
+            if (subProtocolType === ICoinSubProtocol_1.SubProtocolType.TOKEN && subProtocolContractAddress) {
+                return subProtocolContractAddress;
+            }
+            else {
+                throw new errors_1.UnsupportedError(coinlib_error_1.Domain.ETHEREUM, 'can only retrieve balance of ERC20 tokens');
+            }
+        }));
+        const balances = await this.options.nodeClient.callBalanceOfOnContracts(contractAddresses, address);
+        return contractAddresses.map((contractAddresse) => balances[contractAddresse]?.toFixed() ?? '0');
+    }
+    async getBalanceOfExtendedPublicKey(extendedPublicKey, offset = 0) {
+        const publicKey = await this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0);
+        return this.getBalanceOfPublicKey(publicKey);
+    }
+    async getAvailableBalanceOfAddresses(addresses) {
+        return this.getBalanceOfAddresses(addresses);
+    }
+    async estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey, recipients, fee) {
+        const publicKey = await this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0);
+        return this.estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee);
+    }
+    async estimateFeeDefaultsFromExtendedPublicKey(extendedPublicKey, recipients, values, data) {
+        const publicKey = await this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0);
+        return this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data);
+    }
+    async prepareTransactionFromExtendedPublicKey(extendedPublicKey, _offset, recipients, values, fee, data) {
+        const publicKey = await this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0);
+        return this.prepareTransactionFromPublicKey(publicKey, recipients, values, fee, data);
+    }
+    async estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const balanceWrapper = new bignumber_1.BigNumber(balance);
+        let maxFee;
+        if (fee !== undefined) {
+            maxFee = new bignumber_1.BigNumber(fee);
+        }
+        else {
+            const estimatedFeeDefaults = await this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, [balance]);
+            maxFee = new bignumber_1.BigNumber(estimatedFeeDefaults.medium).shiftedBy(this.decimals);
+            if (maxFee.gte(balanceWrapper)) {
+                maxFee = new bignumber_1.BigNumber(0);
+            }
+        }
+        let amountWithoutFees = balanceWrapper.minus(maxFee);
+        if (amountWithoutFees.isNegative()) {
+            amountWithoutFees = new bignumber_1.BigNumber(0);
+        }
+        return amountWithoutFees.toFixed();
+    }
+    async estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data) {
+        if (recipients.length !== values.length) {
+            return Promise.reject('recipients length does not match with values');
+        }
+        if (recipients.length !== 1) {
+            return Promise.reject('you cannot have 0 recipients');
+        }
+        const address = await this.getAddressFromPublicKey(publicKey).then((address) => address.address);
+        const estimatedGas = await this.options.nodeClient.estimateTransactionGas(address, recipients[0], utils_1.EthereumUtils.toHex(values[0]), undefined, utils_1.EthereumUtils.toHex(this.MAX_GAS_ESTIMATE));
+        const gasPrise = await this.options.nodeClient.getGasPrice();
+        const feeStepFactor = new bignumber_1.BigNumber(0.5);
+        const estimatedFee = estimatedGas.times(gasPrise);
+        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: lowFee.shiftedBy(-this.feeDecimals).toFixed(),
+            medium: mediumFee.shiftedBy(-this.feeDecimals).toFixed(),
+            high: highFee.shiftedBy(-this.feeDecimals).toFixed()
+        };
+    }
+    async prepareTransactionFromPublicKey(publicKey, recipients, values, fee, data) {
+        const wrappedValues = values.map((value) => new bignumber_1.BigNumber(value));
+        const wrappedFee = new bignumber_1.BigNumber(fee);
+        const address = await this.getAddressFromPublicKey(publicKey).then((address) => address.address);
+        if (recipients.length !== values.length) {
+            return Promise.reject('recipients length does not match with values');
+        }
+        if (recipients.length !== 1) {
+            return Promise.reject('you cannot have 0 recipients');
+        }
+        const amount = utils_1.EthereumUtils.toHex(wrappedValues[0].toFixed());
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const gasLimit = await this.options.nodeClient.estimateTransactionGas(address, recipients[0], amount, undefined, utils_1.EthereumUtils.toHex(this.MAX_GAS_ESTIMATE));
+        const gasPrice = wrappedFee.div(gasLimit).integerValue(bignumber_1.BigNumber.ROUND_CEIL);
+        if (new bignumber_1.BigNumber(balance).gte(new bignumber_1.BigNumber(wrappedValues[0].plus(wrappedFee)))) {
+            const txCount = await this.options.nodeClient.fetchTransactionCount(address);
+            const transaction = {
+                nonce: utils_1.EthereumUtils.toHex(txCount),
+                gasLimit: utils_1.EthereumUtils.toHex(gasLimit.toFixed()),
+                gasPrice: utils_1.EthereumUtils.toHex(gasPrice.toFixed()), // 10 Gwei
+                to: recipients[0],
+                value: amount,
+                chainId: this.options.network.extras.chainID,
+                data: '0x'
+            };
+            return transaction;
+        }
+        else {
+            throw new errors_1.BalanceError(coinlib_error_1.Domain.ETHEREUM, 'not enough balance');
+        }
+    }
+    async broadcastTransaction(rawTransaction) {
+        return this.options.nodeClient.sendSignedTransaction(`0x${rawTransaction}`);
+    }
+    async getTransactionsFromExtendedPublicKey(extendedPublicKey, limit, cursor) {
+        const publicKey = await this.getPublicKeyFromExtendedPublicKey(extendedPublicKey, 0, 0);
+        return this.getTransactionsFromPublicKey(publicKey, limit, cursor);
+    }
+    async getTransactionsFromPublicKey(publicKey, limit = 50, cursor) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getTransactionsFromAddresses([address.address], limit, cursor);
+    }
+    getTransactionsFromAddresses(addresses, limit, cursor) {
+        return new Promise((overallResolve, overallReject) => {
+            const promises = [];
+            for (const address of addresses) {
+                promises.push(this.options.infoClient.fetchTransactions(this, address, limit, cursor));
             }
             Promise.all(promises)
-                .then(function (values) {
-                var page = Math.max.apply(Math, values.map(function (txResult) { return txResult.cursor.page; }));
-                overallResolve(values.reduce(function (a, b) {
-                    return { transactions: a.transactions.concat(b.transactions), cursor: { page: page } };
+                .then((values) => {
+                const page = Math.max(...values.map((txResult) => txResult.cursor.page));
+                overallResolve(values.reduce((a, b) => {
+                    return { transactions: a.transactions.concat(b.transactions), cursor: { page } };
                 }));
             })
                 .catch(overallReject);
         });
-    };
-    BaseEthereumProtocol.prototype.signMessage = function (message, keypair) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.signMessage(message, keypair)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.verifyMessage = function (message, signature, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.verifyMessage(message, signature, publicKey)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.encryptAsymmetric = function (message, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(message, publicKey)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.decryptAsymmetric = function (message, keypair) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(message, keypair)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.encryptAES = function (message, privateKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.encryptAES(message, privateKey)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.decryptAES = function (message, privateKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoClient.decryptAES(message, privateKey)];
-            });
-        });
-    };
-    BaseEthereumProtocol.prototype.getTransactionStatuses = function (transactionHashes) {
-        return __awaiter(this, void 0, void 0, function () {
-            var statusPromises;
-            var _this = this;
-            return __generator(this, function (_a) {
-                statusPromises = transactionHashes.map(function (txHash) {
-                    return _this.options.nodeClient.getTransactionStatus(txHash);
-                });
-                return [2 /*return*/, Promise.all(statusPromises)];
-            });
+    }
+    async signMessage(message, keypair) {
+        return this.cryptoClient.signMessage(message, keypair);
+    }
+    async verifyMessage(message, signature, publicKey) {
+        return this.cryptoClient.verifyMessage(message, signature, publicKey);
+    }
+    async encryptAsymmetric(message, publicKey) {
+        return this.cryptoClient.encryptAsymmetric(message, publicKey);
+    }
+    async decryptAsymmetric(message, keypair) {
+        return this.cryptoClient.decryptAsymmetric(message, keypair);
+    }
+    async encryptAES(message, privateKey) {
+        return this.cryptoClient.encryptAES(message, privateKey);
+    }
+    async decryptAES(message, privateKey) {
+        return this.cryptoClient.decryptAES(message, privateKey);
+    }
+    async getTransactionStatuses(transactionHashes) {
+        const statusPromises = transactionHashes.map((txHash) => {
+            return this.options.nodeClient.getTransactionStatus(txHash);
         });
-    };
-    return BaseEthereumProtocol;
-}());
+        return Promise.all(statusPromises);
+    }
+}
 exports.BaseEthereumProtocol = BaseEthereumProtocol;
 //# sourceMappingURL=BaseEthereumProtocol.js.map