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

package/v0/protocol/sapling/TezosSaplingProtocol.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,552 +41,964 @@ 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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TezosSaplingProtocol = void 0;
-const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
 // @ts-ignore
-const bip39_2_5_0_1 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0");
-const errors_1 = require("@airgap/coinlib-core/errors");
-const coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
-const NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
-const array_1 = require("@airgap/coinlib-core/utils/array");
-const sapling = __importStar(require("@airgap/sapling-wasm"));
-const random_1 = require("@stablelib/random");
-const TezosContract_1 = require("../contract/TezosContract");
-const TezosAddress_1 = require("../TezosAddress");
-const TezosProtocol_1 = require("../TezosProtocol");
-const TezosProtocolOptions_1 = require("../TezosProtocolOptions");
-const TezosUtils_1 = require("../TezosUtils");
-const MichelsonAddress_1 = require("../types/michelson/primitives/MichelsonAddress");
-const TezosOperationType_1 = require("../types/TezosOperationType");
-const TezosSaplingInjectorClient_1 = require("./injector/TezosSaplingInjectorClient");
-const TezosSaplingNodeClient_1 = require("./node/TezosSaplingNodeClient");
-const TezosSaplingAddress_1 = require("./TezosSaplingAddress");
-const TezosSaplingCryptoClient_1 = require("./TezosSaplingCryptoClient");
-const TezosSaplingBookkeeper_1 = require("./utils/TezosSaplingBookkeeper");
-const TezosSaplingEncoder_1 = require("./utils/TezosSaplingEncoder");
-const TezosSaplingForger_1 = require("./utils/TezosSaplingForger");
-const TezosSaplingState_1 = require("./utils/TezosSaplingState");
-class TezosSaplingProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
-    constructor(options) {
-        super();
-        this.options = options;
-        this.supportsHD = false;
-        this.addressIsCaseSensitive = true;
-        this.addressValidationPattern = '^(zet1[1-9A-Za-z]{65}|tz1[1-9A-Za-z]{33})$';
-        this.addressPlaceholder = 'zet1...';
-        this.tezosProtocol = new TezosProtocol_1.TezosProtocol(new TezosProtocolOptions_1.TezosProtocolOptions(this.options.network, new TezosProtocolOptions_1.TezosProtocolConfig()));
-        this.name = options.config.name;
-        this.symbol = options.config.symbol ?? this.tezosProtocol.symbol;
-        this.marketSymbol = options.config.marketSymbol ?? this.tezosProtocol.marketSymbol;
-        this.feeSymbol = this.tezosProtocol.feeSymbol;
-        this.feeDefaults = options.config.feeDefaults ?? this.tezosProtocol.feeDefaults;
-        this.decimals = options.config.decimals ?? this.tezosProtocol.decimals;
-        this.feeDecimals = this.tezosProtocol.feeDecimals;
-        this.identifier = options.config.identifier ?? this.tezosProtocol.identifier;
-        this.units = this.options.config.units ?? this.tezosProtocol.units;
-        this.standardDerivationPath = this.tezosProtocol.standardDerivationPath;
-        this.cryptoClient = new TezosSaplingCryptoClient_1.TezosSaplingCryptoClient(this.tezosProtocol.cryptoClient);
-        this.nodeClient = this.options.config.contractAddress
-            ? new TezosSaplingNodeClient_1.TezosSaplingNodeClient(this.options.network.rpcUrl, this.options.config.contractAddress)
+var bip39_2_5_0_1 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0");
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var NonExtendedProtocol_1 = require("@airgap/coinlib-core/protocols/NonExtendedProtocol");
+var array_1 = require("@airgap/coinlib-core/utils/array");
+var sapling = __importStar(require("@airgap/sapling-wasm"));
+var random_1 = require("@stablelib/random");
+var TezosContract_1 = require("../contract/TezosContract");
+var TezosAddress_1 = require("../TezosAddress");
+var TezosProtocol_1 = require("../TezosProtocol");
+var TezosProtocolOptions_1 = require("../TezosProtocolOptions");
+var TezosUtils_1 = require("../TezosUtils");
+var MichelsonAddress_1 = require("../types/michelson/primitives/MichelsonAddress");
+var TezosOperationType_1 = require("../types/TezosOperationType");
+var TezosSaplingInjectorClient_1 = require("./injector/TezosSaplingInjectorClient");
+var TezosSaplingNodeClient_1 = require("./node/TezosSaplingNodeClient");
+var TezosSaplingAddress_1 = require("./TezosSaplingAddress");
+var TezosSaplingCryptoClient_1 = require("./TezosSaplingCryptoClient");
+var TezosSaplingBookkeeper_1 = require("./utils/TezosSaplingBookkeeper");
+var TezosSaplingEncoder_1 = require("./utils/TezosSaplingEncoder");
+var TezosSaplingForger_1 = require("./utils/TezosSaplingForger");
+var TezosSaplingState_1 = require("./utils/TezosSaplingState");
+var TezosSaplingProtocol = /** @class */ (function (_super) {
+    __extends(TezosSaplingProtocol, _super);
+    function TezosSaplingProtocol(options) {
+        var _this = this;
+        var _a, _b, _c, _d, _e, _f;
+        _this = _super.call(this) || this;
+        _this.options = options;
+        _this.supportsHD = false;
+        _this.addressIsCaseSensitive = true;
+        _this.addressValidationPattern = '^(zet1[1-9A-Za-z]{65}|tz1[1-9A-Za-z]{33})$';
+        _this.addressPlaceholder = 'zet1...';
+        _this.tezosProtocol = new TezosProtocol_1.TezosProtocol(new TezosProtocolOptions_1.TezosProtocolOptions(_this.options.network, new TezosProtocolOptions_1.TezosProtocolConfig()));
+        _this.name = options.config.name;
+        _this.symbol = (_a = options.config.symbol) !== null && _a !== void 0 ? _a : _this.tezosProtocol.symbol;
+        _this.marketSymbol = (_b = options.config.marketSymbol) !== null && _b !== void 0 ? _b : _this.tezosProtocol.marketSymbol;
+        _this.feeSymbol = _this.tezosProtocol.feeSymbol;
+        _this.feeDefaults = (_c = options.config.feeDefaults) !== null && _c !== void 0 ? _c : _this.tezosProtocol.feeDefaults;
+        _this.decimals = (_d = options.config.decimals) !== null && _d !== void 0 ? _d : _this.tezosProtocol.decimals;
+        _this.feeDecimals = _this.tezosProtocol.feeDecimals;
+        _this.identifier = (_e = options.config.identifier) !== null && _e !== void 0 ? _e : _this.tezosProtocol.identifier;
+        _this.units = (_f = _this.options.config.units) !== null && _f !== void 0 ? _f : _this.tezosProtocol.units;
+        _this.standardDerivationPath = _this.tezosProtocol.standardDerivationPath;
+        _this.cryptoClient = new TezosSaplingCryptoClient_1.TezosSaplingCryptoClient(_this.tezosProtocol.cryptoClient);
+        _this.nodeClient = _this.options.config.contractAddress
+            ? new TezosSaplingNodeClient_1.TezosSaplingNodeClient(_this.options.network.rpcUrl, _this.options.config.contractAddress)
             : undefined;
-        this.contract = this.options.config.contractAddress
-            ? new TezosContract_1.TezosContract(this.options.config.contractAddress, this.options.network)
+        _this.contract = _this.options.config.contractAddress
+            ? new TezosContract_1.TezosContract(_this.options.config.contractAddress, _this.options.network)
             : undefined;
-        this.injectorClient =
-            this.options.config.injectorUrl && this.options.config.contractAddress
-                ? new TezosSaplingInjectorClient_1.TezosSaplingInjectorClient(this.options.config.injectorUrl, this.options.config.contractAddress)
+        _this.injectorClient =
+            _this.options.config.injectorUrl && _this.options.config.contractAddress
+                ? new TezosSaplingInjectorClient_1.TezosSaplingInjectorClient(_this.options.config.injectorUrl, _this.options.config.contractAddress)
                 : undefined;
-        this.state = new TezosSaplingState_1.TezosSaplingState(this.options.config.merkleTreeHeight);
-        this.encoder = new TezosSaplingEncoder_1.TezosSaplingEncoder();
-        this.forger = new TezosSaplingForger_1.TezosSaplingForger(this.cryptoClient, this.state, this.encoder, this.options.config.externalProvider);
-        this.bookkeeper = new TezosSaplingBookkeeper_1.TezosSaplingBookkeeper(this.identifier, this.options.network, this.cryptoClient, this.encoder);
-    }
-    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 getContractAddress() {
-        return this.contract?.address;
-    }
-    async setContractAddress(address, configuration) {
-        this.options.config.contractAddress = address;
-        this.nodeClient = new TezosSaplingNodeClient_1.TezosSaplingNodeClient(this.options.network.rpcUrl, address);
-        this.contract = new TezosContract_1.TezosContract(address, this.options.network);
-        this.options.config.injectorUrl = configuration?.injectorUrl;
-        this.injectorClient = new TezosSaplingInjectorClient_1.TezosSaplingInjectorClient(configuration?.injectorUrl, address);
-    }
-    async initParameters(spendParams, outputParams) {
-        const externalInitParameters = this.options.config.externalProvider?.initParameters;
-        if (externalInitParameters !== undefined) {
-            await externalInitParameters(spendParams, outputParams);
-        }
-        else {
-            await sapling.initParameters(spendParams, outputParams);
-        }
-    }
-    async getBlockExplorerLinkForTxId(txId) {
-        return this.tezosProtocol.getBlockExplorerLinkForTxId(txId);
-    }
-    async getPublicKeyFromMnemonic(mnemonic, derivationPath, password) {
-        const seed = this.getSeedFromMnemonic(mnemonic, password);
-        return this.getPublicKeyFromHexSecret(seed.toString('hex'), derivationPath);
-    }
-    async getPrivateKeyFromMnemonic(mnemonic, derivationPath, password) {
-        const seed = this.getSeedFromMnemonic(mnemonic, password);
-        return this.getPrivateKeyFromHexSecret(seed.toString('hex'), derivationPath);
-    }
-    getSeedFromMnemonic(mnemonic, password) {
-        const seed = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
+        _this.state = new TezosSaplingState_1.TezosSaplingState(_this.options.config.merkleTreeHeight);
+        _this.encoder = new TezosSaplingEncoder_1.TezosSaplingEncoder();
+        _this.forger = new TezosSaplingForger_1.TezosSaplingForger(_this.cryptoClient, _this.state, _this.encoder, _this.options.config.externalProvider);
+        _this.bookkeeper = new TezosSaplingBookkeeper_1.TezosSaplingBookkeeper(_this.identifier, _this.options.network, _this.cryptoClient, _this.encoder);
+        return _this;
+    }
+    TezosSaplingProtocol.prototype.getSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.symbol];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getName = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.name];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getMarketSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.marketSymbol];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAssetSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, undefined];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getFeeSymbol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeSymbol];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.decimals];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getFeeDecimals = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDecimals];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getIdentifier = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.identifier];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getFeeDefaults = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDefaults];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getUnits = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.units];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getSupportsHD = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.supportsHD];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getStandardDerivationPath = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.standardDerivationPath];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAddressIsCaseSensitive = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressIsCaseSensitive];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAddressValidationPattern = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressValidationPattern];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAddressPlaceholder = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.addressPlaceholder];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getOptions = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getContractAddress = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                return [2 /*return*/, (_a = this.contract) === null || _a === void 0 ? void 0 : _a.address];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.setContractAddress = function (address, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.options.config.contractAddress = address;
+                this.nodeClient = new TezosSaplingNodeClient_1.TezosSaplingNodeClient(this.options.network.rpcUrl, address);
+                this.contract = new TezosContract_1.TezosContract(address, this.options.network);
+                this.options.config.injectorUrl = configuration === null || configuration === void 0 ? void 0 : configuration.injectorUrl;
+                this.injectorClient = new TezosSaplingInjectorClient_1.TezosSaplingInjectorClient(configuration === null || configuration === void 0 ? void 0 : configuration.injectorUrl, address);
+                return [2 /*return*/];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.initParameters = function (spendParams, outputParams) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var externalInitParameters;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        externalInitParameters = (_a = this.options.config.externalProvider) === null || _a === void 0 ? void 0 : _a.initParameters;
+                        if (!(externalInitParameters !== undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, externalInitParameters(spendParams, outputParams)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, sapling.initParameters(spendParams, outputParams)];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getBlockExplorerLinkForTxId = function (txId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.tezosProtocol.getBlockExplorerLinkForTxId(txId)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var seed;
+            return __generator(this, function (_a) {
+                seed = this.getSeedFromMnemonic(mnemonic, password);
+                return [2 /*return*/, this.getPublicKeyFromHexSecret(seed.toString('hex'), derivationPath)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var seed;
+            return __generator(this, function (_a) {
+                seed = this.getSeedFromMnemonic(mnemonic, password);
+                return [2 /*return*/, this.getPrivateKeyFromHexSecret(seed.toString('hex'), derivationPath)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getSeedFromMnemonic = function (mnemonic, password) {
+        var seed = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
         // We xor the two halves of the BIP-39 seed, as does `tezos-client`
-        const first32 = seed.slice(0, 32);
-        const second32 = seed.slice(32);
-        return Buffer.from(first32.map((byte, index) => byte ^ second32[index]));
-    }
-    async getPublicKeyFromHexSecret(secret, derivationPath) {
-        const viewingKey = await sapling.getExtendedFullViewingKey(secret, derivationPath);
-        return viewingKey.toString('hex');
-    }
-    async getPrivateKeyFromHexSecret(secret, derivationPath) {
-        const xsk = await sapling.getExtendedSpendingKey(secret, derivationPath);
-        return xsk.toString('hex');
-    }
-    async getAddressFromPublicKey(viewingKey, cursor) {
-        const current = cursor?.hasNext && cursor?.diversifierIndex
-            ? await TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(viewingKey, cursor.diversifierIndex)
-            : undefined;
-        const address = current
-            ? await TezosSaplingAddress_1.TezosSaplingAddress.next(viewingKey, current)
-            : await TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(viewingKey);
-        return {
-            address: address.asString(),
-            cursor: {
-                hasNext: address.diversifierIndex !== undefined,
-                diversifierIndex: address.diversifierIndex
-            }
-        };
-    }
-    async getAddressesFromPublicKey(viewingKey, cursor) {
-        return [await this.getAddressFromPublicKey(viewingKey, cursor)];
-    }
-    async getAddressFromViewingKey(viewingKey, index) {
-        const address = await TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(viewingKey, index);
-        return {
-            address: address.asString(),
-            cursor: {
-                hasNext: address.diversifierIndex !== undefined,
-                diversifierIndex: address.diversifierIndex
-            }
-        };
-    }
-    async getTransactionsFromPublicKey(publicKey, limit, cursor) {
-        if (this.nodeClient === undefined) {
-            return {
-                transactions: [],
-                cursor: { page: 0 }
-            };
-        }
-        const saplingStateDiff = await this.nodeClient.getSaplingStateDiff();
-        const incoming = [];
-        const outgoing = [];
-        let page = cursor?.page ?? 0;
-        let pageStart = page * limit;
-        let pageEnd = pageStart + limit;
-        while (incoming.length + outgoing.length < limit && pageStart < saplingStateDiff.commitments_and_ciphertexts.length) {
-            const commitmentsAndCiphertexts = saplingStateDiff.commitments_and_ciphertexts
-                .map(([commitment, ciphertext], index) => [commitment, ciphertext, new bignumber_1.default(index)])
-                .reverse()
-                .slice(pageStart, pageEnd);
-            const inputs = await Promise.all([
-                this.bookkeeper.getIncomingInputs(publicKey, commitmentsAndCiphertexts),
-                this.bookkeeper.getOutgoingInputs(publicKey, commitmentsAndCiphertexts)
-            ]);
-            incoming.push(...inputs[0]);
-            outgoing.push(...inputs[1]);
-            page += 1;
-            pageStart += limit;
-            pageEnd += limit;
-        }
-        const airGapIncoming = await Promise.all(incoming.map(async (input) => ({
-            from: ['Shielded Pool'],
-            to: [input.address],
-            isInbound: true,
-            amount: input.value,
-            fee: '0',
-            protocolIdentifier: this.identifier,
-            network: this.options.network
-        })));
-        const airGapOutgoing = await Promise.all(outgoing.map(async (input) => ({
-            from: [(await this.getAddressFromPublicKey(publicKey)).address],
-            to: [input.address],
-            isInbound: false,
-            amount: input.value,
-            fee: '0',
-            protocolIdentifier: this.identifier,
-            network: this.options.network
-        })));
-        return {
-            transactions: airGapIncoming.concat(airGapOutgoing),
-            cursor: { page: page + 1 }
-        };
-    }
-    async signWithPrivateKey(privateKey, transaction) {
-        const stateTree = await this.state.getStateTreeFromStateDiff(transaction.stateDiff);
-        const boundData = transaction.unshieldTarget && transaction.unshieldTarget.length > 0
-            ? this.createAddressBoundData(transaction.unshieldTarget)
-            : undefined;
-        const forgedTransaction = await this.forger.forgeSaplingTransaction(transaction.ins, transaction.outs, stateTree, this.getAntiReplay(transaction.chainId, transaction.contractAddress), boundData, Buffer.from(privateKey, 'hex'));
-        return this.encoder.encodeTransaction(forgedTransaction).toString('hex');
-    }
-    async getTransactionDetails(transaction, data) {
-        const tx = transaction.transaction;
-        const airGapTxs = [];
-        if (this.isRawTezosSaplingTransaction(tx)) {
-            const unshieldTarget = tx.unshieldTarget.length > 0 ? tx.unshieldTarget : undefined;
-            const from = await this.getAddressFromPublicKey(transaction.publicKey).then((address) => TezosSaplingAddress_1.TezosSaplingAddress.fromValue(address.address, address.cursor.diversifierIndex));
-            const details = this.bookkeeper
-                .getUnsignedTransactionDetails(from, tx.ins, tx.outs, unshieldTarget)
-                .map((details) => ({
-                ...details,
-                extra: {
-                    ...details.extra,
-                    destination: tx.contractAddress,
-                    chainId: tx.chainId
-                },
-                transactionDetails: tx
-            }));
-            airGapTxs.push(...details);
-        }
-        else {
-            const wrappedOperation = await this.tezosProtocol.unforgeUnsignedTezosWrappedOperation(tx.binaryTransaction);
-            airGapTxs.push(...(await this.getTransactionDetailsFromWrappedOperation(wrappedOperation, data?.knownViewingKeys)));
-        }
-        return this.filterOutPaybacks(airGapTxs);
-    }
-    async getTransactionDetailsFromSigned(transaction, data) {
-        const airGapTxs = [];
-        const tx = transaction.transaction;
-        const defaultDetails = {
-            from: ['Shielded Pool'],
-            to: ['Shielded Pool'],
-            isInbound: false,
-            amount: '0',
-            fee: '0',
-            protocolIdentifier: this.identifier,
-            network: this.options.network
-        };
-        if (this.contract?.areValidParameters(tx)) {
-            const partialDetails = await this.getPartialDetailsFromContractParameters(tx, data?.knownViewingKeys);
-            airGapTxs.push(...partialDetails.map((partial) => ({
-                ...defaultDetails,
-                ...partial
-            })));
-        }
-        else {
-            try {
-                const wrappedOperation = await this.tezosProtocol.unforgeSignedTezosWrappedOperation(tx);
-                airGapTxs.push(...(await this.getTransactionDetailsFromWrappedOperation(wrappedOperation, data?.knownViewingKeys)));
-            }
-            catch {
-                const partialDetails = await this.bookkeeper.getTransactionsPartialDetails([tx], data?.knownViewingKeys);
-                airGapTxs.push(...partialDetails.map((partial) => ({
-                    ...defaultDetails,
-                    ...partial
-                })));
-            }
-        }
-        return this.filterOutPaybacks(airGapTxs);
-    }
-    async getTransactionDetailsFromWrappedOperation(operation, knownViewingKeys = []) {
-        const contractOperations = operation.contents.filter((content) => content.kind === TezosOperationType_1.TezosOperationType.TRANSACTION && content.parameters !== undefined);
-        const details = await Promise.all(contractOperations.map(async (operation) => {
-            const saplingDetails = await this.getPartialDetailsFromContractParameters(operation.parameters, knownViewingKeys);
-            return saplingDetails.map((partials) => ({
-                from: [operation.source],
-                to: ['Shielded Pool'],
-                isInbound: false,
-                amount: operation.amount,
-                fee: operation.fee,
-                protocolIdentifier: this.identifier,
-                network: this.options.network,
-                ...partials,
-                transactionDetails: operation
-            }));
-        }));
-        return (0, array_1.flattenArray)(details);
-    }
-    async getPartialDetailsFromContractParameters(rawOrParsed, knownViewingKeys = []) {
-        const parameters = typeof rawOrParsed === 'string' ? (this.contract ? this.contract.parseParameters(rawOrParsed) : JSON.parse(rawOrParsed)) : rawOrParsed;
-        const txs = await this.parseParameters(parameters);
-        return this.bookkeeper.getTransactionsPartialDetails(txs, knownViewingKeys);
-    }
-    filterOutPaybacks(airGapTxs) {
-        const filtered = airGapTxs.filter((details) => {
+        var first32 = seed.slice(0, 32);
+        var second32 = seed.slice(32);
+        return Buffer.from(first32.map(function (byte, index) { return byte ^ second32[index]; }));
+    };
+    TezosSaplingProtocol.prototype.getPublicKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var viewingKey;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, sapling.getExtendedFullViewingKey(secret, derivationPath)];
+                    case 1:
+                        viewingKey = _a.sent();
+                        return [2 /*return*/, viewingKey.toString('hex')];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getPrivateKeyFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var xsk;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, sapling.getExtendedSpendingKey(secret, derivationPath)];
+                    case 1:
+                        xsk = _a.sent();
+                        return [2 /*return*/, xsk.toString('hex')];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAddressFromPublicKey = function (viewingKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var current, _a, address, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!((cursor === null || cursor === void 0 ? void 0 : cursor.hasNext) && (cursor === null || cursor === void 0 ? void 0 : cursor.diversifierIndex))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(viewingKey, cursor.diversifierIndex)];
+                    case 1:
+                        _a = _c.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = undefined;
+                        _c.label = 3;
+                    case 3:
+                        current = _a;
+                        if (!current) return [3 /*break*/, 5];
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.next(viewingKey, current)];
+                    case 4:
+                        _b = _c.sent();
+                        return [3 /*break*/, 7];
+                    case 5: return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(viewingKey)];
+                    case 6:
+                        _b = _c.sent();
+                        _c.label = 7;
+                    case 7:
+                        address = _b;
+                        return [2 /*return*/, {
+                                address: address.asString(),
+                                cursor: {
+                                    hasNext: address.diversifierIndex !== undefined,
+                                    diversifierIndex: address.diversifierIndex
+                                }
+                            }];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAddressesFromPublicKey = function (viewingKey, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(viewingKey, cursor)];
+                    case 1: return [2 /*return*/, [_a.sent()]];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAddressFromViewingKey = function (viewingKey, index) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(viewingKey, index)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, {
+                                address: address.asString(),
+                                cursor: {
+                                    hasNext: address.diversifierIndex !== undefined,
+                                    diversifierIndex: address.diversifierIndex
+                                }
+                            }];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getTransactionsFromPublicKey = function (publicKey, limit, cursor) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var saplingStateDiff, incoming, outgoing, page, pageStart, pageEnd, commitmentsAndCiphertexts, inputs, airGapIncoming, airGapOutgoing;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.nodeClient === undefined) {
+                            return [2 /*return*/, {
+                                    transactions: [],
+                                    cursor: { page: 0 }
+                                }];
+                        }
+                        return [4 /*yield*/, this.nodeClient.getSaplingStateDiff()];
+                    case 1:
+                        saplingStateDiff = _b.sent();
+                        incoming = [];
+                        outgoing = [];
+                        page = (_a = cursor === null || cursor === void 0 ? void 0 : cursor.page) !== null && _a !== void 0 ? _a : 0;
+                        pageStart = page * limit;
+                        pageEnd = pageStart + limit;
+                        _b.label = 2;
+                    case 2:
+                        if (!(incoming.length + outgoing.length < limit && pageStart < saplingStateDiff.commitments_and_ciphertexts.length)) return [3 /*break*/, 4];
+                        commitmentsAndCiphertexts = saplingStateDiff.commitments_and_ciphertexts
+                            .map(function (_a, index) {
+                            var commitment = _a[0], ciphertext = _a[1];
+                            return [commitment, ciphertext, new bignumber_1.default(index)];
+                        })
+                            .reverse()
+                            .slice(pageStart, pageEnd);
+                        return [4 /*yield*/, Promise.all([
+                                this.bookkeeper.getIncomingInputs(publicKey, commitmentsAndCiphertexts),
+                                this.bookkeeper.getOutgoingInputs(publicKey, commitmentsAndCiphertexts)
+                            ])];
+                    case 3:
+                        inputs = _b.sent();
+                        incoming.push.apply(incoming, inputs[0]);
+                        outgoing.push.apply(outgoing, inputs[1]);
+                        page += 1;
+                        pageStart += limit;
+                        pageEnd += limit;
+                        return [3 /*break*/, 2];
+                    case 4: return [4 /*yield*/, Promise.all(incoming.map(function (input) { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                return [2 /*return*/, ({
+                                        from: ['Shielded Pool'],
+                                        to: [input.address],
+                                        isInbound: true,
+                                        amount: input.value,
+                                        fee: '0',
+                                        protocolIdentifier: this.identifier,
+                                        network: this.options.network
+                                    })];
+                            });
+                        }); }))];
+                    case 5:
+                        airGapIncoming = _b.sent();
+                        return [4 /*yield*/, Promise.all(outgoing.map(function (input) { return __awaiter(_this, void 0, void 0, function () {
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _a = {};
+                                            return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                                        case 1: return [2 /*return*/, (_a.from = [(_b.sent()).address],
+                                                _a.to = [input.address],
+                                                _a.isInbound = false,
+                                                _a.amount = input.value,
+                                                _a.fee = '0',
+                                                _a.protocolIdentifier = this.identifier,
+                                                _a.network = this.options.network,
+                                                _a)];
+                                    }
+                                });
+                            }); }))];
+                    case 6:
+                        airGapOutgoing = _b.sent();
+                        return [2 /*return*/, {
+                                transactions: airGapIncoming.concat(airGapOutgoing),
+                                cursor: { page: page + 1 }
+                            }];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.signWithPrivateKey = function (privateKey, transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stateTree, boundData, forgedTransaction;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.state.getStateTreeFromStateDiff(transaction.stateDiff)];
+                    case 1:
+                        stateTree = _a.sent();
+                        boundData = transaction.unshieldTarget && transaction.unshieldTarget.length > 0
+                            ? this.createAddressBoundData(transaction.unshieldTarget)
+                            : undefined;
+                        return [4 /*yield*/, this.forger.forgeSaplingTransaction(transaction.ins, transaction.outs, stateTree, this.getAntiReplay(transaction.chainId, transaction.contractAddress), boundData, Buffer.from(privateKey, 'hex'))];
+                    case 2:
+                        forgedTransaction = _a.sent();
+                        return [2 /*return*/, this.encoder.encodeTransaction(forgedTransaction).toString('hex')];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getTransactionDetails = function (transaction, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tx, airGapTxs, unshieldTarget, from, details, wrappedOperation, _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        tx = transaction.transaction;
+                        airGapTxs = [];
+                        if (!this.isRawTezosSaplingTransaction(tx)) return [3 /*break*/, 2];
+                        unshieldTarget = tx.unshieldTarget.length > 0 ? tx.unshieldTarget : undefined;
+                        return [4 /*yield*/, this.getAddressFromPublicKey(transaction.publicKey).then(function (address) { return TezosSaplingAddress_1.TezosSaplingAddress.fromValue(address.address, address.cursor.diversifierIndex); })];
+                    case 1:
+                        from = _d.sent();
+                        details = this.bookkeeper
+                            .getUnsignedTransactionDetails(from, tx.ins, tx.outs, unshieldTarget)
+                            .map(function (details) { return (__assign(__assign({}, details), { extra: __assign(__assign({}, details.extra), { destination: tx.contractAddress, chainId: tx.chainId }), transactionDetails: tx })); });
+                        airGapTxs.push.apply(airGapTxs, details);
+                        return [3 /*break*/, 5];
+                    case 2: return [4 /*yield*/, this.tezosProtocol.unforgeUnsignedTezosWrappedOperation(tx.binaryTransaction)];
+                    case 3:
+                        wrappedOperation = _d.sent();
+                        _b = (_a = airGapTxs.push).apply;
+                        _c = [airGapTxs];
+                        return [4 /*yield*/, this.getTransactionDetailsFromWrappedOperation(wrappedOperation, data === null || data === void 0 ? void 0 : data.knownViewingKeys)];
+                    case 4:
+                        _b.apply(_a, _c.concat([(_d.sent())]));
+                        _d.label = 5;
+                    case 5: return [2 /*return*/, this.filterOutPaybacks(airGapTxs)];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getTransactionDetailsFromSigned = function (transaction, data) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var airGapTxs, tx, defaultDetails, partialDetails, wrappedOperation, _b, _c, _d, _e, partialDetails;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        airGapTxs = [];
+                        tx = transaction.transaction;
+                        defaultDetails = {
+                            from: ['Shielded Pool'],
+                            to: ['Shielded Pool'],
+                            isInbound: false,
+                            amount: '0',
+                            fee: '0',
+                            protocolIdentifier: this.identifier,
+                            network: this.options.network
+                        };
+                        if (!((_a = this.contract) === null || _a === void 0 ? void 0 : _a.areValidParameters(tx))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.getPartialDetailsFromContractParameters(tx, data === null || data === void 0 ? void 0 : data.knownViewingKeys)];
+                    case 1:
+                        partialDetails = _f.sent();
+                        airGapTxs.push.apply(airGapTxs, partialDetails.map(function (partial) { return (__assign(__assign({}, defaultDetails), partial)); }));
+                        return [3 /*break*/, 7];
+                    case 2:
+                        _f.trys.push([2, 5, , 7]);
+                        return [4 /*yield*/, this.tezosProtocol.unforgeSignedTezosWrappedOperation(tx)];
+                    case 3:
+                        wrappedOperation = _f.sent();
+                        _c = (_b = airGapTxs.push).apply;
+                        _d = [airGapTxs];
+                        return [4 /*yield*/, this.getTransactionDetailsFromWrappedOperation(wrappedOperation, data === null || data === void 0 ? void 0 : data.knownViewingKeys)];
+                    case 4:
+                        _c.apply(_b, _d.concat([(_f.sent())]));
+                        return [3 /*break*/, 7];
+                    case 5:
+                        _e = _f.sent();
+                        return [4 /*yield*/, this.bookkeeper.getTransactionsPartialDetails([tx], data === null || data === void 0 ? void 0 : data.knownViewingKeys)];
+                    case 6:
+                        partialDetails = _f.sent();
+                        airGapTxs.push.apply(airGapTxs, partialDetails.map(function (partial) { return (__assign(__assign({}, defaultDetails), partial)); }));
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/, this.filterOutPaybacks(airGapTxs)];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getTransactionDetailsFromWrappedOperation = function (operation, knownViewingKeys) {
+        if (knownViewingKeys === void 0) { knownViewingKeys = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            var contractOperations, details;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        contractOperations = operation.contents.filter(function (content) {
+                            return content.kind === TezosOperationType_1.TezosOperationType.TRANSACTION && content.parameters !== undefined;
+                        });
+                        return [4 /*yield*/, Promise.all(contractOperations.map(function (operation) { return __awaiter(_this, void 0, void 0, function () {
+                                var saplingDetails;
+                                var _this = this;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.getPartialDetailsFromContractParameters(operation.parameters, knownViewingKeys)];
+                                        case 1:
+                                            saplingDetails = _a.sent();
+                                            return [2 /*return*/, saplingDetails.map(function (partials) { return (__assign(__assign({ from: [operation.source], to: ['Shielded Pool'], isInbound: false, amount: operation.amount, fee: operation.fee, protocolIdentifier: _this.identifier, network: _this.options.network }, partials), { transactionDetails: operation })); })];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        details = _a.sent();
+                        return [2 /*return*/, (0, array_1.flattenArray)(details)];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getPartialDetailsFromContractParameters = function (rawOrParsed, knownViewingKeys) {
+        if (knownViewingKeys === void 0) { knownViewingKeys = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            var parameters, txs;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        parameters = typeof rawOrParsed === 'string' ? (this.contract ? this.contract.parseParameters(rawOrParsed) : JSON.parse(rawOrParsed)) : rawOrParsed;
+                        return [4 /*yield*/, this.parseParameters(parameters)];
+                    case 1:
+                        txs = _a.sent();
+                        return [2 /*return*/, this.bookkeeper.getTransactionsPartialDetails(txs, knownViewingKeys)];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.filterOutPaybacks = function (airGapTxs) {
+        var filtered = airGapTxs.filter(function (details) {
             if (details.from.length !== details.to.length) {
                 return true;
             }
-            const fromSet = new Set(details.from);
-            const toSet = new Set(details.to);
-            return Array.from(fromSet).some((address) => !toSet.has(address));
+            var fromSet = new Set(details.from);
+            var toSet = new Set(details.to);
+            return Array.from(fromSet).some(function (address) { return !toSet.has(address); });
         });
         return filtered.length > 0 ? filtered : airGapTxs;
-    }
-    async getBalanceOfPublicKey(publicKey) {
-        if (this.nodeClient === undefined) {
-            return '0';
-        }
-        const saplingStateDiff = await this.nodeClient.getSaplingStateDiff();
-        const unspends = await this.bookkeeper.getUnspends(publicKey, saplingStateDiff.commitments_and_ciphertexts, saplingStateDiff.nullifiers);
-        const balance = unspends.reduce((sum, next) => sum.plus(next.value), new bignumber_1.default(0));
-        return balance.toString();
-    }
-    async getTransactionStatuses(transactionHash) {
-        throw new Error('Method not implemented.');
-    }
-    async estimateMaxTransactionValueFromPublicKey(publicKey, recipients, fee) {
-        return this.getBalanceOfPublicKey(publicKey);
-    }
-    async prepareTransactionFromPublicKey(publicKey, recipients, values, fee, data) {
-        if (recipients.length > 1 && values.length > 1) {
-            return Promise.reject('Multiple sapling transactions are not supported');
-        }
-        if (recipients.length === 0 && values.length === 0) {
-            return Promise.reject('No recpients and values have been provided');
-        }
-        const recipient = recipients[0];
-        const value = values[0];
-        if (TezosAddress_1.TezosAddress.isTzAddress(recipient)) {
-            return this.prepareUnshieldTransaction(publicKey, recipient, value, data);
-        }
-        else if (TezosSaplingAddress_1.TezosSaplingAddress.isZetAddress(recipient)) {
-            return this.prepareSaplingTransaction(publicKey, recipient, value, data);
-        }
-        return Promise.reject(`Invalid recpient, expected a 'tz' or 'zet' address, got ${recipient}`);
-    }
-    async wrapSaplingTransactions(publicKey, transactionsOrString, fee, overrideFees = false) {
-        if (this.contract === undefined) {
-            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
-        }
-        let operations;
-        if (typeof transactionsOrString === 'string' && this.contract.areValidParameters(transactionsOrString)) {
-            const parameters = this.contract.parseParameters(transactionsOrString);
-            operations = [this.prepareTezosOperation(parameters, fee)];
-        }
-        else {
-            const transactions = Array.isArray(transactionsOrString) ? transactionsOrString : [transactionsOrString];
-            const contractCalls = await this.prepareContractCalls(transactions);
-            operations = contractCalls.map((contractCall) => this.prepareTezosOperation(contractCall.toJSON(), fee, contractCall.amount?.toString()));
-        }
-        try {
-            const tezosWrappedOperation = await this.tezosProtocol.prepareOperations(publicKey, operations, overrideFees);
-            const binaryTx = await this.tezosProtocol.forgeTezosOperation(tezosWrappedOperation);
-            return { binaryTransaction: binaryTx };
-        }
-        catch (error) {
-            console.error(error);
-            if (error.code !== undefined && error.code === errors_1.ProtocolErrorType.TRANSACTION_FAILED) {
-                const rpcErrors = error.data;
-                const cannotPayStorageFee = rpcErrors.find((error) => error.id.endsWith('.contract.cannot_pay_storage_fee'));
-                if (cannotPayStorageFee) {
-                    throw new errors_1.BalanceError(coinlib_error_1.Domain.TEZOS, 'Balance too low, cannot pay for storage fee');
+    };
+    TezosSaplingProtocol.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var saplingStateDiff, unspends, balance;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.nodeClient === undefined) {
+                            return [2 /*return*/, '0'];
+                        }
+                        return [4 /*yield*/, this.nodeClient.getSaplingStateDiff()];
+                    case 1:
+                        saplingStateDiff = _a.sent();
+                        return [4 /*yield*/, this.bookkeeper.getUnspends(publicKey, saplingStateDiff.commitments_and_ciphertexts, saplingStateDiff.nullifiers)];
+                    case 2:
+                        unspends = _a.sent();
+                        balance = unspends.reduce(function (sum, next) { return sum.plus(next.value); }, new bignumber_1.default(0));
+                        return [2 /*return*/, balance.toString()];
                 }
-                const balanceTooLowError = rpcErrors.find((error) => error.id.endsWith('.contract.balance_too_low'));
-                if (balanceTooLowError) {
-                    throw new errors_1.BalanceError(coinlib_error_1.Domain.TEZOS, 'Balance too low');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getTransactionStatuses = function (transactionHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method not implemented.');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.estimateMaxTransactionValueFromPublicKey = function (publicKey, recipients, fee) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.getBalanceOfPublicKey(publicKey)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.prepareTransactionFromPublicKey = function (publicKey, recipients, values, fee, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var recipient, value;
+            return __generator(this, function (_a) {
+                if (recipients.length > 1 && values.length > 1) {
+                    return [2 /*return*/, Promise.reject('Multiple sapling transactions are not supported')];
                 }
-            }
-            throw error;
-        }
-    }
-    prepareTezosOperation(parameters, fee, amount = '0') {
+                if (recipients.length === 0 && values.length === 0) {
+                    return [2 /*return*/, Promise.reject('No recpients and values have been provided')];
+                }
+                recipient = recipients[0];
+                value = values[0];
+                if (TezosAddress_1.TezosAddress.isTzAddress(recipient)) {
+                    return [2 /*return*/, this.prepareUnshieldTransaction(publicKey, recipient, value, data)];
+                }
+                else if (TezosSaplingAddress_1.TezosSaplingAddress.isZetAddress(recipient)) {
+                    return [2 /*return*/, this.prepareSaplingTransaction(publicKey, recipient, value, data)];
+                }
+                return [2 /*return*/, Promise.reject("Invalid recpient, expected a 'tz' or 'zet' address, got ".concat(recipient))];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.wrapSaplingTransactions = function (publicKey, transactionsOrString, fee, overrideFees) {
+        if (overrideFees === void 0) { overrideFees = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var operations, parameters, transactions, contractCalls, tezosWrappedOperation, binaryTx, error_1, rpcErrors, cannotPayStorageFee, balanceTooLowError;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.contract === undefined) {
+                            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
+                        }
+                        if (!(typeof transactionsOrString === 'string' && this.contract.areValidParameters(transactionsOrString))) return [3 /*break*/, 1];
+                        parameters = this.contract.parseParameters(transactionsOrString);
+                        operations = [this.prepareTezosOperation(parameters, fee)];
+                        return [3 /*break*/, 3];
+                    case 1:
+                        transactions = Array.isArray(transactionsOrString) ? transactionsOrString : [transactionsOrString];
+                        return [4 /*yield*/, this.prepareContractCalls(transactions)];
+                    case 2:
+                        contractCalls = _a.sent();
+                        operations = contractCalls.map(function (contractCall) { var _a; return _this.prepareTezosOperation(contractCall.toJSON(), fee, (_a = contractCall.amount) === null || _a === void 0 ? void 0 : _a.toString()); });
+                        _a.label = 3;
+                    case 3:
+                        _a.trys.push([3, 6, , 7]);
+                        return [4 /*yield*/, this.tezosProtocol.prepareOperations(publicKey, operations, overrideFees)];
+                    case 4:
+                        tezosWrappedOperation = _a.sent();
+                        return [4 /*yield*/, this.tezosProtocol.forgeTezosOperation(tezosWrappedOperation)];
+                    case 5:
+                        binaryTx = _a.sent();
+                        return [2 /*return*/, { binaryTransaction: binaryTx }];
+                    case 6:
+                        error_1 = _a.sent();
+                        console.error(error_1);
+                        if (error_1.code !== undefined && error_1.code === errors_1.ProtocolErrorType.TRANSACTION_FAILED) {
+                            rpcErrors = error_1.data;
+                            cannotPayStorageFee = rpcErrors.find(function (error) { return error.id.endsWith('.contract.cannot_pay_storage_fee'); });
+                            if (cannotPayStorageFee) {
+                                throw new errors_1.BalanceError(coinlib_error_1.Domain.TEZOS, 'Balance too low, cannot pay for storage fee');
+                            }
+                            balanceTooLowError = rpcErrors.find(function (error) { return error.id.endsWith('.contract.balance_too_low'); });
+                            if (balanceTooLowError) {
+                                throw new errors_1.BalanceError(coinlib_error_1.Domain.TEZOS, 'Balance too low');
+                            }
+                        }
+                        throw error_1;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.prepareTezosOperation = function (parameters, fee, amount) {
+        if (amount === void 0) { amount = '0'; }
         return {
             kind: TezosOperationType_1.TezosOperationType.TRANSACTION,
-            fee,
-            amount,
+            fee: fee,
+            amount: amount,
             destination: this.options.config.contractAddress,
-            parameters
+            parameters: parameters
         };
-    }
-    async prepareShieldTransaction(publicKey, recipient, value, fee, data) {
-        const encodedTransaction = await this.mint(recipient, value);
-        return this.wrapSaplingTransactions(publicKey, [encodedTransaction], fee, data?.overrideFees);
-    }
-    async prepareUnshieldTransaction(viewingKey, recipient, value, data) {
-        if (!TezosAddress_1.TezosAddress.isTzAddress(recipient)) {
-            return Promise.reject(`Invalid recpient, expected a 'tz' address, got ${recipient}`);
-        }
-        const burnTransaction = await this.burn(viewingKey, value);
-        return {
-            ...burnTransaction,
-            unshieldTarget: recipient
-        };
-    }
-    async prepareSaplingTransaction(viewingKey, recipient, value, data) {
-        if (this.nodeClient === undefined || this.options.config.contractAddress === undefined) {
-            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
-        }
-        if (!TezosSaplingAddress_1.TezosSaplingAddress.isZetAddress(recipient)) {
-            return Promise.reject(`Invalid recpient, expected a 'zet' address, got ${recipient}`);
-        }
-        const dummyInputsAmount = Math.max(new bignumber_1.default(data?.dummyInputs ?? 0).toNumber(), 0);
-        const dummyOutputsAmount = Math.max(new bignumber_1.default(data?.dummyOutputs ?? 0).toNumber(), 0);
-        const [stateDiff, chainId] = await Promise.all([
-            this.nodeClient.getSaplingStateDiff(),
-            this.nodeClient.getChainId()
-        ]);
-        const [inputs, toSpend] = await this.chooseInputs(viewingKey, stateDiff.commitments_and_ciphertexts, stateDiff.nullifiers, value);
-        const address = await this.getAddressFromPublicKey(viewingKey).then((address) => TezosSaplingAddress_1.TezosSaplingAddress.fromValue(address.address, address.cursor.diversifierIndex));
-        const paymentOutput = this.createPaymentOutput(await TezosSaplingAddress_1.TezosSaplingAddress.fromValue(recipient), value);
-        const paybackOutput = this.createPaybackOutput(address, toSpend, value);
-        const [dummyInputs, dummyOutputs] = await Promise.all([
-            Promise.all(Array.from({ length: dummyInputsAmount }, (_v, _k) => this.createDummyInput(address))),
-            Promise.all(Array.from({ length: dummyOutputsAmount }, (_v, _k) => this.createDummyOutput()))
-        ]);
-        return {
-            ins: inputs.concat(dummyInputs),
-            outs: [paymentOutput, paybackOutput, ...dummyOutputs].filter((output) => output !== undefined),
-            contractAddress: this.options.config.contractAddress,
-            chainId,
-            stateDiff,
-            unshieldTarget: ''
-        };
-    }
-    async mint(recipient, value) {
-        if (this.nodeClient === undefined || this.options.config.contractAddress === undefined) {
-            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
-        }
-        if (!TezosSaplingAddress_1.TezosSaplingAddress.isZetAddress(recipient)) {
-            return Promise.reject(`Invalid recipient, expected a 'zet' address, got ${recipient}`);
-        }
-        const [saplingStateDiff, chainId] = await Promise.all([
-            this.nodeClient.getSaplingStateDiff(),
-            this.nodeClient.getChainId()
-        ]);
-        const output = {
-            address: (await TezosSaplingAddress_1.TezosSaplingAddress.fromValue(recipient)).asString(),
-            value,
-            memo: Buffer.alloc(this.options.config.memoSize).toString('hex'),
-            browsable: true
-        };
-        const stateTree = await this.state.getStateTreeFromStateDiff(saplingStateDiff, true);
-        const forgedTransaction = await this.forger.forgeSaplingTransaction([], [output], stateTree, this.getAntiReplay(chainId, this.options.config.contractAddress));
-        return this.encoder.encodeTransaction(forgedTransaction).toString('hex');
-    }
-    async burn(viewingKey, value) {
-        if (this.nodeClient === undefined || this.options.config.contractAddress === undefined) {
-            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
-        }
-        const [stateDiff, chainId] = await Promise.all([
-            this.nodeClient.getSaplingStateDiff(),
-            this.nodeClient.getChainId()
-        ]);
-        const [inputs, toSpend] = await this.chooseInputs(viewingKey, stateDiff.commitments_and_ciphertexts, stateDiff.nullifiers, value);
-        const paybackOutput = {
-            address: (await this.getAddressFromPublicKey(viewingKey)).address,
-            value: toSpend.minus(value).toString(),
-            memo: Buffer.alloc(this.options.config.memoSize).toString('hex'),
-            browsable: true
-        };
-        return {
-            ins: inputs,
-            outs: [paybackOutput],
-            contractAddress: this.options.config.contractAddress,
-            chainId,
-            stateDiff,
-            unshieldTarget: ''
-        };
-    }
-    async chooseInputs(viewingKey, commitmentsWithCiphertext, nullifiers, value) {
-        const unspends = await this.bookkeeper.getUnspends(viewingKey, commitmentsWithCiphertext, nullifiers);
-        const balance = this.bookkeeper.sumNotes(unspends);
-        if (balance.lt(value)) {
-            return Promise.reject('Not enough balance');
-        }
-        const chosenUnspends = [];
-        let toSpend = new bignumber_1.default(0);
-        for (const unspend of unspends) {
-            if (toSpend.gte(value)) {
-                break;
-            }
-            toSpend = toSpend.plus(unspend.value);
-            chosenUnspends.push(unspend);
-        }
-        return [chosenUnspends, toSpend];
-    }
-    createPaymentOutput(address, value, memo = Buffer.alloc(this.options.config.memoSize)) {
+    };
+    TezosSaplingProtocol.prototype.prepareShieldTransaction = function (publicKey, recipient, value, fee, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedTransaction;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.mint(recipient, value)];
+                    case 1:
+                        encodedTransaction = _a.sent();
+                        return [2 /*return*/, this.wrapSaplingTransactions(publicKey, [encodedTransaction], fee, data === null || data === void 0 ? void 0 : data.overrideFees)];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.prepareUnshieldTransaction = function (viewingKey, recipient, value, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var burnTransaction;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!TezosAddress_1.TezosAddress.isTzAddress(recipient)) {
+                            return [2 /*return*/, Promise.reject("Invalid recpient, expected a 'tz' address, got ".concat(recipient))];
+                        }
+                        return [4 /*yield*/, this.burn(viewingKey, value)];
+                    case 1:
+                        burnTransaction = _a.sent();
+                        return [2 /*return*/, __assign(__assign({}, burnTransaction), { unshieldTarget: recipient })];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.prepareSaplingTransaction = function (viewingKey, recipient, value, data) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var dummyInputsAmount, dummyOutputsAmount, _c, stateDiff, chainId, _d, inputs, toSpend, address, paymentOutput, _e, paybackOutput, _f, dummyInputs, dummyOutputs;
+            var _this = this;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        if (this.nodeClient === undefined || this.options.config.contractAddress === undefined) {
+                            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
+                        }
+                        if (!TezosSaplingAddress_1.TezosSaplingAddress.isZetAddress(recipient)) {
+                            return [2 /*return*/, Promise.reject("Invalid recpient, expected a 'zet' address, got ".concat(recipient))];
+                        }
+                        dummyInputsAmount = Math.max(new bignumber_1.default((_a = data === null || data === void 0 ? void 0 : data.dummyInputs) !== null && _a !== void 0 ? _a : 0).toNumber(), 0);
+                        dummyOutputsAmount = Math.max(new bignumber_1.default((_b = data === null || data === void 0 ? void 0 : data.dummyOutputs) !== null && _b !== void 0 ? _b : 0).toNumber(), 0);
+                        return [4 /*yield*/, Promise.all([
+                                this.nodeClient.getSaplingStateDiff(),
+                                this.nodeClient.getChainId()
+                            ])];
+                    case 1:
+                        _c = _g.sent(), stateDiff = _c[0], chainId = _c[1];
+                        return [4 /*yield*/, this.chooseInputs(viewingKey, stateDiff.commitments_and_ciphertexts, stateDiff.nullifiers, value)];
+                    case 2:
+                        _d = _g.sent(), inputs = _d[0], toSpend = _d[1];
+                        return [4 /*yield*/, this.getAddressFromPublicKey(viewingKey).then(function (address) {
+                                return TezosSaplingAddress_1.TezosSaplingAddress.fromValue(address.address, address.cursor.diversifierIndex);
+                            })];
+                    case 3:
+                        address = _g.sent();
+                        _e = this.createPaymentOutput;
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromValue(recipient)];
+                    case 4:
+                        paymentOutput = _e.apply(this, [_g.sent(), value]);
+                        paybackOutput = this.createPaybackOutput(address, toSpend, value);
+                        return [4 /*yield*/, Promise.all([
+                                Promise.all(Array.from({ length: dummyInputsAmount }, function (_v, _k) { return _this.createDummyInput(address); })),
+                                Promise.all(Array.from({ length: dummyOutputsAmount }, function (_v, _k) { return _this.createDummyOutput(); }))
+                            ])];
+                    case 5:
+                        _f = _g.sent(), dummyInputs = _f[0], dummyOutputs = _f[1];
+                        return [2 /*return*/, {
+                                ins: inputs.concat(dummyInputs),
+                                outs: __spreadArray([paymentOutput, paybackOutput], dummyOutputs, true).filter(function (output) { return output !== undefined; }),
+                                contractAddress: this.options.config.contractAddress,
+                                chainId: chainId,
+                                stateDiff: stateDiff,
+                                unshieldTarget: ''
+                            }];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.mint = function (recipient, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, saplingStateDiff, chainId, output, stateTree, forgedTransaction;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (this.nodeClient === undefined || this.options.config.contractAddress === undefined) {
+                            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
+                        }
+                        if (!TezosSaplingAddress_1.TezosSaplingAddress.isZetAddress(recipient)) {
+                            return [2 /*return*/, Promise.reject("Invalid recipient, expected a 'zet' address, got ".concat(recipient))];
+                        }
+                        return [4 /*yield*/, Promise.all([
+                                this.nodeClient.getSaplingStateDiff(),
+                                this.nodeClient.getChainId()
+                            ])];
+                    case 1:
+                        _a = _c.sent(), saplingStateDiff = _a[0], chainId = _a[1];
+                        _b = {};
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromValue(recipient)];
+                    case 2:
+                        output = (_b.address = (_c.sent()).asString(),
+                            _b.value = value,
+                            _b.memo = Buffer.alloc(this.options.config.memoSize).toString('hex'),
+                            _b.browsable = true,
+                            _b);
+                        return [4 /*yield*/, this.state.getStateTreeFromStateDiff(saplingStateDiff, true)];
+                    case 3:
+                        stateTree = _c.sent();
+                        return [4 /*yield*/, this.forger.forgeSaplingTransaction([], [output], stateTree, this.getAntiReplay(chainId, this.options.config.contractAddress))];
+                    case 4:
+                        forgedTransaction = _c.sent();
+                        return [2 /*return*/, this.encoder.encodeTransaction(forgedTransaction).toString('hex')];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.burn = function (viewingKey, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, stateDiff, chainId, _b, inputs, toSpend, paybackOutput;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.nodeClient === undefined || this.options.config.contractAddress === undefined) {
+                            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, 'Contract address not set.');
+                        }
+                        return [4 /*yield*/, Promise.all([
+                                this.nodeClient.getSaplingStateDiff(),
+                                this.nodeClient.getChainId()
+                            ])];
+                    case 1:
+                        _a = _d.sent(), stateDiff = _a[0], chainId = _a[1];
+                        return [4 /*yield*/, this.chooseInputs(viewingKey, stateDiff.commitments_and_ciphertexts, stateDiff.nullifiers, value)];
+                    case 2:
+                        _b = _d.sent(), inputs = _b[0], toSpend = _b[1];
+                        _c = {};
+                        return [4 /*yield*/, this.getAddressFromPublicKey(viewingKey)];
+                    case 3:
+                        paybackOutput = (_c.address = (_d.sent()).address,
+                            _c.value = toSpend.minus(value).toString(),
+                            _c.memo = Buffer.alloc(this.options.config.memoSize).toString('hex'),
+                            _c.browsable = true,
+                            _c);
+                        return [2 /*return*/, {
+                                ins: inputs,
+                                outs: [paybackOutput],
+                                contractAddress: this.options.config.contractAddress,
+                                chainId: chainId,
+                                stateDiff: stateDiff,
+                                unshieldTarget: ''
+                            }];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.chooseInputs = function (viewingKey, commitmentsWithCiphertext, nullifiers, value) {
+        return __awaiter(this, void 0, void 0, function () {
+            var unspends, balance, chosenUnspends, toSpend, _i, unspends_1, unspend;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.bookkeeper.getUnspends(viewingKey, commitmentsWithCiphertext, nullifiers)];
+                    case 1:
+                        unspends = _a.sent();
+                        balance = this.bookkeeper.sumNotes(unspends);
+                        if (balance.lt(value)) {
+                            return [2 /*return*/, Promise.reject('Not enough balance')];
+                        }
+                        chosenUnspends = [];
+                        toSpend = new bignumber_1.default(0);
+                        for (_i = 0, unspends_1 = unspends; _i < unspends_1.length; _i++) {
+                            unspend = unspends_1[_i];
+                            if (toSpend.gte(value)) {
+                                break;
+                            }
+                            toSpend = toSpend.plus(unspend.value);
+                            chosenUnspends.push(unspend);
+                        }
+                        return [2 /*return*/, [chosenUnspends, toSpend]];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.createPaymentOutput = function (address, value, memo) {
+        if (memo === void 0) { memo = Buffer.alloc(this.options.config.memoSize); }
         return {
             address: address.asString(),
             value: new bignumber_1.default(value).toString(),
             memo: memo.toString('hex'),
             browsable: true
         };
-    }
-    createPaybackOutput(address, toSpend, value, memo = Buffer.alloc(this.options.config.memoSize)) {
-        const paybackValue = toSpend.minus(value);
+    };
+    TezosSaplingProtocol.prototype.createPaybackOutput = function (address, toSpend, value, memo) {
+        if (memo === void 0) { memo = Buffer.alloc(this.options.config.memoSize); }
+        var paybackValue = toSpend.minus(value);
         return paybackValue.gt(0)
             ? {
                 address: address.asString(),
@@ -569,94 +1007,183 @@ class TezosSaplingProtocol extends NonExtendedProtocol_1.NonExtendedProtocol {
                 browsable: true
             }
             : undefined;
-    }
-    async createDummyInput(address) {
-        const rcm = await sapling.randR();
-        return {
-            rcm: rcm.toString('hex'),
-            pos: '0',
-            value: '0',
-            address: address.asString()
-        };
-    }
-    async createDummyOutput() {
-        const address = await this.getDummyAddress();
-        const memo = (0, random_1.randomBytes)(this.options.config.memoSize);
-        return {
-            address: address.address,
-            value: '0',
-            memo: Buffer.from(memo).toString('hex'),
-            browsable: false
-        };
-    }
-    async getDummyAddress() {
-        const seed = (0, random_1.randomBytes)(32);
-        const viewingKey = await this.getPublicKeyFromHexSecret(Buffer.from(seed).toString('hex'), this.standardDerivationPath);
-        return this.getAddressFromPublicKey(viewingKey);
-    }
-    createAddressBoundData(address) {
-        const michelson = MichelsonAddress_1.MichelsonAddress.from(TezosUtils_1.TezosUtils.encodeTzAddress(address));
+    };
+    TezosSaplingProtocol.prototype.createDummyInput = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rcm;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, sapling.randR()];
+                    case 1:
+                        rcm = _a.sent();
+                        return [2 /*return*/, {
+                                rcm: rcm.toString('hex'),
+                                pos: '0',
+                                value: '0',
+                                address: address.asString()
+                            }];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.createDummyOutput = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var address, memo;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getDummyAddress()];
+                    case 1:
+                        address = _a.sent();
+                        memo = (0, random_1.randomBytes)(this.options.config.memoSize);
+                        return [2 /*return*/, {
+                                address: address.address,
+                                value: '0',
+                                memo: Buffer.from(memo).toString('hex'),
+                                browsable: false
+                            }];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getDummyAddress = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var seed, viewingKey;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        seed = (0, random_1.randomBytes)(32);
+                        return [4 /*yield*/, this.getPublicKeyFromHexSecret(Buffer.from(seed).toString('hex'), this.standardDerivationPath)];
+                    case 1:
+                        viewingKey = _a.sent();
+                        return [2 /*return*/, this.getAddressFromPublicKey(viewingKey)];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.createAddressBoundData = function (address) {
+        var michelson = MichelsonAddress_1.MichelsonAddress.from(TezosUtils_1.TezosUtils.encodeTzAddress(address));
         return TezosUtils_1.TezosUtils.packMichelsonType(michelson);
-    }
-    getAntiReplay(chainId, contractAddress) {
+    };
+    TezosSaplingProtocol.prototype.getAntiReplay = function (chainId, contractAddress) {
         return contractAddress + chainId;
-    }
-    async broadcastTransaction(rawTransaction) {
-        if (!this.injectorClient) {
-            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, "Can't broadcast a sapling transaction, an injector service URL or contract address has not be set.");
-        }
-        try {
-            const hash = await this.injectorClient.injectTransaction(rawTransaction);
-            return hash;
-        }
-        catch (error) {
-            throw new errors_1.NetworkError(coinlib_error_1.Domain.TEZOS, error);
-        }
-    }
-    async signMessage(message, keypair) {
-        return this.tezosProtocol.signMessage(message, keypair);
-    }
-    async verifyMessage(message, signature, publicKey) {
-        return this.tezosProtocol.verifyMessage(message, signature, publicKey);
-    }
-    async encryptAsymmetric(payload, publicKey) {
-        return this.encryptAsymmetric(payload, publicKey);
-    }
-    async decryptAsymmetric(encryptedPayload, keypair) {
-        return this.decryptAsymmetric(encryptedPayload, keypair);
-    }
-    async encryptAES(payload, privateKey) {
-        return this.encryptAES(payload, privateKey);
-    }
-    async decryptAES(encryptedPayload, privateKey) {
-        return this.decryptAES(encryptedPayload, privateKey);
-    }
-    async getBlockExplorerLinkForAddress(address) {
-        throw new Error('Method `getBlockExplorerLinkForAddress` not supported.');
-    }
-    async getTransactionsFromAddresses(addresses, limit, cursor) {
-        throw new Error('Method `getTransactionsFromAddresses` not supported.');
-    }
-    async getBalanceOfAddresses(addresses) {
-        throw new Error('Method `getBalanceOfAddresses` not supported.');
-    }
-    async getAvailableBalanceOfAddresses(addresses) {
-        throw new Error('Method `getAvailableBalanceOfAddresses` not supported.');
-    }
-    async getBalanceOfPublicKeyForSubProtocols(publicKey, subProtocols) {
-        throw new Error('Method `getBalanceOfPublicKeyForSubProtocols` not supported.');
-    }
-    async estimateFeeDefaultsFromPublicKey(publicKey, recipients, values, data) {
-        throw new Error('Method `estimateFeeDefaultsFromPublicKey` not supported.');
-    }
-    isRawTezosSaplingTransaction(transaction) {
+    };
+    TezosSaplingProtocol.prototype.broadcastTransaction = function (rawTransaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hash, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.injectorClient) {
+                            throw new errors_1.PropertyUndefinedError(coinlib_error_1.Domain.TEZOS, "Can't broadcast a sapling transaction, an injector service URL or contract address has not be set.");
+                        }
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.injectorClient.injectTransaction(rawTransaction)];
+                    case 2:
+                        hash = _a.sent();
+                        return [2 /*return*/, hash];
+                    case 3:
+                        error_2 = _a.sent();
+                        throw new errors_1.NetworkError(coinlib_error_1.Domain.TEZOS, error_2);
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.signMessage = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.tezosProtocol.signMessage(message, keypair)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.verifyMessage = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.tezosProtocol.verifyMessage(message, signature, publicKey)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.encryptAsymmetric = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.encryptAsymmetric(payload, publicKey)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.decryptAsymmetric = function (encryptedPayload, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.decryptAsymmetric(encryptedPayload, keypair)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.encryptAES = function (payload, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.encryptAES(payload, privateKey)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.decryptAES = function (encryptedPayload, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.decryptAES(encryptedPayload, privateKey)];
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getBlockExplorerLinkForAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method `getBlockExplorerLinkForAddress` not supported.');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getTransactionsFromAddresses = function (addresses, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method `getTransactionsFromAddresses` not supported.');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method `getBalanceOfAddresses` not supported.');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getAvailableBalanceOfAddresses = function (addresses) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method `getAvailableBalanceOfAddresses` not supported.');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.getBalanceOfPublicKeyForSubProtocols = function (publicKey, subProtocols) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method `getBalanceOfPublicKeyForSubProtocols` not supported.');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.estimateFeeDefaultsFromPublicKey = function (publicKey, recipients, values, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error('Method `estimateFeeDefaultsFromPublicKey` not supported.');
+            });
+        });
+    };
+    TezosSaplingProtocol.prototype.isRawTezosSaplingTransaction = function (transaction) {
         return (transaction instanceof Object &&
             'ins' in transaction &&
             'outs' in transaction &&
             'contractAddress' in transaction &&
             'chainId' in transaction &&
             'stateDiff' in transaction);
-    }
-}
+    };
+    return TezosSaplingProtocol;
+}(NonExtendedProtocol_1.NonExtendedProtocol));
 exports.TezosSaplingProtocol = TezosSaplingProtocol;
 //# sourceMappingURL=TezosSaplingProtocol.js.map