@taquito/sapling 24.2.0 → 24.3.0-beta.1

package/dist/taquito-sapling.umd.js

@@ -41,28 +41,6 @@
     /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
-    function __rest(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;
-    }
-
-    function __awaiter(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());
-        });
-    }
-
     function __classPrivateFieldGet(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");
@@ -83,20 +61,20 @@
 
     /**
      *  @category Error
-     *  @description Error indicates the spending key is invalid
+     *  Error indicates the spending key is invalid
      */
     class InvalidSpendingKey extends core.ParameterValidationError {
-        constructor(sk, errorDetail) {
+        constructor(a, b) {
+            const errorDetail = arguments.length >= 2 ? b : a;
             super();
-            this.sk = sk;
-            this.errorDetail = errorDetail;
             this.name = 'InvalidSpendingKey';
-            this.message = `Invalid spending key "${sk}" ${errorDetail}.`;
+            this.errorDetail = errorDetail;
+            this.message = `Invalid spending key: ${errorDetail}.`;
         }
     }
     /**
      *  @category Error
-     *  @description Error indicates an invalid Merkle tree being passed
+     *  Error indicates an invalid Merkle tree being passed
      */
     class InvalidMerkleTreeError extends core.ParameterValidationError {
         constructor(root) {
@@ -108,7 +86,7 @@
     }
     /**
      *  @category Error
-     *  @description Error indicates a failure when trying to construct the Merkle tree
+     *  Error indicates a failure when trying to construct the Merkle tree
      */
     class TreeConstructionFailure extends core.TaquitoError {
         constructor(message) {
@@ -119,7 +97,7 @@
     }
     /**
      *  @category Error
-     *  @description Error indicates the memo is invalid
+     *  Error indicates the memo is invalid
      */
     class InvalidMemo extends core.ParameterValidationError {
         constructor(memo, errorDetails) {
@@ -132,7 +110,7 @@
     }
     /**
      *  @category Error
-     *  @description Error indicates not enough balance to prepare the sapling transaction
+     *  Error indicates not enough balance to prepare the sapling transaction
      */
     class InsufficientBalance extends core.TaquitoError {
         constructor(realBalance, amountToSpend) {
@@ -145,7 +123,7 @@
     }
     /**
      *  @category Error
-     *  @description Error indicates SaplingTransactionViewer failure
+     *  Error indicates SaplingTransactionViewer failure
      */
     class SaplingTransactionViewerError extends core.TaquitoError {
         constructor(message) {
@@ -179,7 +157,7 @@
 
     class SaplingForger {
         /**
-         * @description Forge sapling transactions
+         * Forge sapling transactions
          * @param spendDescriptions the list of spend descriptions
          * @param outputDescriptions the list of output descriptions
          * @param signature signature hash
@@ -204,7 +182,7 @@
             ]);
         }
         /**
-         * @description Forge list of spend descriptions
+         * Forge list of spend descriptions
          * @param spendDescriptions list of spend descriptions
          * @returns concatenated forged bytes of type Buffer
          */
@@ -226,7 +204,7 @@
             ]);
         }
         /**
-         * @description Forge list of output descriptions
+         * Forge list of output descriptions
          * @param outputDescriptions list of output descriptions
          * @returns concatenated forged bytes of type Buffer
          */
@@ -279,7 +257,7 @@
 
     var _SaplingTransactionViewer_viewingKeyProvider, _SaplingTransactionViewer_readProvider, _SaplingTransactionViewer_saplingContractId;
     /**
-     * @description Allows to retrieve and decrypt sapling transactions using on a viewing key
+     * Allows to retrieve and decrypt sapling transactions using on a viewing key
      *
      * @param inMemoryViewingKey Holds the sapling viewing key
      * @param saplingContractId Address of the sapling contract or sapling id if the smart contract contains multiple sapling states
@@ -295,102 +273,120 @@
             __classPrivateFieldSet(this, _SaplingTransactionViewer_readProvider, readProvider, "f");
         }
         /**
-         * @description Retrieve the unspent balance associated with the configured viewing key and sapling state
+         * Retrieve the unspent balance associated with the configured viewing key and sapling state
          *
          * @returns the balance in mutez represented as a BigNumber
          *
          */
-        getBalance() {
-            return __awaiter(this, void 0, void 0, function* () {
-                let balance = new BigNumber(0);
-                const { commitments_and_ciphertexts, nullifiers } = yield this.getSaplingDiff();
-                for (let i = 0; i < commitments_and_ciphertexts.length; i++) {
-                    const decrypted = yield this.decryptCiphertextAsReceiver(commitments_and_ciphertexts[i]);
-                    if (decrypted) {
-                        const valueBigNumber = convertValueToBigNumber(decrypted.value);
-                        const isSpent = yield this.isSpent(decrypted.paymentAddress, valueBigNumber.toString(), decrypted.randomCommitmentTrapdoor, i, nullifiers);
-                        if (!isSpent) {
-                            balance = balance.plus(valueBigNumber);
-                        }
+        async getBalance() {
+            let balance = new BigNumber(0);
+            const { commitments_and_ciphertexts, nullifiers } = await this.getSaplingDiff();
+            for (let i = 0; i < commitments_and_ciphertexts.length; i++) {
+                const decrypted = await this.decryptCiphertextAsReceiver(commitments_and_ciphertexts[i]);
+                if (decrypted) {
+                    const valueBigNumber = convertValueToBigNumber(decrypted.value);
+                    const isSpent = await this.isSpent(decrypted.paymentAddress, valueBigNumber.toString(), decrypted.randomCommitmentTrapdoor, i, nullifiers);
+                    if (!isSpent) {
+                        balance = balance.plus(valueBigNumber);
                     }
                 }
-                return balance;
-            });
+            }
+            return balance;
         }
         /**
-         * @description Retrieve all the incoming and outgoing transactions associated with the configured viewing key.
+         * Retrieve all the incoming and outgoing transactions associated with the configured viewing key.
          * The response properties are in Uint8Array format; use the getIncomingAndOutgoingTransactions method for readable properties
          *
          */
-        getIncomingAndOutgoingTransactionsRaw() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const incoming = [];
-                const outgoing = [];
-                const { commitments_and_ciphertexts, nullifiers } = yield this.getSaplingDiff();
-                for (let i = 0; i < commitments_and_ciphertexts.length; i++) {
-                    const decryptedAsReceiver = yield this.decryptCiphertextAsReceiver(commitments_and_ciphertexts[i]);
-                    const decryptedAsSender = yield this.decryptCiphertextAsSender(commitments_and_ciphertexts[i]);
-                    if (decryptedAsReceiver) {
-                        const balance = convertValueToBigNumber(decryptedAsReceiver.value);
-                        const isSpent = yield this.isSpent(decryptedAsReceiver.paymentAddress, balance.toString(), decryptedAsReceiver.randomCommitmentTrapdoor, i, nullifiers);
-                        incoming.push(Object.assign(Object.assign({}, decryptedAsReceiver), { isSpent, position: i }));
-                    }
-                    if (decryptedAsSender) {
-                        outgoing.push(decryptedAsSender);
-                    }
+        async getIncomingAndOutgoingTransactionsRaw() {
+            const incoming = [];
+            const outgoing = [];
+            const { commitments_and_ciphertexts, nullifiers } = await this.getSaplingDiff();
+            for (let i = 0; i < commitments_and_ciphertexts.length; i++) {
+                const decryptedAsReceiver = await this.decryptCiphertextAsReceiver(commitments_and_ciphertexts[i]);
+                const decryptedAsSender = await this.decryptCiphertextAsSender(commitments_and_ciphertexts[i]);
+                if (decryptedAsReceiver) {
+                    const balance = convertValueToBigNumber(decryptedAsReceiver.value);
+                    const isSpent = await this.isSpent(decryptedAsReceiver.paymentAddress, balance.toString(), decryptedAsReceiver.randomCommitmentTrapdoor, i, nullifiers);
+                    incoming.push({ ...decryptedAsReceiver, isSpent, position: i });
                 }
-                return {
-                    incoming,
-                    outgoing,
-                };
-            });
+                if (decryptedAsSender) {
+                    outgoing.push(decryptedAsSender);
+                }
+            }
+            return {
+                incoming,
+                outgoing,
+            };
         }
         /**
-         * @description Retrieve all the incoming and outgoing decoded transactions associated with the configured viewing key
+         * Retrieve all the incoming and outgoing decoded transactions associated with the configured viewing key
          *
          */
-        getIncomingAndOutgoingTransactions() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const tx = yield this.getIncomingAndOutgoingTransactionsRaw();
-                const incoming = tx.incoming.map((_a) => {
-                    var { isSpent } = _a, rest = __rest(_a, ["isSpent"]);
-                    return Object.assign(Object.assign({}, readableFormat(rest)), { isSpent });
-                });
-                const outgoing = tx.outgoing.map((outgoingTx) => {
-                    return readableFormat(outgoingTx);
-                });
-                return { incoming, outgoing };
+        async getIncomingAndOutgoingTransactions() {
+            const tx = await this.getIncomingAndOutgoingTransactionsRaw();
+            const incoming = tx.incoming.map(({ isSpent, ...rest }) => {
+                return { ...readableFormat(rest), isSpent };
             });
+            const outgoing = tx.outgoing.map((outgoingTx) => {
+                return readableFormat(outgoingTx);
+            });
+            return { incoming, outgoing };
         }
-        getSaplingDiff() {
-            return __awaiter(this, void 0, void 0, function* () {
-                let saplingDiffResponse;
-                if (__classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").saplingId) {
-                    saplingDiffResponse = yield __classPrivateFieldGet(this, _SaplingTransactionViewer_readProvider, "f").getSaplingDiffById({ id: __classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").saplingId }, 'head');
-                }
-                else if (__classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").contractAddress) {
-                    saplingDiffResponse = yield __classPrivateFieldGet(this, _SaplingTransactionViewer_readProvider, "f").getSaplingDiffByContract(__classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").contractAddress, 'head');
+        async getSaplingDiff() {
+            let saplingDiffResponse;
+            if (__classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").saplingId) {
+                saplingDiffResponse = await __classPrivateFieldGet(this, _SaplingTransactionViewer_readProvider, "f").getSaplingDiffById({ id: __classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").saplingId }, 'head');
+            }
+            else if (__classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").contractAddress) {
+                saplingDiffResponse = await __classPrivateFieldGet(this, _SaplingTransactionViewer_readProvider, "f").getSaplingDiffByContract(__classPrivateFieldGet(this, _SaplingTransactionViewer_saplingContractId, "f").contractAddress, 'head');
+            }
+            else {
+                throw new SaplingTransactionViewerError('A contract address or a sapling id was expected in the SaplingTransactionViewer constructor.');
+            }
+            return saplingDiffResponse;
+        }
+        async decryptCiphertextAsReceiver(commitmentsAndCiphertexts) {
+            const commitment = commitmentsAndCiphertexts[0];
+            const { epk, payload_enc, nonce_enc } = commitmentsAndCiphertexts[1];
+            const incomingViewingKey = await __classPrivateFieldGet(this, _SaplingTransactionViewer_viewingKeyProvider, "f").getIncomingViewingKey();
+            const keyAgreement = await sapling__namespace.keyAgreement(epk, incomingViewingKey);
+            const keyAgreementHash = blake.blake2b(keyAgreement, Buffer.from(KDF_KEY), 32);
+            const decrypted = await this.decryptCiphertext(keyAgreementHash, utils.hex2buf(nonce_enc), utils.hex2buf(payload_enc));
+            if (decrypted) {
+                const { diversifier, value, randomCommitmentTrapdoor: rcm, memo, } = this.extractTransactionProperties(decrypted);
+                const paymentAddress = bufToUint8Array(await sapling__namespace.getRawPaymentAddressFromIncomingViewingKey(incomingViewingKey, diversifier));
+                try {
+                    const valid = await sapling__namespace.verifyCommitment(commitment, paymentAddress, convertValueToBigNumber(value).toString(), rcm);
+                    if (valid) {
+                        return { value, memo, paymentAddress, randomCommitmentTrapdoor: rcm };
+                    }
                 }
-                else {
-                    throw new SaplingTransactionViewerError('A contract address or a sapling id was expected in the SaplingTransactionViewer constructor.');
+                catch (ex) {
+                    if (!/invalid value/.test(ex)) {
+                        throw ex;
+                    }
                 }
-                return saplingDiffResponse;
-            });
+            }
         }
-        decryptCiphertextAsReceiver(commitmentsAndCiphertexts) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const commitment = commitmentsAndCiphertexts[0];
-                const { epk, payload_enc, nonce_enc } = commitmentsAndCiphertexts[1];
-                const incomingViewingKey = yield __classPrivateFieldGet(this, _SaplingTransactionViewer_viewingKeyProvider, "f").getIncomingViewingKey();
-                const keyAgreement = yield sapling__namespace.keyAgreement(epk, incomingViewingKey);
+        async decryptCiphertextAsSender(commitmentsAndCiphertexts) {
+            const commitment = commitmentsAndCiphertexts[0];
+            const { epk, payload_enc, nonce_enc, payload_out, nonce_out, cv } = commitmentsAndCiphertexts[1];
+            const outgoingViewingKey = await __classPrivateFieldGet(this, _SaplingTransactionViewer_viewingKeyProvider, "f").getOutgoingViewingKey();
+            const concat = cv.concat(commitment, epk, outgoingViewingKey.toString('hex'));
+            const outgoingCipherKey = blake.blake2b(Buffer.from(concat, 'hex'), Buffer.from(OCK_KEY), 32);
+            const decryptedOut = await this.decryptCiphertext(outgoingCipherKey, utils.hex2buf(nonce_out), utils.hex2buf(payload_out));
+            if (decryptedOut) {
+                const { recipientDiversifiedTransmissionKey: pkd, ephemeralPrivateKey: esk } = this.extractPkdAndEsk(decryptedOut);
+                const keyAgreement = await sapling__namespace.keyAgreement(pkd, esk);
                 const keyAgreementHash = blake.blake2b(keyAgreement, Buffer.from(KDF_KEY), 32);
-                const decrypted = yield this.decryptCiphertext(keyAgreementHash, utils.hex2buf(nonce_enc), utils.hex2buf(payload_enc));
-                if (decrypted) {
-                    const { diversifier, value, randomCommitmentTrapdoor: rcm, memo, } = this.extractTransactionProperties(decrypted);
-                    const paymentAddress = bufToUint8Array(yield sapling__namespace.getRawPaymentAddressFromIncomingViewingKey(incomingViewingKey, diversifier));
+                const decryptedEnc = await this.decryptCiphertext(keyAgreementHash, utils.hex2buf(nonce_enc), utils.hex2buf(payload_enc));
+                if (decryptedEnc) {
+                    const { diversifier, value, randomCommitmentTrapdoor: rcm, memo, } = this.extractTransactionProperties(decryptedEnc);
+                    const paymentAddress = utils.mergebuf(diversifier, pkd);
                     try {
-                        const valid = yield sapling__namespace.verifyCommitment(commitment, paymentAddress, convertValueToBigNumber(value).toString(), rcm);
-                        if (valid) {
+                        const isValid = await sapling__namespace.verifyCommitment(commitment, paymentAddress, convertValueToBigNumber(value).toString(), rcm);
+                        if (isValid) {
                             return { value, memo, paymentAddress, randomCommitmentTrapdoor: rcm };
                         }
                     }
@@ -400,43 +396,10 @@
                         }
                     }
                 }
-            });
-        }
-        decryptCiphertextAsSender(commitmentsAndCiphertexts) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const commitment = commitmentsAndCiphertexts[0];
-                const { epk, payload_enc, nonce_enc, payload_out, nonce_out, cv } = commitmentsAndCiphertexts[1];
-                const outgoingViewingKey = yield __classPrivateFieldGet(this, _SaplingTransactionViewer_viewingKeyProvider, "f").getOutgoingViewingKey();
-                const concat = cv.concat(commitment, epk, outgoingViewingKey.toString('hex'));
-                const outgoingCipherKey = blake.blake2b(Buffer.from(concat, 'hex'), Buffer.from(OCK_KEY), 32);
-                const decryptedOut = yield this.decryptCiphertext(outgoingCipherKey, utils.hex2buf(nonce_out), utils.hex2buf(payload_out));
-                if (decryptedOut) {
-                    const { recipientDiversifiedTransmissionKey: pkd, ephemeralPrivateKey: esk } = this.extractPkdAndEsk(decryptedOut);
-                    const keyAgreement = yield sapling__namespace.keyAgreement(pkd, esk);
-                    const keyAgreementHash = blake.blake2b(keyAgreement, Buffer.from(KDF_KEY), 32);
-                    const decryptedEnc = yield this.decryptCiphertext(keyAgreementHash, utils.hex2buf(nonce_enc), utils.hex2buf(payload_enc));
-                    if (decryptedEnc) {
-                        const { diversifier, value, randomCommitmentTrapdoor: rcm, memo, } = this.extractTransactionProperties(decryptedEnc);
-                        const paymentAddress = utils.mergebuf(diversifier, pkd);
-                        try {
-                            const isValid = yield sapling__namespace.verifyCommitment(commitment, paymentAddress, convertValueToBigNumber(value).toString(), rcm);
-                            if (isValid) {
-                                return { value, memo, paymentAddress, randomCommitmentTrapdoor: rcm };
-                            }
-                        }
-                        catch (ex) {
-                            if (!/invalid value/.test(ex)) {
-                                throw ex;
-                            }
-                        }
-                    }
-                }
-            });
+            }
         }
-        decryptCiphertext(keyAgreementHash, nonce, payload) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return nacl.openSecretBox(keyAgreementHash, nonce, payload);
-            });
+        async decryptCiphertext(keyAgreementHash, nonce, payload) {
+            return nacl.openSecretBox(keyAgreementHash, nonce, payload);
         }
         extractTransactionProperties(decrypted) {
             return {
@@ -453,11 +416,9 @@
                 ephemeralPrivateKey: decrypted.slice(32),
             };
         }
-        isSpent(address, value, randomCommitmentTrapdoor, position, nullifiers) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const computedNullifier = yield sapling__namespace.computeNullifier(__classPrivateFieldGet(this, _SaplingTransactionViewer_viewingKeyProvider, "f").getFullViewingKey(), address, value, randomCommitmentTrapdoor, position);
-                return nullifiers.includes(computedNullifier.toString('hex'));
-            });
+        async isSpent(address, value, randomCommitmentTrapdoor, position, nullifiers) {
+            const computedNullifier = await sapling__namespace.computeNullifier(__classPrivateFieldGet(this, _SaplingTransactionViewer_viewingKeyProvider, "f").getFullViewingKey(), address, value, randomCommitmentTrapdoor, position);
+            return nullifiers.includes(computedNullifier.toString('hex'));
         }
     }
     _SaplingTransactionViewer_viewingKeyProvider = new WeakMap(), _SaplingTransactionViewer_readProvider = new WeakMap(), _SaplingTransactionViewer_saplingContractId = new WeakMap();
@@ -475,7 +436,7 @@
         return pairs;
     }
     /**
-     * @description helper function to assist in Lazy initializing an object
+     * helper function to assist in Lazy initializing an object
      */
     class Lazy {
         constructor(init) {
@@ -484,14 +445,12 @@
             this.value = undefined;
         }
         // initializes the lazily initiated object
-        get() {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (!this.isInitialized) {
-                    this.value = yield this.init();
-                    this.isInitialized = true;
-                }
-                return this.value;
-            });
+        async get() {
+            if (!this.isInitialized) {
+                this.value = await this.init();
+                this.isInitialized = true;
+            }
+            return this.value;
         }
     }
     /**
@@ -513,7 +472,7 @@
      *
      */
     /**
-     * @description The SaplingState class's main purpose is to provide a Merkle path for the forger and the transaction builder, so that it may verify that the Sapling transaction is valid
+     * The SaplingState class's main purpose is to provide a Merkle path for the forger and the transaction builder, so that it may verify that the Sapling transaction is valid
      *
      */
     class SaplingState {
@@ -522,25 +481,23 @@
             this.uncommittedMerkleHash = '0100000000000000000000000000000000000000000000000000000000000000';
             this.uncommittedMerkleHashes = new Lazy(() => this.createUncommittedMerkleHashes());
         }
-        getStateTree(stateDiff_1) {
-            return __awaiter(this, arguments, void 0, function* (stateDiff, constructTree = true) {
-                if (this.stateTree !== undefined && this.stateTree.root === stateDiff.root) {
-                    return this.stateTree;
-                }
-                const commitments = stateDiff.commitments_and_ciphertexts.map(([commitment, _]) => commitment);
-                let merkleTree;
-                if (constructTree) {
-                    merkleTree = yield this.constructMerkleTree(commitments, 0);
-                    yield this.validateMerkleTree(merkleTree, stateDiff.root);
-                }
-                this.stateTree = {
-                    height: this.height,
-                    size: commitments.length,
-                    root: stateDiff.root,
-                    tree: merkleTree,
-                };
+        async getStateTree(stateDiff, constructTree = true) {
+            if (this.stateTree !== undefined && this.stateTree.root === stateDiff.root) {
                 return this.stateTree;
-            });
+            }
+            const commitments = stateDiff.commitments_and_ciphertexts.map(([commitment, _]) => commitment);
+            let merkleTree;
+            if (constructTree) {
+                merkleTree = await this.constructMerkleTree(commitments, 0);
+                await this.validateMerkleTree(merkleTree, stateDiff.root);
+            }
+            this.stateTree = {
+                height: this.height,
+                size: commitments.length,
+                root: stateDiff.root,
+                tree: merkleTree,
+            };
+            return this.stateTree;
         }
         /**
          *
@@ -548,17 +505,15 @@
          * @param position position of the hash in the Merkle tree
          * @returns a promise of a string that serves as the Merkle path that can be passed on to the Sapling forger or the transaction builder
          */
-        getWitness(stateTree, position) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const heightBuffer = utils.hex2Bytes(changeEndianness(utils.num2PaddedHex(stateTree.height)));
-                const posBuffer = utils.hex2Bytes(changeEndianness(utils.num2PaddedHex(position, 64)));
-                const neighbouringHashes = yield this.getNeighbouringHashes([], stateTree.height, position, stateTree.tree);
-                const witness = neighbouringHashes
-                    .map((hash) => Buffer.concat([utils.hex2Bytes(changeEndianness(utils.num2PaddedHex(hash.length))), hash]))
-                    .reverse()
-                    .reduce((acc, next) => Buffer.concat([acc, next]));
-                return Buffer.concat([heightBuffer, witness, posBuffer]).toString('hex');
-            });
+        async getWitness(stateTree, position) {
+            const heightBuffer = utils.hex2Bytes(changeEndianness(utils.num2PaddedHex(stateTree.height)));
+            const posBuffer = utils.hex2Bytes(changeEndianness(utils.num2PaddedHex(position, 64)));
+            const neighbouringHashes = await this.getNeighbouringHashes([], stateTree.height, position, stateTree.tree);
+            const witness = neighbouringHashes
+                .map((hash) => Buffer.concat([utils.hex2Bytes(changeEndianness(utils.num2PaddedHex(hash.length))), hash]))
+                .reverse()
+                .reduce((acc, next) => Buffer.concat([acc, next]));
+            return Buffer.concat([heightBuffer, witness, posBuffer]).toString('hex');
         }
         /**
          *
@@ -566,51 +521,45 @@
          * @param height height of the desired Merkle tree
          * @returns a promise of MerkleTree type object
          */
-        constructMerkleTree(leaves, height) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (height === this.height && leaves.length === 1) {
-                    return leaves[0];
-                }
-                if (height === this.height || leaves.length > Math.pow(2, this.height - 1 - height)) {
-                    throw new TreeConstructionFailure('Children length exceeds maximum number of nodes in a merkle tree');
-                }
-                const pairedLeaves = pairNodes(leaves);
-                const updatedLeaves = yield Promise.all(pairedLeaves.map((chunk) => __awaiter(this, void 0, void 0, function* () {
-                    const left = yield this.getMerkleHash(chunk[0], height);
-                    const right = yield this.getMerkleHash(chunk[1], height);
-                    const parentHash = yield sapling.merkleHash(height, left, right);
-                    return [parentHash.toString('hex'), chunk[0], chunk[1]];
-                })));
-                return this.constructMerkleTree(updatedLeaves, height + 1);
-            });
-        }
-        getMerkleHash(tree, height) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (tree === undefined) {
-                    return (yield this.uncommittedMerkleHashes.get())[height];
-                }
-                else if (typeof tree === 'string') {
-                    return Buffer.from(tree, 'hex');
-                }
-                else {
-                    return Buffer.from(tree[0], 'hex');
-                }
-            });
+        async constructMerkleTree(leaves, height) {
+            if (height === this.height && leaves.length === 1) {
+                return leaves[0];
+            }
+            if (height === this.height || leaves.length > Math.pow(2, this.height - 1 - height)) {
+                throw new TreeConstructionFailure('Children length exceeds maximum number of nodes in a merkle tree');
+            }
+            const pairedLeaves = pairNodes(leaves);
+            const updatedLeaves = await Promise.all(pairedLeaves.map(async (chunk) => {
+                const left = await this.getMerkleHash(chunk[0], height);
+                const right = await this.getMerkleHash(chunk[1], height);
+                const parentHash = await sapling.merkleHash(height, left, right);
+                return [parentHash.toString('hex'), chunk[0], chunk[1]];
+            }));
+            return this.constructMerkleTree(updatedLeaves, height + 1);
+        }
+        async getMerkleHash(tree, height) {
+            if (tree === undefined) {
+                return (await this.uncommittedMerkleHashes.get())[height];
+            }
+            else if (typeof tree === 'string') {
+                return Buffer.from(tree, 'hex');
+            }
+            else {
+                return Buffer.from(tree[0], 'hex');
+            }
         }
         /**
          *
          * @returns hashes of empty or null values to fill in the Merkle tree
          */
-        createUncommittedMerkleHashes() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const res = new Array(this.height);
-                res[0] = Buffer.from(this.uncommittedMerkleHash, 'hex');
-                for (let i = 0; i < this.height; i++) {
-                    const hash = res[i];
-                    res[i + 1] = yield sapling.merkleHash(i, hash, hash);
-                }
-                return res;
-            });
+        async createUncommittedMerkleHashes() {
+            const res = new Array(this.height);
+            res[0] = Buffer.from(this.uncommittedMerkleHash, 'hex');
+            for (let i = 0; i < this.height; i++) {
+                const hash = res[i];
+                res[i + 1] = await sapling.merkleHash(i, hash, hash);
+            }
+            return res;
         }
         /**
          *
@@ -618,13 +567,11 @@
          * @param expectedRoot the expected merkle root to validate against
          * @throws {@link InvalidMerkleTreeError}
          */
-        validateMerkleTree(tree, expectedRoot) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const root = yield this.getMerkleHash(tree, this.height - 1);
-                if (root.toString('hex') !== expectedRoot) {
-                    throw new InvalidMerkleTreeError(root.toString('hex'));
-                }
-            });
+        async validateMerkleTree(tree, expectedRoot) {
+            const root = await this.getMerkleHash(tree, this.height - 1);
+            if (root.toString('hex') !== expectedRoot) {
+                throw new InvalidMerkleTreeError(root.toString('hex'));
+            }
         }
         /**
          *
@@ -634,30 +581,28 @@
          * @param tree the Merkle tree that we want to traverse
          * @returns the accumulated Buffer array of neighbouring hashes
          */
-        getNeighbouringHashes(acc, height, position, tree) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (typeof tree === 'undefined') {
-                    throw new Error();
-                }
-                else if (typeof tree === 'string') {
-                    return acc;
+        async getNeighbouringHashes(acc, height, position, tree) {
+            if (typeof tree === 'undefined') {
+                throw new Error();
+            }
+            else if (typeof tree === 'string') {
+                return acc;
+            }
+            else {
+                let nextPos, nextTree, otherTree;
+                const fullTree = new BigNumber(2).pow(height - 1);
+                if (position.lt(fullTree)) {
+                    nextPos = position;
+                    nextTree = tree[1];
+                    otherTree = tree[2];
                 }
                 else {
-                    let nextPos, nextTree, otherTree;
-                    const fullTree = new BigNumber(2).pow(height - 1);
-                    if (position.lt(fullTree)) {
-                        nextPos = position;
-                        nextTree = tree[1];
-                        otherTree = tree[2];
-                    }
-                    else {
-                        nextPos = position.minus(fullTree);
-                        nextTree = tree[2];
-                        otherTree = tree[1];
-                    }
-                    return this.getNeighbouringHashes([yield this.getMerkleHash(otherTree, height - 1), ...acc], height - 1, nextPos, nextTree);
+                    nextPos = position.minus(fullTree);
+                    nextTree = tree[2];
+                    otherTree = tree[1];
                 }
-            });
+                return this.getNeighbouringHashes([await this.getMerkleHash(otherTree, height - 1), ...acc], height - 1, nextPos, nextTree);
+            }
         }
     }
 
@@ -665,67 +610,52 @@
     const saplingOutputParams = require('../saplingOutputParams');
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     const saplingSpendParams = require('../saplingSpendParams');
+    let cachedParams;
     class SaplingWrapper {
-        withProvingContext(action) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.initSaplingParameters();
-                return sapling__namespace.withProvingContext(action);
-            });
+        async withProvingContext(action) {
+            await this.initSaplingParameters();
+            return sapling__namespace.withProvingContext(action);
         }
         getRandomBytes(length) {
             return random.randomBytes(length);
         }
-        randR() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.randR();
-            });
+        async randR() {
+            return sapling__namespace.randR();
         }
-        getOutgoingViewingKey(vk) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.getOutgoingViewingKey(vk);
-            });
+        async getOutgoingViewingKey(vk) {
+            return sapling__namespace.getOutgoingViewingKey(vk);
         }
-        preparePartialOutputDescription(parametersOutputProof) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const partialOutputDesc = yield sapling__namespace.preparePartialOutputDescription(parametersOutputProof.saplingContext, parametersOutputProof.address, parametersOutputProof.randomCommitmentTrapdoor, parametersOutputProof.ephemeralPrivateKey, parametersOutputProof.amount);
-                return {
-                    commitmentValue: partialOutputDesc.cv,
-                    commitment: partialOutputDesc.cm,
-                    proof: partialOutputDesc.proof,
-                };
-            });
+        async preparePartialOutputDescription(parametersOutputProof) {
+            const partialOutputDesc = await sapling__namespace.preparePartialOutputDescription(parametersOutputProof.saplingContext, parametersOutputProof.address, parametersOutputProof.randomCommitmentTrapdoor, parametersOutputProof.ephemeralPrivateKey, parametersOutputProof.amount);
+            return {
+                commitmentValue: partialOutputDesc.cv,
+                commitment: partialOutputDesc.cm,
+                proof: partialOutputDesc.proof,
+            };
         }
-        getDiversifiedFromRawPaymentAddress(decodedDestination) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.getDiversifiedFromRawPaymentAddress(decodedDestination);
-            });
+        async getDiversifiedFromRawPaymentAddress(decodedDestination) {
+            return sapling__namespace.getDiversifiedFromRawPaymentAddress(decodedDestination);
         }
-        deriveEphemeralPublicKey(diversifier, esk) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.deriveEphemeralPublicKey(diversifier, esk);
-            });
+        async deriveEphemeralPublicKey(diversifier, esk) {
+            return sapling__namespace.deriveEphemeralPublicKey(diversifier, esk);
         }
-        getPkdFromRawPaymentAddress(destination) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.getPkdFromRawPaymentAddress(destination);
-            });
+        async getPkdFromRawPaymentAddress(destination) {
+            return sapling__namespace.getPkdFromRawPaymentAddress(destination);
         }
-        keyAgreement(p, sk) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.keyAgreement(p, sk);
-            });
+        async keyAgreement(p, sk) {
+            return sapling__namespace.keyAgreement(p, sk);
         }
-        createBindingSignature(saplingContext, balance, transactionSigHash) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.createBindingSignature(saplingContext, balance, transactionSigHash);
-            });
+        async createBindingSignature(saplingContext, balance, transactionSigHash) {
+            return sapling__namespace.createBindingSignature(saplingContext, balance, transactionSigHash);
         }
-        initSaplingParameters() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const spendParams = Buffer.from(saplingSpendParams.saplingSpendParams, 'base64');
-                const outputParams = Buffer.from(saplingOutputParams.saplingOutputParams, 'base64');
-                return sapling__namespace.initParameters(spendParams, outputParams);
-            });
+        async initSaplingParameters() {
+            if (!cachedParams) {
+                cachedParams = {
+                    spend: Buffer.from(saplingSpendParams.saplingSpendParams, 'base64'),
+                    output: Buffer.from(saplingOutputParams.saplingOutputParams, 'base64'),
+                };
+            }
+            return sapling__namespace.initParameters(cachedParams.spend, cachedParams.output);
         }
     }
 
@@ -752,241 +682,228 @@
             __classPrivateFieldSet(this, _SaplingTransactionBuilder_saplingWrapper, saplingWrapper, "f");
             __classPrivateFieldSet(this, _SaplingTransactionBuilder_readProvider, readProvider, "f");
         }
-        createShieldedTx(saplingTransactionParams, txTotalAmount, boundData) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const rcm = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
-                const balance = this.calculateTransactionBalance('0', txTotalAmount.toString());
-                const { signature, inputs, outputs } = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").withProvingContext((saplingContext) => __awaiter(this, void 0, void 0, function* () {
-                    const outputs = [];
-                    const inputs = [];
-                    for (const i in saplingTransactionParams) {
-                        const [address] = utils.b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
-                            utils.PrefixV2.SaplingAddress,
-                        ]);
-                        outputs.push(yield this.prepareSaplingOutputDescription({
-                            saplingContext,
-                            address,
-                            amount: saplingTransactionParams[i].amount,
-                            memo: saplingTransactionParams[i].memo,
-                            randomCommitmentTrapdoor: rcm,
-                        }));
-                    }
-                    const signature = yield this.createBindingSignature({
+        async createShieldedTx(saplingTransactionParams, txTotalAmount, boundData) {
+            const rcm = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
+            const balance = this.calculateTransactionBalance('0', txTotalAmount.toString());
+            const { signature, inputs, outputs } = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").withProvingContext(async (saplingContext) => {
+                const outputs = [];
+                const inputs = [];
+                for (const i in saplingTransactionParams) {
+                    const [address] = utils.b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
+                        utils.PrefixV2.SaplingAddress,
+                    ]);
+                    outputs.push(await this.prepareSaplingOutputDescription({
                         saplingContext,
-                        inputs,
-                        outputs,
-                        balance,
-                        boundData,
-                    });
-                    return { signature, inputs, outputs };
-                }));
-                return {
+                        address,
+                        amount: saplingTransactionParams[i].amount,
+                        memo: saplingTransactionParams[i].memo,
+                        randomCommitmentTrapdoor: rcm,
+                    }));
+                }
+                const signature = await this.createBindingSignature({
+                    saplingContext,
                     inputs,
                     outputs,
-                    signature,
                     balance,
-                };
+                    boundData,
+                });
+                return { signature, inputs, outputs };
             });
+            return {
+                inputs,
+                outputs,
+                signature,
+                balance,
+            };
         }
-        createSaplingTx(saplingTransactionParams, txTotalAmount, boundData, chosenInputs) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const randomCommitmentTrapdoor = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
-                const saplingViewer = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemorySpendingKey, "f").getSaplingViewingKeyProvider();
-                const outgoingViewingKey = yield saplingViewer.getOutgoingViewingKey();
-                const { signature, balance, inputs, outputs } = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").withProvingContext((saplingContext) => __awaiter(this, void 0, void 0, function* () {
-                    const outputs = [];
-                    const inputs = [];
-                    inputs.push(...(yield this.prepareSaplingSpendDescription(saplingContext, chosenInputs.inputsToSpend)));
-                    let sumAmountOutput = new BigNumber(0);
-                    for (const i in saplingTransactionParams) {
-                        sumAmountOutput = sumAmountOutput.plus(new BigNumber(saplingTransactionParams[i].amount));
-                        const [address] = utils.b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
-                            utils.PrefixV2.SaplingAddress,
-                        ]);
-                        outputs.push(yield this.prepareSaplingOutputDescription({
-                            saplingContext,
-                            address,
-                            amount: saplingTransactionParams[i].amount,
-                            memo: saplingTransactionParams[i].memo,
-                            randomCommitmentTrapdoor,
-                            outgoingViewingKey,
-                        }));
-                    }
-                    if (chosenInputs.sumSelectedInputs.isGreaterThan(sumAmountOutput)) {
-                        const payBackAddress = (yield saplingViewer.getAddress()).address;
-                        const [address] = utils.b58DecodeAndCheckPrefix(payBackAddress, [utils.PrefixV2.SaplingAddress]);
-                        const { payBackOutput, payBackAmount } = yield this.createPaybackOutput({
-                            saplingContext,
-                            address,
-                            amount: txTotalAmount.toString(),
-                            memo: DEFAULT_MEMO,
-                            randomCommitmentTrapdoor: randomCommitmentTrapdoor,
-                            outgoingViewingKey: outgoingViewingKey,
-                        }, chosenInputs.sumSelectedInputs);
-                        sumAmountOutput = sumAmountOutput.plus(new BigNumber(payBackAmount));
-                        outputs.push(payBackOutput);
-                    }
-                    const balance = this.calculateTransactionBalance(chosenInputs.sumSelectedInputs.toString(), sumAmountOutput.toString());
-                    const signature = yield this.createBindingSignature({
+        async createSaplingTx(saplingTransactionParams, txTotalAmount, boundData, chosenInputs) {
+            const randomCommitmentTrapdoor = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
+            const saplingViewer = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemorySpendingKey, "f").getSaplingViewingKeyProvider();
+            const outgoingViewingKey = await saplingViewer.getOutgoingViewingKey();
+            const { signature, balance, inputs, outputs } = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").withProvingContext(async (saplingContext) => {
+                const outputs = [];
+                const inputs = [];
+                inputs.push(...(await this.prepareSaplingSpendDescription(saplingContext, chosenInputs.inputsToSpend)));
+                let sumAmountOutput = new BigNumber(0);
+                for (const i in saplingTransactionParams) {
+                    sumAmountOutput = sumAmountOutput.plus(new BigNumber(saplingTransactionParams[i].amount));
+                    const [address] = utils.b58DecodeAndCheckPrefix(saplingTransactionParams[i].to, [
+                        utils.PrefixV2.SaplingAddress,
+                    ]);
+                    outputs.push(await this.prepareSaplingOutputDescription({
                         saplingContext,
-                        inputs,
-                        outputs,
-                        balance,
-                        boundData,
-                    });
-                    return { signature, balance, inputs, outputs };
-                }));
-                return {
+                        address,
+                        amount: saplingTransactionParams[i].amount,
+                        memo: saplingTransactionParams[i].memo,
+                        randomCommitmentTrapdoor,
+                        outgoingViewingKey,
+                    }));
+                }
+                if (chosenInputs.sumSelectedInputs.isGreaterThan(sumAmountOutput)) {
+                    const payBackAddress = (await saplingViewer.getAddress()).address;
+                    const [address] = utils.b58DecodeAndCheckPrefix(payBackAddress, [utils.PrefixV2.SaplingAddress]);
+                    const { payBackOutput, payBackAmount } = await this.createPaybackOutput({
+                        saplingContext,
+                        address,
+                        amount: txTotalAmount.toString(),
+                        memo: DEFAULT_MEMO,
+                        randomCommitmentTrapdoor: randomCommitmentTrapdoor,
+                        outgoingViewingKey: outgoingViewingKey,
+                    }, chosenInputs.sumSelectedInputs);
+                    sumAmountOutput = sumAmountOutput.plus(new BigNumber(payBackAmount));
+                    outputs.push(payBackOutput);
+                }
+                const balance = this.calculateTransactionBalance(chosenInputs.sumSelectedInputs.toString(), sumAmountOutput.toString());
+                const signature = await this.createBindingSignature({
+                    saplingContext,
                     inputs,
                     outputs,
-                    signature,
                     balance,
-                };
+                    boundData,
+                });
+                return { signature, balance, inputs, outputs };
             });
+            return {
+                inputs,
+                outputs,
+                signature,
+                balance,
+            };
         }
         // sum of values of inputs minus sums of values of output equals balance
         calculateTransactionBalance(inputTotal, outputTotal) {
             return new BigNumber(inputTotal).minus(new BigNumber(outputTotal));
         }
-        prepareSaplingOutputDescription(parametersOutputDescription) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const ephemeralPrivateKey = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
-                const { commitmentValue, commitment, proof } = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").preparePartialOutputDescription({
-                    saplingContext: parametersOutputDescription.saplingContext,
-                    address: parametersOutputDescription.address,
-                    randomCommitmentTrapdoor: parametersOutputDescription.randomCommitmentTrapdoor,
-                    ephemeralPrivateKey,
-                    amount: parametersOutputDescription.amount,
-                });
-                const diversifier = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getDiversifiedFromRawPaymentAddress(parametersOutputDescription.address);
-                const ephemeralPublicKey = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").deriveEphemeralPublicKey(diversifier, ephemeralPrivateKey);
-                const outgoingCipherKey = parametersOutputDescription.outgoingViewingKey
-                    ? blake.blake2b(Buffer.concat([
-                        commitmentValue,
-                        commitment,
-                        ephemeralPublicKey,
-                        parametersOutputDescription.outgoingViewingKey,
-                    ]), Buffer.from(OCK_KEY), 32)
-                    : __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getRandomBytes(32);
-                const ciphertext = yield this.encryptCiphertext({
-                    address: parametersOutputDescription.address,
-                    ephemeralPrivateKey,
-                    diversifier,
-                    outgoingCipherKey,
-                    amount: parametersOutputDescription.amount,
-                    randomCommitmentTrapdoor: parametersOutputDescription.randomCommitmentTrapdoor,
-                    memo: parametersOutputDescription.memo,
-                });
-                return {
+        async prepareSaplingOutputDescription(parametersOutputDescription) {
+            const ephemeralPrivateKey = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
+            const { commitmentValue, commitment, proof } = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").preparePartialOutputDescription({
+                saplingContext: parametersOutputDescription.saplingContext,
+                address: parametersOutputDescription.address,
+                randomCommitmentTrapdoor: parametersOutputDescription.randomCommitmentTrapdoor,
+                ephemeralPrivateKey,
+                amount: parametersOutputDescription.amount,
+            });
+            const diversifier = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getDiversifiedFromRawPaymentAddress(parametersOutputDescription.address);
+            const ephemeralPublicKey = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").deriveEphemeralPublicKey(diversifier, ephemeralPrivateKey);
+            const outgoingCipherKey = parametersOutputDescription.outgoingViewingKey
+                ? blake.blake2b(Buffer.concat([
+                    commitmentValue,
                     commitment,
-                    proof,
-                    ciphertext: Object.assign(Object.assign({}, ciphertext), { commitmentValue,
-                        ephemeralPublicKey }),
-                };
+                    ephemeralPublicKey,
+                    parametersOutputDescription.outgoingViewingKey,
+                ]), Buffer.from(OCK_KEY), 32)
+                : __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getRandomBytes(32);
+            const ciphertext = await this.encryptCiphertext({
+                address: parametersOutputDescription.address,
+                ephemeralPrivateKey,
+                diversifier,
+                outgoingCipherKey,
+                amount: parametersOutputDescription.amount,
+                randomCommitmentTrapdoor: parametersOutputDescription.randomCommitmentTrapdoor,
+                memo: parametersOutputDescription.memo,
             });
+            return {
+                commitment,
+                proof,
+                ciphertext: {
+                    ...ciphertext,
+                    commitmentValue,
+                    ephemeralPublicKey,
+                },
+            };
         }
-        prepareSaplingSpendDescription(saplingContext, inputsToSpend) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const publicKeyReRandomization = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
-                let stateDiff;
-                if (__classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingId, "f")) {
-                    stateDiff = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_readProvider, "f").getSaplingDiffById({ id: __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingId, "f") }, 'head');
-                }
-                else {
-                    stateDiff = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_readProvider, "f").getSaplingDiffByContract(__classPrivateFieldGet(this, _SaplingTransactionBuilder_contractAddress, "f"), 'head');
-                }
-                const stateTree = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingState, "f").getStateTree(stateDiff, true);
-                const saplingSpendDescriptions = [];
-                for (let i = 0; i < inputsToSpend.length; i++) {
-                    const amount = convertValueToBigNumber(inputsToSpend[i].value).toString();
-                    const witness = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingState, "f").getWitness(stateTree, new BigNumber(inputsToSpend[i].position));
-                    const unsignedSpendDescription = __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemoryProvingKey, "f")
-                        ? yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemoryProvingKey, "f").prepareSpendDescription({
-                            saplingContext,
-                            address: inputsToSpend[i].paymentAddress,
-                            randomCommitmentTrapdoor: inputsToSpend[i].randomCommitmentTrapdoor,
-                            publicKeyReRandomization,
-                            amount,
-                            root: stateDiff.root,
-                            witness,
-                        })
-                        : yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemorySpendingKey, "f").prepareSpendDescription({
-                            saplingContext,
-                            address: inputsToSpend[i].paymentAddress,
-                            randomCommitmentTrapdoor: inputsToSpend[i].randomCommitmentTrapdoor,
-                            publicKeyReRandomization,
-                            amount,
-                            root: stateDiff.root,
-                            witness,
-                        });
-                    const unsignedSpendDescriptionBytes = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeUnsignedTxInput(unsignedSpendDescription);
-                    const hash = blake.blake2b(unsignedSpendDescriptionBytes, yield this.getAntiReplay(), 32);
-                    const spendDescription = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemorySpendingKey, "f").signSpendDescription({
+        async prepareSaplingSpendDescription(saplingContext, inputsToSpend) {
+            const publicKeyReRandomization = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").randR();
+            let stateDiff;
+            if (__classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingId, "f")) {
+                stateDiff = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_readProvider, "f").getSaplingDiffById({ id: __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingId, "f") }, 'head');
+            }
+            else {
+                stateDiff = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_readProvider, "f").getSaplingDiffByContract(__classPrivateFieldGet(this, _SaplingTransactionBuilder_contractAddress, "f"), 'head');
+            }
+            const stateTree = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingState, "f").getStateTree(stateDiff, true);
+            const saplingSpendDescriptions = [];
+            for (let i = 0; i < inputsToSpend.length; i++) {
+                const amount = convertValueToBigNumber(inputsToSpend[i].value).toString();
+                const witness = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingState, "f").getWitness(stateTree, new BigNumber(inputsToSpend[i].position));
+                const unsignedSpendDescription = __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemoryProvingKey, "f")
+                    ? await __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemoryProvingKey, "f").prepareSpendDescription({
+                        saplingContext,
+                        address: inputsToSpend[i].paymentAddress,
+                        randomCommitmentTrapdoor: inputsToSpend[i].randomCommitmentTrapdoor,
+                        publicKeyReRandomization,
+                        amount,
+                        root: stateDiff.root,
+                        witness,
+                    })
+                    : await __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemorySpendingKey, "f").prepareSpendDescription({
+                        saplingContext,
+                        address: inputsToSpend[i].paymentAddress,
+                        randomCommitmentTrapdoor: inputsToSpend[i].randomCommitmentTrapdoor,
                         publicKeyReRandomization,
-                        unsignedSpendDescription,
-                        hash,
+                        amount,
+                        root: stateDiff.root,
+                        witness,
                     });
-                    if (spendDescription.signature === undefined) {
-                        throw new Error('Spend signing failed');
-                    }
-                    saplingSpendDescriptions.push(spendDescription);
-                }
-                return saplingSpendDescriptions;
-            });
-        }
-        encryptCiphertext(parametersCiphertext) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const recipientDiversifiedTransmissionKey = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getPkdFromRawPaymentAddress(parametersCiphertext.address);
-                const keyAgreement = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").keyAgreement(recipientDiversifiedTransmissionKey, parametersCiphertext.ephemeralPrivateKey);
-                const keyAgreementHash = blake.blake2b(keyAgreement, Buffer.from(KDF_KEY), 32);
-                const nonceEnc = Buffer.from(__classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getRandomBytes(24));
-                const transactionPlaintext = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeTransactionPlaintext({
-                    diversifier: parametersCiphertext.diversifier,
-                    amount: parametersCiphertext.amount,
-                    randomCommitmentTrapdoor: parametersCiphertext.randomCommitmentTrapdoor,
-                    memoSize: __classPrivateFieldGet(this, _SaplingTransactionBuilder_memoSize, "f") * 2,
-                    memo: parametersCiphertext.memo,
-                });
-                const nonceOut = Buffer.from(__classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getRandomBytes(24));
-                const payloadEnc = Buffer.from(nacl.secretBox(keyAgreementHash, nonceEnc, transactionPlaintext));
-                const payloadOut = Buffer.from(nacl.secretBox(parametersCiphertext.outgoingCipherKey, nonceOut, Buffer.concat([
-                    recipientDiversifiedTransmissionKey,
-                    parametersCiphertext.ephemeralPrivateKey,
-                ])));
-                return { payloadEnc, nonceEnc, payloadOut, nonceOut };
-            });
-        }
-        createPaybackOutput(params, sumSelectedInputs) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const payBackAmount = sumSelectedInputs.minus(params.amount).toString();
-                const payBackOutput = yield this.prepareSaplingOutputDescription({
-                    saplingContext: params.saplingContext,
-                    address: params.address,
-                    amount: payBackAmount,
-                    memo: params.memo,
-                    randomCommitmentTrapdoor: params.randomCommitmentTrapdoor,
-                    outgoingViewingKey: params.outgoingViewingKey,
+                const unsignedSpendDescriptionBytes = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeUnsignedTxInput(unsignedSpendDescription);
+                const hash = blake.blake2b(unsignedSpendDescriptionBytes, await this.getAntiReplay(), 32);
+                const spendDescription = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_inMemorySpendingKey, "f").signSpendDescription({
+                    publicKeyReRandomization,
+                    unsignedSpendDescription,
+                    hash,
                 });
-                return { payBackOutput, payBackAmount };
-            });
-        }
-        createBindingSignature(parametersBindingSig) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const outputs = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeOutputDescriptions(parametersBindingSig.outputs);
-                const inputs = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeSpendDescriptions(parametersBindingSig.inputs);
-                const transactionSigHash = blake.blake2b(Buffer.concat([inputs, outputs, parametersBindingSig.boundData]), yield this.getAntiReplay(), 32);
-                return __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").createBindingSignature(parametersBindingSig.saplingContext, parametersBindingSig.balance.toFixed(), transactionSigHash);
-            });
-        }
-        getAntiReplay() {
-            return __awaiter(this, void 0, void 0, function* () {
-                let chainId = __classPrivateFieldGet(this, _SaplingTransactionBuilder_chainId, "f");
-                if (!chainId) {
-                    chainId = yield __classPrivateFieldGet(this, _SaplingTransactionBuilder_readProvider, "f").getChainId();
-                    __classPrivateFieldSet(this, _SaplingTransactionBuilder_chainId, chainId, "f");
+                if (spendDescription.signature === undefined) {
+                    throw new Error('Spend signing failed');
                 }
-                return Buffer.from(`${__classPrivateFieldGet(this, _SaplingTransactionBuilder_contractAddress, "f")}${chainId}`);
+                saplingSpendDescriptions.push(spendDescription);
+            }
+            return saplingSpendDescriptions;
+        }
+        async encryptCiphertext(parametersCiphertext) {
+            const recipientDiversifiedTransmissionKey = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getPkdFromRawPaymentAddress(parametersCiphertext.address);
+            const keyAgreement = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").keyAgreement(recipientDiversifiedTransmissionKey, parametersCiphertext.ephemeralPrivateKey);
+            const keyAgreementHash = blake.blake2b(keyAgreement, Buffer.from(KDF_KEY), 32);
+            const nonceEnc = Buffer.from(__classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getRandomBytes(24));
+            const transactionPlaintext = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeTransactionPlaintext({
+                diversifier: parametersCiphertext.diversifier,
+                amount: parametersCiphertext.amount,
+                randomCommitmentTrapdoor: parametersCiphertext.randomCommitmentTrapdoor,
+                memoSize: __classPrivateFieldGet(this, _SaplingTransactionBuilder_memoSize, "f") * 2,
+                memo: parametersCiphertext.memo,
             });
+            const nonceOut = Buffer.from(__classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").getRandomBytes(24));
+            const payloadEnc = Buffer.from(nacl.secretBox(keyAgreementHash, nonceEnc, transactionPlaintext));
+            const payloadOut = Buffer.from(nacl.secretBox(parametersCiphertext.outgoingCipherKey, nonceOut, Buffer.concat([
+                recipientDiversifiedTransmissionKey,
+                parametersCiphertext.ephemeralPrivateKey,
+            ])));
+            return { payloadEnc, nonceEnc, payloadOut, nonceOut };
+        }
+        async createPaybackOutput(params, sumSelectedInputs) {
+            const payBackAmount = sumSelectedInputs.minus(params.amount).toString();
+            const payBackOutput = await this.prepareSaplingOutputDescription({
+                saplingContext: params.saplingContext,
+                address: params.address,
+                amount: payBackAmount,
+                memo: params.memo,
+                randomCommitmentTrapdoor: params.randomCommitmentTrapdoor,
+                outgoingViewingKey: params.outgoingViewingKey,
+            });
+            return { payBackOutput, payBackAmount };
+        }
+        async createBindingSignature(parametersBindingSig) {
+            const outputs = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeOutputDescriptions(parametersBindingSig.outputs);
+            const inputs = __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingForger, "f").forgeSpendDescriptions(parametersBindingSig.inputs);
+            const transactionSigHash = blake.blake2b(Buffer.concat([inputs, outputs, parametersBindingSig.boundData]), await this.getAntiReplay(), 32);
+            return __classPrivateFieldGet(this, _SaplingTransactionBuilder_saplingWrapper, "f").createBindingSignature(parametersBindingSig.saplingContext, parametersBindingSig.balance.toFixed(), transactionSigHash);
+        }
+        async getAntiReplay() {
+            let chainId = __classPrivateFieldGet(this, _SaplingTransactionBuilder_chainId, "f");
+            if (!chainId) {
+                chainId = await __classPrivateFieldGet(this, _SaplingTransactionBuilder_readProvider, "f").getChainId();
+                __classPrivateFieldSet(this, _SaplingTransactionBuilder_chainId, chainId, "f");
+            }
+            return Buffer.from(`${__classPrivateFieldGet(this, _SaplingTransactionBuilder_contractAddress, "f")}${chainId}`);
         }
     }
     _SaplingTransactionBuilder_inMemorySpendingKey = new WeakMap(), _SaplingTransactionBuilder_inMemoryProvingKey = new WeakMap(), _SaplingTransactionBuilder_saplingForger = new WeakMap(), _SaplingTransactionBuilder_contractAddress = new WeakMap(), _SaplingTransactionBuilder_saplingId = new WeakMap(), _SaplingTransactionBuilder_memoSize = new WeakMap(), _SaplingTransactionBuilder_readProvider = new WeakMap(), _SaplingTransactionBuilder_saplingWrapper = new WeakMap(), _SaplingTransactionBuilder_chainId = new WeakMap(), _SaplingTransactionBuilder_saplingState = new WeakMap();
@@ -1001,7 +918,7 @@
             }
             catch (err) {
                 if (err instanceof core.ParameterValidationError) {
-                    throw new InvalidSpendingKey(spendingKey, 'invalid spending key');
+                    throw new InvalidSpendingKey('invalid spending key');
                 }
                 else {
                     throw err;
@@ -1010,7 +927,7 @@
         })();
         if (pre === utils.PrefixV2.EncryptedSaplingSpendingKey) {
             if (!password) {
-                throw new InvalidSpendingKey(spendingKey, 'no password provided to decrypt');
+                throw new InvalidSpendingKey('no password provided to decrypt');
             }
             const salt = toBuffer(keyArr.slice(0, 8));
             const encryptedSk = toBuffer(keyArr.slice(8));
@@ -1020,7 +937,7 @@
             const decrypted = nacl.openSecretBox(new Uint8Array(encryptionKey), new Uint8Array(24), // zero nonce - uniqueness provided by per-encryption derived key
             new Uint8Array(encryptedSk));
             if (!decrypted) {
-                throw new InvalidSpendingKey(spendingKey, 'incorrect password or unable to decrypt');
+                throw new InvalidSpendingKey('incorrect password or unable to decrypt');
             }
             return toBuffer(decrypted);
         }
@@ -1031,7 +948,7 @@
 
     var _InMemoryViewingKey_fullViewingKey;
     /**
-     * @description Holds the viewing key
+     * Holds the viewing key
      */
     class InMemoryViewingKey {
         constructor(fullViewingKey) {
@@ -1039,7 +956,7 @@
             __classPrivateFieldSet(this, _InMemoryViewingKey_fullViewingKey, Buffer.from(fullViewingKey, 'hex'), "f");
         }
         /**
-         * @description Allows to instantiate the InMemoryViewingKey from an encrypted/unencrypted spending key
+         * Allows to instantiate the InMemoryViewingKey from an encrypted/unencrypted spending key
          *
          * @param spendingKey Base58Check-encoded spending key
          * @param password Optional password to decrypt the spending key
@@ -1049,15 +966,13 @@
          * ```
          *
          */
-        static fromSpendingKey(spendingKey, password) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const spendingKeyBuf = decryptKey(spendingKey, password);
-                const viewingKey = yield sapling__namespace.getExtendedFullViewingKeyFromSpendingKey(spendingKeyBuf);
-                return new InMemoryViewingKey(viewingKey.toString('hex'));
-            });
+        static async fromSpendingKey(spendingKey, password) {
+            const spendingKeyBuf = decryptKey(spendingKey, password);
+            const viewingKey = await sapling__namespace.getExtendedFullViewingKeyFromSpendingKey(spendingKeyBuf);
+            return new InMemoryViewingKey(viewingKey.toString('hex'));
         }
         /**
-         * @description Retrieve the full viewing key
+         * Retrieve the full viewing key
          * @returns Buffer representing the full viewing key
          *
          */
@@ -1065,46 +980,40 @@
             return __classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f");
         }
         /**
-         * @description Retrieve the outgoing viewing key
+         * Retrieve the outgoing viewing key
          * @returns Buffer representing the outgoing viewing key
          *
          */
-        getOutgoingViewingKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.getOutgoingViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"));
-            });
+        async getOutgoingViewingKey() {
+            return sapling__namespace.getOutgoingViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"));
         }
         /**
-         * @description Retrieve the incoming viewing key
+         * Retrieve the incoming viewing key
          * @returns Buffer representing the incoming viewing key
          *
          */
-        getIncomingViewingKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return sapling__namespace.getIncomingViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"));
-            });
+        async getIncomingViewingKey() {
+            return sapling__namespace.getIncomingViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"));
         }
         /**
-         * @description Retrieve a payment address
+         * Retrieve a payment address
          * @param addressIndex used to determine which diversifier should be used to derive the address, default is 0
          * @returns Base58Check-encoded address and its index
          *
          */
-        getAddress(addressIndex) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const { index, raw } = yield sapling__namespace.getPaymentAddressFromViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"), addressIndex);
-                return {
-                    address: utils.b58Encode(raw, utils.PrefixV2.SaplingAddress),
-                    addressIndex: index.readInt32LE(),
-                };
-            });
+        async getAddress(addressIndex) {
+            const { index, raw } = await sapling__namespace.getPaymentAddressFromViewingKey(__classPrivateFieldGet(this, _InMemoryViewingKey_fullViewingKey, "f"), addressIndex);
+            return {
+                address: utils.b58Encode(raw, utils.PrefixV2.SaplingAddress),
+                addressIndex: index.readInt32LE(),
+            };
         }
     }
     _InMemoryViewingKey_fullViewingKey = new WeakMap();
 
     var _InMemorySpendingKey_spendingKeyBuf, _InMemorySpendingKey_saplingViewingKey;
     /**
-     * @description holds the spending key, create proof and signature for spend descriptions
+     * holds the spending key, create proof and signature for spend descriptions
      * can instantiate from mnemonic word list or decrypt a encrypted spending key
      * with access to instantiate a InMemoryViewingKey
      */
@@ -1125,35 +1034,31 @@
          * @param derivationPath tezos current standard 'm/'
          * @returns InMemorySpendingKey class instantiated
          */
-        static fromMnemonic(mnemonic_1) {
-            return __awaiter(this, arguments, void 0, function* (mnemonic, derivationPath = 'm/') {
-                // no password passed here. password provided only changes from sask -> MMXj
-                const fullSeed = yield bip39__namespace.mnemonicToSeed(mnemonic);
-                const first32 = fullSeed.slice(0, 32);
-                const second32 = fullSeed.slice(32);
-                // reduce seed bytes must be 32 bytes reflecting both halves
-                const seed = Buffer.from(first32.map((byte, index) => byte ^ second32[index]));
-                const spendingKeyArr = new Uint8Array(yield sapling__namespace.getExtendedSpendingKey(seed, derivationPath));
-                const spendingKey = utils.b58Encode(spendingKeyArr, utils.PrefixV2.SaplingSpendingKey);
-                return new InMemorySpendingKey(spendingKey);
-            });
+        static async fromMnemonic(mnemonic, derivationPath = 'm/') {
+            // no password passed here. password provided only changes from sask -> MMXj
+            const fullSeed = await bip39__namespace.mnemonicToSeed(mnemonic);
+            const first32 = fullSeed.slice(0, 32);
+            const second32 = fullSeed.slice(32);
+            // reduce seed bytes must be 32 bytes reflecting both halves
+            const seed = Buffer.from(first32.map((byte, index) => byte ^ second32[index]));
+            const spendingKeyArr = new Uint8Array(await sapling__namespace.getExtendedSpendingKey(seed, derivationPath));
+            const spendingKey = utils.b58Encode(spendingKeyArr, utils.PrefixV2.SaplingSpendingKey);
+            return new InMemorySpendingKey(spendingKey);
         }
         /**
          *
          * @returns InMemoryViewingKey instantiated class
          */
-        getSaplingViewingKeyProvider() {
-            return __awaiter(this, void 0, void 0, function* () {
-                let viewingKey;
-                if (!__classPrivateFieldGet(this, _InMemorySpendingKey_saplingViewingKey, "f")) {
-                    viewingKey = yield sapling__namespace.getExtendedFullViewingKeyFromSpendingKey(__classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"));
-                    __classPrivateFieldSet(this, _InMemorySpendingKey_saplingViewingKey, new InMemoryViewingKey(viewingKey.toString('hex')), "f");
-                }
-                return __classPrivateFieldGet(this, _InMemorySpendingKey_saplingViewingKey, "f");
-            });
+        async getSaplingViewingKeyProvider() {
+            let viewingKey;
+            if (!__classPrivateFieldGet(this, _InMemorySpendingKey_saplingViewingKey, "f")) {
+                viewingKey = await sapling__namespace.getExtendedFullViewingKeyFromSpendingKey(__classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"));
+                __classPrivateFieldSet(this, _InMemorySpendingKey_saplingViewingKey, new InMemoryViewingKey(viewingKey.toString('hex')), "f");
+            }
+            return __classPrivateFieldGet(this, _InMemorySpendingKey_saplingViewingKey, "f");
         }
         /**
-         * @description Prepare an unsigned sapling spend description using the spending key
+         * Prepare an unsigned sapling spend description using the spending key
          * @param parametersSpendProof.saplingContext The sapling proving context
          * @param parametersSpendProof.address The address of the input
          * @param parametersSpendProof.randomCommitmentTrapdoor The randomness of the commitment
@@ -1161,61 +1066,54 @@
          * @param parametersSpendProof.amount The value of the input
          * @param parametersSpendProof.root The root of the merkle tree
          * @param parametersSpendProof.witness The path of the commitment in the tree
-         * @param derivationPath tezos current standard 'm/'
          * @returns The unsigned spend description
          */
-        prepareSpendDescription(parametersSpendProof) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const spendDescription = yield sapling__namespace.prepareSpendDescriptionWithSpendingKey(parametersSpendProof.saplingContext, __classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"), parametersSpendProof.address, parametersSpendProof.randomCommitmentTrapdoor, parametersSpendProof.publicKeyReRandomization, parametersSpendProof.amount, parametersSpendProof.root, parametersSpendProof.witness);
-                return {
-                    commitmentValue: spendDescription.cv,
-                    nullifier: spendDescription.nf,
-                    publicKeyReRandomization: spendDescription.rk,
-                    rtAnchor: spendDescription.rt,
-                    proof: spendDescription.proof,
-                };
-            });
+        async prepareSpendDescription(parametersSpendProof) {
+            const spendDescription = await sapling__namespace.prepareSpendDescriptionWithSpendingKey(parametersSpendProof.saplingContext, __classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"), parametersSpendProof.address, parametersSpendProof.randomCommitmentTrapdoor, parametersSpendProof.publicKeyReRandomization, parametersSpendProof.amount, parametersSpendProof.root, parametersSpendProof.witness);
+            return {
+                commitmentValue: spendDescription.cv,
+                nullifier: spendDescription.nf,
+                publicKeyReRandomization: spendDescription.rk,
+                rtAnchor: spendDescription.rt,
+                proof: spendDescription.proof,
+            };
         }
         /**
-         * @description Sign a sapling spend description
+         * Sign a sapling spend description
          * @param parametersSpendSig.publicKeyReRandomization The re-randomization of the public key
          * @param parametersSpendSig.unsignedSpendDescription The unsigned Spend description
          * @param parametersSpendSig.hash The data to be signed
          * @returns The signed spend description
          */
-        signSpendDescription(parametersSpendSig) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const signedSpendDescription = yield sapling__namespace.signSpendDescription({
-                    cv: parametersSpendSig.unsignedSpendDescription.commitmentValue,
-                    rt: parametersSpendSig.unsignedSpendDescription.rtAnchor,
-                    nf: parametersSpendSig.unsignedSpendDescription.nullifier,
-                    rk: parametersSpendSig.unsignedSpendDescription.publicKeyReRandomization,
-                    proof: parametersSpendSig.unsignedSpendDescription.proof,
-                }, __classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"), parametersSpendSig.publicKeyReRandomization, parametersSpendSig.hash);
-                return {
-                    commitmentValue: signedSpendDescription.cv,
-                    nullifier: signedSpendDescription.nf,
-                    publicKeyReRandomization: signedSpendDescription.rk,
-                    proof: signedSpendDescription.proof,
-                    signature: signedSpendDescription.spendAuthSig,
-                };
-            });
+        async signSpendDescription(parametersSpendSig) {
+            const signedSpendDescription = await sapling__namespace.signSpendDescription({
+                cv: parametersSpendSig.unsignedSpendDescription.commitmentValue,
+                rt: parametersSpendSig.unsignedSpendDescription.rtAnchor,
+                nf: parametersSpendSig.unsignedSpendDescription.nullifier,
+                rk: parametersSpendSig.unsignedSpendDescription.publicKeyReRandomization,
+                proof: parametersSpendSig.unsignedSpendDescription.proof,
+            }, __classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"), parametersSpendSig.publicKeyReRandomization, parametersSpendSig.hash);
+            return {
+                commitmentValue: signedSpendDescription.cv,
+                nullifier: signedSpendDescription.nf,
+                publicKeyReRandomization: signedSpendDescription.rk,
+                proof: signedSpendDescription.proof,
+                signature: signedSpendDescription.spendAuthSig,
+            };
         }
         /**
-         * @description Return a proof authorizing key from the configured spending key
+         * Return a proof authorizing key from the configured spending key
          */
-        getProvingKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const provingKey = yield sapling__namespace.getProofAuthorizingKey(__classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"));
-                return provingKey.toString('hex');
-            });
+        async getProvingKey() {
+            const provingKey = await sapling__namespace.getProofAuthorizingKey(__classPrivateFieldGet(this, _InMemorySpendingKey_spendingKeyBuf, "f"));
+            return provingKey.toString('hex');
         }
     }
     _InMemorySpendingKey_spendingKeyBuf = new WeakMap(), _InMemorySpendingKey_saplingViewingKey = new WeakMap();
 
     var _InMemoryProvingKey_provingKey;
     /**
-     * @description holds the proving key, create proof for spend descriptions
+     * holds the proving key, create proof for spend descriptions
      * The class can be instantiated from a proving key or a spending key
      */
     class InMemoryProvingKey {
@@ -1224,7 +1122,7 @@
             __classPrivateFieldSet(this, _InMemoryProvingKey_provingKey, Buffer.from(provingKey, 'hex'), "f");
         }
         /**
-         * @description Allows to instantiate the InMemoryProvingKey from an encrypted/unencrypted spending key
+         * Allows to instantiate the InMemoryProvingKey from an encrypted/unencrypted spending key
          *
          * @param spendingKey Base58Check-encoded spending key
          * @param password Optional password to decrypt the spending key
@@ -1234,15 +1132,13 @@
          * ```
          *
          */
-        static fromSpendingKey(spendingKey, password) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const decodedSpendingKey = decryptKey(spendingKey, password);
-                const provingKey = yield sapling__namespace.getProofAuthorizingKey(decodedSpendingKey);
-                return new InMemoryProvingKey(provingKey.toString('hex'));
-            });
+        static async fromSpendingKey(spendingKey, password) {
+            const decodedSpendingKey = decryptKey(spendingKey, password);
+            const provingKey = await sapling__namespace.getProofAuthorizingKey(decodedSpendingKey);
+            return new InMemoryProvingKey(provingKey.toString('hex'));
         }
         /**
-         * @description Prepare an unsigned sapling spend description using the proving key
+         * Prepare an unsigned sapling spend description using the proving key
          *
          * @param parametersSpendProof.saplingContext The sapling proving context
          * @param parametersSpendProof.address The address of the input
@@ -1251,20 +1147,17 @@
          * @param parametersSpendProof.amount The value of the input
          * @param parametersSpendProof.root The root of the merkle tree
          * @param parametersSpendProof.witness The path of the commitment in the tree
-         * @param derivationPath tezos current standard 'm/'
          * @returns The unsinged spend description
          */
-        prepareSpendDescription(parametersSpendProof) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const spendDescription = yield sapling__namespace.prepareSpendDescriptionWithAuthorizingKey(parametersSpendProof.saplingContext, __classPrivateFieldGet(this, _InMemoryProvingKey_provingKey, "f"), parametersSpendProof.address, parametersSpendProof.randomCommitmentTrapdoor, parametersSpendProof.publicKeyReRandomization, parametersSpendProof.amount, parametersSpendProof.root, parametersSpendProof.witness);
-                return {
-                    commitmentValue: spendDescription.cv,
-                    nullifier: spendDescription.nf,
-                    publicKeyReRandomization: spendDescription.rk,
-                    rtAnchor: spendDescription.rt,
-                    proof: spendDescription.proof,
-                };
-            });
+        async prepareSpendDescription(parametersSpendProof) {
+            const spendDescription = await sapling__namespace.prepareSpendDescriptionWithAuthorizingKey(parametersSpendProof.saplingContext, __classPrivateFieldGet(this, _InMemoryProvingKey_provingKey, "f"), parametersSpendProof.address, parametersSpendProof.randomCommitmentTrapdoor, parametersSpendProof.publicKeyReRandomization, parametersSpendProof.amount, parametersSpendProof.root, parametersSpendProof.witness);
+            return {
+                commitmentValue: spendDescription.cv,
+                nullifier: spendDescription.nf,
+                publicKeyReRandomization: spendDescription.rk,
+                rtAnchor: spendDescription.rt,
+                proof: spendDescription.proof,
+            };
         }
     }
     _InMemoryProvingKey_provingKey = new WeakMap();
@@ -1275,7 +1168,7 @@
      */
     var _SaplingToolkit_inMemorySpendingKey, _SaplingToolkit_saplingId, _SaplingToolkit_contractAddress, _SaplingToolkit_memoSize, _SaplingToolkit_readProvider, _SaplingToolkit_packer, _SaplingToolkit_saplingForger, _SaplingToolkit_saplingTxBuilder, _SaplingToolkit_saplingTransactionViewer;
     /**
-     * @description Class that surfaces all of the sapling capability allowing to read from a sapling state and prepare transactions
+     * 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
@@ -1317,104 +1210,95 @@
             __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.
+         * 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 SaplingTransactionViewer(saplingViewingKey, this.getSaplingContractId(), __classPrivateFieldGet(this, _SaplingToolkit_readProvider, "f"));
-                    __classPrivateFieldSet(this, _SaplingToolkit_saplingTransactionViewer, saplingTransactionViewer, "f");
-                }
-                return __classPrivateFieldGet(this, _SaplingToolkit_saplingTransactionViewer, "f");
-            });
+        async getSaplingTransactionViewer() {
+            let saplingTransactionViewer;
+            if (!__classPrivateFieldGet(this, _SaplingToolkit_saplingTransactionViewer, "f")) {
+                const saplingViewingKey = await __classPrivateFieldGet(this, _SaplingToolkit_inMemorySpendingKey, "f").getSaplingViewingKeyProvider();
+                saplingTransactionViewer = new 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
+         * 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, DEFAULT_BOUND_DATA);
-                const forgedSaplingTx = __classPrivateFieldGet(this, _SaplingToolkit_saplingForger, "f").forgeSaplingTransaction({
-                    inputs,
-                    outputs,
-                    balance,
-                    root,
-                    boundData: DEFAULT_BOUND_DATA,
-                    signature,
-                });
-                return forgedSaplingTx.toString('hex');
+        async prepareShieldedTransaction(shieldedTxParams) {
+            const { formatedParams, totalAmount } = this.formatTransactionParams(shieldedTxParams, this.validateDestinationSaplingAddress);
+            const root = await this.getRoot();
+            const { inputs, outputs, signature, balance } = await __classPrivateFieldGet(this, _SaplingToolkit_saplingTxBuilder, "f").createShieldedTx(formatedParams, totalAmount, DEFAULT_BOUND_DATA);
+            const forgedSaplingTx = __classPrivateFieldGet(this, _SaplingToolkit_saplingForger, "f").forgeSaplingTransaction({
+                inputs,
+                outputs,
+                balance,
+                root,
+                boundData: DEFAULT_BOUND_DATA,
+                signature,
             });
+            return forgedSaplingTx.toString('hex');
         }
         /**
-         * @description Prepare an unshielded transaction
+         * 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(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');
+        async prepareUnshieldedTransaction(unshieldedTxParams) {
+            const { formatedParams, totalAmount } = this.formatTransactionParams([unshieldedTxParams], this.validateDestinationImplicitAddress);
+            const boundData = await this.createBoundData(formatedParams[0].to);
+            const root = await this.getRoot();
+            const chosenInputs = await this.selectInputsToSpend(new BigNumber(formatedParams[0].amount));
+            const { inputs, outputs, signature, balance } = await __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)
+         * 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, DEFAULT_BOUND_DATA, chosenInputs);
-                const forgedSaplingTx = __classPrivateFieldGet(this, _SaplingToolkit_saplingForger, "f").forgeSaplingTransaction({
-                    inputs,
-                    outputs,
-                    balance,
-                    root,
-                    boundData: DEFAULT_BOUND_DATA,
-                    signature,
-                });
-                return forgedSaplingTx.toString('hex');
+        async prepareSaplingTransaction(saplingTxParams) {
+            const { formatedParams, totalAmount } = this.formatTransactionParams(saplingTxParams, this.validateDestinationSaplingAddress);
+            const root = await this.getRoot();
+            const chosenInputs = await this.selectInputsToSpend(totalAmount);
+            const { inputs, outputs, signature, balance } = await __classPrivateFieldGet(this, _SaplingToolkit_saplingTxBuilder, "f").createSaplingTx(formatedParams, totalAmount, DEFAULT_BOUND_DATA, chosenInputs);
+            const forgedSaplingTx = __classPrivateFieldGet(this, _SaplingToolkit_saplingForger, "f").forgeSaplingTransaction({
+                inputs,
+                outputs,
+                balance,
+                root,
+                boundData: DEFAULT_BOUND_DATA,
+                signature,
             });
+            return forgedSaplingTx.toString('hex');
         }
         formatTransactionParams(txParams, validateDestination) {
             const formatedParams = [];
             let totalAmount = new BigNumber(0);
             txParams.forEach((param) => {
-                var _a;
                 validateDestination(param.to);
                 const amountMutez = param.mutez
                     ? param.amount.toString()
                     : utils.format('tz', 'mutez', param.amount).toString();
                 totalAmount = totalAmount.plus(new BigNumber(amountMutez));
-                const memo = (_a = param.memo) !== null && _a !== void 0 ? _a : DEFAULT_MEMO;
+                const memo = param.memo ?? DEFAULT_MEMO;
                 if (memo.length > __classPrivateFieldGet(this, _SaplingToolkit_memoSize, "f")) {
                     throw new InvalidMemo(memo, `expecting length to be less than ${__classPrivateFieldGet(this, _SaplingToolkit_memoSize, "f")}`);
                 }
@@ -1422,27 +1306,23 @@
             });
             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;
-                }
-            });
+        async getRoot() {
+            if (__classPrivateFieldGet(this, _SaplingToolkit_saplingId, "f")) {
+                const { root } = await __classPrivateFieldGet(this, _SaplingToolkit_readProvider, "f").getSaplingDiffById({ id: __classPrivateFieldGet(this, _SaplingToolkit_saplingId, "f") }, 'head');
+                return root;
+            }
+            else {
+                const { root } = await __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 = utils.b58DecodePublicKeyHash(destination, 'hex');
-                const packedDestination = yield __classPrivateFieldGet(this, _SaplingToolkit_packer, "f").packData({
-                    data: { bytes },
-                    type: { prim: 'bytes' },
-                });
-                return Buffer.from(packedDestination.packed, 'hex');
+        async createBoundData(destination) {
+            const bytes = utils.b58DecodePublicKeyHash(destination, 'hex');
+            const packedDestination = await __classPrivateFieldGet(this, _SaplingToolkit_packer, "f").packData({
+                data: { bytes },
+                type: { prim: 'bytes' },
             });
+            return Buffer.from(packedDestination.packed, 'hex');
         }
         validateDestinationImplicitAddress(to) {
             const toValidation = utils.validateKeyHash(to);
@@ -1454,7 +1334,7 @@
             try {
                 utils.b58DecodeAndCheckPrefix(to, [utils.PrefixV2.SaplingAddress]);
             }
-            catch (_a) {
+            catch {
                 throw new core.InvalidAddressError(to, `expecting prefix ${utils.PrefixV2.SaplingAddress}.`);
             }
         }
@@ -1468,25 +1348,23 @@
             }
             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(0);
-                incoming.forEach((input) => {
-                    if (!input.isSpent && sumSelectedInputs.isLessThan(amountMutez)) {
-                        const txAmount = convertValueToBigNumber(input.value);
-                        sumSelectedInputs = sumSelectedInputs.plus(txAmount);
-                        const { isSpent: _isSpent } = input, rest = __rest(input, ["isSpent"]);
-                        inputsToSpend.push(rest);
-                    }
-                });
-                if (sumSelectedInputs.isLessThan(new BigNumber(amountMutez))) {
-                    throw new InsufficientBalance(sumSelectedInputs.toString(), amountMutez.toString());
+        async selectInputsToSpend(amountMutez) {
+            const saplingTxViewer = await this.getSaplingTransactionViewer();
+            const { incoming } = await saplingTxViewer.getIncomingAndOutgoingTransactionsRaw();
+            const inputsToSpend = [];
+            let sumSelectedInputs = new BigNumber(0);
+            incoming.forEach((input) => {
+                if (!input.isSpent && sumSelectedInputs.isLessThan(amountMutez)) {
+                    const txAmount = convertValueToBigNumber(input.value);
+                    sumSelectedInputs = sumSelectedInputs.plus(txAmount);
+                    const { isSpent: _isSpent, ...rest } = input;
+                    inputsToSpend.push(rest);
                 }
-                return { inputsToSpend, sumSelectedInputs };
             });
+            if (sumSelectedInputs.isLessThan(new BigNumber(amountMutez))) {
+                throw new InsufficientBalance(sumSelectedInputs.toString(), amountMutez.toString());
+            }
+            return { inputsToSpend, sumSelectedInputs };
         }
     }
     _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();