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

package/v1/protocol/erc20/ERC20Protocol.js

@@ -1,30 +1,4 @@
 "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);
@@ -41,357 +15,236 @@ 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.ERC20ProtocolImpl = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const coinlib_core_1 = require("@airgap/coinlib-core");
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
 // @ts-ignore
-var ethUtil = __importStar(require("@airgap/coinlib-core/dependencies/src/ethereumjs-util-5.2.0"));
-var errors_1 = require("@airgap/coinlib-core/errors");
-var hex_1 = require("@airgap/coinlib-core/utils/hex");
-var module_kit_1 = require("@airgap/module-kit");
-var tx_1 = require("@ethereumjs/tx");
-var HttpEthereumNodeClient_1 = require("../../clients/node/HttpEthereumNodeClient");
-var EthereumUtils_1 = require("../../utils/EthereumUtils");
-var EthereumBaseProtocol_1 = require("../EthereumBaseProtocol");
-var EthereumTransaction = require('@airgap/coinlib-core/dependencies/src/ethereumjs-tx-1.3.7/index');
+const ethUtil = __importStar(require("@airgap/coinlib-core/dependencies/src/ethereumjs-util-5.2.0"));
+const errors_1 = require("@airgap/coinlib-core/errors");
+const hex_1 = require("@airgap/coinlib-core/utils/hex");
+const module_kit_1 = require("@airgap/module-kit");
+const tx_1 = require("@ethereumjs/tx");
+const HttpEthereumNodeClient_1 = require("../../clients/node/HttpEthereumNodeClient");
+const EthereumUtils_1 = require("../../utils/EthereumUtils");
+const EthereumBaseProtocol_1 = require("../EthereumBaseProtocol");
+const EthereumTransaction = require('@airgap/coinlib-core/dependencies/src/ethereumjs-tx-1.3.7/index');
 // Implementation
-var ERC20ProtocolImpl = /** @class */ (function (_super) {
-    __extends(ERC20ProtocolImpl, _super);
-    function ERC20ProtocolImpl(nodeClient, infoClient, options) {
-        var _this = _super.call(this, nodeClient, infoClient, {
+class ERC20ProtocolImpl extends EthereumBaseProtocol_1.EthereumBaseProtocolImpl {
+    constructor(nodeClient, infoClient, options) {
+        super(nodeClient, infoClient, {
             network: options.network,
             name: options.name,
             identifier: options.identifier,
             units: options.units,
             mainUnit: options.mainUnit
-        }) || this;
-        _this.contractAddress = options.contractAddress;
-        return _this;
+        });
+        this.contractAddress = options.contractAddress;
     }
     // Common
-    ERC20ProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var ethTransactionDetails;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, _super.prototype.getDetailsFromTransaction.call(this, transaction, publicKey)];
-                    case 1:
-                        ethTransactionDetails = _a.sent();
-                        switch (transaction.type) {
-                            case 'signed':
-                                return [2 /*return*/, this.getDetailsFromSignedContractTransaction(transaction, ethTransactionDetails)];
-                            case 'unsigned':
-                                return [2 /*return*/, this.getDetailsFromUnsignedContractTransaction(transaction, ethTransactionDetails)];
-                            default:
-                                (0, coinlib_core_1.assertNever)(transaction);
-                                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, 'Unsupported transaction type.');
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.getDetailsFromSignedContractTransaction = function (transaction, ethTransactionDetails) {
-        return __awaiter(this, void 0, void 0, function () {
-            var extractedTx, tokenTransferDetails;
-            return __generator(this, function (_a) {
-                if (ethTransactionDetails.length !== 1) {
-                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ERC20, 'More than one ETH transaction detected.');
-                }
-                extractedTx = new EthereumTransaction(transaction.serialized);
-                tokenTransferDetails = new HttpEthereumNodeClient_1.EthereumRPCDataTransfer("0x".concat(extractedTx.data.toString('hex')));
-                return [2 /*return*/, [
-                        __assign(__assign({}, ethTransactionDetails[0]), { to: [ethUtil.toChecksumAddress(tokenTransferDetails.recipient)], amount: (0, module_kit_1.newAmount)(tokenTransferDetails.amount, 'blockchain') })
-                    ]];
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.getDetailsFromUnsignedContractTransaction = function (transaction, ethTransactionDetails) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, typedTransaction, tokenTransferDetails;
-            return __generator(this, function (_a) {
-                if (ethTransactionDetails.length !== 1) {
-                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ERC20, 'More than one ETH transaction detected.');
-                }
-                if (transaction.ethereumType === 'raw') {
-                    data = transaction.data;
-                }
-                else {
-                    typedTransaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
-                    data = typedTransaction.data.toString('hex');
-                }
-                tokenTransferDetails = new HttpEthereumNodeClient_1.EthereumRPCDataTransfer(data);
-                return [2 /*return*/, [
-                        __assign(__assign({}, ethTransactionDetails[0]), { to: [ethUtil.toChecksumAddress(tokenTransferDetails.recipient)], amount: (0, module_kit_1.newAmount)(tokenTransferDetails.amount, 'blockchain') })
-                    ]];
-            });
-        });
-    };
+    async getDetailsFromTransaction(transaction, publicKey) {
+        const ethTransactionDetails = await super.getDetailsFromTransaction(transaction, publicKey);
+        switch (transaction.type) {
+            case 'signed':
+                return this.getDetailsFromSignedContractTransaction(transaction, ethTransactionDetails);
+            case 'unsigned':
+                return this.getDetailsFromUnsignedContractTransaction(transaction, ethTransactionDetails);
+            default:
+                (0, coinlib_core_1.assertNever)(transaction);
+                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.ETHEREUM, 'Unsupported transaction type.');
+        }
+    }
+    async getDetailsFromSignedContractTransaction(transaction, ethTransactionDetails) {
+        if (ethTransactionDetails.length !== 1) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ERC20, 'More than one ETH transaction detected.');
+        }
+        const extractedTx = new EthereumTransaction(transaction.serialized);
+        const tokenTransferDetails = new HttpEthereumNodeClient_1.EthereumRPCDataTransfer(`0x${extractedTx.data.toString('hex')}`);
+        return [
+            {
+                ...ethTransactionDetails[0],
+                to: [ethUtil.toChecksumAddress(tokenTransferDetails.recipient)],
+                amount: (0, module_kit_1.newAmount)(tokenTransferDetails.amount, 'blockchain')
+            }
+        ];
+    }
+    async getDetailsFromUnsignedContractTransaction(transaction, ethTransactionDetails) {
+        if (ethTransactionDetails.length !== 1) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ERC20, 'More than one ETH transaction detected.');
+        }
+        let data;
+        if (transaction.ethereumType === 'raw') {
+            data = transaction.data;
+        }
+        else {
+            const typedTransaction = tx_1.TransactionFactory.fromSerializedData(Buffer.from(transaction.serialized, 'hex'));
+            data = typedTransaction.data.toString('hex');
+        }
+        const tokenTransferDetails = new HttpEthereumNodeClient_1.EthereumRPCDataTransfer(data);
+        return [
+            {
+                ...ethTransactionDetails[0],
+                to: [ethUtil.toChecksumAddress(tokenTransferDetails.recipient)],
+                amount: (0, module_kit_1.newAmount)(tokenTransferDetails.amount, 'blockchain')
+            }
+        ];
+    }
     // Offline
-    ERC20ProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var rawTransaction;
-            return __generator(this, function (_a) {
-                if (transaction.ethereumType !== 'raw') {
-                    // no v0 implementation
-                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ERC20, 'Unsupported unsigned transaction type.');
-                }
-                rawTransaction = __assign(__assign({}, transaction), { data: !transaction.data || transaction.data === '0x'
-                        ? new HttpEthereumNodeClient_1.EthereumRPCDataTransfer(transaction.to, transaction.value).abiEncoded()
-                        : transaction.data });
-                return [2 /*return*/, _super.prototype.signTransactionWithSecretKey.call(this, rawTransaction, secretKey)];
-            });
-        });
-    };
+    async signTransactionWithSecretKey(transaction, secretKey) {
+        if (transaction.ethereumType !== 'raw') {
+            // no v0 implementation
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.ERC20, 'Unsupported unsigned transaction type.');
+        }
+        const rawTransaction = {
+            ...transaction,
+            data: !transaction.data || transaction.data === '0x'
+                ? new HttpEthereumNodeClient_1.EthereumRPCDataTransfer(transaction.to, transaction.value).abiEncoded()
+                : transaction.data
+        };
+        return super.signTransactionWithSecretKey(rawTransaction, secretKey);
+    }
     // Online
-    ERC20ProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    ERC20ProtocolImpl.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)];
-            });
-        });
-    };
-    ERC20ProtocolImpl.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.fetchContractTransactions(_this.contractAddress, 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);
-                    })];
-            });
-        });
-    };
-    ERC20ProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.getBalanceOfAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getBalanceOfAddresses([address])];
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.getBalanceOfAddresses = function (addresses) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balances, totalBalance;
-            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.callBalanceOf(_this.contractAddress, address);
-                        }))];
-                    case 1:
-                        balances = _a.sent();
-                        totalBalance = balances.reduce(function (a, b) { return a.plus(b); });
-                        return [2 /*return*/, { total: (0, module_kit_1.newAmount)(totalBalance, 'blockchain') }];
-                }
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var balance;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 1:
-                        balance = _b.sent();
-                        return [2 /*return*/, (_a = balance.transferable) !== null && _a !== void 0 ? _a : balance.total];
-                }
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var fee, estimatedFee, wrappedFee, wrappedAmount, balance, wrappedBalance, address, ethBalance, wrappedEthBalance, estimatedGas, txCount, gasPrice, 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.default((0, module_kit_1.newAmount)(fee).blockchain(this.feeUnits).value);
-                        wrappedAmount = new bignumber_1.default((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
-                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 4:
-                        balance = _b.sent();
-                        wrappedBalance = new bignumber_1.default((0, module_kit_1.newAmount)((_a = balance.transferable) !== null && _a !== void 0 ? _a : balance.total).blockchain(this.units).value);
-                        if (!wrappedBalance.isGreaterThanOrEqualTo(wrappedAmount)) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 5:
-                        address = _b.sent();
-                        return [4 /*yield*/, _super.prototype.getBalanceOfAddresses.call(this, [address])];
-                    case 6:
-                        ethBalance = _b.sent();
-                        wrappedEthBalance = new bignumber_1.default((0, module_kit_1.newAmount)(ethBalance.total).blockchain(this.units).value);
-                        return [4 /*yield*/, this.estimateGas(address, details[0].to, wrappedAmount)];
-                    case 7:
-                        estimatedGas = _b.sent();
-                        if (!wrappedEthBalance.isGreaterThanOrEqualTo(wrappedFee)) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.nodeClient.fetchTransactionCount(address)];
-                    case 8:
-                        txCount = _b.sent();
-                        gasPrice = wrappedFee.isEqualTo(0)
-                            ? new bignumber_1.default(0)
-                            : wrappedFee.div(estimatedGas).integerValue(bignumber_1.default.ROUND_CEIL);
-                        transaction = (0, module_kit_1.newUnsignedTransaction)({
-                            ethereumType: 'raw',
-                            nonce: EthereumUtils_1.EthereumUtils.toHex(txCount),
-                            gasLimit: EthereumUtils_1.EthereumUtils.toHex(estimatedGas.toFixed()),
-                            gasPrice: EthereumUtils_1.EthereumUtils.toHex(gasPrice.toFixed()),
-                            to: this.contractAddress,
-                            value: EthereumUtils_1.EthereumUtils.toHex(new bignumber_1.default(0).toFixed()),
-                            chainId: this.options.network.chainId,
-                            data: new HttpEthereumNodeClient_1.EthereumRPCDataTransfer(details[0].to, EthereumUtils_1.EthereumUtils.toHex(wrappedAmount.toFixed())).abiEncoded()
-                        });
-                        return [2 /*return*/, transaction];
-                    case 9: throw new errors_1.BalanceError(coinlib_core_1.Domain.ERC20, 'not enough ETH balance');
-                    case 10: return [3 /*break*/, 12];
-                    case 11: throw new errors_1.BalanceError(coinlib_core_1.Domain.ERC20, 'not enough token balance');
-                    case 12: return [2 /*return*/];
-                }
-            });
+    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.fetchContractTransactions(this.contractAddress, 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);
         });
-    };
+    }
+    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.callBalanceOf(this.contractAddress, address);
+        }));
+        const totalBalance = balances.reduce((a, b) => a.plus(b));
+        return { total: (0, module_kit_1.newAmount)(totalBalance, 'blockchain') };
+    }
+    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        return balance.transferable ?? balance.total;
+    }
+    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.default((0, module_kit_1.newAmount)(fee).blockchain(this.feeUnits).value);
+        const wrappedAmount = new bignumber_1.default((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        const wrappedBalance = new bignumber_1.default((0, module_kit_1.newAmount)(balance.transferable ?? balance.total).blockchain(this.units).value);
+        if (wrappedBalance.isGreaterThanOrEqualTo(wrappedAmount)) {
+            const address = await this.getAddressFromPublicKey(publicKey);
+            const ethBalance = await super.getBalanceOfAddresses([address]);
+            const wrappedEthBalance = new bignumber_1.default((0, module_kit_1.newAmount)(ethBalance.total).blockchain(this.units).value);
+            const estimatedGas = await this.estimateGas(address, details[0].to, wrappedAmount);
+            if (wrappedEthBalance.isGreaterThanOrEqualTo(wrappedFee)) {
+                const txCount = await this.nodeClient.fetchTransactionCount(address);
+                const gasPrice = wrappedFee.isEqualTo(0)
+                    ? new bignumber_1.default(0)
+                    : wrappedFee.div(estimatedGas).integerValue(bignumber_1.default.ROUND_CEIL);
+                const transaction = (0, module_kit_1.newUnsignedTransaction)({
+                    ethereumType: 'raw',
+                    nonce: EthereumUtils_1.EthereumUtils.toHex(txCount),
+                    gasLimit: EthereumUtils_1.EthereumUtils.toHex(estimatedGas.toFixed()),
+                    gasPrice: EthereumUtils_1.EthereumUtils.toHex(gasPrice.toFixed()),
+                    to: this.contractAddress,
+                    value: EthereumUtils_1.EthereumUtils.toHex(new bignumber_1.default(0).toFixed()),
+                    chainId: this.options.network.chainId,
+                    data: new HttpEthereumNodeClient_1.EthereumRPCDataTransfer(details[0].to, EthereumUtils_1.EthereumUtils.toHex(wrappedAmount.toFixed())).abiEncoded()
+                });
+                return transaction;
+            }
+            else {
+                throw new errors_1.BalanceError(coinlib_core_1.Domain.ERC20, 'not enough ETH balance');
+            }
+        }
+        else {
+            throw new errors_1.BalanceError(coinlib_core_1.Domain.ERC20, 'not enough token balance');
+        }
+    }
     // Custom
-    ERC20ProtocolImpl.prototype.name = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.getContractName(this.contractAddress)];
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.symbol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.getContractSymbol(this.contractAddress)];
-            });
-        });
-    };
-    ERC20ProtocolImpl.prototype.decimals = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.nodeClient.getContractDecimals(this.contractAddress)];
-            });
-        });
-    };
-    ERC20ProtocolImpl.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.estimateTransferGas(this.contractAddress, fromAddress, toAddress, hexAmount)];
-            });
-        });
-    };
-    return ERC20ProtocolImpl;
-}(EthereumBaseProtocol_1.EthereumBaseProtocolImpl));
+    async name() {
+        return this.nodeClient.getContractName(this.contractAddress);
+    }
+    async symbol() {
+        return this.nodeClient.getContractSymbol(this.contractAddress);
+    }
+    async decimals() {
+        return this.nodeClient.getContractDecimals(this.contractAddress);
+    }
+    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.estimateTransferGas(this.contractAddress, fromAddress, toAddress, hexAmount);
+    }
+}
 exports.ERC20ProtocolImpl = ERC20ProtocolImpl;
 //# sourceMappingURL=ERC20Protocol.js.map