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

package/v1/protocol/kt/TezosKtProtocol.js

@@ -1,521 +1,277 @@
 "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 __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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTezosKtProtocol = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var axios_0_19_0_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0"));
-var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-var errors_1 = require("@airgap/coinlib-core/errors");
-var module_kit_1 = require("@airgap/module-kit");
-var factory_1 = require("../../indexer/factory");
-var TezosOperationType_1 = require("../../types/operations/TezosOperationType");
-var encoding_1 = require("../../utils/encoding");
-var operations_1 = require("../../utils/operations");
-var TezosProtocol_1 = require("../TezosProtocol");
+exports.createTezosKtProtocol = createTezosKtProtocol;
+const coinlib_core_1 = require("@airgap/coinlib-core");
+const axios_0_19_0_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0"));
+const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+const errors_1 = require("@airgap/coinlib-core/errors");
+const module_kit_1 = require("@airgap/module-kit");
+const factory_1 = require("../../indexer/factory");
+const TezosOperationType_1 = require("../../types/operations/TezosOperationType");
+const encoding_1 = require("../../utils/encoding");
+const operations_1 = require("../../utils/operations");
+const TezosProtocol_1 = require("../TezosProtocol");
 // Implementation
-var INDEX_LIMIT = 10000;
-var MIGRATION_FEE = 5000;
-var TezosKtProtocolImpl = /** @class */ (function () {
-    function TezosKtProtocolImpl(options) {
-        var completeOptions = (0, TezosProtocol_1.createTezosProtocolOptions)(options.network);
+const INDEX_LIMIT = 10000;
+const MIGRATION_FEE = 5000;
+class TezosKtProtocolImpl {
+    constructor(options) {
+        const completeOptions = (0, TezosProtocol_1.createTezosProtocolOptions)(options.network);
         this.tezos = (0, TezosProtocol_1.createTezosProtocol)(completeOptions);
         this.indexerClient = (0, factory_1.createTezosIndexerClient)(completeOptions.network.indexerType, completeOptions.network.indexerApi);
     }
     // SubProtocol
-    TezosKtProtocolImpl.prototype.getType = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, 'account'];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.mainProtocol = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, coinlib_core_1.MainProtocolSymbols.XTZ];
-            });
-        });
-    };
+    async getType() {
+        return 'account';
+    }
+    async mainProtocol() {
+        return coinlib_core_1.MainProtocolSymbols.XTZ;
+    }
     // Common
-    TezosKtProtocolImpl.prototype.getMetadata = function () {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var tezosMetadata;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0: return [4 /*yield*/, this.tezos.getMetadata()];
-                    case 1:
-                        tezosMetadata = _d.sent();
-                        return [2 /*return*/, __assign(__assign({}, tezosMetadata), { identifier: coinlib_core_1.SubProtocolSymbols.XTZ_KT, account: __assign(__assign({}, ((_a = tezosMetadata.account) !== null && _a !== void 0 ? _a : {})), { address: __assign(__assign({}, ((_c = (_b = tezosMetadata.account) === null || _b === void 0 ? void 0 : _b.address) !== null && _c !== void 0 ? _c : {})), { regex: '^(tz1|KT1)[1-9A-Za-z]{33}$' }) }) })];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tzAddress;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.tezos.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        tzAddress = _a.sent();
-                        return [2 /*return*/, {
-                                address: tzAddress,
-                                cursor: {
-                                    hasNext: true,
-                                    index: 0
-                                }
-                            }];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getInitialAddressesFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var tzAddress, ktAddresses, addresses;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.tezos.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        tzAddress = _a.sent();
-                        return [4 /*yield*/, this.indexerClient.getDelegatorContracts(tzAddress, INDEX_LIMIT)];
-                    case 2:
-                        ktAddresses = _a.sent();
-                        addresses = __spreadArray([tzAddress], ktAddresses, true);
-                        return [2 /*return*/, addresses.map(function (address, index) { return ({
-                                address: address,
-                                cursor: {
-                                    hasNext: index < addresses.length - 1,
-                                    index: index
-                                }
-                            }); })];
+    async getMetadata() {
+        const tezosMetadata = await this.tezos.getMetadata();
+        return {
+            ...tezosMetadata,
+            identifier: coinlib_core_1.SubProtocolSymbols.XTZ_KT,
+            account: {
+                ...(tezosMetadata.account ?? {}),
+                address: {
+                    ...(tezosMetadata.account?.address ?? {}),
+                    regex: '^(tz1|KT1)[1-9A-Za-z]{33}$'
                 }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getNextAddressFromPublicKey = function (publicKey, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var addresses, index;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!cursor.hasNext) {
-                            return [2 /*return*/, undefined];
-                        }
-                        return [4 /*yield*/, this.getInitialAddressesFromPublicKey(publicKey)];
-                    case 1:
-                        addresses = _a.sent();
-                        index = cursor.index + 1;
-                        return [2 /*return*/, addresses[index]];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.getDetailsFromTransaction(transaction, publicKey)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.verifyMessageWithPublicKey(message, signature, publicKey)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.encryptAsymmetricWithPublicKey(payload, publicKey)];
-            });
-        });
-    };
+            }
+        };
+    }
+    async getAddressFromPublicKey(publicKey) {
+        const tzAddress = await this.tezos.getAddressFromPublicKey(publicKey);
+        return {
+            address: tzAddress,
+            cursor: {
+                hasNext: true,
+                index: 0
+            }
+        };
+    }
+    async getInitialAddressesFromPublicKey(publicKey) {
+        const tzAddress = await this.tezos.getAddressFromPublicKey(publicKey);
+        const ktAddresses = await this.indexerClient.getDelegatorContracts(tzAddress, INDEX_LIMIT);
+        const addresses = [tzAddress, ...ktAddresses];
+        return addresses.map((address, index) => ({
+            address,
+            cursor: {
+                hasNext: index < addresses.length - 1,
+                index
+            }
+        }));
+    }
+    async getNextAddressFromPublicKey(publicKey, cursor) {
+        if (!cursor.hasNext) {
+            return undefined;
+        }
+        const addresses = await this.getInitialAddressesFromPublicKey(publicKey);
+        const index = cursor.index + 1;
+        return addresses[index];
+    }
+    async getDetailsFromTransaction(transaction, publicKey) {
+        return this.tezos.getDetailsFromTransaction(transaction, publicKey);
+    }
+    async verifyMessageWithPublicKey(message, signature, publicKey) {
+        return this.tezos.verifyMessageWithPublicKey(message, signature, publicKey);
+    }
+    async encryptAsymmetricWithPublicKey(payload, publicKey) {
+        return this.tezos.encryptAsymmetricWithPublicKey(payload, publicKey);
+    }
     // Offline
-    TezosKtProtocolImpl.prototype.getCryptoConfiguration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.getCryptoConfiguration()];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.getKeyPairFromDerivative(derivative)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.signTransactionWithSecretKey(transaction, secretKey)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.signMessageWithKeyPair(message, keyPair)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.decryptAsymmetricWithKeyPair(payload, keyPair)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.encryptAESWithSecretKey(payload, secretKey)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.decryptAESWithSecretKey(payload, secretKey)];
-            });
-        });
-    };
+    async getCryptoConfiguration() {
+        return this.tezos.getCryptoConfiguration();
+    }
+    async getKeyPairFromDerivative(derivative) {
+        return this.tezos.getKeyPairFromDerivative(derivative);
+    }
+    async signTransactionWithSecretKey(transaction, secretKey) {
+        return this.tezos.signTransactionWithSecretKey(transaction, secretKey);
+    }
+    async signMessageWithKeyPair(message, keyPair) {
+        return this.tezos.signMessageWithKeyPair(message, keyPair);
+    }
+    async decryptAsymmetricWithKeyPair(payload, keyPair) {
+        return this.decryptAsymmetricWithKeyPair(payload, keyPair);
+    }
+    async encryptAESWithSecretKey(payload, secretKey) {
+        return this.encryptAESWithSecretKey(payload, secretKey);
+    }
+    async decryptAESWithSecretKey(payload, secretKey) {
+        return this.decryptAESWithSecretKey(payload, secretKey);
+    }
     // Online
-    TezosKtProtocolImpl.prototype.getNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.getNetwork()];
-            });
-        });
-    };
-    TezosKtProtocolImpl.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.address, limit, cursor)];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var transactions;
-            var _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.tezos.getTransactionsForAddress(address, limit, this.toTezosTransactionCursor(cursor, address))];
-                    case 1:
-                        transactions = _c.sent();
-                        return [2 /*return*/, {
-                                transactions: transactions.transactions,
-                                cursor: {
-                                    hasNext: transactions.cursor.hasNext,
-                                    offsets: Object.assign((_a = cursor === null || cursor === void 0 ? void 0 : cursor.offsets) !== null && _a !== void 0 ? _a : {}, (_b = {}, _b[address] = transactions.cursor.offset, _b))
-                                }
-                            }];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getTransactionsForAddresses = function (addresses, limit, cursor) {
-        return __awaiter(this, void 0, void 0, function () {
-            var singleLimit, singleLimitCompensation, allTransactions;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (addresses.length === 0) {
-                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'At least one address must be provided.');
-                        }
-                        singleLimit = new bignumber_1.default(limit).div(addresses.length).decimalPlaces(0, bignumber_1.default.ROUND_FLOOR).toNumber();
-                        singleLimitCompensation = Math.max(limit - addresses.length * singleLimit, 0);
-                        return [4 /*yield*/, Promise.all(addresses.map(function (address, index) { return __awaiter(_this, void 0, void 0, function () {
-                                var limit, transactions;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            limit = index === 0 ? singleLimit + singleLimitCompensation : singleLimit;
-                                            return [4 /*yield*/, this.tezos.getTransactionsForAddress(address, limit, this.toTezosTransactionCursor(cursor, address))];
-                                        case 1:
-                                            transactions = _a.sent();
-                                            return [2 /*return*/, [address, transactions]];
-                                    }
-                                });
-                            }); }))];
-                    case 1:
-                        allTransactions = _a.sent();
-                        return [2 /*return*/, allTransactions.reduce(function (acc, next) {
-                                var _a;
-                                // tslint:disable-next-line: no-object-literal-type-assertion
-                                return {
-                                    transactions: acc.transactions.concat(next[1].transactions),
-                                    cursor: {
-                                        hasNext: acc.cursor.hasNext || next[1].cursor.hasNext,
-                                        offsets: Object.assign(acc.cursor.offsets, (_a = {}, _a[next[0]] = next[1].cursor.offset, _a))
-                                    }
-                                };
-                            }, {
-                                transactions: [],
-                                cursor: { hasNext: false, offsets: {} }
-                                // tslint:disable-next-line: no-object-literal-type-assertion
-                            })];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.getBalanceOfPublicKey(publicKey)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getBalanceOfAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.getBalanceOfAddress(address)];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getBalanceOfAddresses = function (addresses) {
-        return __awaiter(this, void 0, void 0, function () {
-            var metadata, allBalances;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getMetadata()];
-                    case 1:
-                        metadata = _a.sent();
-                        return [4 /*yield*/, Promise.all(addresses.map(function (address) { return _this.tezos.getBalanceOfAddress(address); }))];
-                    case 2:
-                        allBalances = _a.sent();
-                        return [2 /*return*/, allBalances.reduce(function (acc, next) { return ({
-                                total: (0, module_kit_1.newAmount)(new bignumber_1.default((0, module_kit_1.newAmount)(acc.total).blockchain(metadata.units).value).plus((0, module_kit_1.newAmount)(next.total).blockchain(metadata.units).value), 'blockchain')
-                            }); })];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, _to, _configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var balance;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 1:
-                        balance = _a.sent();
-                        return [2 /*return*/, balance.total];
+    async getNetwork() {
+        return this.tezos.getNetwork();
+    }
+    async getTransactionsForPublicKey(publicKey, limit, cursor) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getTransactionsForAddress(address.address, limit, cursor);
+    }
+    async getTransactionsForAddress(address, limit, cursor) {
+        const transactions = await this.tezos.getTransactionsForAddress(address, limit, this.toTezosTransactionCursor(cursor, address));
+        return {
+            transactions: transactions.transactions,
+            cursor: {
+                hasNext: transactions.cursor.hasNext,
+                offsets: Object.assign(cursor?.offsets ?? {}, { [address]: transactions.cursor.offset })
+            }
+        };
+    }
+    async getTransactionsForAddresses(addresses, limit, cursor) {
+        if (addresses.length === 0) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'At least one address must be provided.');
+        }
+        const singleLimit = new bignumber_1.default(limit).div(addresses.length).decimalPlaces(0, bignumber_1.default.ROUND_FLOOR).toNumber();
+        const singleLimitCompensation = Math.max(limit - addresses.length * singleLimit, 0);
+        const allTransactions = await Promise.all(addresses.map(async (address, index) => {
+            const limit = index === 0 ? singleLimit + singleLimitCompensation : singleLimit;
+            const transactions = await this.tezos.getTransactionsForAddress(address, limit, this.toTezosTransactionCursor(cursor, address));
+            return [address, transactions];
+        }));
+        return allTransactions.reduce((acc, next) => {
+            // tslint:disable-next-line: no-object-literal-type-assertion
+            return {
+                transactions: acc.transactions.concat(next[1].transactions),
+                cursor: {
+                    hasNext: acc.cursor.hasNext || next[1].cursor.hasNext,
+                    offsets: Object.assign(acc.cursor.offsets, { [next[0]]: next[1].cursor.offset })
                 }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (_publicKey, _details, _configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, (0, module_kit_1.newAmount)(MIGRATION_FEE, 'blockchain')];
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.prepareTransactionWithPublicKey = function (_publicKey, _details, _configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.TEZOS, 'sending funds from KT addresses is not supported. Please use the migration feature.');
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.broadcastTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.tezos.broadcastTransaction(transaction)];
-            });
+            };
+        }, {
+            transactions: [],
+            cursor: { hasNext: false, offsets: {} }
+            // tslint:disable-next-line: no-object-literal-type-assertion
         });
-    };
+    }
+    async getBalanceOfPublicKey(publicKey) {
+        return this.tezos.getBalanceOfPublicKey(publicKey);
+    }
+    async getBalanceOfAddress(address) {
+        return this.tezos.getBalanceOfAddress(address);
+    }
+    async getBalanceOfAddresses(addresses) {
+        const metadata = await this.getMetadata();
+        const allBalances = await Promise.all(addresses.map((address) => this.tezos.getBalanceOfAddress(address)));
+        return allBalances.reduce((acc, next) => ({
+            total: (0, module_kit_1.newAmount)(new bignumber_1.default((0, module_kit_1.newAmount)(acc.total).blockchain(metadata.units).value).plus((0, module_kit_1.newAmount)(next.total).blockchain(metadata.units).value), 'blockchain')
+        }));
+    }
+    async getTransactionMaxAmountWithPublicKey(publicKey, _to, _configuration) {
+        const balance = await this.getBalanceOfPublicKey(publicKey);
+        return balance.total;
+    }
+    async getTransactionFeeWithPublicKey(_publicKey, _details, _configuration) {
+        return (0, module_kit_1.newAmount)(MIGRATION_FEE, 'blockchain');
+    }
+    async prepareTransactionWithPublicKey(_publicKey, _details, _configuration) {
+        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.TEZOS, 'sending funds from KT addresses is not supported. Please use the migration feature.');
+    }
+    async broadcastTransaction(transaction) {
+        return this.tezos.broadcastTransaction(transaction);
+    }
     // Custom
-    TezosKtProtocolImpl.prototype.migrateKtContract = function (publicKey, destinationContract) {
-        return __awaiter(this, void 0, void 0, function () {
-            var metadata, counter, branch, operations, tzAddress, balanceOfManager, wrappedBalanceOfManager, amount, wrappedAmount, network, results, accountManager, hexDestination, spendOperation, tezosWrappedOperation, binaryTx, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getMetadata()];
-                    case 1:
-                        metadata = _a.sent();
-                        counter = new bignumber_1.default(1);
-                        branch = '';
-                        operations = [];
-                        return [4 /*yield*/, this.tezos.getAddressFromPublicKey(publicKey)];
-                    case 2:
-                        tzAddress = _a.sent();
-                        return [4 /*yield*/, this.tezos.getBalanceOfAddress(tzAddress)];
-                    case 3:
-                        balanceOfManager = _a.sent();
-                        wrappedBalanceOfManager = new bignumber_1.default((0, module_kit_1.newAmount)(balanceOfManager.total).blockchain(metadata.units).value);
-                        if (wrappedBalanceOfManager.isLessThan(MIGRATION_FEE)) {
-                            throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance on tz address for fee');
-                        }
-                        return [4 /*yield*/, this.getBalanceOfAddress(destinationContract)];
-                    case 4:
-                        amount = _a.sent();
-                        wrappedAmount = new bignumber_1.default((0, module_kit_1.newAmount)(amount.total).blockchain(metadata.units).value);
-                        return [4 /*yield*/, this.tezos.getNetwork()];
-                    case 5:
-                        network = _a.sent();
-                        return [4 /*yield*/, Promise.all([
-                                axios_0_19_0_1.default.get("".concat(network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(tzAddress, "/counter")),
-                                axios_0_19_0_1.default.get("".concat(network.rpcUrl, "/chains/main/blocks/head~2/hash")),
-                                axios_0_19_0_1.default.get("".concat(network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(tzAddress, "/manager_key"))
-                            ]).catch(function (error) {
-                                if (error.response && error.response.status !== 404) {
-                                    throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
-                                }
-                            })];
-                    case 6:
-                        results = (_a.sent());
-                        counter = new bignumber_1.default(results[0].data).plus(1);
-                        branch = results[1].data;
-                        accountManager = results[2].data;
-                        // check if we have revealed the address already
-                        if (!accountManager) {
-                            operations.push((0, operations_1.createRevealOperation)(counter, publicKey, tzAddress));
-                            counter = counter.plus(1);
-                        }
-                        hexDestination = (0, encoding_1.decodeBase58)(tzAddress).toString('hex');
-                        if (hexDestination.length > 42) {
-                            // must be less or equal 21 bytes
-                            throw new errors_1.InvalidValueError(coinlib_core_1.Domain.TEZOS, 'provided source is invalid');
-                        }
-                        while (hexDestination.length !== 42) {
-                            // fill up with 0s to match 21 bytes
-                            hexDestination = "0".concat(hexDestination);
-                        }
-                        spendOperation = {
-                            kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
-                            fee: MIGRATION_FEE.toString(),
-                            gas_limit: '26283',
-                            storage_limit: '0',
-                            amount: '0',
-                            counter: counter.toFixed(),
-                            destination: destinationContract,
-                            source: tzAddress,
-                            parameters: {
-                                entrypoint: 'do',
-                                value: [
-                                    { prim: 'DROP' },
-                                    { prim: 'NIL', args: [{ prim: 'operation' }] },
-                                    {
-                                        prim: 'PUSH',
-                                        args: [
-                                            { prim: 'key_hash' },
-                                            {
-                                                bytes: hexDestination
-                                            }
-                                        ]
-                                    },
-                                    { prim: 'IMPLICIT_ACCOUNT' },
-                                    {
-                                        prim: 'PUSH',
-                                        args: [{ prim: 'mutez' }, { int: wrappedAmount.toString(10) }]
-                                    },
-                                    { prim: 'UNIT' },
-                                    { prim: 'TRANSFER_TOKENS' },
-                                    { prim: 'CONS' }
-                                ]
+    async migrateKtContract(publicKey, destinationContract) {
+        const metadata = await this.getMetadata();
+        let counter = new bignumber_1.default(1);
+        let branch = '';
+        const operations = [];
+        const tzAddress = await this.tezos.getAddressFromPublicKey(publicKey);
+        const balanceOfManager = await this.tezos.getBalanceOfAddress(tzAddress);
+        const wrappedBalanceOfManager = new bignumber_1.default((0, module_kit_1.newAmount)(balanceOfManager.total).blockchain(metadata.units).value);
+        if (wrappedBalanceOfManager.isLessThan(MIGRATION_FEE)) {
+            throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance on tz address for fee');
+        }
+        const amount = await this.getBalanceOfAddress(destinationContract);
+        const wrappedAmount = new bignumber_1.default((0, module_kit_1.newAmount)(amount.total).blockchain(metadata.units).value);
+        const network = await this.tezos.getNetwork();
+        const results = (await Promise.all([
+            axios_0_19_0_1.default.get(`${network.rpcUrl}/chains/main/blocks/head/context/contracts/${tzAddress}/counter`),
+            axios_0_19_0_1.default.get(`${network.rpcUrl}/chains/main/blocks/head~2/hash`),
+            axios_0_19_0_1.default.get(`${network.rpcUrl}/chains/main/blocks/head/context/contracts/${tzAddress}/manager_key`)
+        ]).catch((error) => {
+            if (error.response && error.response.status !== 404) {
+                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+            }
+        }));
+        counter = new bignumber_1.default(results[0].data).plus(1);
+        branch = results[1].data;
+        const accountManager = results[2].data;
+        // check if we have revealed the address already
+        if (!accountManager) {
+            operations.push((0, operations_1.createRevealOperation)(counter, publicKey, tzAddress));
+            counter = counter.plus(1);
+        }
+        let hexDestination = (0, encoding_1.decodeBase58)(tzAddress).toString('hex');
+        if (hexDestination.length > 42) {
+            // must be less or equal 21 bytes
+            throw new errors_1.InvalidValueError(coinlib_core_1.Domain.TEZOS, 'provided source is invalid');
+        }
+        while (hexDestination.length !== 42) {
+            // fill up with 0s to match 21 bytes
+            hexDestination = `0${hexDestination}`;
+        }
+        // Taken from https://blog.nomadic-labs.com/babylon-update-instructions-for-delegation-wallet-developers.html#transfer-from-a-managertz-smart-contract-to-an-implicit-tz-account
+        const spendOperation = {
+            kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
+            fee: MIGRATION_FEE.toString(),
+            gas_limit: '26283',
+            storage_limit: '0',
+            amount: '0',
+            counter: counter.toFixed(),
+            destination: destinationContract,
+            source: tzAddress,
+            parameters: {
+                entrypoint: 'do',
+                value: [
+                    { prim: 'DROP' },
+                    { prim: 'NIL', args: [{ prim: 'operation' }] },
+                    {
+                        prim: 'PUSH',
+                        args: [
+                            { prim: 'key_hash' },
+                            {
+                                bytes: hexDestination
                             }
-                        };
-                        operations.push(spendOperation);
-                        _a.label = 7;
-                    case 7:
-                        _a.trys.push([7, 9, , 10]);
-                        tezosWrappedOperation = {
-                            branch: branch,
-                            contents: operations
-                        };
-                        return [4 /*yield*/, this.tezos.forgeOperation(tezosWrappedOperation)];
-                    case 8:
-                        binaryTx = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({ binary: binaryTx })];
-                    case 9:
-                        error_1 = _a.sent();
-                        console.warn(error_1.message);
-                        throw new errors_1.OperationFailedError(coinlib_core_1.Domain.TEZOS, 'Forging Tezos TX failed.');
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    TezosKtProtocolImpl.prototype.toTezosTransactionCursor = function (cursor, address) {
+                        ]
+                    },
+                    { prim: 'IMPLICIT_ACCOUNT' },
+                    {
+                        prim: 'PUSH',
+                        args: [{ prim: 'mutez' }, { int: wrappedAmount.toString(10) }]
+                    },
+                    { prim: 'UNIT' },
+                    { prim: 'TRANSFER_TOKENS' },
+                    { prim: 'CONS' }
+                ]
+            }
+        };
+        operations.push(spendOperation);
+        try {
+            const tezosWrappedOperation = {
+                branch,
+                contents: operations
+            };
+            const binaryTx = await this.tezos.forgeOperation(tezosWrappedOperation);
+            return (0, module_kit_1.newUnsignedTransaction)({ binary: binaryTx });
+        }
+        catch (error) {
+            console.warn(error.message);
+            throw new errors_1.OperationFailedError(coinlib_core_1.Domain.TEZOS, 'Forging Tezos TX failed.');
+        }
+    }
+    toTezosTransactionCursor(cursor, address) {
         return cursor && cursor.offsets[address] ? { hasNext: cursor.hasNext, offset: cursor.offsets[address] } : undefined;
-    };
-    return TezosKtProtocolImpl;
-}());
+    }
+}
 // Factory
-function createTezosKtProtocol(options) {
-    if (options === void 0) { options = {}; }
+function createTezosKtProtocol(options = {}) {
     return new TezosKtProtocolImpl(options);
 }
-exports.createTezosKtProtocol = createTezosKtProtocol;
 //# sourceMappingURL=TezosKtProtocol.js.map