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

package/v1/protocol/TezosProtocol.js

@@ -0,0 +1,948 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTezosProtocolOptions = exports.TEZOS_GHOSTNET_PROTOCOL_NETWORK = exports.TEZOS_MAINNET_PROTOCOL_NETWORK = exports.createTezosProtocol = exports.TezosProtocolImpl = exports.TEZOS_ACCOUNT_METADATA = exports.TEZOS_DERIVATION_PATH = exports.TEZOS_UNITS = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var module_kit_1 = require("@airgap/module-kit");
+var TezosCryptoClient_1 = require("../crypto/TezosCryptoClient");
+var TezosAddress_1 = require("../data/TezosAddress");
+var factory_1 = require("../indexer/factory");
+var network_1 = require("../types/network");
+var TezosOperationType_1 = require("../types/operations/TezosOperationType");
+var key_1 = require("../utils/key");
+var operations_1 = require("../utils/operations");
+var TezosAccountant_1 = require("../utils/protocol/tezos/TezosAccountant");
+var TezosForger_1 = require("../utils/protocol/tezos/TezosForger");
+var signature_1 = require("../utils/signature");
+// Implementation
+var MAX_OPERATIONS_PER_GROUP = 200;
+var MAX_GAS_PER_BLOCK = 5200000;
+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;
+exports.TEZOS_UNITS = {
+    tez: {
+        symbol: { value: 'XTZ', market: 'xtz' },
+        decimals: 6
+    },
+    mutez: {
+        symbol: { value: 'mutez' },
+        decimals: 0
+    },
+    nanotez: {
+        symbol: { value: 'nanotez' },
+        decimals: -3
+    }
+};
+exports.TEZOS_DERIVATION_PATH = "m/44h/1729h/0h/0h";
+exports.TEZOS_ACCOUNT_METADATA = {
+    standardDerivationPath: exports.TEZOS_DERIVATION_PATH,
+    address: {
+        isCaseSensitive: true,
+        placeholder: 'tz1...',
+        regex: '^((tz1|tz2|tz3|KT1)[1-9A-Za-z]{33}|zet1[1-9A-Za-z]{65})$'
+    }
+};
+var TezosProtocolImpl = /** @class */ (function () {
+    function TezosProtocolImpl(options) {
+        // Common
+        this.units = exports.TEZOS_UNITS;
+        this.feeDefaults = {
+            low: (0, module_kit_1.newAmount)(0.00142, 'tez').blockchain(this.units),
+            medium: (0, module_kit_1.newAmount)(0.00152, 'tez').blockchain(this.units),
+            high: (0, module_kit_1.newAmount)(0.003, 'tez').blockchain(this.units)
+        };
+        this.metadata = {
+            identifier: coinlib_core_1.MainProtocolSymbols.XTZ,
+            name: 'Tezos',
+            units: this.units,
+            mainUnit: 'tez',
+            fee: {
+                defaults: this.feeDefaults
+            },
+            account: exports.TEZOS_ACCOUNT_METADATA
+        };
+        // Offline
+        this.cryptoConfiguration = {
+            algorithm: 'ed25519'
+        };
+        this.options = createTezosProtocolOptions(options.network);
+        this.forger = new TezosForger_1.TezosForger();
+        this.accountant = new TezosAccountant_1.TezosAccountant(this.forger, this.options.network);
+        this.indexerClient = (0, factory_1.createTezosIndexerClient)(this.options.network.indexer);
+        this.cryptoClient = new TezosCryptoClient_1.TezosCryptoClient();
+    }
+    TezosProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, TezosAddress_1.TezosAddress.fromPublicKey(publicKey).asString()];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.accountant.getDetailsFromTransaction(transaction)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedSignature, hexPublicKey;
+            return __generator(this, function (_a) {
+                encodedSignature = (0, signature_1.convertSignature)(signature, 'encoded');
+                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.verifyMessage(message, encodedSignature.value, hexPublicKey.value)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexPublicKey;
+            return __generator(this, function (_a) {
+                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoConfiguration];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // should we maybe return encoded keys, i.e. edsk... and edpk... strings?
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newSecretKey)(Buffer.concat([Buffer.from(derivative.secretKey, 'hex'), Buffer.from(derivative.publicKey, 'hex')]).toString('hex'), 'hex'),
+                        publicKey: (0, module_kit_1.newPublicKey)(derivative.publicKey, 'hex')
+                    }];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, binaryTransaction, opSignature, signedOp;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+                binaryTransaction = Buffer.from(transaction.binary, 'hex');
+                opSignature = this.cryptoClient.operationSignature(Buffer.from(hexSecretKey.value, 'hex'), binaryTransaction);
+                signedOp = Buffer.concat([binaryTransaction, opSignature]);
+                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ binary: signedOp.toString('hex') })];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, signature;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
+                        return [4 /*yield*/, this.cryptoClient.signMessage(message, { privateKey: hexSecretKey.value })];
+                    case 1:
+                        signature = _a.sent();
+                        return [2 /*return*/, (0, module_kit_1.newSignature)(signature, 'encoded')];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey, hexPublicKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(keyPair.secretKey, 'hex');
+                hexPublicKey = (0, key_1.convertPublicKey)(keyPair.publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(payload, { publicKey: hexPublicKey.value, privateKey: hexSecretKey.value })];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.encryptAES(payload, hexSecretKey.value)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSecretKey;
+            return __generator(this, function (_a) {
+                hexSecretKey = (0, key_1.convertSecretKey)(secretKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.decryptAES(payload, hexSecretKey.value)];
+            });
+        });
+    };
+    // Online
+    TezosProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getTransactionsForAddress(address, limit, cursor)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactions;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.indexerClient.getTransactions(address, limit, cursor === null || cursor === void 0 ? void 0 : cursor.offset)];
+                    case 1:
+                        transactions = _b.sent();
+                        return [2 /*return*/, {
+                                transactions: transactions.map(function (transaction) { return (__assign(__assign({}, transaction), { network: _this.options.network })); }),
+                                cursor: {
+                                    hasNext: transactions.length >= limit,
+                                    offset: ((_a = cursor === null || cursor === void 0 ? void 0 : cursor.offset) !== null && _a !== void 0 ? _a : 0) + transactions.length
+                                }
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getBalanceOfAddress(address)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, data, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        balance = new bignumber_1.default(0);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/balance"))];
+                    case 2:
+                        data = (_a.sent()).data;
+                        balance = new bignumber_1.default(data);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        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 errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error_1);
+                        }
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/, { total: (0, module_kit_1.newAmount)(balance, 'blockchain') }];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var total, adjustedTotal;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        total = (_a.sent()).total;
+                        adjustedTotal = new bignumber_1.default((0, module_kit_1.newAmount)(total).convert('mutez', this.units).value).minus(1) // Tezos accounts can never be empty. We must leave at least 1 mutez behind.
+                        ;
+                        return [2 /*return*/, this.getTansactionMaxAmountWithBalance(publicKey, adjustedTotal, to, configuration === null || configuration === void 0 ? void 0 : configuration.fee)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getTansactionMaxAmountWithBalance = function (publicKey, balance, to, fee) {
+        return __awaiter(this, void 0, void 0, function () {
+            var maxFee, estimatedFee, error_2, rpcErrors, balanceTooLowError, excess, newMaxBalance, amountWithoutFees;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(fee !== undefined)) return [3 /*break*/, 1];
+                        maxFee = fee;
+                        return [3 /*break*/, 4];
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, to.map(function (recipient) { return ({
+                                to: recipient,
+                                amount: (0, module_kit_1.newAmount)(balance.div(to.length).decimalPlaces(0, bignumber_1.default.ROUND_CEIL), 'blockchain')
+                            }); }))];
+                    case 2:
+                        estimatedFee = _a.sent();
+                        maxFee = (0, module_kit_1.newAmount)(estimatedFee.medium).blockchain(this.units);
+                        if (balance.lte(maxFee.value)) {
+                            maxFee = (0, module_kit_1.newAmount)(0, 'blockchain');
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_2 = _a.sent();
+                        if (error_2.code !== undefined && error_2.code === errors_1.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.getTansactionMaxAmountWithBalance(publicKey, newMaxBalance, to, fee)];
+                                }
+                            }
+                        }
+                        throw error_2;
+                    case 4:
+                        maxFee = (0, module_kit_1.newAmount)(maxFee).blockchain(this.units);
+                        amountWithoutFees = balance.minus(maxFee.value);
+                        if (amountWithoutFees.isNegative()) {
+                            amountWithoutFees = new bignumber_1.default(0);
+                        }
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(amountWithoutFees, 'blockchain')];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details) {
+        return __awaiter(this, void 0, void 0, function () {
+            var operations, i, recipient, transaction;
+            return __generator(this, function (_a) {
+                if (details.length === 0) {
+                    return [2 /*return*/, this.feeDefaults];
+                }
+                operations = [];
+                for (i = 0; i < details.length; ++i) {
+                    recipient = details[i].to;
+                    transaction = {
+                        kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
+                        amount: (0, module_kit_1.newAmount)(details[i].amount).blockchain(this.units).value,
+                        destination: recipient,
+                        fee: '0'
+                    };
+                    operations.push(transaction);
+                }
+                return [2 /*return*/, this.getOperationFeeDefaults(publicKey, operations)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.getOperationFeeDefaults = function (publicKey, operations) {
+        return __awaiter(this, void 0, void 0, function () {
+            var estimated, hasReveal, estimatedFee, feeStepFactor, lowFee, mediumFee, highFee;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.prepareOperations(publicKey, operations)];
+                    case 1:
+                        estimated = _a.sent();
+                        hasReveal = estimated.contents.some(function (op) { return op.kind === TezosOperationType_1.TezosOperationType.REVEAL; });
+                        estimatedFee = estimated.contents
+                            .reduce(function (current, next) {
+                            if (next.fee !== undefined) {
+                                return current.plus(new bignumber_1.default(next.fee));
+                            }
+                            return current;
+                        }, new bignumber_1.default(0))
+                            .minus(hasReveal ? operations_1.REVEAL_FEE : 0)
+                            .div(hasReveal ? estimated.contents.length - 1 : estimated.contents.length);
+                        feeStepFactor = new bignumber_1.default(0.2);
+                        lowFee = estimatedFee;
+                        mediumFee = lowFee.plus(lowFee.times(feeStepFactor).integerValue(bignumber_1.default.ROUND_FLOOR));
+                        highFee = mediumFee.plus(mediumFee.times(feeStepFactor).integerValue(bignumber_1.default.ROUND_FLOOR));
+                        return [2 /*return*/, {
+                                low: (0, module_kit_1.newAmount)(lowFee, 'blockchain'),
+                                medium: (0, module_kit_1.newAmount)(mediumFee, 'blockchain'),
+                                high: (0, module_kit_1.newAmount)(highFee, 'blockchain')
+                            }];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var transactions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (details.length > MAX_OPERATIONS_PER_GROUP) {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, "this transaction exceeds the maximum allowed number of transactions per operation (".concat(MAX_OPERATIONS_PER_GROUP, "). Please use the \"prepareTransactionsFromPublicKey\" method instead."));
+                        }
+                        return [4 /*yield*/, this.prepareTransactionsWithPublicKey(publicKey, details, configuration)];
+                    case 1:
+                        transactions = _a.sent();
+                        if (transactions.length === 1) {
+                            return [2 /*return*/, transactions[0]];
+                        }
+                        else {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, 'Transaction could not be prepared. More or less than 1 operations have been generated.');
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var injectionResponse;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.default
+                            .post("".concat(this.options.network.rpcUrl, "/injection/operation?chain=main"), JSON.stringify(transaction.binary), {
+                            headers: { 'content-type': 'application/json' }
+                        })
+                            .catch(function (error) {
+                            throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+                        })
+                        // returns hash if successful
+                    ];
+                    case 1:
+                        injectionResponse = (_a.sent()).data;
+                        // returns hash if successful
+                        return [2 /*return*/, injectionResponse];
+                }
+            });
+        });
+    };
+    // Custom
+    TezosProtocolImpl.prototype.forgeOperation = function (wrappedOperation) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.forger.forgeOperation(wrappedOperation)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.unforgeOperation = function (forged, type) {
+        if (type === void 0) { type = 'unsigned'; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.forger.unforgeOperation(forged, type)];
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.prepareTransactionsWithPublicKey = function (publicKey, details, configuration) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var operationsPerGroup, fee, estimatedFee, wrappedFee, address, operations, results, currentCounter, counter, branch, accountManager, _b, total, transferable, balance, transactions, allOperations, numberOfGroups, startingCounter, i, start, end, operationsGroup, wrappedOperationWithEstimatedGas, forged;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        operationsPerGroup = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.operationsPerGroup) !== null && _a !== void 0 ? _a : MAX_OPERATIONS_PER_GROUP;
+                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 1];
+                        fee = configuration.fee;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, details)];
+                    case 2:
+                        estimatedFee = _c.sent();
+                        fee = estimatedFee.medium;
+                        _c.label = 3;
+                    case 3:
+                        wrappedFee = new bignumber_1.default((0, module_kit_1.newAmount)(fee).blockchain(this.units).value);
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 4:
+                        address = _c.sent();
+                        operations = [];
+                        return [4 /*yield*/, Promise.all([
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/counter")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head~2/hash")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/manager_key"))
+                            ]).catch(function (error) {
+                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+                            })];
+                    case 5:
+                        results = _c.sent();
+                        currentCounter = new bignumber_1.default(results[0].data);
+                        counter = currentCounter.plus(1);
+                        branch = results[1].data;
+                        accountManager = results[2].data;
+                        // check if we have revealed the address already
+                        if (!accountManager) {
+                            operations.push((0, operations_1.createRevealOperation)(counter, publicKey, address));
+                            counter = counter.plus(1);
+                        }
+                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 6:
+                        _b = _c.sent(), total = _b.total, transferable = _b.transferable;
+                        balance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable !== null && transferable !== void 0 ? transferable : total).blockchain(this.units).value);
+                        transactions = [];
+                        return [4 /*yield*/, this.createTransactionOperations(operations, details, wrappedFee, address, counter, balance)];
+                    case 7:
+                        allOperations = _c.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;
+                        _c.label = 8;
+                    case 8:
+                        if (!(i < numberOfGroups)) return [3 /*break*/, 12];
+                        start = i * operationsPerGroup;
+                        end = start + operationsPerGroup;
+                        operationsGroup = allOperations.slice(start, end);
+                        return [4 /*yield*/, this.estimateAndReplaceLimitsAndFee({
+                                branch: branch,
+                                contents: operationsGroup
+                            }, false, startingCounter)];
+                    case 9:
+                        wrappedOperationWithEstimatedGas = _c.sent();
+                        return [4 /*yield*/, this.forgeOperation(wrappedOperationWithEstimatedGas)];
+                    case 10:
+                        forged = _c.sent();
+                        transactions.push((0, module_kit_1.newUnsignedTransaction)({ binary: forged }));
+                        _c.label = 11;
+                    case 11:
+                        i++;
+                        return [3 /*break*/, 8];
+                    case 12: return [2 /*return*/, transactions];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.prepareOperations = function (publicKey, operationRequests, overrideParameters) {
+        if (overrideParameters === void 0) { overrideParameters = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var counter, branch, operations, address, results, accountManager, hasRevealInOperationRequests, operationPromises, _a, _b, _c, wrappedOperation;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        counter = new bignumber_1.default(1);
+                        operations = [];
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _d.sent();
+                        return [4 /*yield*/, Promise.all([
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/counter")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head~2/hash")),
+                                index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/context/contracts/").concat(address, "/manager_key"))
+                            ]).catch(function (error) {
+                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, error);
+                            })];
+                    case 2:
+                        results = _d.sent();
+                        counter = new bignumber_1.default(results[0].data).plus(1);
+                        branch = results[1].data;
+                        accountManager = results[2].data;
+                        hasRevealInOperationRequests = operationRequests.some(function (request) { return request.kind === TezosOperationType_1.TezosOperationType.REVEAL; });
+                        // check if we have revealed the address already
+                        if (!accountManager && !hasRevealInOperationRequests) {
+                            operations.push((0, operations_1.createRevealOperation)(counter, publicKey, address));
+                            counter = counter.plus(1);
+                        }
+                        operationPromises = operationRequests.map(function (operationRequest, index) { return __awaiter(_this, void 0, void 0, function () {
+                            var recipient, receivingBalance, total, defaultCounter, defaultFee, defaultGasLimit, defaultStorageLimit, revealOperation, delegationOperation, transactionOperation, originationOperation;
+                            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+                            return __generator(this, function (_w) {
+                                switch (_w.label) {
+                                    case 0:
+                                        // TODO: Handle activation burn
+                                        if (!operationRequest.kind) {
+                                            throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "kind" was not defined');
+                                        }
+                                        recipient = operationRequest.destination;
+                                        if (!(recipient && recipient.toLowerCase().startsWith('tz'))) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, this.getBalanceOfAddress(recipient)];
+                                    case 1:
+                                        total = (_w.sent()).total;
+                                        receivingBalance = new bignumber_1.default((0, module_kit_1.newAmount)(total).blockchain(this.units).value);
+                                        _w.label = 2;
+                                    case 2:
+                                        defaultCounter = counter.plus(index).toFixed() // TODO: Handle counter if we have some operations without counters in the array
+                                        ;
+                                        defaultFee = FEE_PLACEHOLDER;
+                                        defaultGasLimit = '10300';
+                                        defaultStorageLimit = receivingBalance && receivingBalance.isZero() && recipient && recipient.toLowerCase().startsWith('tz') ? '300' : '0' // taken from eztz
+                                        ;
+                                        switch (operationRequest.kind) {
+                                            // TODO: Handle if the dApp already provides a reveal operation
+                                            case TezosOperationType_1.TezosOperationType.REVEAL:
+                                                revealOperation = operationRequest;
+                                                if (!revealOperation.public_key) {
+                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "public_key" was not defined');
+                                                }
+                                                revealOperation.source = (_a = revealOperation.source) !== null && _a !== void 0 ? _a : address;
+                                                revealOperation.counter = (_b = revealOperation.counter) !== null && _b !== void 0 ? _b : defaultCounter;
+                                                revealOperation.fee = (_c = revealOperation.fee) !== null && _c !== void 0 ? _c : defaultFee;
+                                                revealOperation.gas_limit = (_d = revealOperation.gas_limit) !== null && _d !== void 0 ? _d : defaultGasLimit;
+                                                revealOperation.storage_limit = (_e = revealOperation.storage_limit) !== null && _e !== void 0 ? _e : defaultStorageLimit;
+                                                return [2 /*return*/, revealOperation];
+                                            case TezosOperationType_1.TezosOperationType.DELEGATION:
+                                                delegationOperation = operationRequest;
+                                                // The delegate property is optional, so we don't have any mandatory properties to check for
+                                                delegationOperation.source = (_f = delegationOperation.source) !== null && _f !== void 0 ? _f : address;
+                                                delegationOperation.counter = (_g = delegationOperation.counter) !== null && _g !== void 0 ? _g : defaultCounter;
+                                                delegationOperation.fee = (_h = delegationOperation.fee) !== null && _h !== void 0 ? _h : defaultFee;
+                                                delegationOperation.gas_limit = (_j = delegationOperation.gas_limit) !== null && _j !== void 0 ? _j : defaultGasLimit;
+                                                delegationOperation.storage_limit = (_k = delegationOperation.storage_limit) !== null && _k !== void 0 ? _k : defaultStorageLimit;
+                                                return [2 /*return*/, delegationOperation];
+                                            case TezosOperationType_1.TezosOperationType.TRANSACTION:
+                                                transactionOperation = operationRequest;
+                                                if (!transactionOperation.amount) {
+                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "amount" was not defined');
+                                                }
+                                                if (!transactionOperation.destination) {
+                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "destination" was not defined');
+                                                }
+                                                transactionOperation.source = (_l = transactionOperation.source) !== null && _l !== void 0 ? _l : address;
+                                                transactionOperation.counter = (_m = transactionOperation.counter) !== null && _m !== void 0 ? _m : defaultCounter;
+                                                transactionOperation.fee = (_o = transactionOperation.fee) !== null && _o !== void 0 ? _o : defaultFee;
+                                                transactionOperation.gas_limit = (_p = transactionOperation.gas_limit) !== null && _p !== void 0 ? _p : GAS_LIMIT_PLACEHOLDER;
+                                                transactionOperation.storage_limit = (_q = transactionOperation.storage_limit) !== null && _q !== void 0 ? _q : STORAGE_LIMIT_PLACEHOLDER;
+                                                return [2 /*return*/, transactionOperation];
+                                            case TezosOperationType_1.TezosOperationType.ORIGINATION:
+                                                originationOperation = operationRequest;
+                                                if (!originationOperation.balance) {
+                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "balance" was not defined');
+                                                }
+                                                if (!originationOperation.script) {
+                                                    throw new errors_1.PropertyUndefinedError(coinlib_core_1.Domain.TEZOS, 'property "script" was not defined');
+                                                }
+                                                originationOperation.source = (_r = originationOperation.source) !== null && _r !== void 0 ? _r : address;
+                                                originationOperation.counter = (_s = originationOperation.counter) !== null && _s !== void 0 ? _s : defaultCounter;
+                                                originationOperation.fee = (_t = originationOperation.fee) !== null && _t !== void 0 ? _t : defaultFee;
+                                                originationOperation.gas_limit = (_u = originationOperation.gas_limit) !== null && _u !== void 0 ? _u : GAS_LIMIT_PLACEHOLDER;
+                                                originationOperation.storage_limit = (_v = originationOperation.storage_limit) !== null && _v !== void 0 ? _v : STORAGE_LIMIT_PLACEHOLDER;
+                                                return [2 /*return*/, originationOperation];
+                                            case TezosOperationType_1.TezosOperationType.ENDORSEMENT:
+                                            case TezosOperationType_1.TezosOperationType.SEED_NONCE_REVELATION:
+                                            case TezosOperationType_1.TezosOperationType.DOUBLE_ENDORSEMENT_EVIDENCE:
+                                            case TezosOperationType_1.TezosOperationType.DOUBLE_BAKING_EVIDENCE:
+                                            case TezosOperationType_1.TezosOperationType.ACTIVATE_ACCOUNT:
+                                            case TezosOperationType_1.TezosOperationType.PROPOSALS:
+                                            case TezosOperationType_1.TezosOperationType.BALLOT:
+                                                // Do not change anything
+                                                return [2 /*return*/, operationRequest];
+                                            default:
+                                                (0, coinlib_core_1.assertNever)(operationRequest.kind);
+                                                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.TEZOS, "unsupported operation type \"".concat(JSON.stringify(operationRequest.kind), "\""));
+                                        }
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        _b = (_a = operations.push).apply;
+                        _c = [operations];
+                        return [4 /*yield*/, Promise.all(operationPromises)];
+                    case 3:
+                        _b.apply(_a, _c.concat([(_d.sent())]));
+                        wrappedOperation = {
+                            branch: branch,
+                            contents: operations
+                        };
+                        return [2 /*return*/, this.estimateAndReplaceLimitsAndFee(wrappedOperation, overrideParameters)];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.estimateAndReplaceLimitsAndFee = function (wrappedOperation, overrideParameters, startingCounter) {
+        if (overrideParameters === void 0) { overrideParameters = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            var fakeSignature, opKinds, contents, block, body, forgedOperation, gasLimitTotal, response, fee, nonRevealOperations, feePerOperation_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fakeSignature = 'sigUHx32f9wesZ1n2BWpixXz4AQaZggEtchaQNHYGRCoWNAXx45WGW2ua3apUUUAGMLPwAU41QoaFCzVSL61VaessLg4YbbP';
+                        opKinds = [
+                            TezosOperationType_1.TezosOperationType.TRANSACTION,
+                            TezosOperationType_1.TezosOperationType.REVEAL,
+                            TezosOperationType_1.TezosOperationType.ORIGINATION,
+                            TezosOperationType_1.TezosOperationType.DELEGATION
+                        ];
+                        contents = wrappedOperation.contents.map(function (operation, i) {
+                            if (!opKinds.includes(operation.kind)) {
+                                return operation;
+                            }
+                            var op = operation;
+                            var gasValue = new bignumber_1.default(MAX_GAS_PER_BLOCK).dividedToIntegerBy(wrappedOperation.contents.length);
+                            var gas_limit = new bignumber_1.default(GAS_LIMIT_PLACEHOLDER).gt(gasValue) ? gasValue : GAS_LIMIT_PLACEHOLDER;
+                            var counter = startingCounter ? startingCounter.plus(i).toString() : op.counter;
+                            return __assign(__assign({}, operation), { gas_limit: gas_limit, counter: counter });
+                        });
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head"))];
+                    case 1:
+                        block = (_a.sent()).data;
+                        body = {
+                            chain_id: block.chain_id,
+                            operation: {
+                                branch: wrappedOperation.branch,
+                                contents: contents,
+                                signature: fakeSignature // signature will not be checked, so it is ok to always use this one
+                            }
+                        };
+                        return [4 /*yield*/, this.forgeOperation(wrappedOperation)];
+                    case 2:
+                        forgedOperation = _a.sent();
+                        gasLimitTotal = 0;
+                        return [4 /*yield*/, index_1.default
+                                .post("".concat(this.options.network.rpcUrl, "/chains/main/blocks/head/helpers/scripts/run_operation"), body, {
+                                headers: { 'Content-Type': 'application/json' }
+                            })
+                                .catch(function (runOperationError) {
+                                throw new errors_1.NetworkError(coinlib_core_1.Domain.TEZOS, runOperationError);
+                            })];
+                    case 3:
+                        response = _a.sent();
+                        if (wrappedOperation.contents.length !== response.data.contents.length) {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.TEZOS, "Run Operation did not return same number of operations. Locally we have ".concat(wrappedOperation.contents.length, ", but got back ").concat(response.data.contents.length));
+                        }
+                        wrappedOperation.contents.forEach(function (content, i) {
+                            var metadata = response.data.contents[i].metadata;
+                            if (metadata.operation_result) {
+                                var result = metadata.operation_result;
+                                var gasLimit_1 = 0;
+                                var storageLimit_1 = 0;
+                                // If there are internal operations, we first add gas and storage used of internal operations
+                                if (metadata.internal_operation_results) {
+                                    metadata.internal_operation_results.forEach(function (internalOperation) {
+                                        if (internalOperation === null || internalOperation === void 0 ? void 0 : internalOperation.result) {
+                                            if (internalOperation.result.errors) {
+                                                throw new errors_1.TransactionError(coinlib_core_1.Domain.TEZOS, 'An internal operation produced an error', internalOperation.result.errors);
+                                            }
+                                            gasLimit_1 += Math.ceil(Number(internalOperation.result.consumed_milligas) / 1000);
+                                            if (internalOperation.result.paid_storage_size_diff) {
+                                                storageLimit_1 += Number(internalOperation.result.paid_storage_size_diff);
+                                            }
+                                            if (internalOperation.result.originated_contracts) {
+                                                storageLimit_1 += internalOperation.result.originated_contracts.length * 257;
+                                            }
+                                            if (internalOperation.result.allocated_destination_contract) {
+                                                storageLimit_1 += 257;
+                                            }
+                                        }
+                                    });
+                                }
+                                if (result.errors) {
+                                    throw new errors_1.TransactionError(coinlib_core_1.Domain.TEZOS, 'The operation produced an error', result.errors);
+                                }
+                                // Add gas and storage used by operation
+                                gasLimit_1 += Math.ceil(Number(result.consumed_milligas) / 1000);
+                                if (result.paid_storage_size_diff) {
+                                    storageLimit_1 += Number(result.paid_storage_size_diff);
+                                }
+                                if (result.originated_contracts) {
+                                    storageLimit_1 += result.originated_contracts.length * 257;
+                                }
+                                if (result.allocated_destination_contract) {
+                                    storageLimit_1 += 257;
+                                }
+                                // in prepareTransactionsFromPublicKey() we invoke this method with overrideParameters = false
+                                if ((content.gas_limit && overrideParameters) || content.gas_limit === GAS_LIMIT_PLACEHOLDER) {
+                                    ;
+                                    content.gas_limit = gasLimit_1.toString();
+                                }
+                                if ((content.storage_limit && overrideParameters) || content.storage_limit === STORAGE_LIMIT_PLACEHOLDER) {
+                                    ;
+                                    content.storage_limit = storageLimit_1.toString();
+                                }
+                                gasLimitTotal += gasLimit_1;
+                            }
+                        });
+                        if (overrideParameters || wrappedOperation.contents.some(function (operation) { return (operation === null || operation === void 0 ? void 0 : operation.fee) === FEE_PLACEHOLDER; })) {
+                            fee = MINIMAL_FEE +
+                                MINIMAL_FEE_PER_BYTE * Math.ceil((forgedOperation.length + 128) / 2) + // 128 is the length of a hex signature
+                                MINIMAL_FEE_PER_GAS_UNIT * gasLimitTotal +
+                                100 // add 100 for safety
+                            ;
+                            nonRevealOperations = wrappedOperation.contents.filter(function (operation) { return operation.kind !== 'reveal'; });
+                            feePerOperation_1 = Math.ceil(fee / nonRevealOperations.length);
+                            wrappedOperation.contents.forEach(function (content) {
+                                if (content.fee && content.kind !== 'reveal') {
+                                    ;
+                                    content.fee = feePerOperation_1.toString();
+                                }
+                            });
+                        }
+                        return [2 /*return*/, wrappedOperation];
+                }
+            });
+        });
+    };
+    TezosProtocolImpl.prototype.createTransactionOperations = function (previousOperations, details, fee, address, counter, balance) {
+        return __awaiter(this, void 0, void 0, function () {
+            var amountUsedByPreviousOperations, operations, firstValue, i, recipient, value, _a, total, transferable, receivingBalance, spendOperation;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        amountUsedByPreviousOperations = (0, operations_1.getAmountUsedByPreviousOperations)(previousOperations);
+                        operations = [];
+                        if (!amountUsedByPreviousOperations.isZero()) {
+                            firstValue = new bignumber_1.default((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
+                            if (balance.isLessThan(firstValue.plus(fee).plus(amountUsedByPreviousOperations))) {
+                                // if not, make room for the init fee
+                                details[0] = __assign(__assign({}, details[0]), { amount: (0, module_kit_1.newAmount)(firstValue.minus(amountUsedByPreviousOperations), 'blockchain') // deduct fee from balance
+                                 });
+                            }
+                        }
+                        i = 0;
+                        _b.label = 1;
+                    case 1:
+                        if (!(i < details.length)) return [3 /*break*/, 4];
+                        recipient = details[i].to;
+                        value = new bignumber_1.default((0, module_kit_1.newAmount)(details[i].amount).blockchain(this.units).value);
+                        return [4 /*yield*/, this.getBalanceOfAddress(recipient)];
+                    case 2:
+                        _a = _b.sent(), total = _a.total, transferable = _a.transferable;
+                        receivingBalance = new bignumber_1.default((0, module_kit_1.newAmount)(transferable !== null && transferable !== void 0 ? transferable : total).blockchain(this.units).value);
+                        // if our receiver has 0 balance, the account is not activated yet.
+                        if (receivingBalance.isZero() && recipient.toLowerCase().startsWith('tz')) {
+                            // We have to supply an additional 0.257 XTZ fee for storage_limit costs, which gets automatically deducted from the sender so we just have to make sure enough balance is around
+                            if (balance.isLessThan(fee.plus(operations_1.ACTIVATION_BURN))) {
+                                // If we don't have enough funds to pay the activation + fee, we throw an error
+                                throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'Insufficient balance to pay activation burn!');
+                            }
+                            else if (balance.isLessThan(value.plus(fee).plus(operations_1.ACTIVATION_BURN))) {
+                                // Check whether the sender has enough to cover the amount to send + fee + activation
+                                // If not, we deduct it from amount sent to make room for the activation burn
+                                value = value.minus(operations_1.ACTIVATION_BURN); // deduct fee from balance
+                            }
+                        }
+                        if (balance.isEqualTo(value.plus(fee))) {
+                            // Tezos accounts can never be empty. If user tries to send everything, we must leave 1 mutez behind.
+                            value = value.minus(1);
+                        }
+                        else if (balance.isLessThan(value.plus(fee))) {
+                            throw new errors_1.BalanceError(coinlib_core_1.Domain.TEZOS, 'not enough balance');
+                        }
+                        spendOperation = {
+                            kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
+                            fee: fee.toFixed(),
+                            gas_limit: GAS_LIMIT_PLACEHOLDER,
+                            storage_limit: STORAGE_LIMIT_PLACEHOLDER,
+                            amount: value.toFixed(),
+                            counter: counter.plus(i).toFixed(),
+                            destination: recipient,
+                            source: address
+                        };
+                        operations.push(spendOperation);
+                        _b.label = 3;
+                    case 3:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, operations];
+                }
+            });
+        });
+    };
+    return TezosProtocolImpl;
+}());
+exports.TezosProtocolImpl = TezosProtocolImpl;
+// Factory
+function createTezosProtocol(options) {
+    if (options === void 0) { options = {}; }
+    return new TezosProtocolImpl(options);
+}
+exports.createTezosProtocol = createTezosProtocol;
+exports.TEZOS_MAINNET_PROTOCOL_NETWORK = {
+    name: 'Mainnet',
+    type: 'mainnet',
+    rpcUrl: 'https://tezos-node.prod.gke.papers.tech',
+    network: network_1.TezosNetwork.MAINNET,
+    blockExplorer: {
+        type: 'tzkt',
+        url: 'https://tzkt.io'
+    },
+    indexer: {
+        type: 'tzkt',
+        apiUrl: 'https://tezos-mainnet-indexer.prod.gke.papers.tech'
+    }
+};
+exports.TEZOS_GHOSTNET_PROTOCOL_NETWORK = {
+    name: 'Ghostnet',
+    type: 'testnet',
+    rpcUrl: 'https://tezos-ghostnet-node.prod.gke.papers.tech',
+    network: network_1.TezosNetwork.GHOSTNET,
+    blockExplorer: {
+        type: 'tzkt',
+        url: 'https://ghostnet.tzkt.io'
+    },
+    indexer: {
+        type: 'tzkt',
+        apiUrl: 'https://tezos-ghostnet-indexer.prod.gke.papers.tech'
+    }
+};
+var DEFAULT_TEZOS_PROTOCOL_NETWORK = exports.TEZOS_MAINNET_PROTOCOL_NETWORK;
+function createTezosProtocolOptions(network) {
+    if (network === void 0) { network = {}; }
+    return {
+        network: __assign(__assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK), network), { blockExplorer: __assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK.blockExplorer), network.blockExplorer), indexer: __assign(__assign({}, DEFAULT_TEZOS_PROTOCOL_NETWORK.indexer), network.indexer) })
+    };
+}
+exports.createTezosProtocolOptions = createTezosProtocolOptions;
+//# sourceMappingURL=TezosProtocol.js.map