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

package/v0/protocol/TezosProtocol.js

@@ -1,4 +1,30 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -15,984 +41,1525 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TezosProtocol = exports.TezosNetwork = exports.TezosDelegatorAction = void 0;
-const taquito_local_forging_1 = require("@airgap/coinlib-core/dependencies/src/@taquito/local-forging-15.0.1/packages/taquito-local-forging/src/taquito-local-forging");
-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"));
+var taquito_local_forging_1 = require("@airgap/coinlib-core/dependencies/src/@taquito/local-forging-15.0.1/packages/taquito-local-forging/src/taquito-local-forging");
+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"));
 // @ts-ignore
-const index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
+var index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
 // @ts-ignore
-const bs58check = __importStar(require("@airgap/coinlib-core/dependencies/src/bs58check-2.1.2/index"));
-const index_3 = require("@airgap/coinlib-core/dependencies/src/hd-wallet-js-b216450e56954a6e82ace0aade9474673de5d9d5/src/index");
-const coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
-const index_4 = require("@airgap/coinlib-core/errors/index");
-const NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
-const assert_1 = require("@airgap/coinlib-core/utils/assert");
-const ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
-const TezosAddress_1 = require("./TezosAddress");
-const TezosCryptoClient_1 = require("./TezosCryptoClient");
-const TezosProtocolOptions_1 = require("./TezosProtocolOptions");
-const TezosUtils_1 = require("./TezosUtils");
-const TezosOperationType_1 = require("./types/TezosOperationType");
-const MAX_OPERATIONS_PER_GROUP = 200;
-const MAX_GAS_PER_BLOCK = 2600000;
-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;
+var bs58check = __importStar(require("@airgap/coinlib-core/dependencies/src/bs58check-2.1.2/index"));
+var index_3 = require("@airgap/coinlib-core/dependencies/src/hd-wallet-js-b216450e56954a6e82ace0aade9474673de5d9d5/src/index");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var index_4 = require("@airgap/coinlib-core/errors/index");
+var NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
+var assert_1 = require("@airgap/coinlib-core/utils/assert");
+var ProtocolSymbols_1 = require("@airgap/coinlib-core/utils/ProtocolSymbols");
+var TezosAddress_1 = require("./TezosAddress");
+var TezosCryptoClient_1 = require("./TezosCryptoClient");
+var TezosProtocolOptions_1 = require("./TezosProtocolOptions");
+var TezosUtils_1 = require("./TezosUtils");
+var TezosOperationType_1 = require("./types/TezosOperationType");
+var MAX_OPERATIONS_PER_GROUP = 200;
+var MAX_GAS_PER_BLOCK = 2600000;
+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 TezosDelegatorAction;
 (function (TezosDelegatorAction) {
     TezosDelegatorAction["DELEGATE"] = "delegate";
     TezosDelegatorAction["UNDELEGATE"] = "undelegate";
     TezosDelegatorAction["CHANGE_BAKER"] = "change_baker";
-})(TezosDelegatorAction || (exports.TezosDelegatorAction = TezosDelegatorAction = {}));
+})(TezosDelegatorAction = exports.TezosDelegatorAction || (exports.TezosDelegatorAction = {}));
 // 8.25%
-const SELF_BOND_REQUIREMENT = 0.0825;
+var SELF_BOND_REQUIREMENT = 0.0825;
 var TezosNetwork;
 (function (TezosNetwork) {
     TezosNetwork["MAINNET"] = "mainnet";
     TezosNetwork["GHOSTNET"] = "ghostnet";
-})(TezosNetwork || (exports.TezosNetwork = TezosNetwork = {}));
-class TezosProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
-    // TODO: Should we remove these getters and replace the calls to `this.options.network...`?
-    get jsonRPCAPI() {
-        return this.options.network.rpcUrl;
-    }
-    constructor(options = new TezosProtocolOptions_1.TezosProtocolOptions()) {
-        super();
-        this.options = options;
-        this.symbol = 'XTZ';
-        this.name = 'Tezos';
-        this.marketSymbol = 'xtz';
-        this.feeSymbol = 'xtz';
-        this.decimals = 6;
-        this.feeDecimals = 6; // micro tez is the smallest, 1000000 microtez is 1 tez
-        this.identifier = ProtocolSymbols_1.MainProtocolSymbols.XTZ;
+})(TezosNetwork = exports.TezosNetwork || (exports.TezosNetwork = {}));
+var TezosProtocol = /** @class */ (function (_super) {
+    __extends(TezosProtocol, _super);
+    function TezosProtocol(options) {
+        if (options === void 0) { options = new TezosProtocolOptions_1.TezosProtocolOptions(); }
+        var _this = _super.call(this) || this;
+        _this.options = options;
+        _this.symbol = 'XTZ';
+        _this.name = 'Tezos';
+        _this.marketSymbol = 'xtz';
+        _this.feeSymbol = 'xtz';
+        _this.decimals = 6;
+        _this.feeDecimals = 6; // micro tez is the smallest, 1000000 microtez is 1 tez
+        _this.identifier = ProtocolSymbols_1.MainProtocolSymbols.XTZ;
         // tezbox default
-        this.feeDefaults = {
+        _this.feeDefaults = {
             low: '0.001420',
             medium: '0.001520',
             high: '0.003000'
         };
-        this.units = [
+        _this.units = [
             {
                 unitSymbol: 'XTZ',
                 factor: '1'
             }
         ];
-        this.supportsHD = false;
-        this.standardDerivationPath = `m/44h/1729h/0h/0h`;
-        this.addressIsCaseSensitive = true;
-        this.addressValidationPattern = '^((tz1|tz2|tz3|tz4|KT1)[1-9A-Za-z]{33}|zet1[1-9A-Za-z]{65})$';
-        this.addressPlaceholder = 'tz1...';
+        _this.supportsHD = false;
+        _this.standardDerivationPath = "m/44h/1729h/0h/0h";
+        _this.addressIsCaseSensitive = true;
+        _this.addressValidationPattern = '^((tz1|tz2|tz3|tz4|KT1)[1-9A-Za-z]{33}|zet1[1-9A-Za-z]{65})$';
+        _this.addressPlaceholder = 'tz1...';
         // https://gitlab.com/tezos/tezos/-/blob/master/docs/whitedoc/proof_of_stake.rst
         // cycle has 4096 blocks, which are at least one minute apart
-        this.minCycleDuration = 4096 * 60 * 1000; // ms
-        this.transactionFee = new bignumber_1.default('1400');
-        this.originationSize = new bignumber_1.default('257');
-        this.storageCostPerByte = new bignumber_1.default('1000');
-        this.revealFee = new bignumber_1.default('1300');
-        this.activationBurn = this.originationSize.times(this.storageCostPerByte);
-        this.originationBurn = this.originationSize.times(this.storageCostPerByte); // https://tezos.stackexchange.com/a/787
-        this.cryptoClient = new TezosCryptoClient_1.TezosCryptoClient(TezosUtils_1.TezosUtils.tezosPrefixes.edsig);
-    }
-    async getSymbol() {
-        return this.symbol;
-    }
-    async getName() {
-        return this.name;
-    }
-    async getMarketSymbol() {
-        return this.marketSymbol;
-    }
-    async getAssetSymbol() {
-        return undefined;
-    }
-    async getFeeSymbol() {
-        return this.feeSymbol;
-    }
-    async getDecimals() {
-        return this.decimals;
-    }
-    async getFeeDecimals() {
-        return this.feeDecimals;
-    }
-    async getIdentifier() {
-        return this.identifier;
-    }
-    async getFeeDefaults() {
-        return this.feeDefaults;
-    }
-    async getUnits() {
-        return this.units;
-    }
-    async getSupportsHD() {
-        return this.supportsHD;
-    }
-    async getStandardDerivationPath() {
-        return this.standardDerivationPath;
-    }
-    async getAddressIsCaseSensitive() {
-        return this.addressIsCaseSensitive;
-    }
-    async getAddressValidationPattern() {
-        return this.addressValidationPattern;
-    }
-    async getAddressPlaceholder() {
-        return this.addressPlaceholder;
-    }
-    async getOptions() {
-        return this.options;
-    }
-    async getBlockExplorerLinkForAddress(address) {
-        return this.options.network.blockExplorer.getAddressLink(address);
-    }
-    async getBlockExplorerLinkForTxId(txId) {
-        return this.options.network.blockExplorer.getTransactionLink(txId);
-    }
-    async getPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
-        const secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
-        return this.getPublicKeyFromHexSecret(secret, derivationPath);
-    }
-    async getPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
-        const secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
-        return this.getPrivateKeyFromHexSecret(secret, derivationPath);
-    }
+        _this.minCycleDuration = 4096 * 60 * 1000; // ms
+        _this.transactionFee = new bignumber_1.default('1400');
+        _this.originationSize = new bignumber_1.default('257');
+        _this.storageCostPerByte = new bignumber_1.default('1000');
+        _this.revealFee = new bignumber_1.default('1300');
+        _this.activationBurn = _this.originationSize.times(_this.storageCostPerByte);
+        _this.originationBurn = _this.originationSize.times(_this.storageCostPerByte); // https://tezos.stackexchange.com/a/787
+        _this.cryptoClient = new TezosCryptoClient_1.TezosCryptoClient(TezosUtils_1.TezosUtils.tezosPrefixes.edsig);
+        return _this;
+    }
+    Object.defineProperty(TezosProtocol.prototype, "jsonRPCAPI", {
+        // TODO: Should we remove these getters and replace the calls to `this.options.network...`?
+        get: function () {
+            return this.options.network.rpcUrl;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TezosProtocol.prototype.getSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.symbol];
+            });
+        });
+    };
+    TezosProtocol.prototype.getName = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.name];
+            });
+        });
+    };
+    TezosProtocol.prototype.getMarketSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.marketSymbol];
+            });
+        });
+    };
+    TezosProtocol.prototype.getAssetSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    TezosProtocol.prototype.getFeeSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeSymbol];
+            });
+        });
+    };
+    TezosProtocol.prototype.getDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.decimals];
+            });
+        });
+    };
+    TezosProtocol.prototype.getFeeDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDecimals];
+            });
+        });
+    };
+    TezosProtocol.prototype.getIdentifier = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.identifier];
+            });
+        });
+    };
+    TezosProtocol.prototype.getFeeDefaults = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDefaults];
+            });
+        });
+    };
+    TezosProtocol.prototype.getUnits = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.units];
+            });
+        });
+    };
+    TezosProtocol.prototype.getSupportsHD = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.supportsHD];
+            });
+        });
+    };
+    TezosProtocol.prototype.getStandardDerivationPath = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.standardDerivationPath];
+            });
+        });
+    };
+    TezosProtocol.prototype.getAddressIsCaseSensitive = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressIsCaseSensitive];
+            });
+        });
+    };
+    TezosProtocol.prototype.getAddressValidationPattern = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressValidationPattern];
+            });
+        });
+    };
+    TezosProtocol.prototype.getAddressPlaceholder = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressPlaceholder];
+            });
+        });
+    };
+    TezosProtocol.prototype.getOptions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options];
+            });
+        });
+    };
+    TezosProtocol.prototype.getBlockExplorerLinkForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network.blockExplorer.getAddressLink(address)];
+            });
+        });
+    };
+    TezosProtocol.prototype.getBlockExplorerLinkForTxId = function (txId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network.blockExplorer.getTransactionLink(txId)];
+            });
+        });
+    };
+    TezosProtocol.prototype.getPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var secret;
+            return __generator(this, function (_a) {
+                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+                return [2 /*return*/, this.getPublicKeyFromHexSecret(secret, derivationPath)];
+            });
+        });
+    };
+    TezosProtocol.prototype.getPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var secret;
+            return __generator(this, function (_a) {
+                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+                return [2 /*return*/, this.getPrivateKeyFromHexSecret(secret, derivationPath)];
+            });
+        });
+    };
     /**
      * Returns the PublicKey as String, derived from a supplied hex-string
      * @param secret HEX-Secret from BIP39
      * @param derivationPath DerivationPath for Key
      */
-    async getPublicKeyFromHexSecret(secret, derivationPath) {
-        // both AE and Tezos use the same ECC curves (ed25519)
-        const { publicKey } = (0, index_3.generateWalletUsingDerivationPath)(Buffer.from(secret, 'hex'), derivationPath); // TODO: Look into typings
-        return Buffer.from(publicKey).toString('hex');
-    }
+    TezosProtocol.prototype.getPublicKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var publicKey;
+            return __generator(this, function (_a) {
+                publicKey = (0, index_3.generateWalletUsingDerivationPath)(Buffer.from(secret, 'hex'), derivationPath) // TODO: Look into typings
+                .publicKey;
+                return [2 /*return*/, Buffer.from(publicKey).toString('hex')];
+            });
+        });
+    };
     /**
      * Returns the PrivateKey as Buffer, derived from a supplied hex-string
      * @param secret HEX-Secret from BIP39
      * @param derivationPath DerivationPath for Key
      */
-    async getPrivateKeyFromHexSecret(secret, derivationPath) {
-        // both AE and Tezos use the same ECC curves (ed25519)
-        const { secretKey } = (0, index_3.generateWalletUsingDerivationPath)(Buffer.from(secret, 'hex'), derivationPath); // TODO: Look into typings
-        return Buffer.from(secretKey).toString('hex');
-    }
-    async getAddressFromPublicKey(publicKey, cursor) {
-        const address = await TezosAddress_1.TezosAddress.fromPublicKey(publicKey);
-        return {
-            address: address.asString(),
-            cursor: { hasNext: false }
-        };
-    }
-    async getAddressesFromPublicKey(publicKey, cursor) {
-        const address = await this.getAddressFromPublicKey(publicKey, cursor);
-        return [address];
-    }
-    async getTransactionsFromPublicKey(publicKey, limit, cursor) {
-        const addresses = await this.getAddressesFromPublicKey(publicKey).then((addresses) => addresses.map((address) => address.address));
-        return this.getTransactionsFromAddresses(addresses, limit, cursor);
-    }
-    async getTransactionsFromAddresses(addresses, limit, cursor) {
-        const address = addresses[0];
-        const results = await this.options.network.extras.indexerClient.getTransactions(address, limit, cursor?.offset);
-        return {
-            transactions: results.map((transaction) => ({
-                ...transaction,
-                protocolIdentifier: this.identifier,
-                network: this.options.network
-            })),
-            cursor: { offset: (cursor?.offset ?? 0) + results.length }
-        };
-    }
-    async signWithPrivateKey(privateKey, transaction) {
-        const opSignature = await this.cryptoClient.operationSignature(Buffer.from(privateKey, 'hex'), transaction);
-        const signedOpBytes = Buffer.concat([Buffer.from(transaction.binaryTransaction, 'hex'), Buffer.from(opSignature)]);
-        return signedOpBytes.toString('hex');
-    }
-    async getTransactionDetails(unsignedTx) {
-        const binaryTransaction = unsignedTx.transaction.binaryTransaction;
-        const wrappedOperations = await this.unforgeUnsignedTezosWrappedOperation(binaryTransaction);
-        return this.getAirGapTxFromWrappedOperations(wrappedOperations);
-    }
-    async getTransactionDetailsFromSigned(signedTx) {
-        const binaryTransaction = signedTx.transaction;
-        const wrappedOperations = await this.unforgeSignedTezosWrappedOperation(binaryTransaction);
-        return this.getAirGapTxFromWrappedOperations(wrappedOperations);
-    }
-    async getAirGapTxFromWrappedOperations(wrappedOperations) {
-        const assertNever = (_x) => undefined;
-        return Promise.all(wrappedOperations.contents.map(async (tezosOperation) => {
-            let operation;
-            let partialTxs = [];
-            switch (tezosOperation.kind) {
-                case TezosOperationType_1.TezosOperationType.REVEAL:
-                    operation = tezosOperation;
-                    partialTxs = [
-                        {
-                            from: [operation.source],
-                            to: ['Reveal']
-                        }
-                    ];
-                    break;
-                case TezosOperationType_1.TezosOperationType.TRANSACTION:
-                    const tezosSpendOperation = tezosOperation;
-                    operation = tezosSpendOperation;
-                    partialTxs = (await this.getTransactionOperationDetails(tezosSpendOperation)).map((tx) => ({
-                        ...tx,
-                        extra: {
-                            ...tx.extra,
-                            parameters: tezosSpendOperation.parameters
-                        }
-                    }));
-                    break;
-                case TezosOperationType_1.TezosOperationType.ORIGINATION:
-                    {
-                        const tezosOriginationOperation = tezosOperation;
-                        operation = tezosOriginationOperation;
-                        const delegate = tezosOriginationOperation.delegate;
-                        partialTxs = [
-                            {
-                                from: [operation.source],
-                                amount: new bignumber_1.default(tezosOriginationOperation.balance).toFixed(),
-                                to: [delegate ? `Delegate: ${delegate}` : 'Origination']
-                            }
-                        ];
-                    }
-                    break;
-                case TezosOperationType_1.TezosOperationType.DELEGATION:
-                    {
-                        operation = tezosOperation;
-                        const delegate = operation.delegate;
-                        partialTxs = [
-                            {
-                                from: [operation.source],
-                                to: [delegate ? delegate : 'Undelegate']
+    TezosProtocol.prototype.getPrivateKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var secretKey;
+            return __generator(this, function (_a) {
+                secretKey = (0, index_3.generateWalletUsingDerivationPath)(Buffer.from(secret, 'hex'), derivationPath) // TODO: Look into typings
+                .secretKey;
+                return [2 /*return*/, Buffer.from(secretKey).toString('hex')];
+            });
+        });
+    };
+    TezosProtocol.prototype.getAddressFromPublicKey = function (publicKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, TezosAddress_1.TezosAddress.fromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, {
+                                address: address.asString(),
+                                cursor: { hasNext: false }
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getAddressesFromPublicKey = function (publicKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey, cursor)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, [address]];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getTransactionsFromPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var addresses;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressesFromPublicKey(publicKey).then(function (addresses) {
+                            return addresses.map(function (address) { return address.address; });
+                        })];
+                    case 1:
+                        addresses = _a.sent();
+                        return [2 /*return*/, this.getTransactionsFromAddresses(addresses, limit, cursor)];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getTransactionsFromAddresses = function (addresses, limit, cursor) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var address, results;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        address = addresses[0];
+                        return [4 /*yield*/, this.options.network.extras.indexerClient.getTransactions(address, limit, cursor === null || cursor === void 0 ? void 0 : cursor.offset)];
+                    case 1:
+                        results = _b.sent();
+                        return [2 /*return*/, {
+                                transactions: results.map(function (transaction) { return (__assign(__assign({}, transaction), { protocolIdentifier: _this.identifier, network: _this.options.network })); }),
+                                cursor: { offset: ((_a = cursor === null || cursor === void 0 ? void 0 : cursor.offset) !== null && _a !== void 0 ? _a : 0) + results.length }
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.signWithPrivateKey = function (privateKey, transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var opSignature, signedOpBytes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cryptoClient.operationSignature(Buffer.from(privateKey, 'hex'), transaction)];
+                    case 1:
+                        opSignature = _a.sent();
+                        signedOpBytes = Buffer.concat([Buffer.from(transaction.binaryTransaction, 'hex'), Buffer.from(opSignature)]);
+                        return [2 /*return*/, signedOpBytes.toString('hex')];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getTransactionDetails = function (unsignedTx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var binaryTransaction, wrappedOperations;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        binaryTransaction = unsignedTx.transaction.binaryTransaction;
+                        return [4 /*yield*/, this.unforgeUnsignedTezosWrappedOperation(binaryTransaction)];
+                    case 1:
+                        wrappedOperations = _a.sent();
+                        return [2 /*return*/, this.getAirGapTxFromWrappedOperations(wrappedOperations)];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getTransactionDetailsFromSigned = function (signedTx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var binaryTransaction, wrappedOperations;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        binaryTransaction = signedTx.transaction;
+                        return [4 /*yield*/, this.unforgeSignedTezosWrappedOperation(binaryTransaction)];
+                    case 1:
+                        wrappedOperations = _a.sent();
+                        return [2 /*return*/, this.getAirGapTxFromWrappedOperations(wrappedOperations)];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getAirGapTxFromWrappedOperations = function (wrappedOperations) {
+        return __awaiter(this, void 0, void 0, function () {
+            var assertNever;
+            var _this = this;
+            return __generator(this, function (_a) {
+                assertNever = function (_x) { return undefined; };
+                return [2 /*return*/, Promise.all(wrappedOperations.contents.map(function (tezosOperation) { return __awaiter(_this, void 0, void 0, function () {
+                        var operation, partialTxs, _a, tezosSpendOperation_1, tezosOriginationOperation, delegate, delegate;
+                        var _this = this;
+                        return __generator(this, function (_b) {
+                            switch (_b.label) {
+                                case 0:
+                                    partialTxs = [];
+                                    _a = tezosOperation.kind;
+                                    switch (_a) {
+                                        case TezosOperationType_1.TezosOperationType.REVEAL: return [3 /*break*/, 1];
+                                        case TezosOperationType_1.TezosOperationType.TRANSACTION: return [3 /*break*/, 2];
+                                        case TezosOperationType_1.TezosOperationType.ORIGINATION: return [3 /*break*/, 4];
+                                        case TezosOperationType_1.TezosOperationType.DELEGATION: return [3 /*break*/, 5];
+                                        case TezosOperationType_1.TezosOperationType.ENDORSEMENT: return [3 /*break*/, 6];
+                                        case TezosOperationType_1.TezosOperationType.SEED_NONCE_REVELATION: return [3 /*break*/, 6];
+                                        case TezosOperationType_1.TezosOperationType.DOUBLE_ENDORSEMENT_EVIDENCE: return [3 /*break*/, 6];
+                                        case TezosOperationType_1.TezosOperationType.DOUBLE_BAKING_EVIDENCE: return [3 /*break*/, 6];
+                                        case TezosOperationType_1.TezosOperationType.ACTIVATE_ACCOUNT: return [3 /*break*/, 6];
+                                        case TezosOperationType_1.TezosOperationType.PROPOSALS: return [3 /*break*/, 6];
+                                        case TezosOperationType_1.TezosOperationType.BALLOT: return [3 /*break*/, 6];
+                                    }
+                                    return [3 /*break*/, 7];
+                                case 1:
+                                    operation = tezosOperation;
+                                    partialTxs = [
+                                        {
+                                            from: [operation.source],
+                                            to: ['Reveal']
+                                        }
+                                    ];
+                                    return [3 /*break*/, 8];
+                                case 2:
+                                    tezosSpendOperation_1 = tezosOperation;
+                                    operation = tezosSpendOperation_1;
+                                    return [4 /*yield*/, this.getTransactionOperationDetails(tezosSpendOperation_1)];
+                                case 3:
+                                    partialTxs = (_b.sent()).map(function (tx) { return (__assign(__assign({}, tx), { extra: __assign(__assign({}, tx.extra), { parameters: tezosSpendOperation_1.parameters }) })); });
+                                    return [3 /*break*/, 8];
+                                case 4:
+                                    {
+                                        tezosOriginationOperation = tezosOperation;
+                                        operation = tezosOriginationOperation;
+                                        delegate = tezosOriginationOperation.delegate;
+                                        partialTxs = [
+                                            {
+                                                from: [operation.source],
+                                                amount: new bignumber_1.default(tezosOriginationOperation.balance).toFixed(),
+                                                to: [delegate ? "Delegate: ".concat(delegate) : 'Origination']
+                                            }
+                                        ];
+                                    }
+                                    return [3 /*break*/, 8];
+                                case 5:
+                                    {
+                                        operation = tezosOperation;
+                                        delegate = operation.delegate;
+                                        partialTxs = [
+                                            {
+                                                from: [operation.source],
+                                                to: [delegate ? delegate : 'Undelegate']
+                                            }
+                                        ];
+                                    }
+                                    return [3 /*break*/, 8];
+                                case 6: throw new index_4.UnsupportedError(coinlib_error_1.Domain.TEZOS, 'operation not supported: ' + JSON.stringify(tezosOperation.kind));
+                                case 7:
+                                    // Exhaustive switch
+                                    assertNever(tezosOperation.kind);
+                                    throw new index_4.NotFoundError(coinlib_error_1.Domain.TEZOS, 'no operation to unforge found');
+                                case 8: return [2 /*return*/, partialTxs.map(function (partialTx) {
+                                        return __assign({ amount: '0', fee: operation !== undefined ? new bignumber_1.default(operation.fee).toString(10) : '0', from: [], isInbound: false, protocolIdentifier: _this.identifier, network: _this.options.network, to: [], transactionDetails: tezosOperation }, partialTx);
+                                    })];
                             }
-                        ];
-                    }
-                    break;
-                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:
-                    throw new index_4.UnsupportedError(coinlib_error_1.Domain.TEZOS, 'operation not supported: ' + JSON.stringify(tezosOperation.kind));
-                default:
-                    // Exhaustive switch
-                    assertNever(tezosOperation.kind);
-                    throw new index_4.NotFoundError(coinlib_error_1.Domain.TEZOS, 'no operation to unforge found');
-            }
-            return partialTxs.map((partialTx) => {
-                return {
-                    amount: '0',
-                    fee: operation !== undefined ? new bignumber_1.default(operation.fee).toString(10) : '0',
-                    from: [],
-                    isInbound: false,
-                    protocolIdentifier: this.identifier,
-                    network: this.options.network,
-                    to: [],
-                    transactionDetails: tezosOperation,
-                    ...partialTx
-                };
+                        });
+                    }); })).then(function (airGapTxs) {
+                        return airGapTxs.reduce(function (flatten, next) { return flatten.concat(next); }, []);
+                    })];
             });
-        })).then((airGapTxs) => airGapTxs.reduce((flatten, next) => flatten.concat(next), []));
-    }
-    async getBalanceOfAddresses(addresses, _data) {
-        let balance = new bignumber_1.default(0);
-        for (const address of addresses) {
-            try {
-                const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${address}/balance`);
-                balance = balance.plus(new bignumber_1.default(data));
-            }
-            catch (error) {
-                // if node returns 404 (which means 'no account found'), go with 0 balance
-                if (error.response && error.response.status !== 404) {
-                    throw new index_4.NetworkError(coinlib_error_1.Domain.TEZOS, error);
+        });
+    };
+    TezosProtocol.prototype.getBalanceOfAddresses = function (addresses, _data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, _i, addresses_1, address, data, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        balance = new bignumber_1.default(0);
+                        _i = 0, addresses_1 = addresses;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < addresses_1.length)) return [3 /*break*/, 6];
+                        address = addresses_1[_i];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/balance"))];
+                    case 3:
+                        data = (_a.sent()).data;
+                        balance = balance.plus(new bignumber_1.default(data));
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _a.sent();
+                        // if node returns 404 (which means 'no account found'), go with 0 balance
+                        if (error_1.response && error_1.response.status !== 404) {
+                            throw new index_4.NetworkError(coinlib_error_1.Domain.TEZOS, error_1);
+                        }
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 6: return [2 /*return*/, balance.toString(10)];
                 }
-            }
-        }
-        return balance.toString(10);
-    }
-    async getBalanceOfPublicKey(publicKey, data) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getBalanceOfAddresses([address.address], data);
-    }
-    async getBalanceOfPublicKeyForSubProtocols(publicKey, subProtocols) {
-        return Promise.all(subProtocols.map((subProtocol) => subProtocol.getBalanceOfPublicKey(publicKey).catch(() => '0')));
-    }
-    async getAvailableBalanceOfAddresses(addresses, data) {
-        return this.getBalanceOfAddresses(addresses, data);
-    }
-    async estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee) {
-        const balance = await this.getBalanceOfPublicKey(publicKey);
-        const balanceWrapper = new bignumber_1.default(balance).minus(1); // Tezos accounts can never be empty. We must leave at least 1 mutez behind.
-        return this.estimateMaxTansactionValueWithBalance(publicKey, balanceWrapper, recipients, fee);
-    }
-    async estimateMaxTansactionValueWithBalance(publicKey, balance, recipients, fee) {
-        let maxFee = new bignumber_1.default(0);
-        if (fee !== undefined) {
-            maxFee = new bignumber_1.default(fee);
-        }
-        else {
-            try {
-                const estimatedFeeDefaults = await this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, [balance.toFixed()]);
-                maxFee = new bignumber_1.default(estimatedFeeDefaults.medium).shiftedBy(this.decimals);
-                if (maxFee.gte(balance)) {
-                    maxFee = new bignumber_1.default(0);
+            });
+        });
+    };
+    TezosProtocol.prototype.getBalanceOfPublicKey = function (publicKey, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getBalanceOfAddresses([address.address], data)];
                 }
-            }
-            catch (error) {
-                if (error.code !== undefined && error.code === index_4.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.estimateMaxTansactionValueWithBalance(publicKey, newMaxBalance, recipients, fee);
+            });
+        });
+    };
+    TezosProtocol.prototype.getBalanceOfPublicKeyForSubProtocols = function (publicKey, subProtocols) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, Promise.all(subProtocols.map(function (subProtocol) { return subProtocol.getBalanceOfPublicKey(publicKey).catch(function () { return '0'; }); }))];
+            });
+        });
+    };
+    TezosProtocol.prototype.getAvailableBalanceOfAddresses = function (addresses, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getBalanceOfAddresses(addresses, data)];
+            });
+        });
+    };
+    TezosProtocol.prototype.estimateMaxTransactionValueFromPublicKey = function (publicKey, recipients, fee) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, balanceWrapper;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        balanceWrapper = new bignumber_1.default(balance).minus(1) // Tezos accounts can never be empty. We must leave at least 1 mutez behind.
+                        ;
+                        return [2 /*return*/, this.estimateMaxTansactionValueWithBalance(publicKey, balanceWrapper, recipients, fee)];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.estimateMaxTansactionValueWithBalance = function (publicKey, balance, recipients, fee) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxFee, estimatedFeeDefaults, error_2, rpcErrors, balanceTooLowError, excess, newMaxBalance, amountWithoutFees;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        maxFee = new bignumber_1.default(0);
+                        if (!(fee !== undefined)) return [3 /*break*/, 1];
+                        maxFee = new bignumber_1.default(fee);
+                        return [3 /*break*/, 4];
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.estimateFeeDefaultsFromPublicKey(publicKey, recipients, [balance.toFixed()])];
+                    case 2:
+                        estimatedFeeDefaults = _a.sent();
+                        maxFee = new bignumber_1.default(estimatedFeeDefaults.medium).shiftedBy(this.decimals);
+                        if (maxFee.gte(balance)) {
+                            maxFee = new bignumber_1.default(0);
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        if (error_2.code !== undefined && error_2.code === index_4.ProtocolErrorType.TRANSACTION_FAILED && Array.isArray(error_2.data)) {
+                            rpcErrors = error_2.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.estimateMaxTansactionValueWithBalance(publicKey, newMaxBalance, recipients, fee)];
+                                }
+                            }
+                        }
+                        throw error_2;
+                    case 4:
+                        amountWithoutFees = balance.minus(maxFee);
+                        if (amountWithoutFees.isNegative()) {
+                            amountWithoutFees = new bignumber_1.default(0);
                         }
-                    }
+                        return [2 /*return*/, amountWithoutFees.toFixed()];
                 }
-                throw error;
-            }
-        }
-        let amountWithoutFees = balance.minus(maxFee);
-        if (amountWithoutFees.isNegative()) {
-            amountWithoutFees = new bignumber_1.default(0);
-        }
-        return amountWithoutFees.toFixed();
-    }
-    async estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, _data) {
-        if (recipients.length !== values.length) {
-            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'length of recipients and values does not match!');
-        }
-        const operations = [];
-        for (let i = 0; i < values.length; ++i) {
-            const recipient = recipients[i];
-            const transaction = {
-                kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
-                amount: values[i],
-                destination: recipient,
-                fee: '0'
-            };
-            operations.push(transaction);
-        }
-        if (recipients.length === 0) {
-            return this.feeDefaults;
-        }
-        return this.estimateFeeDefaultsForOperations(publicKey, operations);
-    }
-    async estimateFeeDefaultsForOperations(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 ? this.revealFee : 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: lowFee.shiftedBy(-this.feeDecimals).toFixed(),
-            medium: mediumFee.shiftedBy(-this.feeDecimals).toFixed(),
-            high: highFee.shiftedBy(-this.feeDecimals).toFixed()
-        };
-    }
-    async prepareTransactionFromPublicKey(publicKey, recipients, values, fee, data) {
-        if (recipients.length !== values.length) {
-            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'length of recipients and values does not match!');
-        }
-        if (recipients.length > MAX_OPERATIONS_PER_GROUP) {
-            throw new index_4.ConditionViolationError(coinlib_error_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.prepareTransactionsFromPublicKey(publicKey, recipients, values, fee, data);
-        if (transactions.length === 1) {
-            return transactions[0];
-        }
-        else {
-            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'Transaction could not be prepared. More or less than 1 operations have been generated.');
-        }
-    }
-    async prepareTransactionsFromPublicKey(publicKey, recipients, values, fee, data, operationsPerGroup = MAX_OPERATIONS_PER_GROUP) {
-        const wrappedValues = values.map((value) => new bignumber_1.default(value));
-        const wrappedFee = new bignumber_1.default(fee);
-        if (recipients.length !== wrappedValues.length) {
-            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'length of recipients and values does not match!');
-        }
-        const operations = [];
-        // check if we got an address-index
-        const addressIndex = data && data.addressIndex ? data.addressIndex : 0;
-        const addresses = await this.getAddressesFromPublicKey(publicKey).then((addresses) => addresses.map((address) => address.address));
-        if (!addresses[addressIndex]) {
-            throw new index_4.NotFoundError(coinlib_error_1.Domain.TEZOS, 'no kt-address with this index exists');
-        }
-        const address = addresses[addressIndex];
-        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 index_4.NetworkError(coinlib_error_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(await this.createRevealOperation(counter, publicKey, address));
-            counter = counter.plus(1);
-        }
-        const balance = new bignumber_1.default(await this.getBalanceOfPublicKey(publicKey));
-        const wrappedOperations = [];
-        let allOperations = await this.createTransactionOperations(operations, recipients, wrappedValues, wrappedFee, address, counter, balance);
-        allOperations = operations.concat(allOperations); // if we have a reveal in operations, we need to make sure it is present in the allOperations array
-        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);
-            wrappedOperations.push(await this.forgeAndWrapOperations(wrappedOperationWithEstimatedGas));
-        }
-        return wrappedOperations;
-    }
-    async getTransactionOperationDetails(transactionOperation) {
-        return [
-            {
-                from: [transactionOperation.source],
-                amount: new bignumber_1.default(transactionOperation.amount).toFixed(),
-                to: [transactionOperation.destination] // contract destination but should be the address of actual receiver
-            }
-        ];
-    }
-    async createTransactionOperations(previousOperations, recipients, wrappedValues, wrappedFee, address, counter, balance) {
-        const amountUsedByPreviousOperations = this.getAmountUsedByPreviousOperations(previousOperations);
-        const operations = [];
-        if (!amountUsedByPreviousOperations.isZero()) {
-            if (balance.isLessThan(wrappedValues[0].plus(wrappedFee).plus(amountUsedByPreviousOperations))) {
-                // if not, make room for the init fee
-                wrappedValues[0] = wrappedValues[0].minus(amountUsedByPreviousOperations); // 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 < recipients.length; i++) {
-            const receivingBalance = new bignumber_1.default(await this.getBalanceOfAddresses([recipients[i]]));
-            // if our receiver has 0 balance, the account is not activated yet.
-            if (receivingBalance.isZero() && recipients[i].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(this.activationBurn.plus(wrappedFee))) {
-                    // If we don't have enough funds to pay the activation + fee, we throw an error
-                    throw new index_4.BalanceError(coinlib_error_1.Domain.TEZOS, 'Insufficient balance to pay activation burn!');
+            });
+        });
+    };
+    TezosProtocol.prototype.estimateFeeDefaultsFromPublicKey = function (publicKey, recipients, values, _data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var operations, i, recipient, transaction;
+            return __generator(this, function (_a) {
+                if (recipients.length !== values.length) {
+                    throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'length of recipients and values does not match!');
                 }
-                else if (balance.isLessThan(wrappedValues[i].plus(wrappedFee).plus(this.activationBurn))) {
-                    // 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
-                    wrappedValues[i] = wrappedValues[i].minus(this.activationBurn); // deduct fee from balance
+                operations = [];
+                for (i = 0; i < values.length; ++i) {
+                    recipient = recipients[i];
+                    transaction = {
+                        kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
+                        amount: values[i],
+                        destination: recipient,
+                        fee: '0'
+                    };
+                    operations.push(transaction);
                 }
-            }
-            if (balance.isEqualTo(wrappedValues[i].plus(wrappedFee))) {
-                // Tezos accounts can never be empty. If user tries to send everything, we must leave 1 mutez behind.
-                wrappedValues[i] = wrappedValues[i].minus(1);
-            }
-            else if (balance.isLessThan(wrappedValues[i].plus(wrappedFee))) {
-                throw new index_4.BalanceError(coinlib_error_1.Domain.TEZOS, 'not enough balance');
-            }
-            const spendOperation = {
-                kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
-                fee: wrappedFee.toFixed(),
-                gas_limit: GAS_LIMIT_PLACEHOLDER,
-                storage_limit: STORAGE_LIMIT_PLACEHOLDER,
-                amount: wrappedValues[i].toFixed(),
-                counter: counter.plus(i).toFixed(),
-                destination: recipients[i],
-                source: address
-            };
-            operations.push(spendOperation);
-        }
-        return operations;
-    }
-    async forgeAndWrapOperations(tezosWrappedOperation) {
-        try {
-            const binaryTx = await this.forgeTezosOperation(tezosWrappedOperation);
-            return { binaryTransaction: binaryTx };
-        }
-        catch (error) {
-            throw new index_4.OperationFailedError(coinlib_error_1.Domain.TEZOS, `Forging Tezos TX failed with ${JSON.stringify(error.message)}`);
-        }
-    }
-    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.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.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.address);
-    }
-    async getDelegatorDetailsFromAddress(address) {
-        return this.getDelegatorDetails(address);
-    }
-    async getDelegationDetailsFromPublicKey(publicKey, delegatees) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getDelegationDetailsFromAddress(address.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}`)]);
-        const accountDetails = results[0].data;
-        const balance = accountDetails.balance;
-        const isDelegating = !!accountDetails.delegate;
-        const availableActions = [];
-        if (!isDelegating) {
-            availableActions.push({
-                type: TezosDelegatorAction.DELEGATE,
-                args: ['delegate']
+                if (recipients.length === 0) {
+                    return [2 /*return*/, this.feeDefaults];
+                }
+                return [2 /*return*/, this.estimateFeeDefaultsForOperations(publicKey, operations)];
             });
-        }
-        else if (!bakerAddress || accountDetails.delegate === bakerAddress) {
-            availableActions.push({
-                type: TezosDelegatorAction.UNDELEGATE
+        });
+    };
+    TezosProtocol.prototype.estimateFeeDefaultsForOperations = 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 ? this.revealFee : 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: lowFee.shiftedBy(-this.feeDecimals).toFixed(),
+                                medium: mediumFee.shiftedBy(-this.feeDecimals).toFixed(),
+                                high: highFee.shiftedBy(-this.feeDecimals).toFixed()
+                            }];
+                }
             });
-        }
-        else {
-            availableActions.push({
-                type: TezosDelegatorAction.CHANGE_BAKER,
-                args: ['delegate']
+        });
+    };
+    TezosProtocol.prototype.prepareTransactionFromPublicKey = function (publicKey, recipients, values, fee, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transactions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (recipients.length !== values.length) {
+                            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'length of recipients and values does not match!');
+                        }
+                        if (recipients.length > MAX_OPERATIONS_PER_GROUP) {
+                            throw new index_4.ConditionViolationError(coinlib_error_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.prepareTransactionsFromPublicKey(publicKey, recipients, values, fee, data)];
+                    case 1:
+                        transactions = _a.sent();
+                        if (transactions.length === 1) {
+                            return [2 /*return*/, transactions[0]];
+                        }
+                        else {
+                            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'Transaction could not be prepared. More or less than 1 operations have been generated.');
+                        }
+                        return [2 /*return*/];
+                }
             });
-        }
-        return {
-            address,
-            balance,
-            delegatees: [accountDetails.delegate],
-            availableActions
-        };
-    }
-    async prepareDelegatorActionFromPublicKey(publicKey, type, data) {
-        switch (type) {
-            case TezosDelegatorAction.DELEGATE:
-            case TezosDelegatorAction.CHANGE_BAKER:
-                if (!data || !data.delegate) {
-                    return Promise.reject(`Invalid arguments passed for ${type} action, delegate is missing.`);
+        });
+    };
+    TezosProtocol.prototype.prepareTransactionsFromPublicKey = function (publicKey, recipients, values, fee, data, operationsPerGroup) {
+        if (operationsPerGroup === void 0) { operationsPerGroup = MAX_OPERATIONS_PER_GROUP; }
+        return __awaiter(this, void 0, void 0, function () {
+            var wrappedValues, wrappedFee, operations, addressIndex, addresses, address, results, currentCounter, counter, branch, accountManager, _a, _b, balance, _c, wrappedOperations, allOperations, numberOfGroups, startingCounter, i, start, end, operationsGroup, wrappedOperationWithEstimatedGas, _d, _e;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        wrappedValues = values.map(function (value) { return new bignumber_1.default(value); });
+                        wrappedFee = new bignumber_1.default(fee);
+                        if (recipients.length !== wrappedValues.length) {
+                            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'length of recipients and values does not match!');
+                        }
+                        operations = [];
+                        addressIndex = data && data.addressIndex ? data.addressIndex : 0;
+                        return [4 /*yield*/, this.getAddressesFromPublicKey(publicKey).then(function (addresses) {
+                                return addresses.map(function (address) { return address.address; });
+                            })];
+                    case 1:
+                        addresses = _f.sent();
+                        if (!addresses[addressIndex]) {
+                            throw new index_4.NotFoundError(coinlib_error_1.Domain.TEZOS, 'no kt-address with this index exists');
+                        }
+                        address = addresses[addressIndex];
+                        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 index_4.NetworkError(coinlib_error_1.Domain.TEZOS, error);
+                            })];
+                    case 2:
+                        results = _f.sent();
+                        currentCounter = new bignumber_1.default(results[0].data);
+                        counter = currentCounter.plus(1);
+                        branch = results[1].data;
+                        accountManager = results[2].data;
+                        if (!!accountManager) return [3 /*break*/, 4];
+                        _b = (_a = operations).push;
+                        return [4 /*yield*/, this.createRevealOperation(counter, publicKey, address)];
+                    case 3:
+                        _b.apply(_a, [_f.sent()]);
+                        counter = counter.plus(1);
+                        _f.label = 4;
+                    case 4:
+                        _c = bignumber_1.default.bind;
+                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 5:
+                        balance = new (_c.apply(bignumber_1.default, [void 0, _f.sent()]))();
+                        wrappedOperations = [];
+                        return [4 /*yield*/, this.createTransactionOperations(operations, recipients, wrappedValues, wrappedFee, address, counter, balance)];
+                    case 6:
+                        allOperations = _f.sent();
+                        allOperations = operations.concat(allOperations); // if we have a reveal in operations, we need to make sure it is present in the allOperations array
+                        numberOfGroups = Math.ceil(allOperations.length / operationsPerGroup);
+                        startingCounter = numberOfGroups > 1 ? currentCounter.plus(1) : undefined;
+                        i = 0;
+                        _f.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 = _f.sent();
+                        _e = (_d = wrappedOperations).push;
+                        return [4 /*yield*/, this.forgeAndWrapOperations(wrappedOperationWithEstimatedGas)];
+                    case 9:
+                        _e.apply(_d, [_f.sent()]);
+                        _f.label = 10;
+                    case 10:
+                        i++;
+                        return [3 /*break*/, 7];
+                    case 11: return [2 /*return*/, wrappedOperations];
                 }
-                return [await this.delegate(publicKey, data.delegate)];
-            case TezosDelegatorAction.UNDELEGATE:
-                return [await this.undelegate(publicKey)];
-            default:
-                return Promise.reject('Unsupported delegator action.');
-        }
-    }
-    async prepareOperations(publicKey, operationRequests, overrideParameters = true) {
-        let counter = new bignumber_1.default(1);
-        let branch;
-        const operations = [];
-        const address = await this.getAddressFromPublicKey(publicKey).then((address) => address.address);
-        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 index_4.NetworkError(coinlib_error_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(await this.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 index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "kind" was not defined');
-            }
-            const recipient = operationRequest.destination;
-            let receivingBalance;
-            if (recipient && recipient.toLowerCase().startsWith('tz')) {
-                receivingBalance = new bignumber_1.default(await this.getBalanceOfAddresses([recipient]));
-            }
-            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 index_4.PropertyUndefinedError(coinlib_error_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 index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "amount" was not defined');
-                    }
-                    if (!transactionOperation.destination) {
-                        throw new index_4.PropertyUndefinedError(coinlib_error_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 index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "balance" was not defined');
-                    }
-                    if (!originationOperation.script) {
-                        throw new index_4.PropertyUndefinedError(coinlib_error_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, assert_1.assertNever)(operationRequest.kind);
-                    throw new index_4.UnsupportedError(coinlib_error_1.Domain.TEZOS, `unsupported operation type "${JSON.stringify(operationRequest.kind)}"`);
-            }
+            });
         });
-        operations.push(...(await Promise.all(operationPromises)));
-        const tezosWrappedOperation = {
-            branch,
-            contents: operations
-        };
-        return await this.estimateAndReplaceLimitsAndFee(tezosWrappedOperation, overrideParameters);
-    }
-    async estimateAndReplaceLimitsAndFee(tezosWrappedOperation, 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 = tezosWrappedOperation.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(tezosWrappedOperation.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: tezosWrappedOperation.branch,
-                contents: contents,
-                signature: fakeSignature // signature will not be checked, so it is ok to always use this one
-            }
-        };
-        const forgedOperation = await this.forgeTezosOperation(tezosWrappedOperation);
-        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 index_4.NetworkError(coinlib_error_1.Domain.TEZOS, runOperationError);
-        });
-        if (tezosWrappedOperation.contents.length !== response.data.contents.length) {
-            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, `Run Operation did not return same number of operations. Locally we have ${tezosWrappedOperation.contents.length}, but got back ${response.data.contents.length}`);
-        }
-        tezosWrappedOperation.contents.forEach((content, i) => {
-            const metadata = response.data.contents[i].metadata;
-            if (metadata.operation_result) {
-                const operation = content;
-                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 index_4.TransactionError(coinlib_error_1.Domain.TEZOS, 'An internal operation produced an error', internalOperation.result.errors);
-                            }
-                            gasLimit += Math.ceil(Number(internalOperation.result.consumed_milligas) / 1000);
-                            if (internalOperation.result.paid_storage_size_diff) {
-                                storageLimit += Number(internalOperation.result.paid_storage_size_diff);
+    };
+    TezosProtocol.prototype.getTransactionOperationDetails = function (transactionOperation) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, [
+                        {
+                            from: [transactionOperation.source],
+                            amount: new bignumber_1.default(transactionOperation.amount).toFixed(),
+                            to: [transactionOperation.destination] // contract destination but should be the address of actual receiver
+                        }
+                    ]];
+            });
+        });
+    };
+    TezosProtocol.prototype.createTransactionOperations = function (previousOperations, recipients, wrappedValues, wrappedFee, address, counter, balance) {
+        return __awaiter(this, void 0, void 0, function () {
+            var amountUsedByPreviousOperations, operations, i, receivingBalance, _a, spendOperation;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        amountUsedByPreviousOperations = this.getAmountUsedByPreviousOperations(previousOperations);
+                        operations = [];
+                        if (!amountUsedByPreviousOperations.isZero()) {
+                            if (balance.isLessThan(wrappedValues[0].plus(wrappedFee).plus(amountUsedByPreviousOperations))) {
+                                // if not, make room for the init fee
+                                wrappedValues[0] = wrappedValues[0].minus(amountUsedByPreviousOperations); // deduct fee from balance
                             }
-                            if (internalOperation.result.originated_contracts) {
-                                storageLimit += internalOperation.result.originated_contracts.length * 257;
+                        }
+                        i = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(i < recipients.length)) return [3 /*break*/, 4];
+                        _a = bignumber_1.default.bind;
+                        return [4 /*yield*/, this.getBalanceOfAddresses([recipients[i]])];
+                    case 2:
+                        receivingBalance = new (_a.apply(bignumber_1.default, [void 0, _b.sent()]))();
+                        // if our receiver has 0 balance, the account is not activated yet.
+                        if (receivingBalance.isZero() && recipients[i].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(this.activationBurn.plus(wrappedFee))) {
+                                // If we don't have enough funds to pay the activation + fee, we throw an error
+                                throw new index_4.BalanceError(coinlib_error_1.Domain.TEZOS, 'Insufficient balance to pay activation burn!');
                             }
-                            if (internalOperation.result.allocated_destination_contract) {
-                                storageLimit += 257;
+                            else if (balance.isLessThan(wrappedValues[i].plus(wrappedFee).plus(this.activationBurn))) {
+                                // 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
+                                wrappedValues[i] = wrappedValues[i].minus(this.activationBurn); // deduct fee from balance
                             }
                         }
-                    });
+                        if (balance.isEqualTo(wrappedValues[i].plus(wrappedFee))) {
+                            // Tezos accounts can never be empty. If user tries to send everything, we must leave 1 mutez behind.
+                            wrappedValues[i] = wrappedValues[i].minus(1);
+                        }
+                        else if (balance.isLessThan(wrappedValues[i].plus(wrappedFee))) {
+                            throw new index_4.BalanceError(coinlib_error_1.Domain.TEZOS, 'not enough balance');
+                        }
+                        spendOperation = {
+                            kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
+                            fee: wrappedFee.toFixed(),
+                            gas_limit: GAS_LIMIT_PLACEHOLDER,
+                            storage_limit: STORAGE_LIMIT_PLACEHOLDER,
+                            amount: wrappedValues[i].toFixed(),
+                            counter: counter.plus(i).toFixed(),
+                            destination: recipients[i],
+                            source: address
+                        };
+                        operations.push(spendOperation);
+                        _b.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, operations];
                 }
-                if (result.errors) {
-                    throw new index_4.TransactionError(coinlib_error_1.Domain.TEZOS, 'The operation produced an error', result.errors);
+            });
+        });
+    };
+    TezosProtocol.prototype.forgeAndWrapOperations = function (tezosWrappedOperation) {
+        return __awaiter(this, void 0, void 0, function () {
+            var binaryTx, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.forgeTezosOperation(tezosWrappedOperation)];
+                    case 1:
+                        binaryTx = _a.sent();
+                        return [2 /*return*/, { binaryTransaction: binaryTx }];
+                    case 2:
+                        error_3 = _a.sent();
+                        throw new index_4.OperationFailedError(coinlib_error_1.Domain.TEZOS, "Forging Tezos TX failed with ".concat(JSON.stringify(error_3.message)));
+                    case 3: return [2 /*return*/];
                 }
-                // 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);
+            });
+        });
+    };
+    TezosProtocol.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] || ''];
                 }
-                if (result.originated_contracts) {
-                    storageLimit += result.originated_contracts.length * 257;
+            });
+        });
+    };
+    TezosProtocol.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.address)];
                 }
-                if (result.allocated_destination_contract) {
-                    storageLimit += 257;
+            });
+        });
+    };
+    TezosProtocol.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] : []];
                 }
-                // in prepareTransactionsFromPublicKey() we invoke this method with overrideParameters = false
-                if ((operation.gas_limit && overrideParameters) || operation.gas_limit === GAS_LIMIT_PLACEHOLDER) {
-                    ;
-                    operation.gas_limit = gasLimit.toString();
+            });
+        });
+    };
+    TezosProtocol.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
+                            }];
                 }
-                if ((operation.storage_limit && overrideParameters) || operation.storage_limit === STORAGE_LIMIT_PLACEHOLDER) {
-                    ;
-                    operation.storage_limit = storageLimit.toString();
+            });
+        });
+    };
+    TezosProtocol.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.address)];
                 }
-                gasLimitTotal += gasLimit;
-            }
+            });
         });
-        if (overrideParameters || tezosWrappedOperation.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 = tezosWrappedOperation.contents.filter((operation) => operation.kind !== 'reveal');
-            const feePerOperation = Math.ceil(fee / nonRevealOperations.length);
-            tezosWrappedOperation.contents.forEach((operation) => {
-                if (operation.fee && operation.kind !== 'reveal') {
-                    ;
-                    operation.fee = feePerOperation.toString();
+    };
+    TezosProtocol.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];
                 }
             });
-        }
-        return tezosWrappedOperation;
-    }
-    async getDelegationInfo(delegatedAddress, fetchExtraInfo = true) {
-        const { data } = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/contracts/${delegatedAddress}`);
-        let delegatedOpLevel;
-        let delegatedDate;
-        // if the address is delegated, check since when
-        if (data.delegate && fetchExtraInfo) {
-            const recentTransactionData = await this.options.network.extras.indexerClient.getDelegationInfo(delegatedAddress);
-            if (recentTransactionData) {
-                delegatedDate = recentTransactionData.date;
-                delegatedOpLevel = recentTransactionData.level;
-            }
-        }
-        return {
-            isDelegated: data.delegate ? true : false,
-            value: data.delegate,
-            delegatedDate,
-            delegatedOpLevel
-        };
-    }
-    async bakerInfo(tzAddress) {
-        if (!tzAddress ||
-            !(tzAddress.toLowerCase().startsWith('tz1') ||
-                tzAddress.toLowerCase().startsWith('tz2') ||
-                tzAddress.toLowerCase().startsWith('tz3') ||
-                tzAddress.toLowerCase().startsWith('tz4'))) {
-            throw new index_4.ConditionViolationError(coinlib_error_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/${tzAddress}/balance`)
-                .catch((_error) => undefined),
-            index_1.default
-                .get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${tzAddress}/full_balance`)
-                .catch((_error) => undefined),
-            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${tzAddress}/delegated_balance`),
-            index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/head/context/delegates/${tzAddress}/staking_balance`)
-        ]).catch((error) => {
-            throw new index_4.NetworkError(coinlib_error_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);
-        // 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 bakerInfo = {
-            balance: tzBalance,
-            delegatedBalance,
-            stakingBalance,
-            selfBond,
-            bakerCapacity: stakingBalance.div(stakingCapacity),
-            bakerUsage: stakingCapacity
-        };
-        return bakerInfo;
-    }
-    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).then((address) => address.address);
-        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 index_4.NetworkError(coinlib_error_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(await this.createRevealOperation(counter, publicKey, tzAddress));
-            counter = counter.plus(1);
-        }
-        const balance = new bignumber_1.default(await this.getBalanceOfAddresses([tzAddress]));
-        const fee = new bignumber_1.default(1420);
-        if (balance.isLessThan(fee)) {
-            throw new index_4.BalanceError(coinlib_error_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 binaryTx = await this.forgeTezosOperation(tezosWrappedOperation);
-            return { binaryTransaction: binaryTx };
-        }
-        catch (error) {
-            throw new index_4.OperationFailedError(coinlib_error_1.Domain.TEZOS, `Forging Tezos TX failed with ${JSON.stringify(error.message)}`);
-        }
-    }
-    getAmountUsedByPreviousOperations(operations) {
-        let amountUsed = new bignumber_1.default(0);
-        operations.forEach((operation) => {
+        });
+    };
+    TezosProtocol.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.address)];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getDelegatorDetailsFromAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getDelegatorDetails(address)];
+            });
+        });
+    };
+    TezosProtocol.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.address, delegatees)];
+                }
+            });
+        });
+    };
+    TezosProtocol.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]
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getDelegatorDetails = function (address, bakerAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var results, accountDetails, balance, isDelegating, availableActions;
+            return __generator(this, function (_a) {
+                switch (_a.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))])];
+                    case 1:
+                        results = _a.sent();
+                        accountDetails = results[0].data;
+                        balance = accountDetails.balance;
+                        isDelegating = !!accountDetails.delegate;
+                        availableActions = [];
+                        if (!isDelegating) {
+                            availableActions.push({
+                                type: TezosDelegatorAction.DELEGATE,
+                                args: ['delegate']
+                            });
+                        }
+                        else if (!bakerAddress || accountDetails.delegate === bakerAddress) {
+                            availableActions.push({
+                                type: TezosDelegatorAction.UNDELEGATE
+                            });
+                        }
+                        else {
+                            availableActions.push({
+                                type: TezosDelegatorAction.CHANGE_BAKER,
+                                args: ['delegate']
+                            });
+                        }
+                        return [2 /*return*/, {
+                                address: address,
+                                balance: balance,
+                                delegatees: [accountDetails.delegate],
+                                availableActions: availableActions
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocol.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.DELEGATE: return [3 /*break*/, 1];
+                            case TezosDelegatorAction.CHANGE_BAKER: return [3 /*break*/, 1];
+                            case TezosDelegatorAction.UNDELEGATE: return [3 /*break*/, 3];
+                        }
+                        return [3 /*break*/, 5];
+                    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 [2 /*return*/, Promise.reject('Unsupported delegator action.')];
+                }
+            });
+        });
+    };
+    TezosProtocol.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, _a, _b, operationPromises, _c, _d, _e, tezosWrappedOperation;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        counter = new bignumber_1.default(1);
+                        operations = [];
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey).then(function (address) { return address.address; })];
+                    case 1:
+                        address = _f.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 index_4.NetworkError(coinlib_error_1.Domain.TEZOS, error);
+                            })];
+                    case 2:
+                        results = _f.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; });
+                        if (!(!accountManager && !hasRevealInOperationRequests)) return [3 /*break*/, 4];
+                        _b = (_a = operations).push;
+                        return [4 /*yield*/, this.createRevealOperation(counter, publicKey, address)];
+                    case 3:
+                        _b.apply(_a, [_f.sent()]);
+                        counter = counter.plus(1);
+                        _f.label = 4;
+                    case 4:
+                        operationPromises = operationRequests.map(function (operationRequest, index) { return __awaiter(_this, void 0, void 0, function () {
+                            var recipient, receivingBalance, _a, defaultCounter, defaultFee, defaultGasLimit, defaultStorageLimit, revealOperation, delegationOperation, transactionOperation, originationOperation;
+                            var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+                            return __generator(this, function (_y) {
+                                switch (_y.label) {
+                                    case 0:
+                                        // TODO: Handle activation burn
+                                        if (!operationRequest.kind) {
+                                            throw new index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "kind" was not defined');
+                                        }
+                                        recipient = operationRequest.destination;
+                                        if (!(recipient && recipient.toLowerCase().startsWith('tz'))) return [3 /*break*/, 2];
+                                        _a = bignumber_1.default.bind;
+                                        return [4 /*yield*/, this.getBalanceOfAddresses([recipient])];
+                                    case 1:
+                                        receivingBalance = new (_a.apply(bignumber_1.default, [void 0, _y.sent()]))();
+                                        _y.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 index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "public_key" was not defined');
+                                                }
+                                                revealOperation.source = (_b = revealOperation.source) !== null && _b !== void 0 ? _b : address;
+                                                revealOperation.counter = (_c = revealOperation.counter) !== null && _c !== void 0 ? _c : defaultCounter;
+                                                revealOperation.fee = (_d = revealOperation.fee) !== null && _d !== void 0 ? _d : defaultFee;
+                                                revealOperation.gas_limit = (_e = revealOperation.gas_limit) !== null && _e !== void 0 ? _e : defaultGasLimit;
+                                                revealOperation.storage_limit = (_f = revealOperation.storage_limit) !== null && _f !== void 0 ? _f : 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 = (_g = delegationOperation.source) !== null && _g !== void 0 ? _g : address;
+                                                delegationOperation.counter = (_h = delegationOperation.counter) !== null && _h !== void 0 ? _h : defaultCounter;
+                                                delegationOperation.fee = (_j = delegationOperation.fee) !== null && _j !== void 0 ? _j : defaultFee;
+                                                delegationOperation.gas_limit = (_k = delegationOperation.gas_limit) !== null && _k !== void 0 ? _k : defaultGasLimit;
+                                                delegationOperation.storage_limit = (_l = delegationOperation.storage_limit) !== null && _l !== void 0 ? _l : defaultStorageLimit;
+                                                return [2 /*return*/, delegationOperation];
+                                            case TezosOperationType_1.TezosOperationType.TRANSACTION:
+                                                transactionOperation = operationRequest;
+                                                if (!transactionOperation.amount) {
+                                                    throw new index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "amount" was not defined');
+                                                }
+                                                if (!transactionOperation.destination) {
+                                                    throw new index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "destination" was not defined');
+                                                }
+                                                transactionOperation.source = (_m = transactionOperation.source) !== null && _m !== void 0 ? _m : address;
+                                                transactionOperation.counter = (_o = transactionOperation.counter) !== null && _o !== void 0 ? _o : defaultCounter;
+                                                transactionOperation.fee = (_p = transactionOperation.fee) !== null && _p !== void 0 ? _p : defaultFee;
+                                                transactionOperation.gas_limit = (_q = transactionOperation.gas_limit) !== null && _q !== void 0 ? _q : GAS_LIMIT_PLACEHOLDER;
+                                                transactionOperation.storage_limit = (_r = transactionOperation.storage_limit) !== null && _r !== void 0 ? _r : STORAGE_LIMIT_PLACEHOLDER;
+                                                return [2 /*return*/, transactionOperation];
+                                            case TezosOperationType_1.TezosOperationType.ORIGINATION:
+                                                originationOperation = operationRequest;
+                                                if (!originationOperation.balance) {
+                                                    throw new index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "balance" was not defined');
+                                                }
+                                                if (!originationOperation.script) {
+                                                    throw new index_4.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'property "script" was not defined');
+                                                }
+                                                originationOperation.source = (_s = originationOperation.source) !== null && _s !== void 0 ? _s : address;
+                                                originationOperation.counter = (_t = originationOperation.counter) !== null && _t !== void 0 ? _t : defaultCounter;
+                                                originationOperation.fee = (_u = originationOperation.fee) !== null && _u !== void 0 ? _u : defaultFee;
+                                                originationOperation.gas_limit = (_v = originationOperation.gas_limit) !== null && _v !== void 0 ? _v : GAS_LIMIT_PLACEHOLDER;
+                                                originationOperation.storage_limit = (_w = originationOperation.storage_limit) !== null && _w !== void 0 ? _w : 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, assert_1.assertNever)(operationRequest.kind);
+                                                throw new index_4.UnsupportedError(coinlib_error_1.Domain.TEZOS, "unsupported operation type \"".concat(JSON.stringify(operationRequest.kind), "\""));
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        _d = (_c = operations.push).apply;
+                        _e = [operations];
+                        return [4 /*yield*/, Promise.all(operationPromises)];
+                    case 5:
+                        _d.apply(_c, _e.concat([(_f.sent())]));
+                        tezosWrappedOperation = {
+                            branch: branch,
+                            contents: operations
+                        };
+                        return [4 /*yield*/, this.estimateAndReplaceLimitsAndFee(tezosWrappedOperation, overrideParameters)];
+                    case 6: return [2 /*return*/, _f.sent()];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.estimateAndReplaceLimitsAndFee = function (tezosWrappedOperation, 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 = tezosWrappedOperation.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(tezosWrappedOperation.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: tezosWrappedOperation.branch,
+                                contents: contents,
+                                signature: fakeSignature // signature will not be checked, so it is ok to always use this one
+                            }
+                        };
+                        return [4 /*yield*/, this.forgeTezosOperation(tezosWrappedOperation)];
+                    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 index_4.NetworkError(coinlib_error_1.Domain.TEZOS, runOperationError);
+                            })];
+                    case 3:
+                        response = _a.sent();
+                        if (tezosWrappedOperation.contents.length !== response.data.contents.length) {
+                            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, "Run Operation did not return same number of operations. Locally we have ".concat(tezosWrappedOperation.contents.length, ", but got back ").concat(response.data.contents.length));
+                        }
+                        tezosWrappedOperation.contents.forEach(function (content, i) {
+                            var metadata = response.data.contents[i].metadata;
+                            if (metadata.operation_result) {
+                                var operation = content;
+                                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 index_4.TransactionError(coinlib_error_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 index_4.TransactionError(coinlib_error_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 ((operation.gas_limit && overrideParameters) || operation.gas_limit === GAS_LIMIT_PLACEHOLDER) {
+                                    ;
+                                    operation.gas_limit = gasLimit_1.toString();
+                                }
+                                if ((operation.storage_limit && overrideParameters) || operation.storage_limit === STORAGE_LIMIT_PLACEHOLDER) {
+                                    ;
+                                    operation.storage_limit = storageLimit_1.toString();
+                                }
+                                gasLimitTotal += gasLimit_1;
+                            }
+                        });
+                        if (overrideParameters || tezosWrappedOperation.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 = tezosWrappedOperation.contents.filter(function (operation) { return operation.kind !== 'reveal'; });
+                            feePerOperation_1 = Math.ceil(fee / nonRevealOperations.length);
+                            tezosWrappedOperation.contents.forEach(function (operation) {
+                                if (operation.fee && operation.kind !== 'reveal') {
+                                    ;
+                                    operation.fee = feePerOperation_1.toString();
+                                }
+                            });
+                        }
+                        return [2 /*return*/, tezosWrappedOperation];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getDelegationInfo = function (delegatedAddress, fetchExtraInfo) {
+        if (fetchExtraInfo === void 0) { fetchExtraInfo = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var data, delegatedOpLevel, delegatedDate, recentTransactionData;
+            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(delegatedAddress))];
+                    case 1:
+                        data = (_a.sent()).data;
+                        if (!(data.delegate && fetchExtraInfo)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.options.network.extras.indexerClient.getDelegationInfo(delegatedAddress)];
+                    case 2:
+                        recentTransactionData = _a.sent();
+                        if (recentTransactionData) {
+                            delegatedDate = recentTransactionData.date;
+                            delegatedOpLevel = recentTransactionData.level;
+                        }
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, {
+                            isDelegated: data.delegate ? true : false,
+                            value: data.delegate,
+                            delegatedDate: delegatedDate,
+                            delegatedOpLevel: delegatedOpLevel
+                        }];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.bakerInfo = function (tzAddress) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var results, tzBalance, delegatedBalance, stakingBalance, selfBond, stakingCapacity, bakerInfo;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        if (!tzAddress ||
+                            !(tzAddress.toLowerCase().startsWith('tz1') ||
+                                tzAddress.toLowerCase().startsWith('tz2') ||
+                                tzAddress.toLowerCase().startsWith('tz3') ||
+                                tzAddress.toLowerCase().startsWith('tz4'))) {
+                            throw new index_4.ConditionViolationError(coinlib_error_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(tzAddress, "/balance"))
+                                    .catch(function (_error) { return undefined; }),
+                                index_1.default
+                                    .get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(tzAddress, "/full_balance"))
+                                    .catch(function (_error) { return undefined; }),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(tzAddress, "/delegated_balance")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/delegates/").concat(tzAddress, "/staking_balance"))
+                            ]).catch(function (error) {
+                                throw new index_4.NetworkError(coinlib_error_1.Domain.TEZOS, error);
+                            })];
+                    case 1:
+                        results = _e.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);
+                        selfBond = stakingBalance.minus(delegatedBalance);
+                        stakingCapacity = stakingBalance.div(selfBond.div(SELF_BOND_REQUIREMENT));
+                        bakerInfo = {
+                            balance: tzBalance,
+                            delegatedBalance: delegatedBalance,
+                            stakingBalance: stakingBalance,
+                            selfBond: selfBond,
+                            bakerCapacity: stakingBalance.div(stakingCapacity),
+                            bakerUsage: stakingCapacity
+                        };
+                        return [2 /*return*/, bakerInfo];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.undelegate = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.delegate(publicKey)];
+            });
+        });
+    };
+    TezosProtocol.prototype.delegate = function (publicKey, delegate) {
+        return __awaiter(this, void 0, void 0, function () {
+            var counter, branch, operations, tzAddress, results, accountManager, _a, _b, balance, _c, fee, delegationOperation, tezosWrappedOperation, binaryTx, error_4;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        counter = new bignumber_1.default(1);
+                        branch = '';
+                        operations = [];
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey).then(function (address) { return address.address; })];
+                    case 1:
+                        tzAddress = _d.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 index_4.NetworkError(coinlib_error_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;
+                        if (!!accountManager) return [3 /*break*/, 4];
+                        _b = (_a = operations).push;
+                        return [4 /*yield*/, this.createRevealOperation(counter, publicKey, tzAddress)];
+                    case 3:
+                        _b.apply(_a, [_d.sent()]);
+                        counter = counter.plus(1);
+                        _d.label = 4;
+                    case 4:
+                        _c = bignumber_1.default.bind;
+                        return [4 /*yield*/, this.getBalanceOfAddresses([tzAddress])];
+                    case 5:
+                        balance = new (_c.apply(bignumber_1.default, [void 0, _d.sent()]))();
+                        fee = new bignumber_1.default(1420);
+                        if (balance.isLessThan(fee)) {
+                            throw new index_4.BalanceError(coinlib_error_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);
+                        _d.label = 6;
+                    case 6:
+                        _d.trys.push([6, 8, , 9]);
+                        tezosWrappedOperation = {
+                            branch: branch,
+                            contents: operations
+                        };
+                        return [4 /*yield*/, this.forgeTezosOperation(tezosWrappedOperation)];
+                    case 7:
+                        binaryTx = _d.sent();
+                        return [2 /*return*/, { binaryTransaction: binaryTx }];
+                    case 8:
+                        error_4 = _d.sent();
+                        throw new index_4.OperationFailedError(coinlib_error_1.Domain.TEZOS, "Forging Tezos TX failed with ".concat(JSON.stringify(error_4.message)));
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.getAmountUsedByPreviousOperations = function (operations) {
+        var amountUsed = new bignumber_1.default(0);
+        operations.forEach(function (operation) {
             switch (operation.kind) {
                 case TezosOperationType_1.TezosOperationType.REVEAL:
-                    const revealOperation = operation;
+                    var revealOperation = operation;
                     amountUsed = amountUsed.plus(revealOperation.fee);
                     break;
                 case TezosOperationType_1.TezosOperationType.ORIGINATION:
-                    const originationOperation = operation;
+                    var originationOperation = operation;
                     amountUsed = amountUsed.plus(originationOperation.fee);
                     amountUsed = amountUsed.plus(originationOperation.balance);
                     break;
                 case TezosOperationType_1.TezosOperationType.DELEGATION:
-                    const delegationOperation = operation;
+                    var delegationOperation = operation;
                     amountUsed = amountUsed.plus(delegationOperation.fee);
                     break;
                 case TezosOperationType_1.TezosOperationType.TRANSACTION:
-                    const spendOperation = operation;
+                    var spendOperation = operation;
                     amountUsed = amountUsed.plus(spendOperation.fee);
                     amountUsed = amountUsed.plus(spendOperation.amount);
                     break;
@@ -1007,91 +1574,177 @@ class TezosProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
                 default:
                     // Exhaustive switch
                     (0, assert_1.assertNever)(operation.kind);
-                    throw new index_4.UnsupportedError(coinlib_error_1.Domain.TEZOS, `operation type not supported ${JSON.stringify(operation.kind)}`);
+                    throw new index_4.UnsupportedError(coinlib_error_1.Domain.TEZOS, "operation type not supported ".concat(JSON.stringify(operation.kind)));
             }
         });
         return amountUsed;
-    }
-    async broadcastTransaction(rawTransaction) {
-        const payload = rawTransaction;
-        const { data: injectionResponse } = await index_1.default
-            .post(`${this.options.network.rpcUrl}/injection/operation?chain=main`, JSON.stringify(payload), {
-            headers: { 'content-type': 'application/json' }
-        })
-            .catch((error) => {
-            throw new index_4.NetworkError(coinlib_error_1.Domain.TEZOS, error);
-        });
-        // returns hash if successful
-        return injectionResponse;
-    }
-    checkAndRemovePrefixToHex(base58CheckEncodedPayload, tezosPrefix) {
-        const prefixHex = Buffer.from(tezosPrefix).toString('hex');
-        const payload = bs58check.decode(base58CheckEncodedPayload).toString('hex');
+    };
+    TezosProtocol.prototype.broadcastTransaction = function (rawTransaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var payload, injectionResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        payload = rawTransaction;
+                        return [4 /*yield*/, index_1.default
+                                .post("".concat(this.options.network.rpcUrl, "/injection/operation?chain=main"), JSON.stringify(payload), {
+                                headers: { 'content-type': 'application/json' }
+                            })
+                                .catch(function (error) {
+                                throw new index_4.NetworkError(coinlib_error_1.Domain.TEZOS, error);
+                            })
+                            // returns hash if successful
+                        ];
+                    case 1:
+                        injectionResponse = (_a.sent()).data;
+                        // returns hash if successful
+                        return [2 /*return*/, injectionResponse];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.checkAndRemovePrefixToHex = function (base58CheckEncodedPayload, tezosPrefix) {
+        var prefixHex = Buffer.from(tezosPrefix).toString('hex');
+        var payload = bs58check.decode(base58CheckEncodedPayload).toString('hex');
         if (payload.startsWith(prefixHex)) {
             return payload.substring(tezosPrefix.length * 2);
         }
         else {
-            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, `payload did not match prefix: ${prefixHex}`);
-        }
-    }
-    async unforgeSignedTezosWrappedOperation(hexString) {
-        if (hexString.length <= 128) {
-            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'Not a valid signed transaction');
+            throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, "payload did not match prefix: ".concat(prefixHex));
         }
-        return this.unforgeUnsignedTezosWrappedOperation(hexString.substring(0, hexString.length - 128));
-    }
-    async unforgeUnsignedTezosWrappedOperation(hexString) {
-        return taquito_local_forging_1.localForger.parse(hexString);
-    }
-    async forgeTezosOperation(tezosWrappedOperation) {
-        return taquito_local_forging_1.localForger.forge(tezosWrappedOperation);
-    }
-    async createRevealOperation(counter, publicKey, address, fee = this.revealFee.toFixed()) {
-        const operation = {
-            kind: TezosOperationType_1.TezosOperationType.REVEAL,
-            fee,
-            gas_limit: '10000', // taken from conseiljs
-            storage_limit: '0', // taken from conseiljs
-            counter: counter.toFixed(),
-            public_key: bs58check.encode(Buffer.concat([TezosUtils_1.TezosUtils.tezosPrefixes.edpk, Buffer.from(publicKey, 'hex')])),
-            source: address
-        };
-        return operation;
-    }
-    async getTezosVotingInfo(blockHash) {
-        const response = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/${blockHash}/votes/listings`);
-        return response.data;
-    }
-    async fetchCurrentCycle() {
-        const headMetadata = await this.fetchBlockMetadata('head');
-        const currentCycle = headMetadata.level_info.cycle;
-        return currentCycle;
-    }
-    async fetchBlockMetadata(block) {
-        const result = await index_1.default.get(`${this.options.network.rpcUrl}/chains/main/blocks/${block}/metadata`);
-        return result.data;
-    }
-    async signMessage(message, keypair) {
-        return this.cryptoClient.signMessage(message, keypair);
-    }
-    async verifyMessage(message, signature, publicKey) {
-        return this.cryptoClient.verifyMessage(message, signature, publicKey);
-    }
-    async encryptAsymmetric(message, publicKey) {
-        return this.cryptoClient.encryptAsymmetric(message, publicKey);
-    }
-    async decryptAsymmetric(message, keypair) {
-        return this.cryptoClient.decryptAsymmetric(message, keypair);
-    }
-    async encryptAES(message, privateKey) {
-        return this.cryptoClient.encryptAES(message, privateKey);
-    }
-    async decryptAES(message, privateKey) {
-        return this.cryptoClient.decryptAES(message, privateKey);
-    }
-    async getTransactionStatuses(transactionHashes) {
-        throw new Error('Method not implemented.');
-    }
-}
+    };
+    TezosProtocol.prototype.unforgeSignedTezosWrappedOperation = function (hexString) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (hexString.length <= 128) {
+                    throw new index_4.ConditionViolationError(coinlib_error_1.Domain.TEZOS, 'Not a valid signed transaction');
+                }
+                return [2 /*return*/, this.unforgeUnsignedTezosWrappedOperation(hexString.substring(0, hexString.length - 128))];
+            });
+        });
+    };
+    TezosProtocol.prototype.unforgeUnsignedTezosWrappedOperation = function (hexString) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, taquito_local_forging_1.localForger.parse(hexString)];
+            });
+        });
+    };
+    TezosProtocol.prototype.forgeTezosOperation = function (tezosWrappedOperation) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, taquito_local_forging_1.localForger.forge(tezosWrappedOperation)];
+            });
+        });
+    };
+    TezosProtocol.prototype.createRevealOperation = function (counter, publicKey, address, fee) {
+        if (fee === void 0) { fee = this.revealFee.toFixed(); }
+        return __awaiter(this, void 0, void 0, function () {
+            var operation;
+            return __generator(this, function (_a) {
+                operation = {
+                    kind: TezosOperationType_1.TezosOperationType.REVEAL,
+                    fee: fee,
+                    gas_limit: '10000',
+                    storage_limit: '0',
+                    counter: counter.toFixed(),
+                    public_key: bs58check.encode(Buffer.concat([TezosUtils_1.TezosUtils.tezosPrefixes.edpk, Buffer.from(publicKey, 'hex')])),
+                    source: address
+                };
+                return [2 /*return*/, operation];
+            });
+        });
+    };
+    TezosProtocol.prototype.getTezosVotingInfo = function (blockHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            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/").concat(blockHash, "/votes/listings"))];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, response.data];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.fetchCurrentCycle = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var headMetadata, currentCycle;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.fetchBlockMetadata('head')];
+                    case 1:
+                        headMetadata = _a.sent();
+                        currentCycle = headMetadata.level_info.cycle;
+                        return [2 /*return*/, currentCycle];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.fetchBlockMetadata = function (block) {
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            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/").concat(block, "/metadata"))];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.data];
+                }
+            });
+        });
+    };
+    TezosProtocol.prototype.signMessage = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.signMessage(message, keypair)];
+            });
+        });
+    };
+    TezosProtocol.prototype.verifyMessage = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.verifyMessage(message, signature, publicKey)];
+            });
+        });
+    };
+    TezosProtocol.prototype.encryptAsymmetric = function (message, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(message, publicKey)];
+            });
+        });
+    };
+    TezosProtocol.prototype.decryptAsymmetric = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(message, keypair)];
+            });
+        });
+    };
+    TezosProtocol.prototype.encryptAES = function (message, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.encryptAES(message, privateKey)];
+            });
+        });
+    };
+    TezosProtocol.prototype.decryptAES = function (message, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoClient.decryptAES(message, privateKey)];
+            });
+        });
+    };
+    TezosProtocol.prototype.getTransactionStatuses = function (transactionHashes) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method not implemented.');
+            });
+        });
+    };
+    return TezosProtocol;
+}(NonExtendedProtocol_1.NonExtendedProtocol));
 exports.TezosProtocol = TezosProtocol;
 //# sourceMappingURL=TezosProtocol.js.map