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

package/v1/utils/protocol/sapling/TezosSaplingAccountant.js

@@ -15,56 +15,83 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TezosSaplingAccountant = void 0;
-const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-const array_1 = require("@airgap/coinlib-core/utils/array");
-const hex_1 = require("@airgap/coinlib-core/utils/hex");
-const module_kit_1 = require("@airgap/module-kit");
-const sapling = __importStar(require("@airgap/sapling-wasm"));
-const TezosSaplingAddress_1 = require("../../../data/TezosSaplingAddress");
-const MichelsonBytes_1 = require("../../../types/michelson/primitives/MichelsonBytes");
-const MichelsonString_1 = require("../../../types/michelson/primitives/MichelsonString");
-const pack_1 = require("../../pack");
-class TezosSaplingAccountant {
-    constructor(network, cryptoClient, encoder) {
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var array_1 = require("@airgap/coinlib-core/utils/array");
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var module_kit_1 = require("@airgap/module-kit");
+var sapling = __importStar(require("@airgap/sapling-wasm"));
+var TezosSaplingAddress_1 = require("../../../data/TezosSaplingAddress");
+var MichelsonBytes_1 = require("../../../types/michelson/primitives/MichelsonBytes");
+var MichelsonString_1 = require("../../../types/michelson/primitives/MichelsonString");
+var pack_1 = require("../../pack");
+var TezosSaplingAccountant = /** @class */ (function () {
+    function TezosSaplingAccountant(network, cryptoClient, encoder) {
         this.network = network;
         this.cryptoClient = cryptoClient;
         this.encoder = encoder;
     }
-    getUnsignedTransactionDetails(sender, inputs, outputs, unshieldTarget) {
+    TezosSaplingAccountant.prototype.getUnsignedTransactionDetails = function (sender, inputs, outputs, unshieldTarget) {
+        var _this = this;
         if (unshieldTarget === undefined) {
-            return outputs.map((out) => ({
+            return outputs.map(function (out) { return ({
                 from: [sender.asString()],
                 to: [out.address],
                 isInbound: false,
                 amount: (0, module_kit_1.newAmount)(out.value, 'blockchain'),
                 fee: (0, module_kit_1.newAmount)(0, 'blockchain'),
-                network: this.network
-            }));
+                network: _this.network
+            }); });
         }
         else {
-            const amount = this.sumNotes(inputs).minus(this.sumNotes(outputs));
+            var amount = this.sumNotes(inputs).minus(this.sumNotes(outputs));
             return [
                 {
                     from: [sender.asString()],
@@ -76,196 +103,487 @@ class TezosSaplingAccountant {
                 }
             ];
         }
-    }
-    async getTransactionsPartialDetails(txs, knownViewingKeys = []) {
-        const partials = await Promise.all(txs.map(async (tx) => {
-            const signedBuffer = Buffer.isBuffer(tx) ? tx : Buffer.from(tx, 'hex');
-            const transaction = this.encoder.decodeTransaction(signedBuffer);
-            const [from, details] = await this.getTransactionPartialDetails(transaction, knownViewingKeys);
-            if (transaction.boundData.length > 0) {
-                const boundDataMichelson = (0, pack_1.unpackMichelsonType)(transaction.boundData);
-                let unshieldTarget;
-                if (boundDataMichelson instanceof MichelsonBytes_1.MichelsonBytes) {
-                    unshieldTarget = (0, pack_1.parseTzAddress)(boundDataMichelson.value);
+    };
+    TezosSaplingAccountant.prototype.getTransactionsPartialDetails = function (txs, knownViewingKeys) {
+        if (knownViewingKeys === void 0) { knownViewingKeys = []; }
+        return __awaiter(this, void 0, void 0, function () {
+            var partials;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(txs.map(function (tx) { return __awaiter(_this, void 0, void 0, function () {
+                            var signedBuffer, transaction, _a, from, details, boundDataMichelson, unshieldTarget, unshieldDetails, _b, _c, _d;
+                            var _e;
+                            return __generator(this, function (_f) {
+                                switch (_f.label) {
+                                    case 0:
+                                        signedBuffer = Buffer.isBuffer(tx) ? tx : Buffer.from(tx, 'hex');
+                                        transaction = this.encoder.decodeTransaction(signedBuffer);
+                                        return [4 /*yield*/, this.getTransactionPartialDetails(transaction, knownViewingKeys)];
+                                    case 1:
+                                        _a = _f.sent(), from = _a[0], details = _a[1];
+                                        if (!(transaction.boundData.length > 0)) return [3 /*break*/, 4];
+                                        boundDataMichelson = (0, pack_1.unpackMichelsonType)(transaction.boundData);
+                                        unshieldTarget = void 0;
+                                        if (boundDataMichelson instanceof MichelsonBytes_1.MichelsonBytes) {
+                                            unshieldTarget = (0, pack_1.parseTzAddress)(boundDataMichelson.value);
+                                        }
+                                        else if (boundDataMichelson instanceof MichelsonString_1.MichelsonString) {
+                                            unshieldTarget = boundDataMichelson.value;
+                                        }
+                                        if (!(unshieldTarget !== undefined)) return [3 /*break*/, 4];
+                                        unshieldDetails = {
+                                            to: [unshieldTarget],
+                                            amount: (0, module_kit_1.newAmount)(transaction.balance, 'blockchain')
+                                        };
+                                        if (!(from !== undefined)) return [3 /*break*/, 3];
+                                        _c = (_b = Object).assign;
+                                        _d = [unshieldDetails];
+                                        _e = {};
+                                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(from)];
+                                    case 2:
+                                        unshieldDetails = _c.apply(_b, _d.concat([(_e.from = [(_f.sent()).asString()], _e)]));
+                                        _f.label = 3;
+                                    case 3:
+                                        details.push(unshieldDetails);
+                                        _f.label = 4;
+                                    case 4: return [2 /*return*/, details];
+                                }
+                            });
+                        }); }))];
+                    case 1:
+                        partials = _a.sent();
+                        return [2 /*return*/, (0, array_1.flattenArray)(partials)];
                 }
-                else if (boundDataMichelson instanceof MichelsonString_1.MichelsonString) {
-                    unshieldTarget = boundDataMichelson.value;
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getTransactionPartialDetails = function (transaction, knownViewingKeys) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sender, _a, details;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(transaction.spendDescriptions.length === 0)) return [3 /*break*/, 1];
+                        _a = undefined;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.findSender(transaction, knownViewingKeys)];
+                    case 2:
+                        _a = _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        sender = _a;
+                        return [4 /*yield*/, Promise.all(transaction.outputDescriptions.map(function (description) { return __awaiter(_this, void 0, void 0, function () {
+                                var recipient, from, _a, _b, to, amount, outputDetails;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0: return [4 /*yield*/, this.findRecipient(description, knownViewingKeys)];
+                                        case 1:
+                                            recipient = _c.sent();
+                                            if (!(sender !== undefined)) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(sender)];
+                                        case 2:
+                                            _a = _c.sent();
+                                            return [3 /*break*/, 4];
+                                        case 3:
+                                            _a = undefined;
+                                            _c.label = 4;
+                                        case 4:
+                                            from = _a;
+                                            return [4 /*yield*/, this.decodeDetailsFromOutputDescription(sender, recipient, description)];
+                                        case 5:
+                                            _b = _c.sent(), to = _b[0], amount = _b[1];
+                                            outputDetails = {};
+                                            if (from !== undefined) {
+                                                outputDetails = Object.assign(outputDetails, { from: [from.asString()] });
+                                            }
+                                            if (to !== undefined) {
+                                                outputDetails = Object.assign(outputDetails, { to: [to.asString()] });
+                                            }
+                                            if (amount !== undefined) {
+                                                outputDetails = Object.assign(outputDetails, { amount: (0, module_kit_1.newAmount)(amount, 'blockchain') });
+                                            }
+                                            return [2 /*return*/, outputDetails];
+                                    }
+                                });
+                            }); }))];
+                    case 4:
+                        details = _b.sent();
+                        return [2 /*return*/, [sender, details]];
                 }
-                if (unshieldTarget !== undefined) {
-                    let unshieldDetails = {
-                        to: [unshieldTarget],
-                        amount: (0, module_kit_1.newAmount)(transaction.balance, 'blockchain')
-                    };
-                    if (from !== undefined) {
-                        unshieldDetails = Object.assign(unshieldDetails, { from: [(await TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(from)).asString()] });
-                    }
-                    details.push(unshieldDetails);
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.findSender = function (transaction, viewingKeys) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(viewingKeys.map(function (viewingKey) { return __awaiter(_this, void 0, void 0, function () {
+                            var outputDescription, error_1;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 3]);
+                                        outputDescription = transaction.outputDescriptions[0];
+                                        return [4 /*yield*/, this.cryptoClient.decryptCiphertextOut(viewingKey, outputDescription.ciphertext, outputDescription.cm)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/, viewingKey];
+                                    case 2:
+                                        error_1 = _a.sent();
+                                        return [2 /*return*/, undefined];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                    case 1: return [2 /*return*/, (_a.sent()).find(function (viewingKey) { return viewingKey !== undefined; })];
                 }
-            }
-            return details;
-        }));
-        return (0, array_1.flattenArray)(partials);
-    }
-    async getTransactionPartialDetails(transaction, knownViewingKeys) {
-        const sender = transaction.spendDescriptions.length === 0 ? undefined : await this.findSender(transaction, knownViewingKeys);
-        const details = await Promise.all(transaction.outputDescriptions.map(async (description) => {
-            const recipient = await this.findRecipient(description, knownViewingKeys);
-            const from = sender !== undefined ? await TezosSaplingAddress_1.TezosSaplingAddress.fromViewingKey(sender) : undefined;
-            const [to, amount] = await this.decodeDetailsFromOutputDescription(sender, recipient, description);
-            let outputDetails = {};
-            if (from !== undefined) {
-                outputDetails = Object.assign(outputDetails, { from: [from.asString()] });
-            }
-            if (to !== undefined) {
-                outputDetails = Object.assign(outputDetails, { to: [to.asString()] });
-            }
-            if (amount !== undefined) {
-                outputDetails = Object.assign(outputDetails, { amount: (0, module_kit_1.newAmount)(amount, 'blockchain') });
-            }
-            return outputDetails;
-        }));
-        return [sender, details];
-    }
-    async findSender(transaction, viewingKeys) {
-        return (await Promise.all(viewingKeys.map(async (viewingKey) => {
-            try {
-                // a viewing key is the sender if it can decrypt any ciphertext payload out from the transaction
-                const outputDescription = transaction.outputDescriptions[0];
-                await this.cryptoClient.decryptCiphertextOut(viewingKey, outputDescription.ciphertext, outputDescription.cm);
-                return viewingKey;
-            }
-            catch (error) {
-                return undefined;
-            }
-        }))).find((viewingKey) => viewingKey !== undefined);
-    }
-    async findRecipient(outputDescription, viewingKeys) {
-        return (await Promise.all(viewingKeys.map(async (viewingKey) => {
-            try {
-                // a viewing key is the recipient if it can decrypt the ciphertext payload enc from output description
-                await this.cryptoClient.decryptCiphertextEnc(viewingKey, outputDescription.ciphertext);
-                return viewingKey;
-            }
-            catch (error) {
-                return undefined;
-            }
-        }))).find((viewingKey) => viewingKey !== undefined);
-    }
-    async decodeDetailsFromOutputDescription(sender, recipient, output) {
-        const viewingKey = sender ?? recipient;
-        if (viewingKey !== undefined) {
-            const { address, amount } = await this.cryptoClient.decryptCiphertextEnc(viewingKey, output.ciphertext, viewingKey === sender ? 'sender' : 'receiver', output.cm);
-            return [await TezosSaplingAddress_1.TezosSaplingAddress.fromRaw(address), amount];
-        }
-        return [undefined, undefined];
-    }
-    sumNotes(notes) {
-        return notes.reduce((sum, next) => sum.plus(next.value), new bignumber_1.default(0));
-    }
-    async getIncomingInputs(viewingKey, commitmentsWithCiphertext) {
-        const inputs = (await Promise.all(commitmentsWithCiphertext.map(async ([commitment, ciphertext, position]) => {
-            const decrypted = await this.getIncomingInputFromCiphertext(viewingKey, ciphertext, commitment, position);
-            if (decrypted === undefined || !(await this.verifyCommitment(decrypted[1], commitment))) {
-                return undefined;
-            }
-            return decrypted[1];
-        }))).filter((input) => input !== undefined);
-        return inputs;
-    }
-    async getOutgoingInputs(viewingKey, commitmentsWithCiphertext) {
-        const inputs = (await Promise.all(commitmentsWithCiphertext.map(async ([commitment, ciphertext, position]) => {
-            const decrypted = await this.getOutgoingInputFromCiphertext(viewingKey, ciphertext, commitment, position);
-            if (decrypted === undefined || (decrypted[1].address !== '' && !(await this.verifyCommitment(decrypted[1], commitment)))) {
-                return undefined;
-            }
-            return decrypted[1];
-        }))).filter((input) => input !== undefined);
-        return inputs;
-    }
-    async getUnspends(viewingKey, commitmentsWithCiphertext, nullifiers) {
-        const nullifiersSet = new Set(nullifiers.map((nullifier) => (0, hex_1.stripHexPrefix)(nullifier)));
-        const inputs = await this.getInputs(viewingKey, commitmentsWithCiphertext);
-        const unspends = (await Promise.all(inputs.map(async (input) => {
-            const nullifier = await sapling.computeNullifier(viewingKey, (await TezosSaplingAddress_1.TezosSaplingAddress.fromValue(input.address)).raw, input.value, input.rcm, input.pos);
-            return !nullifiersSet.has(nullifier.toString('hex')) ? input : undefined;
-        }))).filter((input) => input !== undefined);
-        return unspends;
-    }
-    async getInputs(viewingKey, commitmentsWithCiphertext) {
-        const inputs = (await Promise.all(commitmentsWithCiphertext.map(async ([commitment, ciphertext], index) => {
-            const decrypted = await this.getReceiverInputFromCiphertext(viewingKey, ciphertext, new bignumber_1.default(index));
-            if (decrypted === undefined || !(await this.verifyCommitment(decrypted[1], commitment))) {
-                return undefined;
-            }
-            return decrypted[1];
-        }))).filter((input) => input !== undefined);
-        return inputs;
-    }
-    async getReceiverInputFromCiphertext(viewingKey, ciphertext, position) {
-        try {
-            const { diversifier, amount, rcm, memo } = await this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'receiver');
-            const ivk = await sapling.getIncomingViewingKey(viewingKey);
-            const address = await sapling.getRawPaymentAddressFromIncomingViewingKey(ivk, diversifier);
-            const input = {
-                rcm: rcm.toString('hex'),
-                pos: position.toString(),
-                value: amount.toString(),
-                address: (await TezosSaplingAddress_1.TezosSaplingAddress.fromRaw(address)).asString()
-            };
-            return [Buffer.from(memo), input];
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async getSenderInputFromCiphertext(viewingKey, ciphertext, commitment, position) {
-        try {
-            const { amount, address, rcm, memo } = await this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'sender', commitment);
-            const input = {
-                rcm: rcm.toString('hex'),
-                pos: position.toString(),
-                value: amount.toString(),
-                address: (await TezosSaplingAddress_1.TezosSaplingAddress.fromRaw(address)).asString()
-            };
-            return [Buffer.from(memo), input];
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async getIncomingInputFromCiphertext(viewingKey, ciphertext, commitment, position) {
-        const inputWithMemo = await this.getReceiverInputFromCiphertext(viewingKey, ciphertext, position);
-        if (inputWithMemo === undefined) {
-            return undefined;
-        }
-        try {
-            await this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'sender', commitment);
-            // ciphertext can be decrypted, the receiver is also the sender
-            return undefined;
-        }
-        catch (error) {
-            // ciphertext could not be decrypted, the reciever is not the sender
-            return inputWithMemo;
-        }
-    }
-    async getOutgoingInputFromCiphertext(viewingKey, ciphertext, commitment, position) {
-        const inputWithMemo = await this.getSenderInputFromCiphertext(viewingKey, ciphertext, commitment, position);
-        if (inputWithMemo === undefined) {
-            return undefined;
-        }
-        try {
-            await this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'receiver');
-            // ciphertext can be decrypted, the sender is also the receiver
-            return undefined;
-        }
-        catch {
-            // ciphertext could not be decrypted, the sender is not the receiver
-            return inputWithMemo;
-        }
-    }
-    async verifyCommitment(input, expectedCommitment) {
-        return sapling.verifyCommitment(expectedCommitment, (await TezosSaplingAddress_1.TezosSaplingAddress.fromValue(input.address)).raw, input.value, input.rcm);
-    }
-}
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.findRecipient = function (outputDescription, viewingKeys) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(viewingKeys.map(function (viewingKey) { return __awaiter(_this, void 0, void 0, function () {
+                            var error_2;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        _a.trys.push([0, 2, , 3]);
+                                        // a viewing key is the recipient if it can decrypt the ciphertext payload enc from output description
+                                        return [4 /*yield*/, this.cryptoClient.decryptCiphertextEnc(viewingKey, outputDescription.ciphertext)];
+                                    case 1:
+                                        // a viewing key is the recipient if it can decrypt the ciphertext payload enc from output description
+                                        _a.sent();
+                                        return [2 /*return*/, viewingKey];
+                                    case 2:
+                                        error_2 = _a.sent();
+                                        return [2 /*return*/, undefined];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
+                        }); }))];
+                    case 1: return [2 /*return*/, (_a.sent()).find(function (viewingKey) { return viewingKey !== undefined; })];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.decodeDetailsFromOutputDescription = function (sender, recipient, output) {
+        return __awaiter(this, void 0, void 0, function () {
+            var viewingKey, _a, address, amount;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        viewingKey = sender !== null && sender !== void 0 ? sender : recipient;
+                        if (!(viewingKey !== undefined)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.cryptoClient.decryptCiphertextEnc(viewingKey, output.ciphertext, viewingKey === sender ? 'sender' : 'receiver', output.cm)];
+                    case 1:
+                        _a = _b.sent(), address = _a.address, amount = _a.amount;
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromRaw(address)];
+                    case 2: return [2 /*return*/, [_b.sent(), amount]];
+                    case 3: return [2 /*return*/, [undefined, undefined]];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.sumNotes = function (notes) {
+        return notes.reduce(function (sum, next) { return sum.plus(next.value); }, new bignumber_1.default(0));
+    };
+    TezosSaplingAccountant.prototype.getIncomingInputs = function (viewingKey, commitmentsWithCiphertext) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inputs;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(commitmentsWithCiphertext.map(function (_a) {
+                            var commitment = _a[0], ciphertext = _a[1], position = _a[2];
+                            return __awaiter(_this, void 0, void 0, function () {
+                                var decrypted, _b;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0: return [4 /*yield*/, this.getIncomingInputFromCiphertext(viewingKey, ciphertext, commitment, position)];
+                                        case 1:
+                                            decrypted = _c.sent();
+                                            _b = decrypted === undefined;
+                                            if (_b) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, this.verifyCommitment(decrypted[1], commitment)];
+                                        case 2:
+                                            _b = !(_c.sent());
+                                            _c.label = 3;
+                                        case 3:
+                                            if (_b) {
+                                                return [2 /*return*/, undefined];
+                                            }
+                                            return [2 /*return*/, decrypted[1]];
+                                    }
+                                });
+                            });
+                        }))];
+                    case 1:
+                        inputs = (_a.sent()).filter(function (input) { return input !== undefined; });
+                        return [2 /*return*/, inputs];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getOutgoingInputs = function (viewingKey, commitmentsWithCiphertext) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inputs;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(commitmentsWithCiphertext.map(function (_a) {
+                            var commitment = _a[0], ciphertext = _a[1], position = _a[2];
+                            return __awaiter(_this, void 0, void 0, function () {
+                                var decrypted, _b, _c;
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0: return [4 /*yield*/, this.getOutgoingInputFromCiphertext(viewingKey, ciphertext, commitment, position)];
+                                        case 1:
+                                            decrypted = _d.sent();
+                                            _b = decrypted === undefined;
+                                            if (_b) return [3 /*break*/, 4];
+                                            _c = decrypted[1].address !== '';
+                                            if (!_c) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, this.verifyCommitment(decrypted[1], commitment)];
+                                        case 2:
+                                            _c = !(_d.sent());
+                                            _d.label = 3;
+                                        case 3:
+                                            _b = (_c);
+                                            _d.label = 4;
+                                        case 4:
+                                            if (_b) {
+                                                return [2 /*return*/, undefined];
+                                            }
+                                            return [2 /*return*/, decrypted[1]];
+                                    }
+                                });
+                            });
+                        }))];
+                    case 1:
+                        inputs = (_a.sent()).filter(function (input) { return input !== undefined; });
+                        return [2 /*return*/, inputs];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getUnspends = function (viewingKey, commitmentsWithCiphertext, nullifiers) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nullifiersSet, inputs, unspends;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        nullifiersSet = new Set(nullifiers.map(function (nullifier) { return (0, hex_1.stripHexPrefix)(nullifier); }));
+                        return [4 /*yield*/, this.getInputs(viewingKey, commitmentsWithCiphertext)];
+                    case 1:
+                        inputs = _a.sent();
+                        return [4 /*yield*/, Promise.all(inputs.map(function (input) { return __awaiter(_this, void 0, void 0, function () {
+                                var nullifier, _a, _b, _c;
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            _b = (_a = sapling).computeNullifier;
+                                            _c = [viewingKey];
+                                            return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromValue(input.address)];
+                                        case 1: return [4 /*yield*/, _b.apply(_a, _c.concat([(_d.sent()).raw,
+                                                input.value,
+                                                input.rcm,
+                                                input.pos]))];
+                                        case 2:
+                                            nullifier = _d.sent();
+                                            return [2 /*return*/, !nullifiersSet.has(nullifier.toString('hex')) ? input : undefined];
+                                    }
+                                });
+                            }); }))];
+                    case 2:
+                        unspends = (_a.sent()).filter(function (input) { return input !== undefined; });
+                        return [2 /*return*/, unspends];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getInputs = function (viewingKey, commitmentsWithCiphertext) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inputs;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(commitmentsWithCiphertext.map(function (_a, index) {
+                            var commitment = _a[0], ciphertext = _a[1];
+                            return __awaiter(_this, void 0, void 0, function () {
+                                var decrypted, _b;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0: return [4 /*yield*/, this.getReceiverInputFromCiphertext(viewingKey, ciphertext, new bignumber_1.default(index))];
+                                        case 1:
+                                            decrypted = _c.sent();
+                                            _b = decrypted === undefined;
+                                            if (_b) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, this.verifyCommitment(decrypted[1], commitment)];
+                                        case 2:
+                                            _b = !(_c.sent());
+                                            _c.label = 3;
+                                        case 3:
+                                            if (_b) {
+                                                return [2 /*return*/, undefined];
+                                            }
+                                            return [2 /*return*/, decrypted[1]];
+                                    }
+                                });
+                            });
+                        }))];
+                    case 1:
+                        inputs = (_a.sent()).filter(function (input) { return input !== undefined; });
+                        return [2 /*return*/, inputs];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getReceiverInputFromCiphertext = function (viewingKey, ciphertext, position) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, diversifier, amount, rcm, memo, ivk, address, input, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 5, , 6]);
+                        return [4 /*yield*/, this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'receiver')];
+                    case 1:
+                        _a = _d.sent(), diversifier = _a.diversifier, amount = _a.amount, rcm = _a.rcm, memo = _a.memo;
+                        return [4 /*yield*/, sapling.getIncomingViewingKey(viewingKey)];
+                    case 2:
+                        ivk = _d.sent();
+                        return [4 /*yield*/, sapling.getRawPaymentAddressFromIncomingViewingKey(ivk, diversifier)];
+                    case 3:
+                        address = _d.sent();
+                        _c = {
+                            rcm: rcm.toString('hex'),
+                            pos: position.toString(),
+                            value: amount.toString()
+                        };
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromRaw(address)];
+                    case 4:
+                        input = (_c.address = (_d.sent()).asString(),
+                            _c);
+                        return [2 /*return*/, [Buffer.from(memo), input]];
+                    case 5:
+                        _b = _d.sent();
+                        return [2 /*return*/, undefined];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getSenderInputFromCiphertext = function (viewingKey, ciphertext, commitment, position) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, amount, address, rcm, memo, input, _b;
+            var _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'sender', commitment)];
+                    case 1:
+                        _a = _d.sent(), amount = _a.amount, address = _a.address, rcm = _a.rcm, memo = _a.memo;
+                        _c = {
+                            rcm: rcm.toString('hex'),
+                            pos: position.toString(),
+                            value: amount.toString()
+                        };
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromRaw(address)];
+                    case 2:
+                        input = (_c.address = (_d.sent()).asString(),
+                            _c);
+                        return [2 /*return*/, [Buffer.from(memo), input]];
+                    case 3:
+                        _b = _d.sent();
+                        return [2 /*return*/, undefined];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getIncomingInputFromCiphertext = function (viewingKey, ciphertext, commitment, position) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inputWithMemo, error_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getReceiverInputFromCiphertext(viewingKey, ciphertext, position)];
+                    case 1:
+                        inputWithMemo = _a.sent();
+                        if (inputWithMemo === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'sender', commitment)
+                            // ciphertext can be decrypted, the receiver is also the sender
+                        ];
+                    case 3:
+                        _a.sent();
+                        // ciphertext can be decrypted, the receiver is also the sender
+                        return [2 /*return*/, undefined];
+                    case 4:
+                        error_3 = _a.sent();
+                        // ciphertext could not be decrypted, the reciever is not the sender
+                        return [2 /*return*/, inputWithMemo];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.getOutgoingInputFromCiphertext = function (viewingKey, ciphertext, commitment, position) {
+        return __awaiter(this, void 0, void 0, function () {
+            var inputWithMemo, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.getSenderInputFromCiphertext(viewingKey, ciphertext, commitment, position)];
+                    case 1:
+                        inputWithMemo = _b.sent();
+                        if (inputWithMemo === undefined) {
+                            return [2 /*return*/, undefined];
+                        }
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, this.cryptoClient.decryptCiphertextEnc(viewingKey, ciphertext, 'receiver')
+                            // ciphertext can be decrypted, the sender is also the receiver
+                        ];
+                    case 3:
+                        _b.sent();
+                        // ciphertext can be decrypted, the sender is also the receiver
+                        return [2 /*return*/, undefined];
+                    case 4:
+                        _a = _b.sent();
+                        // ciphertext could not be decrypted, the sender is not the receiver
+                        return [2 /*return*/, inputWithMemo];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    TezosSaplingAccountant.prototype.verifyCommitment = function (input, expectedCommitment) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _b = (_a = sapling).verifyCommitment;
+                        _c = [expectedCommitment];
+                        return [4 /*yield*/, TezosSaplingAddress_1.TezosSaplingAddress.fromValue(input.address)];
+                    case 1: return [2 /*return*/, _b.apply(_a, _c.concat([(_d.sent()).raw, input.value, input.rcm]))];
+                }
+            });
+        });
+    };
+    return TezosSaplingAccountant;
+}());
 exports.TezosSaplingAccountant = TezosSaplingAccountant;
 //# sourceMappingURL=TezosSaplingAccountant.js.map