@tezos-x/octez.js-sapling 0.9.0

package/README.md

@@ -0,0 +1,95 @@
+# octez.js Sapling package
+
+_Documentation can be found [here](https://octez.js.io/docs/next/sapling)_
+_TypeDoc style documentation is available on-line [here](https://octez.js.io/typedoc/modules/_octez.js_sapling.html)_
+
+**Maintained by [Nomadic Labs](https://www.nomadic-labs.com/).**
+
+## General Information
+
+Sapling is a protocol allowing to perform private transactions in a decentralized environment. This package allows to read from a sapling state (retrieve the balance and transaction history) and prepare sapling transactions.
+
+## Install
+
+Install the package as follows
+
+```
+npm install @tezos-x/octez.js-sapling
+```
+## Usage
+
+**Retrieve a balance in the Sapling shielded set**
+
+The returned balance is in mutez.
+
+```ts
+import { TezosToolkit, RpcReadAdapter } from '@tezos-x/octez.js';
+import { SaplingToolkit, InMemorySpendingKey } from '@tezos-x/octez.js-sapling';
+
+const tezos = new TezosToolkit('https://YOUR_PREFERRED_RPC_URL');
+
+const saplingContract = await tezos.contract.at('KT1UYwMR6Q6LZnwQEi77DSBrAjKT1tEJb245');
+
+const inMemorySpendingKey = await InMemorySpendingKey.fromMnemonic('YOUR_MNEMONIC');
+
+const readProvider = new RpcReadAdapter(tezos.rpc);
+
+const saplingToolkit = new SaplingToolkit(
+    { saplingSigner: inMemorySpendingKey },
+    { contractAddress: saplingContract.address, memoSize: 8 },
+    readProvider
+)
+
+const txViewer = await saplingToolkit.getSaplingTransactionViewer();
+const initialBalance = await txViewer.getBalance();
+```
+
+**Prepare a shielded transaction**
+
+A shielded transaction allows sending tokens from a Tezos account (tz1, tz2, tz3) to a Sapling address (zet).
+
+```ts
+import { TezosToolkit, RpcReadAdapter } from '@tezos-x/octez.js';
+import { SaplingToolkit, InMemorySpendingKey } from '@tezos-x/octez.js-sapling';
+
+const tezos = new TezosToolkit('https://YOUR_PREFERRED_RPC_URL');
+// set up your signer on the TezosToolkit as usual
+const saplingContract = await tezos.contract.at('KT1UYwMR6Q6LZnwQEi77DSBrAjKT1tEJb245');
+
+const inMemorySpendingKey = await InMemorySpendingKey.fromMnemonic('YOUR_MNEMONIC');
+
+const readProvider = new RpcReadAdapter(tezos.rpc);
+
+const saplingToolkit = new SaplingToolkit(
+    { saplingSigner: inMemorySpendingKey },
+    { contractAddress: saplingContract.address, memoSize: 8 },
+    readProvider
+)
+
+// Fetch a payment address (zet)
+const inMemoryViewingKey = await inMemorySpendingKey.getSaplingViewingKeyProvider();
+const paymentAddress = (await inMemoryViewingKey.getAddress()).address;
+
+// prepare the shielded transaction
+const shieldedTx = await saplingToolkit.prepareShieldedTransaction([{
+    to: paymentAddress,
+    amount: 3,
+    memo: 'test',
+    mutez: false // set to false by default
+}])
+
+// Inject the sapling transaction using the ContractAbstraction
+// The amount MUST be specified in the send method to transfer the 3 tez to the shielded set
+const op = await saplingContract.methodsObject.default([shieldedTx]).send({ amount: 3 });
+await op.confirmation();
+```
+
+Refer to the website documentation for further examples and information: https://octez.js.io/docs/next/sapling
+
+## Additional info
+
+See the top-level project [https://github.com/trilitech/octez.js](https://github.com/trilitech/octez.js) for details on reporting issues, contributing and versioning.
+
+## Disclaimer
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/lib/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BOUND_DATA = exports.DEFAULT_MEMO = exports.OCK_KEY = exports.KDF_KEY = void 0;
+exports.KDF_KEY = 'KDFSaplingForTezosV1';
+exports.OCK_KEY = 'OCK_keystringderivation_TEZOS';
+exports.DEFAULT_MEMO = '';
+exports.DEFAULT_BOUND_DATA = Buffer.from('', 'hex');

package/dist/lib/errors.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingTransactionViewerError = exports.InsufficientBalance = exports.InvalidMemo = exports.TreeConstructionFailure = exports.InvalidMerkleTreeError = exports.InvalidSpendingKey = void 0;
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error indicates the spending key is invalid
+ */
+class InvalidSpendingKey extends octez_js_core_1.ParameterValidationError {
+    constructor(sk, errorDetail) {
+        super();
+        this.sk = sk;
+        this.errorDetail = errorDetail;
+        this.name = 'InvalidSpendingKey';
+        this.message = `Invalid spending key "${sk}" ${errorDetail}.`;
+    }
+}
+exports.InvalidSpendingKey = InvalidSpendingKey;
+/**
+ *  @category Error
+ *  @description Error indicates an invalid Merkle tree being passed
+ */
+class InvalidMerkleTreeError extends octez_js_core_1.ParameterValidationError {
+    constructor(root) {
+        super();
+        this.root = root;
+        this.name = 'InvalidMerkleTreeError';
+        this.message = `Invalid merkle tree has root "${JSON.stringify(root)}" different from expected root.`;
+    }
+}
+exports.InvalidMerkleTreeError = InvalidMerkleTreeError;
+/**
+ *  @category Error
+ *  @description Error indicates a failure when trying to construct the Merkle tree
+ */
+class TreeConstructionFailure extends octez_js_core_1.TaquitoError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'TreeConstructionFailure';
+    }
+}
+exports.TreeConstructionFailure = TreeConstructionFailure;
+/**
+ *  @category Error
+ *  @description Error indicates the memo is invalid
+ */
+class InvalidMemo extends octez_js_core_1.ParameterValidationError {
+    constructor(memo, errorDetails) {
+        super();
+        this.memo = memo;
+        this.errorDetails = errorDetails;
+        this.name = 'InvalidMemo';
+        this.message = `Invalid memo "${memo}" with length ${memo.length} ${errorDetails}`;
+    }
+}
+exports.InvalidMemo = InvalidMemo;
+/**
+ *  @category Error
+ *  @description Error indicates not enough balance to prepare the sapling transaction
+ */
+class InsufficientBalance extends octez_js_core_1.TaquitoError {
+    constructor(realBalance, amountToSpend) {
+        super();
+        this.realBalance = realBalance;
+        this.amountToSpend = amountToSpend;
+        this.name = 'InsufficientBalance';
+        this.message = `Unable to spend "${amountToSpend}" mutez while the balance is only ${realBalance} mutez.`;
+    }
+}
+exports.InsufficientBalance = InsufficientBalance;
+/**
+ *  @category Error
+ *  @description Error indicates SaplingTransactionViewer failure
+ */
+class SaplingTransactionViewerError extends octez_js_core_1.TaquitoError {
+    constructor(message) {
+        super();
+        this.message = message;
+        this.name = 'SaplingTransactionViewerError';
+    }
+}
+exports.SaplingTransactionViewerError = SaplingTransactionViewerError;

package/dist/lib/octez.js-sapling.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * @packageDocumentation
+ * @module @tezos-x/octez.js-sapling
+ */
+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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _SaplingToolkit_inMemorySpendingKey, _SaplingToolkit_saplingId, _SaplingToolkit_contractAddress, _SaplingToolkit_memoSize, _SaplingToolkit_readProvider, _SaplingToolkit_packer, _SaplingToolkit_saplingForger, _SaplingToolkit_saplingTxBuilder, _SaplingToolkit_saplingTransactionViewer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingToolkit = exports.InMemoryProvingKey = exports.InMemorySpendingKey = exports.InMemoryViewingKey = exports.SaplingTransactionViewer = void 0;
+const bignumber_js_1 = require("bignumber.js");
+const octez_js_1 = require("@tezos-x/octez.js");
+const octez_js_utils_1 = require("@tezos-x/octez.js-utils");
+const errors_1 = require("./errors");
+const helpers_1 = require("./sapling-tx-viewer/helpers");
+const sapling_forger_1 = require("./sapling-forger/sapling-forger");
+const sapling_transaction_viewer_1 = require("./sapling-tx-viewer/sapling-transaction-viewer");
+const sapling_transactions_builder_1 = require("./sapling-tx-builder/sapling-transactions-builder");
+const constants_1 = require("./constants");
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+var sapling_transaction_viewer_2 = require("./sapling-tx-viewer/sapling-transaction-viewer");
+Object.defineProperty(exports, "SaplingTransactionViewer", { enumerable: true, get: function () { return sapling_transaction_viewer_2.SaplingTransactionViewer; } });
+var in_memory_viewing_key_1 = require("./sapling-keys/in-memory-viewing-key");
+Object.defineProperty(exports, "InMemoryViewingKey", { enumerable: true, get: function () { return in_memory_viewing_key_1.InMemoryViewingKey; } });
+var in_memory_spending_key_1 = require("./sapling-keys/in-memory-spending-key");
+Object.defineProperty(exports, "InMemorySpendingKey", { enumerable: true, get: function () { return in_memory_spending_key_1.InMemorySpendingKey; } });
+var in_memory_proving_key_1 = require("./sapling-keys/in-memory-proving-key");
+Object.defineProperty(exports, "InMemoryProvingKey", { enumerable: true, get: function () { return in_memory_proving_key_1.InMemoryProvingKey; } });
+/**
+ * @description Class that surfaces all of the sapling capability allowing to read from a sapling state and prepare transactions
+ *
+ * @param keys.saplingSigner Holds the sapling spending key
+ * @param keys.saplingProver (Optional) Allows to generate the proofs with the proving key rather than the spending key
+ * @param saplingContractDetails Contains the address of the sapling contract, the memo size, and an optional sapling id that must be defined if the sapling contract contains more than one sapling state
+ * @param readProvider Allows to read data from the blockchain
+ * @param packer (Optional) Allows packing data. Use the `MichelCodecPacker` by default.
+ * @param saplingForger (Optional) Allows serializing the sapling transactions. Use the `SaplingForger` by default.
+ * @param saplingTxBuilder (Optional) Allows to prepare the sapling transactions. Use the `SaplingTransactionBuilder` by default.
+ * @example
+ * ```
+ * const inMemorySpendingKey = await InMemorySpendingKey.fromMnemonic('YOUR_MNEMONIC');
+ * const readProvider = new RpcReadAdapter(new RpcClient('https://YOUR_PREFERRED_RPC_URL'))
+ *
+ * const saplingToolkit = new SaplingToolkit(
+ *    { saplingSigner: inMemorySpendingKey },
+ *    { contractAddress: SAPLING_CONTRACT_ADDRESS, memoSize: 8 },
+ *    readProvider
+ * )
+ * ```
+ */
+class SaplingToolkit {
+    constructor(keys, saplingContractDetails, readProvider, packer = new octez_js_1.MichelCodecPacker(), saplingForger = new sapling_forger_1.SaplingForger(), saplingTxBuilder = new sapling_transactions_builder_1.SaplingTransactionBuilder(keys, saplingForger, saplingContractDetails, readProvider)) {
+        _SaplingToolkit_inMemorySpendingKey.set(this, void 0);
+        _SaplingToolkit_saplingId.set(this, void 0);
+        _SaplingToolkit_contractAddress.set(this, void 0);
+        _SaplingToolkit_memoSize.set(this, void 0);
+        _SaplingToolkit_readProvider.set(this, void 0);
+        _SaplingToolkit_packer.set(this, void 0);
+        _SaplingToolkit_saplingForger.set(this, void 0);
+        _SaplingToolkit_saplingTxBuilder.set(this, void 0);
+        _SaplingToolkit_saplingTransactionViewer.set(this, void 0);
+        __classPrivateFieldSet(this, _SaplingToolkit_inMemorySpendingKey, keys.saplingSigner, "f");
+        __classPrivateFieldSet(this, _SaplingToolkit_saplingId, saplingContractDetails.saplingId, "f");
+        __classPrivateFieldSet(this, _SaplingToolkit_contractAddress, saplingContractDetails.contractAddress, "f");
+        __classPrivateFieldSet(this, _SaplingToolkit_memoSize, saplingContractDetails.memoSize, "f");
+        __classPrivateFieldSet(this, _SaplingToolkit_readProvider, readProvider, "f");
+        __classPrivateFieldSet(this, _SaplingToolkit_packer, packer, "f");
+        __classPrivateFieldSet(this, _SaplingToolkit_saplingForger, saplingForger, "f");
+        __classPrivateFieldSet(this, _SaplingToolkit_saplingTxBuilder, saplingTxBuilder, "f");
+    }
+    /**
+     * @description Get an instance of `SaplingTransactionViewer` which allows to retrieve and decrypt sapling transactions and calculate the unspent balance.
+     */
+    getSaplingTransactionViewer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let saplingTransactionViewer;
+            if (!__classPrivateFieldGet(this, _SaplingToolkit_saplingTransactionViewer, "f")) {
+                const saplingViewingKey = yield __classPrivateFieldGet(this, _SaplingToolkit_inMemorySpendingKey, "f").getSaplingViewingKeyProvider();
+                saplingTransactionViewer = new sapling_transaction_viewer_1.SaplingTransactionViewer(saplingViewingKey, this.getSaplingContractId(), __classPrivateFieldGet(this, _SaplingToolkit_readProvider, "f"));
+                __classPrivateFieldSet(this, _SaplingToolkit_saplingTransactionViewer, saplingTransactionViewer, "f");
+            }
+            return __classPrivateFieldGet(this, _SaplingToolkit_saplingTransactionViewer, "f");
+        });
+    }
+    /**
+     * @description Prepare a shielded transaction
+     * @param shieldedTxParams `to` is the payment address that will receive the shielded tokens (zet).
+     * `amount` is the amount of shielded tokens in tez by default.
+     * `mutez` needs to be set to true if the amount of shielded tokens is in mutez.
+     * `memo` is an empty string by default.
+     * @returns a string representing the sapling transaction
+     */
+    prepareShieldedTransaction(shieldedTxParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { formatedParams, totalAmount } = this.formatTransactionParams(shieldedTxParams, this.validateDestinationSaplingAddress);
+            const root = yield this.getRoot();
+            const { inputs, outputs, signature, balance } = yield __classPrivateFieldGet(this, _SaplingToolkit_saplingTxBuilder, "f").createShieldedTx(formatedParams, totalAmount, constants_1.DEFAULT_BOUND_DATA);
+            const forgedSaplingTx = __classPrivateFieldGet(this, _SaplingToolkit_saplingForger, "f").forgeSaplingTransaction({
+                inputs,
+                outputs,
+                balance,
+                root,
+                boundData: constants_1.DEFAULT_BOUND_DATA,
+                signature,
+            });
+            return forgedSaplingTx.toString('hex');
+        });
+    }
+    /**
+     * @description Prepare an unshielded transaction
+     * @param unshieldedTxParams `to` is the Tezos address that will receive the unshielded tokens (tz1, tz2 or tz3).
+     * `amount` is the amount of unshielded tokens in tez by default.
+     * `mutez` needs to be set to true if the amount of unshielded tokens is in mutez.
+     * @returns a string representing the sapling transaction.
+     */
+    prepareUnshieldedTransaction(unshieldedTxParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { formatedParams, totalAmount } = this.formatTransactionParams([unshieldedTxParams], this.validateDestinationImplicitAddress);
+            const boundData = yield this.createBoundData(formatedParams[0].to);
+            const root = yield this.getRoot();
+            const chosenInputs = yield this.selectInputsToSpend(new bignumber_js_1.default(formatedParams[0].amount));
+            const { inputs, outputs, signature, balance } = yield __classPrivateFieldGet(this, _SaplingToolkit_saplingTxBuilder, "f").createSaplingTx([], totalAmount, boundData, chosenInputs);
+            const forgedSaplingTx = __classPrivateFieldGet(this, _SaplingToolkit_saplingForger, "f").forgeSaplingTransaction({
+                inputs,
+                outputs,
+                balance,
+                root,
+                boundData,
+                signature,
+            });
+            return forgedSaplingTx.toString('hex');
+        });
+    }
+    /**
+     * @description Prepare a sapling transaction (zet to zet)
+     * @param saplingTxParams `to` is the payment address that will receive the shielded tokens (zet).
+     * `amount` is the amount of unshielded tokens in tez by default.
+     * `mutez` needs to be set to true if the amount of unshielded tokens is in mutez.
+     * `memo` is an empty string by default.
+     * @returns a string representing the sapling transaction.
+     */
+    prepareSaplingTransaction(saplingTxParams) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { formatedParams, totalAmount } = this.formatTransactionParams(saplingTxParams, this.validateDestinationSaplingAddress);
+            const root = yield this.getRoot();
+            const chosenInputs = yield this.selectInputsToSpend(totalAmount);
+            const { inputs, outputs, signature, balance } = yield __classPrivateFieldGet(this, _SaplingToolkit_saplingTxBuilder, "f").createSaplingTx(formatedParams, totalAmount, constants_1.DEFAULT_BOUND_DATA, chosenInputs);
+            const forgedSaplingTx = __classPrivateFieldGet(this, _SaplingToolkit_saplingForger, "f").forgeSaplingTransaction({
+                inputs,
+                outputs,
+                balance,
+                root,
+                boundData: constants_1.DEFAULT_BOUND_DATA,
+                signature,
+            });
+            return forgedSaplingTx.toString('hex');
+        });
+    }
+    formatTransactionParams(txParams, validateDestination) {
+        const formatedParams = [];
+        let totalAmount = new bignumber_js_1.default(0);
+        txParams.forEach((param) => {
+            var _a;
+            validateDestination(param.to);
+            const amountMutez = param.mutez
+                ? param.amount.toString()
+                : (0, octez_js_utils_1.format)('tz', 'mutez', param.amount).toString();
+            totalAmount = totalAmount.plus(new bignumber_js_1.default(amountMutez));
+            const memo = (_a = param.memo) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_MEMO;
+            if (memo.length > __classPrivateFieldGet(this, _SaplingToolkit_memoSize, "f")) {
+                throw new errors_1.InvalidMemo(memo, `expecting length to be less than ${__classPrivateFieldGet(this, _SaplingToolkit_memoSize, "f")}`);
+            }
+            formatedParams.push({ to: param.to, amount: amountMutez, memo });
+        });
+        return { formatedParams, totalAmount };
+    }
+    getRoot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _SaplingToolkit_saplingId, "f")) {
+                const { root } = yield __classPrivateFieldGet(this, _SaplingToolkit_readProvider, "f").getSaplingDiffById({ id: __classPrivateFieldGet(this, _SaplingToolkit_saplingId, "f") }, 'head');
+                return root;
+            }
+            else {
+                const { root } = yield __classPrivateFieldGet(this, _SaplingToolkit_readProvider, "f").getSaplingDiffByContract(__classPrivateFieldGet(this, _SaplingToolkit_contractAddress, "f"), 'head');
+                return root;
+            }
+        });
+    }
+    createBoundData(destination) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bytes = (0, octez_js_utils_1.b58DecodePublicKeyHash)(destination, 'hex');
+            const packedDestination = yield __classPrivateFieldGet(this, _SaplingToolkit_packer, "f").packData({
+                data: { bytes },
+                type: { prim: 'bytes' },
+            });
+            return Buffer.from(packedDestination.packed, 'hex');
+        });
+    }
+    validateDestinationImplicitAddress(to) {
+        const toValidation = (0, octez_js_utils_1.validateKeyHash)(to);
+        if (toValidation !== octez_js_utils_1.ValidationResult.VALID) {
+            throw new octez_js_core_1.InvalidKeyHashError(to, toValidation);
+        }
+    }
+    validateDestinationSaplingAddress(to) {
+        try {
+            (0, octez_js_utils_1.b58DecodeAndCheckPrefix)(to, [octez_js_utils_1.PrefixV2.SaplingAddress]);
+        }
+        catch (_a) {
+            throw new octez_js_core_1.InvalidAddressError(to, `expecting prefix ${octez_js_utils_1.PrefixV2.SaplingAddress}.`);
+        }
+    }
+    getSaplingContractId() {
+        let saplingContractId;
+        if (__classPrivateFieldGet(this, _SaplingToolkit_saplingId, "f")) {
+            saplingContractId = { saplingId: __classPrivateFieldGet(this, _SaplingToolkit_saplingId, "f") };
+        }
+        else {
+            saplingContractId = { contractAddress: __classPrivateFieldGet(this, _SaplingToolkit_contractAddress, "f") };
+        }
+        return saplingContractId;
+    }
+    selectInputsToSpend(amountMutez) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const saplingTxViewer = yield this.getSaplingTransactionViewer();
+            const { incoming } = yield saplingTxViewer.getIncomingAndOutgoingTransactionsRaw();
+            const inputsToSpend = [];
+            let sumSelectedInputs = new bignumber_js_1.default(0);
+            incoming.forEach((input) => {
+                if (!input.isSpent && sumSelectedInputs.isLessThan(amountMutez)) {
+                    const txAmount = (0, helpers_1.convertValueToBigNumber)(input.value);
+                    sumSelectedInputs = sumSelectedInputs.plus(txAmount);
+                    const { isSpent: _isSpent } = input, rest = __rest(input, ["isSpent"]);
+                    inputsToSpend.push(rest);
+                }
+            });
+            if (sumSelectedInputs.isLessThan(new bignumber_js_1.default(amountMutez))) {
+                throw new errors_1.InsufficientBalance(sumSelectedInputs.toString(), amountMutez.toString());
+            }
+            return { inputsToSpend, sumSelectedInputs };
+        });
+    }
+}
+exports.SaplingToolkit = SaplingToolkit;
+_SaplingToolkit_inMemorySpendingKey = new WeakMap(), _SaplingToolkit_saplingId = new WeakMap(), _SaplingToolkit_contractAddress = new WeakMap(), _SaplingToolkit_memoSize = new WeakMap(), _SaplingToolkit_readProvider = new WeakMap(), _SaplingToolkit_packer = new WeakMap(), _SaplingToolkit_saplingForger = new WeakMap(), _SaplingToolkit_saplingTxBuilder = new WeakMap(), _SaplingToolkit_saplingTransactionViewer = new WeakMap();

package/dist/lib/sapling-forger/sapling-forger.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaplingForger = void 0;
+const octez_js_utils_1 = require("@tezos-x/octez.js-utils");
+const bignumber_js_1 = require("bignumber.js");
+class SaplingForger {
+    /**
+     * @description Forge sapling transactions
+     * @param spendDescriptions the list of spend descriptions
+     * @param outputDescriptions the list of output descriptions
+     * @param signature signature hash
+     * @param balance balance of the Sapling contract (input/output difference)
+     * @param root root of the merkle tree
+     * @returns Forged sapling transaction of type Buffer
+     */
+    forgeSaplingTransaction(tx) {
+        const spendBuf = this.forgeSpendDescriptions(tx.inputs);
+        const spend = Buffer.concat([(0, octez_js_utils_1.toHexBuf)(spendBuf.length, 32), spendBuf]);
+        const outputBuf = this.forgeOutputDescriptions(tx.outputs);
+        const output = Buffer.concat([(0, octez_js_utils_1.toHexBuf)(outputBuf.length, 32), outputBuf]);
+        const root = Buffer.from(tx.root, 'hex');
+        return Buffer.concat([
+            spend,
+            output,
+            tx.signature,
+            (0, octez_js_utils_1.toHexBuf)(tx.balance, 64),
+            root,
+            (0, octez_js_utils_1.toHexBuf)(tx.boundData.length, 32),
+            tx.boundData,
+        ]);
+    }
+    /**
+     * @description Forge list of spend descriptions
+     * @param spendDescriptions list of spend descriptions
+     * @returns concatenated forged bytes of type Buffer
+     */
+    forgeSpendDescriptions(spendDescriptions) {
+        const descriptions = [];
+        for (const i of spendDescriptions) {
+            const buff = this.forgeSpendDescription(i);
+            descriptions.push(buff);
+        }
+        return Buffer.concat(descriptions);
+    }
+    forgeSpendDescription(desc) {
+        return Buffer.concat([
+            desc.commitmentValue,
+            desc.nullifier,
+            desc.publicKeyReRandomization,
+            desc.proof,
+            desc.signature,
+        ]);
+    }
+    /**
+     * @description Forge list of output descriptions
+     * @param outputDescriptions list of output descriptions
+     * @returns concatenated forged bytes of type Buffer
+     */
+    forgeOutputDescriptions(outputDescriptions) {
+        const descriptions = [];
+        for (const i of outputDescriptions) {
+            const buff = this.forgeOutputDescription(i);
+            descriptions.push(buff);
+        }
+        return Buffer.concat(descriptions);
+    }
+    forgeOutputDescription(desc) {
+        const ct = desc.ciphertext;
+        return Buffer.concat([
+            desc.commitment,
+            desc.proof,
+            ct.commitmentValue,
+            ct.ephemeralPublicKey,
+            (0, octez_js_utils_1.toHexBuf)(ct.payloadEnc.length, 32),
+            ct.payloadEnc,
+            ct.nonceEnc,
+            ct.payloadOut,
+            ct.nonceOut,
+        ]);
+    }
+    forgeUnsignedTxInput(unsignedSpendDescription) {
+        return Buffer.concat([
+            unsignedSpendDescription.commitmentValue,
+            unsignedSpendDescription.nullifier,
+            unsignedSpendDescription.publicKeyReRandomization,
+            unsignedSpendDescription.proof,
+        ]);
+    }
+    forgeTransactionPlaintext(txPlainText) {
+        const encodedMemo = Buffer.from((0, octez_js_utils_1.stringToBytes)(txPlainText.memo).padEnd(txPlainText.memoSize, '0'), 'hex');
+        return Buffer.concat([
+            txPlainText.diversifier,
+            (0, octez_js_utils_1.toHexBuf)(new bignumber_js_1.default(txPlainText.amount), 64),
+            txPlainText.randomCommitmentTrapdoor,
+            (0, octez_js_utils_1.toHexBuf)(txPlainText.memoSize, 32),
+            encodedMemo,
+        ]);
+    }
+}
+exports.SaplingForger = SaplingForger;

package/dist/lib/sapling-keys/helpers.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptKey = decryptKey;
+const errors_1 = require("../errors");
+const typedarray_to_buffer_1 = require("typedarray-to-buffer");
+const nacl_1 = require("@stablelib/nacl");
+const pbkdf2_1 = require("pbkdf2");
+const octez_js_utils_1 = require("@tezos-x/octez.js-utils");
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+function decryptKey(spendingKey, password) {
+    const [keyArr, pre] = (() => {
+        try {
+            return (0, octez_js_utils_1.b58DecodeAndCheckPrefix)(spendingKey, [
+                octez_js_utils_1.PrefixV2.SaplingSpendingKey,
+                octez_js_utils_1.PrefixV2.EncryptedSaplingSpendingKey,
+            ]);
+        }
+        catch (err) {
+            if (err instanceof octez_js_core_1.ParameterValidationError) {
+                throw new errors_1.InvalidSpendingKey(spendingKey, 'invalid spending key');
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    if (pre === octez_js_utils_1.PrefixV2.EncryptedSaplingSpendingKey) {
+        if (!password) {
+            throw new errors_1.InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
+        }
+        const salt = (0, typedarray_to_buffer_1.default)(keyArr.slice(0, 8));
+        const encryptedSk = (0, typedarray_to_buffer_1.default)(keyArr.slice(8));
+        const encryptionKey = pbkdf2_1.default.pbkdf2Sync(password, salt, 32768, 32, 'sha512');
+        // Zero nonce is safe: fresh random salt per encryption produces unique PBKDF2-derived key.
+        // See: https://gitlab.com/tezos/tezos/-/blob/master/src/lib_signer_backends/encrypted.ml
+        const decrypted = (0, nacl_1.openSecretBox)(new Uint8Array(encryptionKey), new Uint8Array(24), // zero nonce - uniqueness provided by per-encryption derived key
+        new Uint8Array(encryptedSk));
+        if (!decrypted) {
+            throw new errors_1.InvalidSpendingKey(spendingKey, 'incorrect password or unable to decrypt');
+        }
+        return (0, typedarray_to_buffer_1.default)(decrypted);
+    }
+    else {
+        return (0, typedarray_to_buffer_1.default)(keyArr);
+    }
+}