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

package/v1/protocol/kt/TezosKtProtocol.js

@@ -1,277 +1,521 @@
 "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 = 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");
+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");
 // Implementation
-const INDEX_LIMIT = 10000;
-const MIGRATION_FEE = 5000;
-class TezosKtProtocolImpl {
-    constructor(options) {
-        const completeOptions = (0, TezosProtocol_1.createTezosProtocolOptions)(options.network);
+var INDEX_LIMIT = 10000;
+var MIGRATION_FEE = 5000;
+var TezosKtProtocolImpl = /** @class */ (function () {
+    function TezosKtProtocolImpl(options) {
+        var 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
-    async getType() {
-        return 'account';
-    }
-    async mainProtocol() {
-        return coinlib_core_1.MainProtocolSymbols.XTZ;
-    }
+    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];
+            });
+        });
+    };
     // Common
-    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.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}$' }) }) })];
                 }
-            }
-        };
-    }
-    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);
-    }
+            });
+        });
+    };
+    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
+                                }
+                            }); })];
+                }
+            });
+        });
+    };
+    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)];
+            });
+        });
+    };
     // Offline
-    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);
-    }
+    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)];
+            });
+        });
+    };
     // Online
-    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.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)];
                 }
-            };
-        }, {
-            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);
-    }
+    };
+    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];
+                }
+            });
+        });
+    };
+    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)];
+            });
+        });
+    };
     // Custom
-    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
+    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' }
+                                ]
                             }
-                        ]
-                    },
-                    { 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) {
+                        };
+                        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) {
         return cursor && cursor.offsets[address] ? { hasNext: cursor.hasNext, offset: cursor.offsets[address] } : undefined;
-    }
-}
+    };
+    return TezosKtProtocolImpl;
+}());
 // Factory
-function createTezosKtProtocol(options = {}) {
+function createTezosKtProtocol(options) {
+    if (options === void 0) { options = {}; }
     return new TezosKtProtocolImpl(options);
 }
+exports.createTezosKtProtocol = createTezosKtProtocol;
 //# sourceMappingURL=TezosKtProtocol.js.map