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

package/v1/protocol/TezosProtocol.js

@@ -1,84 +1,39 @@
 "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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTezosProtocolOptions = exports.TEZOS_GHOSTNET_PROTOCOL_NETWORK = exports.TEZOS_MAINNET_PROTOCOL_NETWORK = exports.createTezosProtocol = exports.TezosProtocolImpl = exports.TEZOS_ACCOUNT_METADATA = exports.TEZOS_DERIVATION_PATH = exports.TEZOS_UNITS = void 0;
-var coinlib_core_1 = require("@airgap/coinlib-core");
-var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-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 TezosCryptoClient_1 = require("../crypto/TezosCryptoClient");
-var TezosAddress_1 = require("../data/TezosAddress");
-var factory_1 = require("../indexer/factory");
-var network_1 = require("../types/network");
-var TezosOperationType_1 = require("../types/operations/TezosOperationType");
-var TezosDelegatorAction_1 = require("../types/staking/TezosDelegatorAction");
-var key_1 = require("../utils/key");
-var operations_1 = require("../utils/operations");
-var TezosAccountant_1 = require("../utils/protocol/tezos/TezosAccountant");
-var TezosForger_1 = require("../utils/protocol/tezos/TezosForger");
-var signature_1 = require("../utils/signature");
+exports.TEZOS_GHOSTNET_PROTOCOL_NETWORK = exports.TEZOS_MAINNET_PROTOCOL_NETWORK = exports.TezosProtocolImpl = exports.TEZOS_ACCOUNT_METADATA = exports.TEZOS_DERIVATION_PATH = exports.TEZOS_UNITS = void 0;
+exports.createTezosProtocol = createTezosProtocol;
+exports.createTezosProtocolOptions = createTezosProtocolOptions;
+const coinlib_core_1 = require("@airgap/coinlib-core");
+const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+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 TezosCryptoClient_1 = require("../crypto/TezosCryptoClient");
+const TezosAddress_1 = require("../data/TezosAddress");
+const factory_1 = require("../indexer/factory");
+const network_1 = require("../types/network");
+const TezosOperationType_1 = require("../types/operations/TezosOperationType");
+const TezosDelegatorAction_1 = require("../types/staking/TezosDelegatorAction");
+const key_1 = require("../utils/key");
+const operations_1 = require("../utils/operations");
+const TezosAccountant_1 = require("../utils/protocol/tezos/TezosAccountant");
+const TezosForger_1 = require("../utils/protocol/tezos/TezosForger");
+const signature_1 = require("../utils/signature");
 // Implementation
-var MAX_OPERATIONS_PER_GROUP = 200;
-var MIN_CYCLE_DURATION = 4096 * 60 * 1000; // ms
+const MAX_OPERATIONS_PER_GROUP = 200;
+const MIN_CYCLE_DURATION = 4096 * 60 * 1000; // ms
 // const MAX_GAS_PER_BLOCK: number = 2600000
-var MAX_GAS_PER_BLOCK = 1040000;
-var GAS_LIMIT_PLACEHOLDER = '1040000';
-var STORAGE_LIMIT_PLACEHOLDER = '60000';
-var FEE_PLACEHOLDER = '0';
-var MINIMAL_FEE = 100;
-var MINIMAL_FEE_PER_GAS_UNIT = 0.1;
-var MINIMAL_FEE_PER_BYTE = 1;
-var SELF_BOND_REQUIREMENT = 0.0825; // 8.25%
+const MAX_GAS_PER_BLOCK = 1386666;
+const GAS_LIMIT_PLACEHOLDER = '1040000';
+const STORAGE_LIMIT_PLACEHOLDER = '60000';
+const FEE_PLACEHOLDER = '0';
+const MINIMAL_FEE = 100;
+const MINIMAL_FEE_PER_GAS_UNIT = 0.1;
+const MINIMAL_FEE_PER_BYTE = 1;
+const SELF_BOND_REQUIREMENT = 0.0825; // 8.25%
 exports.TEZOS_UNITS = {
     tez: {
         symbol: { value: 'XTZ', market: 'xtz' },
@@ -93,7 +48,7 @@ exports.TEZOS_UNITS = {
         decimals: -3
     }
 };
-exports.TEZOS_DERIVATION_PATH = "m/44h/1729h/0h/0h";
+exports.TEZOS_DERIVATION_PATH = `m/44h/1729h/0h/0h`;
 exports.TEZOS_ACCOUNT_METADATA = {
     standardDerivationPath: exports.TEZOS_DERIVATION_PATH,
     address: {
@@ -102,8 +57,8 @@ exports.TEZOS_ACCOUNT_METADATA = {
         regex: '^((tz1|tz2|tz3|tz4|KT1)[1-9A-Za-z]{33}|zet1[1-9A-Za-z]{65})$'
     }
 };
-var TezosProtocolImpl = /** @class */ (function () {
-    function TezosProtocolImpl(options) {
+class TezosProtocolImpl {
+    constructor(options) {
         this.isTezosProtocol = true;
         // Common
         this.units = exports.TEZOS_UNITS;
@@ -132,1343 +87,853 @@ var TezosProtocolImpl = /** @class */ (function () {
         this.indexerClient = (0, factory_1.createTezosIndexerClient)(this.options.network.indexerType, this.options.network.indexerApi);
         this.cryptoClient = new TezosCryptoClient_1.TezosCryptoClient();
     }
-    TezosProtocolImpl.prototype.getMetadata = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.metadata];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, TezosAddress_1.TezosAddress.fromPublicKey(publicKey).asString()];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountant.getDetailsFromTransaction(transaction)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var encodedSignature, hexPublicKey;
-            return __generator(this, function (_a) {
-                encodedSignature = (0, signature_1.convertSignature)(signature, 'encoded');
-                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.verifyMessage(message, encodedSignature.value, hexPublicKey.value)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexPublicKey;
-            return __generator(this, function (_a) {
-                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getCryptoConfiguration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.cryptoConfiguration];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                // should we maybe return encoded keys, i.e. edsk... and edpk... strings?
-                return [2 /*return*/, {
-                        secretKey: (0, module_kit_1.newSecretKey)(Buffer.concat([Buffer.from(derivative.secretKey, 'hex'), Buffer.from(derivative.publicKey, 'hex')]).toString('hex'), 'hex'),
-                        publicKey: (0, module_kit_1.newPublicKey)(derivative.publicKey, 'hex')
-                    }];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey, binaryTransaction, opSignature, signedOp;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-                binaryTransaction = Buffer.from(transaction.binary, 'hex');
-                opSignature = this.cryptoClient.operationSignature(Buffer.from(hexSecretKey.value, 'hex'), binaryTransaction);
-                signedOp = Buffer.concat([binaryTransaction, opSignature]);
-                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ binary: signedOp.toString('hex') })];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey, signature;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
-                        return [4 /*yield*/, this.cryptoClient.signMessage(message, { privateKey: hexSecretKey.value })];
-                    case 1:
-                        signature = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newSignature)(signature, 'encoded')];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey, hexPublicKey;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
-                hexPublicKey = (0, key_1.convertPublicKey)(keyPair.publicKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(payload, { publicKey: hexPublicKey.value, privateKey: hexSecretKey.value })];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.encryptAES(payload, hexSecretKey.value)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var hexSecretKey;
-            return __generator(this, function (_a) {
-                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
-                return [2 /*return*/, this.cryptoClient.decryptAES(payload, hexSecretKey.value)];
-            });
-        });
-    };
+    async getMetadata() {
+        return this.metadata;
+    }
+    async getAddressFromPublicKey(publicKey) {
+        return TezosAddress_1.TezosAddress.fromPublicKey(publicKey).asString();
+    }
+    async getDetailsFromTransaction(transaction, _publicKey) {
+        return this.accountant.getDetailsFromTransaction(transaction);
+    }
+    async verifyMessageWithPublicKey(message, signature, publicKey) {
+        const encodedSignature = (0, signature_1.convertSignature)(signature, 'encoded');
+        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+        return this.cryptoClient.verifyMessage(message, encodedSignature.value, hexPublicKey.value);
+    }
+    async encryptAsymmetricWithPublicKey(payload, publicKey) {
+        const hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+        return this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value);
+    }
+    async getCryptoConfiguration() {
+        return this.cryptoConfiguration;
+    }
+    async getKeyPairFromDerivative(derivative) {
+        // should we maybe return encoded keys, i.e. edsk... and edpk... strings?
+        return {
+            secretKey: (0, module_kit_1.newSecretKey)(Buffer.concat([Buffer.from(derivative.secretKey, 'hex'), Buffer.from(derivative.publicKey, 'hex')]).toString('hex'), 'hex'),
+            publicKey: (0, module_kit_1.newPublicKey)(derivative.publicKey, 'hex')
+        };
+    }
+    async signTransactionWithSecretKey(transaction, secretKey) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+        const binaryTransaction = Buffer.from(transaction.binary, 'hex');
+        const opSignature = this.cryptoClient.operationSignature(Buffer.from(hexSecretKey.value, 'hex'), binaryTransaction);
+        const signedOp = Buffer.concat([binaryTransaction, opSignature]);
+        return (0, module_kit_1.newSignedTransaction)({ binary: signedOp.toString('hex') });
+    }
+    async signMessageWithKeyPair(message, keyPair) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
+        const signature = await this.cryptoClient.signMessage(message, { privateKey: hexSecretKey.value });
+        return (0, module_kit_1.newSignature)(signature, 'encoded');
+    }
+    async decryptAsymmetricWithKeyPair(payload, keyPair) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
+        const hexPublicKey = (0, key_1.convertPublicKey)(keyPair.publicKey, 'hex');
+        return this.cryptoClient.decryptAsymmetric(payload, { publicKey: hexPublicKey.value, privateKey: hexSecretKey.value });
+    }
+    async encryptAESWithSecretKey(payload, secretKey) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+        return this.cryptoClient.encryptAES(payload, hexSecretKey.value);
+    }
+    async decryptAESWithSecretKey(payload, secretKey) {
+        const hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+        return this.cryptoClient.decryptAES(payload, hexSecretKey.value);
+    }
     // Online
-    TezosProtocolImpl.prototype.getNetwork = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.options.network];
-            });
-        });
-    };
-    TezosProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var transactions;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.indexerClient.getTransactions(address, limit, cursor === null || cursor === void 0 ? void 0 : cursor.offset)];
-                    case 1:
-                        transactions = _b.sent();
-                        return [2 /*return*/, {
-                                transactions: transactions.map(function (transaction) { return (__assign(__assign({}, transaction), { network: _this.options.network })); }),
-                                cursor: {
-                                    hasNext: transactions.length >= limit,
-                                    offset: ((_a = cursor === null || cursor === void 0 ? void 0 : cursor.offset) !== null && _a !== void 0 ? _a : 0) + transactions.length
-                                }
-                            }];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.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)];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getstakeBalance = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, stakeBalance;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/staked_balance"))];
-                    case 1:
-                        data = (_a.sent()).data;
-                        stakeBalance = new bignumber_1.default(data ? data : '0');
-                        return [2 /*return*/, { total: (0, module_kit_1.newAmount)(stakeBalance, 'blockchain') }];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getUnstakeBalance = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, unstakeBalance;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/unstaked_frozen_balance"))];
-                    case 1:
-                        data = (_a.sent()).data;
-                        unstakeBalance = new bignumber_1.default(data ? data : '0');
-                        return [2 /*return*/, { total: (0, module_kit_1.newAmount)(unstakeBalance, 'blockchain') }];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getUnfinalizeRequest = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, unfinalizable;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/unstake_requests"))];
-                    case 1:
-                        data = (_a.sent()).data;
-                        unfinalizable = data
-                            ? data.unfinalizable
-                            : {
-                                requests: []
-                            };
-                        return [2 /*return*/, unfinalizable];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getFinalizeableBalance = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, stakeBalance;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/unstaked_finalizable_balance"))];
-                    case 1:
-                        data = (_a.sent()).data;
-                        stakeBalance = new bignumber_1.default(data ? data : '0');
-                        return [2 /*return*/, { total: (0, module_kit_1.newAmount)(stakeBalance, 'blockchain') }];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getBalanceOfAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var transferableBalance, totalBalance, data, _a, stakeBalance, unstakeBalance, finalizeableBalance, error_1, error_2;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        transferableBalance = new bignumber_1.default(0);
-                        totalBalance = new bignumber_1.default(0);
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 7, , 8]);
-                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/balance"))];
-                    case 2:
-                        data = (_b.sent()).data;
-                        _b.label = 3;
-                    case 3:
-                        _b.trys.push([3, 5, , 6]);
-                        return [4 /*yield*/, Promise.all([
-                                this.getstakeBalance(address),
-                                this.getUnstakeBalance(address),
-                                this.getFinalizeableBalance(address)
-                            ])];
-                    case 4:
-                        _a = _b.sent(), stakeBalance = _a[0], unstakeBalance = _a[1], finalizeableBalance = _a[2];
-                        transferableBalance = new bignumber_1.default(data);
-                        totalBalance = transferableBalance
-                            .plus(stakeBalance.total.value)
-                            .plus(unstakeBalance.total.value)
-                            .plus(finalizeableBalance.total.value);
-                        return [3 /*break*/, 6];
-                    case 5:
-                        error_1 = _b.sent();
-                        transferableBalance = new bignumber_1.default(data);
-                        totalBalance = transferableBalance;
-                        return [3 /*break*/, 6];
-                    case 6: return [3 /*break*/, 8];
-                    case 7:
-                        error_2 = _b.sent();
-                        // if node returns 404 (which means 'no account found'), go with 0 balance
-                        if (error_2.response && error_2.response.status !== 404) {
-                            throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error_2);
-                        }
-                        return [3 /*break*/, 8];
-                    case 8: return [2 /*return*/, { total: (0, module_kit_1.newAmount)(totalBalance, 'blockchain'), transferable: (0, module_kit_1.newAmount)(transferableBalance, 'blockchain') }];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var total, adjustedTotal;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 1:
-                        total = (_a.sent()).total;
-                        adjustedTotal = new bignumber_1.default((0, module_kit_1.newAmount)(total).convert('mutez', this.units).value).minus(1) // Tezos accounts can never be empty. We must leave at least 1 mutez behind.
-                        ;
-                        return [2 /*return*/, this.getTansactionMaxAmountWithBalance(publicKey, adjustedTotal, to, configuration === null || configuration === void 0 ? void 0 : configuration.fee)];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getTansactionMaxAmountWithBalance = function (publicKey, balance, to, fee) {
-        return __awaiter(this, void 0, void 0, function () {
-            var maxFee, estimatedFee, error_3, rpcErrors, balanceTooLowError, excess, newMaxBalance, amountWithoutFees;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(fee !== undefined)) return [3 /*break*/, 1];
-                        maxFee = fee;
-                        return [3 /*break*/, 4];
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, to.map(function (recipient) { return ({
-                                to: recipient,
-                                amount: (0, module_kit_1.newAmount)(balance.div(to.length).decimalPlaces(0, bignumber_1.default.ROUND_CEIL), 'blockchain')
-                            }); }))];
-                    case 2:
-                        estimatedFee = _a.sent();
-                        maxFee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(this.units);
-                        if (balance.lte(maxFee.value)) {
-                            maxFee = (0, module_kit_1.newAmount)(0, 'blockchain');
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_3 = _a.sent();
-                        if (error_3.code !== undefined && error_3.code === errors_1.ProtocolErrorType.TRANSACTION_FAILED && Array.isArray(error_3.data)) {
-                            rpcErrors = error_3.data;
-                            balanceTooLowError = rpcErrors.find(function (error) { return error.id.endsWith('.contract.balance_too_low'); });
-                            if (balanceTooLowError !== undefined && balanceTooLowError.amount !== undefined && balanceTooLowError.balance !== undefined) {
-                                excess = new bignumber_1.default(balanceTooLowError.amount).minus(new bignumber_1.default(balanceTooLowError.balance).minus(1));
-                                newMaxBalance = balance.minus(excess);
-                                if (newMaxBalance.gt(0)) {
-                                    return [2 /*return*/, this.getTansactionMaxAmountWithBalance(publicKey, newMaxBalance, to, fee)];
-                                }
-                            }
-                        }
-                        throw error_3;
-                    case 4:
-                        maxFee = (0, module_kit_1.newAmount)(maxFee).blockchain(this.units);
-                        amountWithoutFees = balance.minus(maxFee.value);
-                        if (amountWithoutFees.isNegative()) {
-                            amountWithoutFees = new bignumber_1.default(0);
-                        }
-                        return [2 /*return*/, (0, module_kit_1.newAmount)(amountWithoutFees, 'blockchain')];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, _configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getTransactionFee(publicKey, details)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getTransactionFee = function (publicKey, details, parameters) {
-        return __awaiter(this, void 0, void 0, function () {
-            var operations, i, recipient, transaction;
-            return __generator(this, function (_a) {
-                if (details.length === 0) {
-                    return [2 /*return*/, this.feeDefaults];
-                }
-                operations = [];
-                for (i = 0; i < details.length; ++i) {
-                    recipient = details[i].to;
-                    transaction = {
-                        kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
-                        amount: (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.units).value,
-                        destination: recipient,
-                        fee: '0',
-                        parameters: parameters
-                    };
-                    operations.push(transaction);
-                }
-                return [2 /*return*/, this.getOperationFeeDefaults(publicKey, operations)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getOperationFeeDefaults = function (publicKey, operations) {
-        return __awaiter(this, void 0, void 0, function () {
-            var estimated, hasReveal, estimatedFee, feeStepFactor, lowFee, mediumFee, highFee;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.prepareOperations(publicKey, operations)];
-                    case 1:
-                        estimated = _a.sent();
-                        hasReveal = estimated.contents.some(function (op) { return op.kind === TezosOperationType_1.TezosOperationType.REVEAL; });
-                        estimatedFee = estimated.contents
-                            .reduce(function (current, next) {
-                            if (next.fee !== undefined) {
-                                return current.plus(new bignumber_1.default(next.fee));
-                            }
-                            return current;
-                        }, new bignumber_1.default(0))
-                            .minus(hasReveal ? operations_1.REVEAL_FEE : 0)
-                            .div(hasReveal ? estimated.contents.length - 1 : estimated.contents.length);
-                        feeStepFactor = new bignumber_1.default(0.2);
-                        lowFee = estimatedFee;
-                        mediumFee = lowFee.plus(lowFee.times(feeStepFactor).integerValue(bignumber_1.default.ROUND_FLOOR));
-                        highFee = mediumFee.plus(mediumFee.times(feeStepFactor).integerValue(bignumber_1.default.ROUND_FLOOR));
-                        return [2 /*return*/, {
-                                low: (0, module_kit_1.newAmount)(lowFee, 'blockchain'),
-                                medium: (0, module_kit_1.newAmount)(mediumFee, 'blockchain'),
-                                high: (0, module_kit_1.newAmount)(highFee, 'blockchain')
-                            }];
+    async getNetwork() {
+        return this.options.network;
+    }
+    async getTransactionsForPublicKey(publicKey, limit, cursor) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getTransactionsForAddress(address, limit, cursor);
+    }
+    async getTransactionsForAddress(address, limit, cursor) {
+        const transactions = await this.indexerClient.getTransactions(address, limit, cursor?.offset);
+        return {
+            transactions: transactions.map((transaction) => ({
+                ...transaction,
+                network: this.options.network
+            })),
+            cursor: {
+                hasNext: transactions.length >= limit,
+                offset: (cursor?.offset ?? 0) + transactions.length
+            }
+        };
+    }
+    async getBalanceOfPublicKey(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getBalanceOfAddress(address);
+    }
+    async getstakeBalance(address) {
+        const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/staked_balance`);
+        const stakeBalance = new bignumber_1.default(data ? data : '0');
+        return { total: (0, module_kit_1.newAmount)(stakeBalance, 'blockchain') };
+    }
+    async getUnstakeBalance(address) {
+        const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/unstaked_frozen_balance`);
+        const unstakeBalance = new bignumber_1.default(data ? data : '0');
+        return { total: (0, module_kit_1.newAmount)(unstakeBalance, 'blockchain') };
+    }
+    async getUnfinalizeRequest(address) {
+        const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/unstake_requests`);
+        const unfinalizable = data
+            ? data.unfinalizable
+            : {
+                requests: []
+            };
+        return unfinalizable;
+    }
+    async getFinalizeableBalance(address) {
+        const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/unstaked_finalizable_balance`);
+        const stakeBalance = new bignumber_1.default(data ? data : '0');
+        return { total: (0, module_kit_1.newAmount)(stakeBalance, 'blockchain') };
+    }
+    async getBalanceOfAddress(address) {
+        let transferableBalance = new bignumber_1.default(0);
+        let totalBalance = new bignumber_1.default(0);
+        try {
+            const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/balance`);
+            try {
+                const [stakeBalance, unstakeBalance, finalizeableBalance] = await Promise.all([
+                    this.getstakeBalance(address),
+                    this.getUnstakeBalance(address),
+                    this.getFinalizeableBalance(address)
+                ]);
+                transferableBalance = new bignumber_1.default(data);
+                totalBalance = transferableBalance
+                    .plus(stakeBalance.total.value)
+                    .plus(unstakeBalance.total.value)
+                    .plus(finalizeableBalance.total.value);
+            }
+            catch (error) {
+                transferableBalance = new bignumber_1.default(data);
+                totalBalance = transferableBalance;
+            }
+        }
+        catch (error) {
+            // if node returns 404 (which means 'no account found'), go with 0 balance
+            if (error.response && error.response.status !== 404) {
+                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+            }
+        }
+        return { total: (0, module_kit_1.newAmount)(totalBalance, 'blockchain'), transferable: (0, module_kit_1.newAmount)(transferableBalance, 'blockchain') };
+    }
+    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
+        const { total } = await this.getBalanceOfPublicKey(publicKey);
+        const adjustedTotal = new bignumber_1.default((0, module_kit_1.newAmount)(total).convert('mutez', this.units).value).minus(1); // Tezos accounts can never be empty. We must leave at least 1 mutez behind.
+        return this.getTansactionMaxAmountWithBalance(publicKey, adjustedTotal, to, configuration?.fee);
+    }
+    async getTansactionMaxAmountWithBalance(publicKey, balance, to, fee) {
+        let maxFee;
+        if (fee !== undefined) {
+            maxFee = fee;
+        }
+        else {
+            try {
+                const estimatedFee = await this.getTransactionFeeWithPublicKey(publicKey, to.map((recipient) => ({
+                    to: recipient,
+                    amount: (0, module_kit_1.newAmount)(balance.div(to.length).decimalPlaces(0, bignumber_1.default.ROUND_CEIL), 'blockchain')
+                })));
+                maxFee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(this.units);
+                if (balance.lte(maxFee.value)) {
+                    maxFee = (0, module_kit_1.newAmount)(0, 'blockchain');
                 }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            var transactions;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (details.length > MAX_OPERATIONS_PER_GROUP) {
-                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, "this transaction exceeds the maximum allowed number of transactions per operation (".concat(MAX_OPERATIONS_PER_GROUP, "). Please use the \"prepareTransactionsFromPublicKey\" method instead."));
-                        }
-                        return [4 /*yield*/, this.prepareTransactionsWithPublicKey(publicKey, details, configuration)];
-                    case 1:
-                        transactions = _a.sent();
-                        if (transactions.length === 1) {
-                            return [2 /*return*/, transactions[0]];
-                        }
-                        else {
-                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'Transaction could not be prepared. More or less than 1 operations have been generated.');
+            }
+            catch (error) {
+                if (error.code !== undefined && error.code === errors_1.ProtocolErrorType.TRANSACTION_FAILED && Array.isArray(error.data)) {
+                    const rpcErrors = error.data;
+                    const balanceTooLowError = rpcErrors.find((error) => error.id.endsWith('.contract.balance_too_low'));
+                    if (balanceTooLowError !== undefined && balanceTooLowError.amount !== undefined && balanceTooLowError.balance !== undefined) {
+                        const excess = new bignumber_1.default(balanceTooLowError.amount).minus(new bignumber_1.default(balanceTooLowError.balance).minus(1));
+                        const newMaxBalance = balance.minus(excess);
+                        if (newMaxBalance.gt(0)) {
+                            return this.getTansactionMaxAmountWithBalance(publicKey, newMaxBalance, to, fee);
                         }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.broadcastTransaction = function (transaction) {
-        return __awaiter(this, void 0, void 0, function () {
-            var injectionResponse;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default
-                            .post("".concat(this.options.network.rpcUrl, "/injection/operation?chain=main"), JSON.stringify(transaction.binary), {
-                            headers: { 'content-type': 'application/json' }
-                        })
-                            .catch(function (error) {
-                            throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
-                        })
-                        // returns hash if successful
-                    ];
-                    case 1:
-                        injectionResponse = (_a.sent()).data;
-                        // returns hash if successful
-                        return [2 /*return*/, injectionResponse];
+                    }
                 }
-            });
-        });
-    };
+                throw error;
+            }
+        }
+        maxFee = (0, module_kit_1.newAmount)(maxFee).blockchain(this.units);
+        let amountWithoutFees = balance.minus(maxFee.value);
+        if (amountWithoutFees.isNegative()) {
+            amountWithoutFees = new bignumber_1.default(0);
+        }
+        return (0, module_kit_1.newAmount)(amountWithoutFees, 'blockchain');
+    }
+    async getTransactionFeeWithPublicKey(publicKey, details, _configuration) {
+        return await this.getTransactionFee(publicKey, details);
+    }
+    async getTransactionFee(publicKey, details, parameters) {
+        if (details.length === 0) {
+            return this.feeDefaults;
+        }
+        const operations = [];
+        for (let i = 0; i < details.length; ++i) {
+            const recipient = details[i].to;
+            const transaction = {
+                kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
+                amount: (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.units).value,
+                destination: recipient,
+                fee: '0',
+                parameters
+            };
+            operations.push(transaction);
+        }
+        return this.getOperationFeeDefaults(publicKey, operations);
+    }
+    async getOperationFeeDefaults(publicKey, operations) {
+        const estimated = await this.prepareOperations(publicKey, operations);
+        const hasReveal = estimated.contents.some((op) => op.kind === TezosOperationType_1.TezosOperationType.REVEAL);
+        const estimatedFee = estimated.contents
+            .reduce((current, next) => {
+            if (next.fee !== undefined) {
+                return current.plus(new bignumber_1.default(next.fee));
+            }
+            return current;
+        }, new bignumber_1.default(0))
+            .minus(hasReveal ? operations_1.REVEAL_FEE : 0)
+            .div(hasReveal ? estimated.contents.length - 1 : estimated.contents.length);
+        const feeStepFactor = new bignumber_1.default(0.2);
+        const lowFee = estimatedFee;
+        const mediumFee = lowFee.plus(lowFee.times(feeStepFactor).integerValue(bignumber_1.default.ROUND_FLOOR));
+        const highFee = mediumFee.plus(mediumFee.times(feeStepFactor).integerValue(bignumber_1.default.ROUND_FLOOR));
+        return {
+            low: (0, module_kit_1.newAmount)(lowFee, 'blockchain'),
+            medium: (0, module_kit_1.newAmount)(mediumFee, 'blockchain'),
+            high: (0, module_kit_1.newAmount)(highFee, 'blockchain')
+        };
+    }
+    async prepareTransactionWithPublicKey(publicKey, details, configuration) {
+        if (details.length > MAX_OPERATIONS_PER_GROUP) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, `this transaction exceeds the maximum allowed number of transactions per operation (${MAX_OPERATIONS_PER_GROUP}). Please use the "prepareTransactionsFromPublicKey" method instead.`);
+        }
+        const transactions = await this.prepareTransactionsWithPublicKey(publicKey, details, configuration);
+        if (transactions.length === 1) {
+            return transactions[0];
+        }
+        else {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'Transaction could not be prepared. More or less than 1 operations have been generated.');
+        }
+    }
+    async broadcastTransaction(transaction) {
+        const { data: injectionResponse } = await index_1.default
+            .post(`${this.options.network.rpcUrl}/injection/operation?chain=main`, JSON.stringify(transaction.binary), {
+            headers: { 'content-type': 'application/json' }
+        })
+            .catch((error) => {
+            throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+        });
+        // returns hash if successful
+        return injectionResponse;
+    }
     // Staking
-    TezosProtocolImpl.prototype.getDefaultDelegatee = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var activeBakers;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates?active"))];
-                    case 1:
-                        activeBakers = (_a.sent()).data;
-                        return [2 /*return*/, activeBakers[0] || ''];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getCurrentDelegateesForPublicKey = 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.getCurrentDelegateesForAddress(address)];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getCurrentDelegateesForAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address))];
-                    case 1:
-                        data = (_a.sent()).data;
-                        return [2 /*return*/, data.delegate ? [data.delegate] : []];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getDelegateeDetails = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, isBakingActive;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/deactivated"))];
-                    case 1:
-                        response = _a.sent();
-                        isBakingActive = !response.data;
-                        return [2 /*return*/, {
-                                status: isBakingActive ? 'Active' : 'Inactive',
-                                address: address
-                            }];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.isPublicKeyDelegating = 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.isAddressDelegating(address)];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.isAddressDelegating = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address))];
-                    case 1:
-                        data = (_a.sent()).data;
-                        return [2 /*return*/, !!data.delegate];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getDelegatorDetailsFromPublicKey = 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.getDelegatorDetailsFromAddress(address)];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getDelegatorDetailsFromAddress = function (address) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.getDelegatorDetails(address)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getDelegationDetailsFromPublicKey = function (publicKey, delegatees) {
-        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.getDelegationDetailsFromAddress(address, delegatees)];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getDelegationDetailsFromAddress = function (address, delegatees) {
-        return __awaiter(this, void 0, void 0, function () {
-            var bakerAddress, results, delegatorDetails, bakerDetails;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (delegatees.length > 1) {
-                            return [2 /*return*/, Promise.reject('Multiple delegation is not supported.')];
-                        }
-                        bakerAddress = delegatees[0];
-                        return [4 /*yield*/, Promise.all([this.getDelegatorDetails(address, bakerAddress), this.getDelegateeDetails(bakerAddress)])];
-                    case 1:
-                        results = _a.sent();
-                        delegatorDetails = results[0];
-                        bakerDetails = results[1];
-                        return [2 /*return*/, {
-                                delegator: delegatorDetails,
-                                delegatees: [bakerDetails]
-                            }];
-                }
+    async getDefaultDelegatee() {
+        const { data: activeBakers } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates?active`);
+        return activeBakers[0] || '';
+    }
+    async getCurrentDelegateesForPublicKey(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getCurrentDelegateesForAddress(address);
+    }
+    async getCurrentDelegateesForAddress(address) {
+        const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}`);
+        return data.delegate ? [data.delegate] : [];
+    }
+    async getDelegateeDetails(address) {
+        const response = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${address}/deactivated`);
+        const isBakingActive = !response.data;
+        return {
+            status: isBakingActive ? 'Active' : 'Inactive',
+            address
+        };
+    }
+    async isPublicKeyDelegating(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.isAddressDelegating(address);
+    }
+    async isAddressDelegating(address) {
+        const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}`);
+        return !!data.delegate;
+    }
+    async getDelegatorDetailsFromPublicKey(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getDelegatorDetailsFromAddress(address);
+    }
+    async getDelegatorDetailsFromAddress(address) {
+        return this.getDelegatorDetails(address);
+    }
+    async getDelegationDetailsFromPublicKey(publicKey, delegatees) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        return this.getDelegationDetailsFromAddress(address, delegatees);
+    }
+    async getDelegationDetailsFromAddress(address, delegatees) {
+        if (delegatees.length > 1) {
+            return Promise.reject('Multiple delegation is not supported.');
+        }
+        const bakerAddress = delegatees[0];
+        const results = await Promise.all([this.getDelegatorDetails(address, bakerAddress), this.getDelegateeDetails(bakerAddress)]);
+        const delegatorDetails = results[0];
+        const bakerDetails = results[1];
+        return {
+            delegator: delegatorDetails,
+            delegatees: [bakerDetails]
+        };
+    }
+    async getDelegatorDetails(address, bakerAddress) {
+        const results = await Promise.all([
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/staked_balance`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/unstaked_finalizable_balance`)
+            // axios.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/unstaked_frozen_balance`)
+        ]);
+        const accountDetails = results[0].data;
+        const stakeBalance = new bignumber_1.default(results[1].data ?? 0);
+        const unstakedFinalizableBalance = new bignumber_1.default(results[2].data ?? 0);
+        // const unstakedFrozenBalance = new BigNumber(results[3].data ?? 0)
+        const balance = accountDetails.balance;
+        const isDelegating = !!accountDetails.delegate;
+        const availableActions = [];
+        if (!isDelegating) {
+            availableActions.push({
+                type: TezosDelegatorAction_1.TezosDelegatorAction.DELEGATE,
+                args: ['delegate']
+            });
+            if (unstakedFinalizableBalance.gt(0)) {
+                availableActions.push({
+                    type: TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKEFINALIZABLEBALANCE
+                });
+            }
+        }
+        else if (!bakerAddress || accountDetails.delegate === bakerAddress) {
+            availableActions.push({
+                type: TezosDelegatorAction_1.TezosDelegatorAction.UNDELEGATE
+            }, {
+                type: TezosDelegatorAction_1.TezosDelegatorAction.STAKE,
+                args: ['stake']
+            });
+            if (stakeBalance.gt(0)) {
+                availableActions.push({
+                    type: TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKE,
+                    args: ['stake']
+                });
+            }
+            if (unstakedFinalizableBalance.gt(0)) {
+                availableActions.push({
+                    type: TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKEFINALIZABLEBALANCE
+                });
+            }
+        }
+        else {
+            availableActions.push({
+                type: TezosDelegatorAction_1.TezosDelegatorAction.CHANGE_BAKER,
+                args: ['delegate']
             });
+        }
+        return {
+            address,
+            balance,
+            delegatees: [accountDetails.delegate],
+            availableActions
+        };
+    }
+    async prepareTransactions(publicKey, details, fee, parameters, operationsPerGroup) {
+        if (fee === undefined) {
+            const estimatedFee = await this.getTransactionFee(publicKey, details, parameters);
+            fee = estimatedFee.medium;
+        }
+        const wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.units).value);
+        const address = await this.getAddressFromPublicKey(publicKey);
+        const operations = [];
+        const results = await Promise.all([
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/counter`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head~2/hash`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/manager_key`)
+        ]).catch((error) => {
+            throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+        });
+        const currentCounter = new bignumber_1.default(results[0].data);
+        let counter = currentCounter.plus(1);
+        const 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, address));
+            counter = counter.plus(1);
+        }
+        const { total, transferable } = await this.getBalanceOfPublicKey(publicKey);
+        const balance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable ?? total).blockchain(this.units).value);
+        const transactions = [];
+        let allOperations = await this.createTransactionOperations(operations, details, wrappedFee, address, counter, balance, parameters);
+        allOperations = operations.concat(allOperations); // if we have a reveal in operations, we need to make sure it is present in the allOperations array
+        operationsPerGroup = operationsPerGroup ?? MAX_OPERATIONS_PER_GROUP;
+        const numberOfGroups = Math.ceil(allOperations.length / operationsPerGroup);
+        const startingCounter = numberOfGroups > 1 ? currentCounter.plus(1) : undefined;
+        for (let i = 0; i < numberOfGroups; i++) {
+            const start = i * operationsPerGroup;
+            const end = start + operationsPerGroup;
+            const operationsGroup = allOperations.slice(start, end);
+            const wrappedOperationWithEstimatedGas = await this.estimateAndReplaceLimitsAndFee({
+                branch,
+                contents: operationsGroup
+            }, false, startingCounter);
+            const forged = await this.forgeOperation(wrappedOperationWithEstimatedGas);
+            transactions.push((0, module_kit_1.newUnsignedTransaction)({ binary: forged }));
+        }
+        return transactions;
+    }
+    async stake(publicKey, amount) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        const details = {
+            to: address,
+            amount: (0, module_kit_1.newAmount)(amount, 'blockchain')
+        };
+        const parameters = {
+            entrypoint: 'stake',
+            value: {
+                prim: 'Unit'
+            }
+        };
+        return (await this.prepareTransactions(publicKey, [details], undefined, parameters))[0];
+    }
+    async unstake(publicKey, amount) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        const details = {
+            to: address,
+            amount: (0, module_kit_1.newAmount)(amount, 'blockchain')
+        };
+        const parameters = {
+            entrypoint: 'unstake',
+            value: {
+                prim: 'Unit'
+            }
+        };
+        return (await this.prepareTransactions(publicKey, [details], undefined, parameters))[0];
+    }
+    async finalizeUnstake(publicKey) {
+        const address = await this.getAddressFromPublicKey(publicKey);
+        const details = {
+            to: address,
+            amount: (0, module_kit_1.newAmount)('0', 'blockchain')
+        };
+        const parameters = {
+            entrypoint: 'finalize_unstake',
+            value: {
+                prim: 'Unit'
+            }
+        };
+        return (await this.prepareTransactions(publicKey, [details], undefined, parameters))[0];
+    }
+    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
+        switch (type) {
+            case TezosDelegatorAction_1.TezosDelegatorAction.DELEGATE:
+            case TezosDelegatorAction_1.TezosDelegatorAction.CHANGE_BAKER:
+                if (!data || !data.delegate) {
+                    return Promise.reject(`Invalid arguments passed for ${type} action, delegate is missing.`);
+                }
+                return [await this.delegate(publicKey, data.delegate)];
+            case TezosDelegatorAction_1.TezosDelegatorAction.UNDELEGATE:
+                return [await this.undelegate(publicKey)];
+            case TezosDelegatorAction_1.TezosDelegatorAction.STAKE:
+                return [await this.stake(publicKey, data.stake)];
+            case TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKE:
+                return [await this.unstake(publicKey, data.stake)];
+            case TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKEFINALIZABLEBALANCE:
+                return [await this.finalizeUnstake(publicKey)];
+            default:
+                return Promise.reject('Unsupported delegator action.');
+        }
+    }
+    async undelegate(publicKey) {
+        return this.delegate(publicKey);
+    }
+    async delegate(publicKey, delegate) {
+        let counter = new bignumber_1.default(1);
+        let branch = '';
+        const operations = [];
+        const tzAddress = await this.getAddressFromPublicKey(publicKey);
+        const results = await Promise.all([
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${tzAddress}/counter`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head~2/hash`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${tzAddress}/manager_key`)
+        ]).catch((error) => {
+            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);
+        }
+        const balance = await this.getBalanceOfAddress(tzAddress);
+        const totalBalance = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.units).value);
+        const fee = new bignumber_1.default(1420);
+        if (totalBalance.isLessThan(fee)) {
+            throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance');
+        }
+        const delegationOperation = {
+            kind: TezosOperationType_1.TezosOperationType.DELEGATION,
+            source: tzAddress,
+            fee: fee.toFixed(),
+            counter: counter.toFixed(),
+            gas_limit: '10000', // taken from eztz
+            storage_limit: '0', // taken from eztz
+            delegate: Array.isArray(delegate) ? delegate[0] : delegate
+        };
+        operations.push(delegationOperation);
+        try {
+            const tezosWrappedOperation = {
+                branch,
+                contents: operations
+            };
+            const binary = await this.forgeOperation(tezosWrappedOperation);
+            return (0, module_kit_1.newUnsignedTransaction)({ binary });
+        }
+        catch (error) {
+            throw new errors_1.OperationFailedError(coinlib_core_1.Domain.TEZOS, `Forging Tezos TX failed with ${JSON.stringify(error.message)}`);
+        }
+    }
+    // Custom
+    async getMinCycleDuration() {
+        return MIN_CYCLE_DURATION;
+    }
+    async getDetailsFromWrappedOperation(wrappedOperation) {
+        return this.accountant.getDetailsFromWrappedOperation(wrappedOperation);
+    }
+    async forgeOperation(wrappedOperation) {
+        return this.forger.forgeOperation(wrappedOperation);
+    }
+    async unforgeOperation(forged, type = 'unsigned') {
+        return this.forger.unforgeOperation(forged, type);
+    }
+    async prepareTransactionsWithPublicKey(publicKey, details, configuration) {
+        return await this.prepareTransactions(publicKey, details, configuration?.fee, undefined, configuration?.operationsPerGroup);
+    }
+    async prepareOperations(publicKey, operationRequests, overrideParameters = true) {
+        let counter = new bignumber_1.default(1);
+        let branch;
+        const operations = [];
+        const address = await this.getAddressFromPublicKey(publicKey);
+        const results = await Promise.all([
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/counter`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head~2/hash`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/manager_key`)
+        ]).catch((error) => {
+            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;
+        const hasRevealInOperationRequests = operationRequests.some((request) => request.kind === TezosOperationType_1.TezosOperationType.REVEAL);
+        // check if we have revealed the address already
+        if (!accountManager && !hasRevealInOperationRequests) {
+            operations.push((0, operations_1.createRevealOperation)(counter, publicKey, address));
+            counter = counter.plus(1);
+        }
+        // tslint:disable:cyclomatic-complexity
+        const operationPromises = operationRequests.map(async (operationRequest, index) => {
+            // TODO: Handle activation burn
+            if (!operationRequest.kind) {
+                throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "kind" was not defined');
+            }
+            const recipient = operationRequest.destination;
+            let receivingBalance;
+            if (recipient && recipient.toLowerCase().startsWith('tz')) {
+                const { total } = await this.getBalanceOfAddress(recipient);
+                receivingBalance = new bignumber_1.default((0, module_kit_1.newAmount)(total).blockchain(this.units).value);
+            }
+            const defaultCounter = counter.plus(index).toFixed(); // TODO: Handle counter if we have some operations without counters in the array
+            const defaultFee = FEE_PLACEHOLDER;
+            const defaultGasLimit = '10300';
+            const defaultStorageLimit = receivingBalance && receivingBalance.isZero() && recipient && recipient.toLowerCase().startsWith('tz') ? '300' : '0'; // taken from eztz
+            switch (operationRequest.kind) {
+                // TODO: Handle if the dApp already provides a reveal operation
+                case TezosOperationType_1.TezosOperationType.REVEAL:
+                    const revealOperation = operationRequest;
+                    if (!revealOperation.public_key) {
+                        throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "public_key" was not defined');
+                    }
+                    revealOperation.source = revealOperation.source ?? address;
+                    revealOperation.counter = revealOperation.counter ?? defaultCounter;
+                    revealOperation.fee = revealOperation.fee ?? defaultFee;
+                    revealOperation.gas_limit = revealOperation.gas_limit ?? defaultGasLimit;
+                    revealOperation.storage_limit = revealOperation.storage_limit ?? defaultStorageLimit;
+                    return revealOperation;
+                case TezosOperationType_1.TezosOperationType.DELEGATION:
+                    const delegationOperation = operationRequest;
+                    // The delegate property is optional, so we don't have any mandatory properties to check for
+                    delegationOperation.source = delegationOperation.source ?? address;
+                    delegationOperation.counter = delegationOperation.counter ?? defaultCounter;
+                    delegationOperation.fee = delegationOperation.fee ?? defaultFee;
+                    delegationOperation.gas_limit = delegationOperation.gas_limit ?? defaultGasLimit;
+                    delegationOperation.storage_limit = delegationOperation.storage_limit ?? defaultStorageLimit;
+                    return delegationOperation;
+                case TezosOperationType_1.TezosOperationType.TRANSACTION:
+                    const transactionOperation = operationRequest;
+                    if (!transactionOperation.amount) {
+                        throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "amount" was not defined');
+                    }
+                    if (!transactionOperation.destination) {
+                        throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "destination" was not defined');
+                    }
+                    transactionOperation.source = transactionOperation.source ?? address;
+                    transactionOperation.counter = transactionOperation.counter ?? defaultCounter;
+                    transactionOperation.fee = transactionOperation.fee ?? defaultFee;
+                    transactionOperation.gas_limit = transactionOperation.gas_limit ?? GAS_LIMIT_PLACEHOLDER;
+                    transactionOperation.storage_limit = transactionOperation.storage_limit ?? STORAGE_LIMIT_PLACEHOLDER;
+                    return transactionOperation;
+                case TezosOperationType_1.TezosOperationType.ORIGINATION:
+                    const originationOperation = operationRequest;
+                    if (!originationOperation.balance) {
+                        throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "balance" was not defined');
+                    }
+                    if (!originationOperation.script) {
+                        throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "script" was not defined');
+                    }
+                    originationOperation.source = originationOperation.source ?? address;
+                    originationOperation.counter = originationOperation.counter ?? defaultCounter;
+                    originationOperation.fee = originationOperation.fee ?? defaultFee;
+                    originationOperation.gas_limit = originationOperation.gas_limit ?? GAS_LIMIT_PLACEHOLDER;
+                    originationOperation.storage_limit = originationOperation.storage_limit ?? STORAGE_LIMIT_PLACEHOLDER;
+                    return originationOperation;
+                case TezosOperationType_1.TezosOperationType.ENDORSEMENT:
+                case TezosOperationType_1.TezosOperationType.SEED_NONCE_REVELATION:
+                case TezosOperationType_1.TezosOperationType.DOUBLE_ENDORSEMENT_EVIDENCE:
+                case TezosOperationType_1.TezosOperationType.DOUBLE_BAKING_EVIDENCE:
+                case TezosOperationType_1.TezosOperationType.ACTIVATE_ACCOUNT:
+                case TezosOperationType_1.TezosOperationType.PROPOSALS:
+                case TezosOperationType_1.TezosOperationType.BALLOT:
+                    // Do not change anything
+                    return operationRequest;
+                default:
+                    (0, coinlib_core_1.assertNever)(operationRequest.kind);
+                    throw new errors_1.UnsupportedError(coinlib_core_1.Domain.TEZOS, `unsupported operation type "${JSON.stringify(operationRequest.kind)}"`);
+            }
         });
-    };
-    TezosProtocolImpl.prototype.getDelegatorDetails = function (address, bakerAddress) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            var results, accountDetails, stakeBalance, unstakedFinalizableBalance, balance, isDelegating, availableActions;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, Promise.all([
-                            index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address)),
-                            index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/staked_balance")),
-                            index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/unstaked_finalizable_balance"))
-                            // axios.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/unstaked_frozen_balance`)
-                        ])];
-                    case 1:
-                        results = _c.sent();
-                        accountDetails = results[0].data;
-                        stakeBalance = new bignumber_1.default((_a = results[1].data) !== null && _a !== void 0 ? _a : 0);
-                        unstakedFinalizableBalance = new bignumber_1.default((_b = results[2].data) !== null && _b !== void 0 ? _b : 0);
-                        balance = accountDetails.balance;
-                        isDelegating = !!accountDetails.delegate;
-                        availableActions = [];
-                        if (!isDelegating) {
-                            availableActions.push({
-                                type: TezosDelegatorAction_1.TezosDelegatorAction.DELEGATE,
-                                args: ['delegate']
-                            });
-                            if (unstakedFinalizableBalance.gt(0)) {
-                                availableActions.push({
-                                    type: TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKEFINALIZABLEBALANCE
-                                });
-                            }
-                        }
-                        else if (!bakerAddress || accountDetails.delegate === bakerAddress) {
-                            availableActions.push({
-                                type: TezosDelegatorAction_1.TezosDelegatorAction.UNDELEGATE
-                            }, {
-                                type: TezosDelegatorAction_1.TezosDelegatorAction.STAKE,
-                                args: ['stake']
-                            });
-                            if (stakeBalance.gt(0)) {
-                                availableActions.push({
-                                    type: TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKE,
-                                    args: ['stake']
-                                });
+        operations.push(...(await Promise.all(operationPromises)));
+        const wrappedOperation = {
+            branch,
+            contents: operations
+        };
+        return this.estimateAndReplaceLimitsAndFee(wrappedOperation, overrideParameters);
+    }
+    async estimateAndReplaceLimitsAndFee(wrappedOperation, overrideParameters = true, startingCounter) {
+        const fakeSignature = 'sigUHx32f9wesZ1n2BWpixXz4AQaZggEtchaQNHYGRCoWNAXx45WGW2ua3apUUUAGMLPwAU41QoaFCzVSL61VaessLg4YbbP';
+        const opKinds = [
+            TezosOperationType_1.TezosOperationType.TRANSACTION,
+            TezosOperationType_1.TezosOperationType.REVEAL,
+            TezosOperationType_1.TezosOperationType.ORIGINATION,
+            TezosOperationType_1.TezosOperationType.DELEGATION
+        ];
+        const contents = wrappedOperation.contents.map((operation, i) => {
+            if (!opKinds.includes(operation.kind)) {
+                return operation;
+            }
+            const op = operation;
+            const gasValue = new bignumber_1.default(MAX_GAS_PER_BLOCK).dividedToIntegerBy(wrappedOperation.contents.length);
+            const gas_limit = new bignumber_1.default(GAS_LIMIT_PLACEHOLDER).gt(gasValue) ? gasValue : GAS_LIMIT_PLACEHOLDER;
+            const counter = startingCounter ? startingCounter.plus(i).toString() : op.counter;
+            return { ...operation, gas_limit, counter };
+        });
+        const { data: block } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/header`);
+        const body = {
+            chain_id: block.chain_id,
+            operation: {
+                branch: wrappedOperation.branch,
+                contents,
+                signature: fakeSignature // signature will not be checked, so it is ok to always use this one
+            }
+        };
+        const forgedOperation = await this.forgeOperation(wrappedOperation);
+        let gasLimitTotal = 0;
+        const response = await index_1.default
+            .post(`${this.options.network.rpcUrl}/chains/main/blocks/head/helpers/scripts/run_operation`, body, {
+            headers: { 'Content-Type': 'application/json' }
+        })
+            .catch((runOperationError) => {
+            throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, runOperationError);
+        });
+        if (wrappedOperation.contents.length !== response.data.contents.length) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, `Run Operation did not return same number of operations. Locally we have ${wrappedOperation.contents.length}, but got back ${response.data.contents.length}`);
+        }
+        wrappedOperation.contents.forEach((content, i) => {
+            const metadata = response.data.contents[i].metadata;
+            if (metadata.operation_result) {
+                const result = metadata.operation_result;
+                let gasLimit = 0;
+                let storageLimit = 0;
+                // If there are internal operations, we first add gas and storage used of internal operations
+                if (metadata.internal_operation_results) {
+                    metadata.internal_operation_results.forEach((internalOperation) => {
+                        if (internalOperation?.result) {
+                            if (internalOperation.result.errors) {
+                                throw new errors_1.TransactionError(coinlib_core_1.Domain.TEZOS, 'An internal operation produced an error', internalOperation.result.errors);
                             }
-                            if (unstakedFinalizableBalance.gt(0)) {
-                                availableActions.push({
-                                    type: TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKEFINALIZABLEBALANCE
-                                });
+                            gasLimit += Math.ceil(Number(internalOperation.result.consumed_milligas) / 1000);
+                            if (internalOperation.result.paid_storage_size_diff) {
+                                storageLimit += Number(internalOperation.result.paid_storage_size_diff);
                             }
-                        }
-                        else {
-                            availableActions.push({
-                                type: TezosDelegatorAction_1.TezosDelegatorAction.CHANGE_BAKER,
-                                args: ['delegate']
-                            });
-                        }
-                        return [2 /*return*/, {
-                                address: address,
-                                balance: balance,
-                                delegatees: [accountDetails.delegate],
-                                availableActions: availableActions
-                            }];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.prepareTransactions = function (publicKey, details, fee, parameters, operationsPerGroup) {
-        return __awaiter(this, void 0, void 0, function () {
-            var estimatedFee, wrappedFee, address, operations, results, currentCounter, counter, branch, accountManager, _a, total, transferable, balance, transactions, allOperations, numberOfGroups, startingCounter, i, start, end, operationsGroup, wrappedOperationWithEstimatedGas, forged;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!(fee === undefined)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.getTransactionFee(publicKey, details, parameters)];
-                    case 1:
-                        estimatedFee = _b.sent();
-                        fee = estimatedFee.medium;
-                        _b.label = 2;
-                    case 2:
-                        wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.units).value);
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 3:
-                        address = _b.sent();
-                        operations = [];
-                        return [4 /*yield*/, Promise.all([
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/counter")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head~2/hash")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/manager_key"))
-                            ]).catch(function (error) {
-                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
-                            })];
-                    case 4:
-                        results = _b.sent();
-                        currentCounter = new bignumber_1.default(results[0].data);
-                        counter = currentCounter.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, address));
-                            counter = counter.plus(1);
-                        }
-                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
-                    case 5:
-                        _a = _b.sent(), total = _a.total, transferable = _a.transferable;
-                        balance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable !== null && transferable !== void 0 ? transferable : total).blockchain(this.units).value);
-                        transactions = [];
-                        return [4 /*yield*/, this.createTransactionOperations(operations, details, wrappedFee, address, counter, balance, parameters)];
-                    case 6:
-                        allOperations = _b.sent();
-                        allOperations = operations.concat(allOperations); // if we have a reveal in operations, we need to make sure it is present in the allOperations array
-                        operationsPerGroup = operationsPerGroup !== null && operationsPerGroup !== void 0 ? operationsPerGroup : MAX_OPERATIONS_PER_GROUP;
-                        numberOfGroups = Math.ceil(allOperations.length / operationsPerGroup);
-                        startingCounter = numberOfGroups > 1 ? currentCounter.plus(1) : undefined;
-                        i = 0;
-                        _b.label = 7;
-                    case 7:
-                        if (!(i < numberOfGroups)) return [3 /*break*/, 11];
-                        start = i * operationsPerGroup;
-                        end = start + operationsPerGroup;
-                        operationsGroup = allOperations.slice(start, end);
-                        return [4 /*yield*/, this.estimateAndReplaceLimitsAndFee({
-                                branch: branch,
-                                contents: operationsGroup
-                            }, false, startingCounter)];
-                    case 8:
-                        wrappedOperationWithEstimatedGas = _b.sent();
-                        return [4 /*yield*/, this.forgeOperation(wrappedOperationWithEstimatedGas)];
-                    case 9:
-                        forged = _b.sent();
-                        transactions.push((0, module_kit_1.newUnsignedTransaction)({ binary: forged }));
-                        _b.label = 10;
-                    case 10:
-                        i++;
-                        return [3 /*break*/, 7];
-                    case 11: return [2 /*return*/, transactions];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.stake = function (publicKey, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address, details, parameters;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        details = {
-                            to: address,
-                            amount: (0, module_kit_1.newAmount)(amount, 'blockchain')
-                        };
-                        parameters = {
-                            entrypoint: 'stake',
-                            value: {
-                                prim: 'Unit'
+                            if (internalOperation.result.originated_contracts) {
+                                storageLimit += internalOperation.result.originated_contracts.length * 257;
                             }
-                        };
-                        return [4 /*yield*/, this.prepareTransactions(publicKey, [details], undefined, parameters)];
-                    case 2: return [2 /*return*/, (_a.sent())[0]];
-                }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.unstake = function (publicKey, amount) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address, details, parameters;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        details = {
-                            to: address,
-                            amount: (0, module_kit_1.newAmount)(amount, 'blockchain')
-                        };
-                        parameters = {
-                            entrypoint: 'unstake',
-                            value: {
-                                prim: 'Unit'
+                            if (internalOperation.result.allocated_destination_contract) {
+                                storageLimit += 257;
                             }
-                        };
-                        return [4 /*yield*/, this.prepareTransactions(publicKey, [details], undefined, parameters)];
-                    case 2: return [2 /*return*/, (_a.sent())[0]];
+                        }
+                    });
                 }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.finalizeUnstake = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var address, details, parameters;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _a.sent();
-                        details = {
-                            to: address,
-                            amount: (0, module_kit_1.newAmount)('0', 'blockchain')
-                        };
-                        parameters = {
-                            entrypoint: 'finalize_unstake',
-                            value: {
-                                prim: 'Unit'
-                            }
-                        };
-                        return [4 /*yield*/, this.prepareTransactions(publicKey, [details], undefined, parameters)];
-                    case 2: return [2 /*return*/, (_a.sent())[0]];
+                if (result.errors) {
+                    throw new errors_1.TransactionError(coinlib_core_1.Domain.TEZOS, 'The operation produced an error', result.errors);
                 }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.prepareDelegatorActionFromPublicKey = function (publicKey, type, data) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = type;
-                        switch (_a) {
-                            case TezosDelegatorAction_1.TezosDelegatorAction.DELEGATE: return [3 /*break*/, 1];
-                            case TezosDelegatorAction_1.TezosDelegatorAction.CHANGE_BAKER: return [3 /*break*/, 1];
-                            case TezosDelegatorAction_1.TezosDelegatorAction.UNDELEGATE: return [3 /*break*/, 3];
-                            case TezosDelegatorAction_1.TezosDelegatorAction.STAKE: return [3 /*break*/, 5];
-                            case TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKE: return [3 /*break*/, 7];
-                            case TezosDelegatorAction_1.TezosDelegatorAction.UNSTAKEFINALIZABLEBALANCE: return [3 /*break*/, 9];
-                        }
-                        return [3 /*break*/, 11];
-                    case 1:
-                        if (!data || !data.delegate) {
-                            return [2 /*return*/, Promise.reject("Invalid arguments passed for ".concat(type, " action, delegate is missing."))];
-                        }
-                        return [4 /*yield*/, this.delegate(publicKey, data.delegate)];
-                    case 2: return [2 /*return*/, [_b.sent()]];
-                    case 3: return [4 /*yield*/, this.undelegate(publicKey)];
-                    case 4: return [2 /*return*/, [_b.sent()]];
-                    case 5: return [4 /*yield*/, this.stake(publicKey, data.stake)];
-                    case 6: return [2 /*return*/, [_b.sent()]];
-                    case 7: return [4 /*yield*/, this.unstake(publicKey, data.stake)];
-                    case 8: return [2 /*return*/, [_b.sent()]];
-                    case 9: return [4 /*yield*/, this.finalizeUnstake(publicKey)];
-                    case 10: return [2 /*return*/, [_b.sent()]];
-                    case 11: return [2 /*return*/, Promise.reject('Unsupported delegator action.')];
+                // Add gas and storage used by operation
+                gasLimit += Math.ceil(Number(result.consumed_milligas) / 1000);
+                if (result.paid_storage_size_diff) {
+                    storageLimit += Number(result.paid_storage_size_diff);
                 }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.undelegate = function (publicKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.delegate(publicKey)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.delegate = function (publicKey, delegate) {
-        return __awaiter(this, void 0, void 0, function () {
-            var counter, branch, operations, tzAddress, results, accountManager, balance, totalBalance, fee, delegationOperation, tezosWrappedOperation, binary, error_4;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        counter = new bignumber_1.default(1);
-                        branch = '';
-                        operations = [];
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        tzAddress = _a.sent();
-                        return [4 /*yield*/, Promise.all([
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(tzAddress, "/counter")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head~2/hash")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(tzAddress, "/manager_key"))
-                            ]).catch(function (error) {
-                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
-                            })];
-                    case 2:
-                        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);
-                        }
-                        return [4 /*yield*/, this.getBalanceOfAddress(tzAddress)];
-                    case 3:
-                        balance = _a.sent();
-                        totalBalance = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.units).value);
-                        fee = new bignumber_1.default(1420);
-                        if (totalBalance.isLessThan(fee)) {
-                            throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance');
-                        }
-                        delegationOperation = {
-                            kind: TezosOperationType_1.TezosOperationType.DELEGATION,
-                            source: tzAddress,
-                            fee: fee.toFixed(),
-                            counter: counter.toFixed(),
-                            gas_limit: '10000',
-                            storage_limit: '0',
-                            delegate: Array.isArray(delegate) ? delegate[0] : delegate
-                        };
-                        operations.push(delegationOperation);
-                        _a.label = 4;
-                    case 4:
-                        _a.trys.push([4, 6, , 7]);
-                        tezosWrappedOperation = {
-                            branch: branch,
-                            contents: operations
-                        };
-                        return [4 /*yield*/, this.forgeOperation(tezosWrappedOperation)];
-                    case 5:
-                        binary = _a.sent();
-                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({ binary: binary })];
-                    case 6:
-                        error_4 = _a.sent();
-                        throw new errors_1.OperationFailedError(coinlib_core_1.Domain.TEZOS, "Forging Tezos TX failed with ".concat(JSON.stringify(error_4.message)));
-                    case 7: return [2 /*return*/];
+                if (result.originated_contracts) {
+                    storageLimit += result.originated_contracts.length * 257;
                 }
-            });
-        });
-    };
-    // Custom
-    TezosProtocolImpl.prototype.getMinCycleDuration = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, MIN_CYCLE_DURATION];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.getDetailsFromWrappedOperation = function (wrappedOperation) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.accountant.getDetailsFromWrappedOperation(wrappedOperation)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.forgeOperation = function (wrappedOperation) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.forger.forgeOperation(wrappedOperation)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.unforgeOperation = function (forged, type) {
-        if (type === void 0) { type = 'unsigned'; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.forger.unforgeOperation(forged, type)];
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.prepareTransactionsWithPublicKey = function (publicKey, details, configuration) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.prepareTransactions(publicKey, details, configuration === null || configuration === void 0 ? void 0 : configuration.fee, undefined, configuration === null || configuration === void 0 ? void 0 : configuration.operationsPerGroup)];
-                    case 1: return [2 /*return*/, _a.sent()];
+                if (result.allocated_destination_contract) {
+                    storageLimit += 257;
                 }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.prepareOperations = function (publicKey, operationRequests, overrideParameters) {
-        if (overrideParameters === void 0) { overrideParameters = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var counter, branch, operations, address, results, accountManager, hasRevealInOperationRequests, operationPromises, _a, _b, _c, wrappedOperation;
-            var _this = this;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        counter = new bignumber_1.default(1);
-                        operations = [];
-                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
-                    case 1:
-                        address = _d.sent();
-                        return [4 /*yield*/, Promise.all([
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/counter")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head~2/hash")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/manager_key"))
-                            ]).catch(function (error) {
-                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
-                            })];
-                    case 2:
-                        results = _d.sent();
-                        counter = new bignumber_1.default(results[0].data).plus(1);
-                        branch = results[1].data;
-                        accountManager = results[2].data;
-                        hasRevealInOperationRequests = operationRequests.some(function (request) { return request.kind === TezosOperationType_1.TezosOperationType.REVEAL; });
-                        // check if we have revealed the address already
-                        if (!accountManager && !hasRevealInOperationRequests) {
-                            operations.push((0, operations_1.createRevealOperation)(counter, publicKey, address));
-                            counter = counter.plus(1);
-                        }
-                        operationPromises = operationRequests.map(function (operationRequest, index) { return __awaiter(_this, void 0, void 0, function () {
-                            var recipient, receivingBalance, total, defaultCounter, defaultFee, defaultGasLimit, defaultStorageLimit, revealOperation, delegationOperation, transactionOperation, originationOperation;
-                            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
-                            return __generator(this, function (_w) {
-                                switch (_w.label) {
-                                    case 0:
-                                        // TODO: Handle activation burn
-                                        if (!operationRequest.kind) {
-                                            throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "kind" was not defined');
-                                        }
-                                        recipient = operationRequest.destination;
-                                        if (!(recipient && recipient.toLowerCase().startsWith('tz'))) return [3 /*break*/, 2];
-                                        return [4 /*yield*/, this.getBalanceOfAddress(recipient)];
-                                    case 1:
-                                        total = (_w.sent()).total;
-                                        receivingBalance = new bignumber_1.default((0, module_kit_1.newAmount)(total).blockchain(this.units).value);
-                                        _w.label = 2;
-                                    case 2:
-                                        defaultCounter = counter.plus(index).toFixed() // TODO: Handle counter if we have some operations without counters in the array
-                                        ;
-                                        defaultFee = FEE_PLACEHOLDER;
-                                        defaultGasLimit = '10300';
-                                        defaultStorageLimit = receivingBalance && receivingBalance.isZero() && recipient && recipient.toLowerCase().startsWith('tz') ? '300' : '0' // taken from eztz
-                                        ;
-                                        switch (operationRequest.kind) {
-                                            // TODO: Handle if the dApp already provides a reveal operation
-                                            case TezosOperationType_1.TezosOperationType.REVEAL:
-                                                revealOperation = operationRequest;
-                                                if (!revealOperation.public_key) {
-                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "public_key" was not defined');
-                                                }
-                                                revealOperation.source = (_a = revealOperation.source) !== null && _a !== void 0 ? _a : address;
-                                                revealOperation.counter = (_b = revealOperation.counter) !== null && _b !== void 0 ? _b : defaultCounter;
-                                                revealOperation.fee = (_c = revealOperation.fee) !== null && _c !== void 0 ? _c : defaultFee;
-                                                revealOperation.gas_limit = (_d = revealOperation.gas_limit) !== null && _d !== void 0 ? _d : defaultGasLimit;
-                                                revealOperation.storage_limit = (_e = revealOperation.storage_limit) !== null && _e !== void 0 ? _e : defaultStorageLimit;
-                                                return [2 /*return*/, revealOperation];
-                                            case TezosOperationType_1.TezosOperationType.DELEGATION:
-                                                delegationOperation = operationRequest;
-                                                // The delegate property is optional, so we don't have any mandatory properties to check for
-                                                delegationOperation.source = (_f = delegationOperation.source) !== null && _f !== void 0 ? _f : address;
-                                                delegationOperation.counter = (_g = delegationOperation.counter) !== null && _g !== void 0 ? _g : defaultCounter;
-                                                delegationOperation.fee = (_h = delegationOperation.fee) !== null && _h !== void 0 ? _h : defaultFee;
-                                                delegationOperation.gas_limit = (_j = delegationOperation.gas_limit) !== null && _j !== void 0 ? _j : defaultGasLimit;
-                                                delegationOperation.storage_limit = (_k = delegationOperation.storage_limit) !== null && _k !== void 0 ? _k : defaultStorageLimit;
-                                                return [2 /*return*/, delegationOperation];
-                                            case TezosOperationType_1.TezosOperationType.TRANSACTION:
-                                                transactionOperation = operationRequest;
-                                                if (!transactionOperation.amount) {
-                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "amount" was not defined');
-                                                }
-                                                if (!transactionOperation.destination) {
-                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "destination" was not defined');
-                                                }
-                                                transactionOperation.source = (_l = transactionOperation.source) !== null && _l !== void 0 ? _l : address;
-                                                transactionOperation.counter = (_m = transactionOperation.counter) !== null && _m !== void 0 ? _m : defaultCounter;
-                                                transactionOperation.fee = (_o = transactionOperation.fee) !== null && _o !== void 0 ? _o : defaultFee;
-                                                transactionOperation.gas_limit = (_p = transactionOperation.gas_limit) !== null && _p !== void 0 ? _p : GAS_LIMIT_PLACEHOLDER;
-                                                transactionOperation.storage_limit = (_q = transactionOperation.storage_limit) !== null && _q !== void 0 ? _q : STORAGE_LIMIT_PLACEHOLDER;
-                                                return [2 /*return*/, transactionOperation];
-                                            case TezosOperationType_1.TezosOperationType.ORIGINATION:
-                                                originationOperation = operationRequest;
-                                                if (!originationOperation.balance) {
-                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "balance" was not defined');
-                                                }
-                                                if (!originationOperation.script) {
-                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "script" was not defined');
-                                                }
-                                                originationOperation.source = (_r = originationOperation.source) !== null && _r !== void 0 ? _r : address;
-                                                originationOperation.counter = (_s = originationOperation.counter) !== null && _s !== void 0 ? _s : defaultCounter;
-                                                originationOperation.fee = (_t = originationOperation.fee) !== null && _t !== void 0 ? _t : defaultFee;
-                                                originationOperation.gas_limit = (_u = originationOperation.gas_limit) !== null && _u !== void 0 ? _u : GAS_LIMIT_PLACEHOLDER;
-                                                originationOperation.storage_limit = (_v = originationOperation.storage_limit) !== null && _v !== void 0 ? _v : STORAGE_LIMIT_PLACEHOLDER;
-                                                return [2 /*return*/, originationOperation];
-                                            case TezosOperationType_1.TezosOperationType.ENDORSEMENT:
-                                            case TezosOperationType_1.TezosOperationType.SEED_NONCE_REVELATION:
-                                            case TezosOperationType_1.TezosOperationType.DOUBLE_ENDORSEMENT_EVIDENCE:
-                                            case TezosOperationType_1.TezosOperationType.DOUBLE_BAKING_EVIDENCE:
-                                            case TezosOperationType_1.TezosOperationType.ACTIVATE_ACCOUNT:
-                                            case TezosOperationType_1.TezosOperationType.PROPOSALS:
-                                            case TezosOperationType_1.TezosOperationType.BALLOT:
-                                                // Do not change anything
-                                                return [2 /*return*/, operationRequest];
-                                            default:
-                                                (0, coinlib_core_1.assertNever)(operationRequest.kind);
-                                                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.TEZOS, "unsupported operation type \"".concat(JSON.stringify(operationRequest.kind), "\""));
-                                        }
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); });
-                        _b = (_a = operations.push).apply;
-                        _c = [operations];
-                        return [4 /*yield*/, Promise.all(operationPromises)];
-                    case 3:
-                        _b.apply(_a, _c.concat([(_d.sent())]));
-                        wrappedOperation = {
-                            branch: branch,
-                            contents: operations
-                        };
-                        return [2 /*return*/, this.estimateAndReplaceLimitsAndFee(wrappedOperation, overrideParameters)];
+                // in prepareTransactionsFromPublicKey() we invoke this method with overrideParameters = false
+                if ((content.gas_limit && overrideParameters) || content.gas_limit === GAS_LIMIT_PLACEHOLDER) {
+                    ;
+                    content.gas_limit = gasLimit.toString();
                 }
-            });
-        });
-    };
-    TezosProtocolImpl.prototype.estimateAndReplaceLimitsAndFee = function (wrappedOperation, overrideParameters, startingCounter) {
-        if (overrideParameters === void 0) { overrideParameters = true; }
-        return __awaiter(this, void 0, void 0, function () {
-            var fakeSignature, opKinds, contents, block, body, forgedOperation, gasLimitTotal, response, fee, nonRevealOperations, feePerOperation_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        fakeSignature = 'sigUHx32f9wesZ1n2BWpixXz4AQaZggEtchaQNHYGRCoWNAXx45WGW2ua3apUUUAGMLPwAU41QoaFCzVSL61VaessLg4YbbP';
-                        opKinds = [
-                            TezosOperationType_1.TezosOperationType.TRANSACTION,
-                            TezosOperationType_1.TezosOperationType.REVEAL,
-                            TezosOperationType_1.TezosOperationType.ORIGINATION,
-                            TezosOperationType_1.TezosOperationType.DELEGATION
-                        ];
-                        contents = wrappedOperation.contents.map(function (operation, i) {
-                            if (!opKinds.includes(operation.kind)) {
-                                return operation;
-                            }
-                            var op = operation;
-                            var gasValue = new bignumber_1.default(MAX_GAS_PER_BLOCK).dividedToIntegerBy(wrappedOperation.contents.length);
-                            var gas_limit = new bignumber_1.default(GAS_LIMIT_PLACEHOLDER).gt(gasValue) ? gasValue : GAS_LIMIT_PLACEHOLDER;
-                            var counter = startingCounter ? startingCounter.plus(i).toString() : op.counter;
-                            return __assign(__assign({}, operation), { gas_limit: gas_limit, counter: counter });
-                        });
-                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/header"))];
-                    case 1:
-                        block = (_a.sent()).data;
-                        body = {
-                            chain_id: block.chain_id,
-                            operation: {
-                                branch: wrappedOperation.branch,
-                                contents: contents,
-                                signature: fakeSignature // signature will not be checked, so it is ok to always use this one
-                            }
-                        };
-                        return [4 /*yield*/, this.forgeOperation(wrappedOperation)];
-                    case 2:
-                        forgedOperation = _a.sent();
-                        gasLimitTotal = 0;
-                        return [4 /*yield*/, index_1.default
-                                .post("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/helpers/scripts/run_operation"), body, {
-                                headers: { 'Content-Type': 'application/json' }
-                            })
-                                .catch(function (runOperationError) {
-                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, runOperationError);
-                            })];
-                    case 3:
-                        response = _a.sent();
-                        if (wrappedOperation.contents.length !== response.data.contents.length) {
-                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, "Run Operation did not return same number of operations. Locally we have ".concat(wrappedOperation.contents.length, ", but got back ").concat(response.data.contents.length));
-                        }
-                        wrappedOperation.contents.forEach(function (content, i) {
-                            var metadata = response.data.contents[i].metadata;
-                            if (metadata.operation_result) {
-                                var result = metadata.operation_result;
-                                var gasLimit_1 = 0;
-                                var storageLimit_1 = 0;
-                                // If there are internal operations, we first add gas and storage used of internal operations
-                                if (metadata.internal_operation_results) {
-                                    metadata.internal_operation_results.forEach(function (internalOperation) {
-                                        if (internalOperation === null || internalOperation === void 0 ? void 0 : internalOperation.result) {
-                                            if (internalOperation.result.errors) {
-                                                throw new errors_1.TransactionError(coinlib_core_1.Domain.TEZOS, 'An internal operation produced an error', internalOperation.result.errors);
-                                            }
-                                            gasLimit_1 += Math.ceil(Number(internalOperation.result.consumed_milligas) / 1000);
-                                            if (internalOperation.result.paid_storage_size_diff) {
-                                                storageLimit_1 += Number(internalOperation.result.paid_storage_size_diff);
-                                            }
-                                            if (internalOperation.result.originated_contracts) {
-                                                storageLimit_1 += internalOperation.result.originated_contracts.length * 257;
-                                            }
-                                            if (internalOperation.result.allocated_destination_contract) {
-                                                storageLimit_1 += 257;
-                                            }
-                                        }
-                                    });
-                                }
-                                if (result.errors) {
-                                    throw new errors_1.TransactionError(coinlib_core_1.Domain.TEZOS, 'The operation produced an error', result.errors);
-                                }
-                                // Add gas and storage used by operation
-                                gasLimit_1 += Math.ceil(Number(result.consumed_milligas) / 1000);
-                                if (result.paid_storage_size_diff) {
-                                    storageLimit_1 += Number(result.paid_storage_size_diff);
-                                }
-                                if (result.originated_contracts) {
-                                    storageLimit_1 += result.originated_contracts.length * 257;
-                                }
-                                if (result.allocated_destination_contract) {
-                                    storageLimit_1 += 257;
-                                }
-                                // in prepareTransactionsFromPublicKey() we invoke this method with overrideParameters = false
-                                if ((content.gas_limit && overrideParameters) || content.gas_limit === GAS_LIMIT_PLACEHOLDER) {
-                                    ;
-                                    content.gas_limit = gasLimit_1.toString();
-                                }
-                                if ((content.storage_limit && overrideParameters) || content.storage_limit === STORAGE_LIMIT_PLACEHOLDER) {
-                                    ;
-                                    content.storage_limit = storageLimit_1.toString();
-                                }
-                                gasLimitTotal += gasLimit_1;
-                            }
-                        });
-                        if (overrideParameters || wrappedOperation.contents.some(function (operation) { return (operation === null || operation === void 0 ? void 0 : operation.fee) === FEE_PLACEHOLDER; })) {
-                            fee = MINIMAL_FEE +
-                                MINIMAL_FEE_PER_BYTE * Math.ceil((forgedOperation.length + 128) / 2) + // 128 is the length of a hex signature
-                                MINIMAL_FEE_PER_GAS_UNIT * gasLimitTotal +
-                                100 // add 100 for safety
-                            ;
-                            nonRevealOperations = wrappedOperation.contents.filter(function (operation) { return operation.kind !== 'reveal'; });
-                            feePerOperation_1 = Math.ceil(fee / nonRevealOperations.length);
-                            wrappedOperation.contents.forEach(function (content) {
-                                if (content.fee && content.kind !== 'reveal') {
-                                    ;
-                                    content.fee = feePerOperation_1.toString();
-                                }
-                            });
-                        }
-                        return [2 /*return*/, wrappedOperation];
+                if ((content.storage_limit && overrideParameters) || content.storage_limit === STORAGE_LIMIT_PLACEHOLDER) {
+                    ;
+                    content.storage_limit = storageLimit.toString();
                 }
-            });
+                gasLimitTotal += gasLimit;
+            }
         });
-    };
-    TezosProtocolImpl.prototype.createTransactionOperations = function (previousOperations, details, fee, address, counter, balance, parameters) {
-        return __awaiter(this, void 0, void 0, function () {
-            var amountUsedByPreviousOperations, operations, firstValue, i, recipient, value, _a, total, transferable, receivingBalance, spendOperation;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        amountUsedByPreviousOperations = (0, operations_1.getAmountUsedByPreviousOperations)(previousOperations);
-                        operations = [];
-                        if (!amountUsedByPreviousOperations.isZero()) {
-                            firstValue = new bignumber_1.default((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
-                            if (balance.isLessThan(firstValue.plus(fee).plus(amountUsedByPreviousOperations))) {
-                                // if not, make room for the init fee
-                                details[0] = __assign(__assign({}, details[0]), { amount: (0, module_kit_1.newAmount)(firstValue.minus(amountUsedByPreviousOperations), 'blockchain') // deduct fee from balance
-                                 });
-                            }
-                        }
-                        i = 0;
-                        _b.label = 1;
-                    case 1:
-                        if (!(i < details.length)) return [3 /*break*/, 4];
-                        recipient = details[i].to;
-                        value = new bignumber_1.default((0, module_kit_1.newAmount)(details[i].amount).blockchain(this.units).value);
-                        return [4 /*yield*/, this.getBalanceOfAddress(recipient)];
-                    case 2:
-                        _a = _b.sent(), total = _a.total, transferable = _a.transferable;
-                        receivingBalance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable !== null && transferable !== void 0 ? transferable : total).blockchain(this.units).value);
-                        // if our receiver has 0 balance, the account is not activated yet.
-                        if (receivingBalance.isZero() && recipient.toLowerCase().startsWith('tz')) {
-                            // We have to supply an additional 0.257 XTZ fee for storage_limit costs, which gets automatically deducted from the sender so we just have to make sure enough balance is around
-                            if (balance.isLessThan(fee.plus(operations_1.ACTIVATION_BURN))) {
-                                // If we don't have enough funds to pay the activation + fee, we throw an error
-                                throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'Insufficient balance to pay activation burn!');
-                            }
-                            else if (balance.isLessThan(value.plus(fee).plus(operations_1.ACTIVATION_BURN))) {
-                                // Check whether the sender has enough to cover the amount to send + fee + activation
-                                // If not, we deduct it from amount sent to make room for the activation burn
-                                value = value.minus(operations_1.ACTIVATION_BURN); // deduct fee from balance
-                            }
-                        }
-                        console.log('createTransactionOperations', balance.toString());
-                        if (balance.isEqualTo(value.plus(fee))) {
-                            // Tezos accounts can never be empty. If user tries to send everything, we must leave 1 mutez behind.
-                            value = value.minus(1);
-                        }
-                        else if (parameters === undefined && balance.isLessThan(value.plus(fee))) {
-                            throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance');
-                        }
-                        spendOperation = {
-                            kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
-                            fee: fee.toFixed(),
-                            gas_limit: GAS_LIMIT_PLACEHOLDER,
-                            storage_limit: STORAGE_LIMIT_PLACEHOLDER,
-                            amount: value.toFixed(),
-                            counter: counter.plus(i).toFixed(),
-                            destination: recipient,
-                            source: address,
-                            parameters: parameters
-                        };
-                        operations.push(spendOperation);
-                        _b.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, operations];
+        if (overrideParameters || wrappedOperation.contents.some((operation) => operation?.fee === FEE_PLACEHOLDER)) {
+            const fee = MINIMAL_FEE +
+                MINIMAL_FEE_PER_BYTE * Math.ceil((forgedOperation.length + 128) / 2) + // 128 is the length of a hex signature
+                MINIMAL_FEE_PER_GAS_UNIT * gasLimitTotal +
+                100; // add 100 for safety
+            const nonRevealOperations = wrappedOperation.contents.filter((operation) => operation.kind !== 'reveal');
+            const feePerOperation = Math.ceil(fee / nonRevealOperations.length);
+            wrappedOperation.contents.forEach((content) => {
+                if (content.fee && content.kind !== 'reveal') {
+                    ;
+                    content.fee = feePerOperation.toString();
                 }
             });
-        });
-    };
-    TezosProtocolImpl.prototype.bakerDetails = function (address) {
-        var _a, _b, _c, _d, _e;
-        return __awaiter(this, void 0, void 0, function () {
-            var results, tzBalance, delegatedBalance, stakingBalance, totalDelegatedStake, selfBond, stakingCapacity, bakerDetails;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        if (!address ||
-                            !(address.toLowerCase().startsWith('tz1') ||
-                                address.toLowerCase().startsWith('tz2') ||
-                                address.toLowerCase().startsWith('tz3') ||
-                                address.toLowerCase().startsWith('tz4'))) {
-                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'non tz-address supplied');
-                        }
-                        return [4 /*yield*/, Promise.all([
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/balance")).catch(function (_error) { return undefined; }),
-                                index_1.default
-                                    .get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/full_balance"))
-                                    .catch(function (_error) { return undefined; }),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/delegated_balance")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/staking_balance")),
-                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(address, "/total_delegated_stake"))
-                            ]).catch(function (error) {
-                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
-                            })];
-                    case 1:
-                        results = _f.sent();
-                        tzBalance = new bignumber_1.default((_b = ((_a = results[0]) !== null && _a !== void 0 ? _a : results[1])) === null || _b === void 0 ? void 0 : _b.data);
-                        delegatedBalance = new bignumber_1.default((_c = results[2]) === null || _c === void 0 ? void 0 : _c.data);
-                        stakingBalance = new bignumber_1.default((_d = results[3]) === null || _d === void 0 ? void 0 : _d.data);
-                        totalDelegatedStake = new bignumber_1.default((_e = results[4]) === null || _e === void 0 ? void 0 : _e.data);
-                        selfBond = stakingBalance.minus(delegatedBalance);
-                        stakingCapacity = stakingBalance.div(selfBond.div(SELF_BOND_REQUIREMENT));
-                        bakerDetails = {
-                            balance: (0, module_kit_1.newAmount)(tzBalance, 'blockchain'),
-                            delegatedBalance: (0, module_kit_1.newAmount)(delegatedBalance, 'blockchain'),
-                            stakingBalance: (0, module_kit_1.newAmount)(stakingBalance, 'blockchain'),
-                            selfBond: (0, module_kit_1.newAmount)(selfBond, 'blockchain'),
-                            bakerCapacity: stakingBalance.div(stakingCapacity).toString(),
-                            bakerUsage: stakingCapacity.toString(),
-                            totalDelegatedStake: (0, module_kit_1.newAmount)(totalDelegatedStake, 'blockchain')
-                        };
-                        return [2 /*return*/, bakerDetails];
+        }
+        return wrappedOperation;
+    }
+    async createTransactionOperations(previousOperations, details, fee, address, counter, balance, parameters) {
+        const amountUsedByPreviousOperations = (0, operations_1.getAmountUsedByPreviousOperations)(previousOperations);
+        const operations = [];
+        if (!amountUsedByPreviousOperations.isZero()) {
+            const firstValue = new bignumber_1.default((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
+            if (balance.isLessThan(firstValue.plus(fee).plus(amountUsedByPreviousOperations))) {
+                // if not, make room for the init fee
+                details[0] = {
+                    ...details[0],
+                    amount: (0, module_kit_1.newAmount)(firstValue.minus(amountUsedByPreviousOperations), 'blockchain') // deduct fee from balance
+                };
+            }
+        }
+        // TODO: We currently do not correctly calculate whether we have enough balance to pay the activation burn if there are multiple recipients
+        for (let i = 0; i < details.length; i++) {
+            const recipient = details[i].to;
+            let value = new bignumber_1.default((0, module_kit_1.newAmount)(details[i].amount).blockchain(this.units).value);
+            const { total, transferable } = await this.getBalanceOfAddress(recipient);
+            const receivingBalance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable ?? total).blockchain(this.units).value);
+            // if our receiver has 0 balance, the account is not activated yet.
+            if (receivingBalance.isZero() && recipient.toLowerCase().startsWith('tz')) {
+                // We have to supply an additional 0.257 XTZ fee for storage_limit costs, which gets automatically deducted from the sender so we just have to make sure enough balance is around
+                if (balance.isLessThan(fee.plus(operations_1.ACTIVATION_BURN))) {
+                    // If we don't have enough funds to pay the activation + fee, we throw an error
+                    throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'Insufficient balance to pay activation burn!');
+                }
+                else if (balance.isLessThan(value.plus(fee).plus(operations_1.ACTIVATION_BURN))) {
+                    // Check whether the sender has enough to cover the amount to send + fee + activation
+                    // If not, we deduct it from amount sent to make room for the activation burn
+                    value = value.minus(operations_1.ACTIVATION_BURN); // deduct fee from balance
                 }
-            });
-        });
-    };
-    return TezosProtocolImpl;
-}());
+            }
+            console.log('createTransactionOperations', balance.toString());
+            if (balance.isEqualTo(value.plus(fee))) {
+                // Tezos accounts can never be empty. If user tries to send everything, we must leave 1 mutez behind.
+                value = value.minus(1);
+            }
+            else if (parameters === undefined && balance.isLessThan(value.plus(fee))) {
+                throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance');
+            }
+            const spendOperation = {
+                kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
+                fee: fee.toFixed(),
+                gas_limit: GAS_LIMIT_PLACEHOLDER,
+                storage_limit: STORAGE_LIMIT_PLACEHOLDER,
+                amount: value.toFixed(),
+                counter: counter.plus(i).toFixed(),
+                destination: recipient,
+                source: address,
+                parameters
+            };
+            operations.push(spendOperation);
+        }
+        return operations;
+    }
+    async bakerDetails(address) {
+        if (!address ||
+            !(address.toLowerCase().startsWith('tz1') ||
+                address.toLowerCase().startsWith('tz2') ||
+                address.toLowerCase().startsWith('tz3') ||
+                address.toLowerCase().startsWith('tz4'))) {
+            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'non tz-address supplied');
+        }
+        const results = await Promise.all([
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${address}/balance`).catch((_error) => undefined),
+            index_1.default
+                .get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${address}/full_balance`)
+                .catch((_error) => undefined),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${address}/delegated_balance`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${address}/staking_balance`),
+            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${address}/total_delegated_stake`)
+        ]).catch((error) => {
+            throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+        });
+        const tzBalance = new bignumber_1.default((results[0] ?? results[1])?.data);
+        const delegatedBalance = new bignumber_1.default(results[2]?.data);
+        const stakingBalance = new bignumber_1.default(results[3]?.data);
+        const totalDelegatedStake = new bignumber_1.default(results[4]?.data);
+        // calculate the self bond of the baker
+        const selfBond = stakingBalance.minus(delegatedBalance);
+        // check what capacity is staked relatively to the self-bond
+        const stakingCapacity = stakingBalance.div(selfBond.div(SELF_BOND_REQUIREMENT));
+        const bakerDetails = {
+            balance: (0, module_kit_1.newAmount)(tzBalance, 'blockchain'),
+            delegatedBalance: (0, module_kit_1.newAmount)(delegatedBalance, 'blockchain'),
+            stakingBalance: (0, module_kit_1.newAmount)(stakingBalance, 'blockchain'),
+            selfBond: (0, module_kit_1.newAmount)(selfBond, 'blockchain'),
+            bakerCapacity: stakingBalance.div(stakingCapacity).toString(),
+            bakerUsage: stakingCapacity.toString(),
+            totalDelegatedStake: (0, module_kit_1.newAmount)(totalDelegatedStake, 'blockchain')
+        };
+        return bakerDetails;
+    }
+}
 exports.TezosProtocolImpl = TezosProtocolImpl;
 // Factory
-function createTezosProtocol(options) {
-    if (options === void 0) { options = {}; }
+function createTezosProtocol(options = {}) {
     return new TezosProtocolImpl(options);
 }
-exports.createTezosProtocol = createTezosProtocol;
 exports.TEZOS_MAINNET_PROTOCOL_NETWORK = {
     name: 'Mainnet',
     type: 'mainnet',
-    rpcUrl: 'https://rpc.tzkt.io/tallinnnet',
+    rpcUrl: 'https://tezos-node.prod.gke.papers.tech',
     network: network_1.TezosNetwork.MAINNET,
-    blockExplorerUrl: 'https://tallinnnet.tzkt.io',
+    blockExplorerUrl: 'https://tzkt.io',
     blockExplorerType: 'tzkt',
-    indexerApi: 'https://api.tallinnnet.tzkt.io',
+    indexerApi: 'https://api.tzkt.io',
     indexerType: 'tzkt'
 };
 exports.TEZOS_GHOSTNET_PROTOCOL_NETWORK = {
@@ -1481,12 +946,10 @@ exports.TEZOS_GHOSTNET_PROTOCOL_NETWORK = {
     indexerApi: 'https://api.ghostnet.tzkt.io',
     indexerType: 'tzkt'
 };
-var DEFAULT_TEZOS_PROTOCOL_NETWORK = exports.TEZOS_MAINNET_PROTOCOL_NETWORK;
-function createTezosProtocolOptions(network) {
-    if (network === void 0) { network = {}; }
+const DEFAULT_TEZOS_PROTOCOL_NETWORK = exports.TEZOS_MAINNET_PROTOCOL_NETWORK;
+function createTezosProtocolOptions(network = {}) {
     return {
-        network: __assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK), network)
+        network: { ...DEFAULT_TEZOS_PROTOCOL_NETWORK, ...network }
     };
 }
-exports.createTezosProtocolOptions = createTezosProtocolOptions;
 //# sourceMappingURL=TezosProtocol.js.map