@taquito/sapling 24.2.0-beta.1 → 24.3.0-beta.0

package/dist/taquito-sapling.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-sapling.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-sapling.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/constants.d.ts

@@ -1,4 +1,4 @@
 export declare const KDF_KEY = "KDFSaplingForTezosV1";
 export declare const OCK_KEY = "OCK_keystringderivation_TEZOS";
 export declare const DEFAULT_MEMO = "";
-export declare const DEFAULT_BOUND_DATA: Buffer;
+export declare const DEFAULT_BOUND_DATA: Buffer<ArrayBuffer>;

package/dist/types/errors.d.ts

@@ -1,16 +1,19 @@
 import { ParameterValidationError, TaquitoError } from '@taquito/core';
 /**
  *  @category Error
- *  @description Error indicates the spending key is invalid
+ *  Error indicates the spending key is invalid
  */
 export declare class InvalidSpendingKey extends ParameterValidationError {
-    readonly sk: string;
+    /**
+     * @deprecated Use `new InvalidSpendingKey(errorDetail)` instead. The spending key argument is ignored for security reasons.
+     */
+    constructor(_sk: string, errorDetail: string);
+    constructor(errorDetail: string);
     readonly errorDetail: string;
-    constructor(sk: string, errorDetail: string);
 }
 /**
  *  @category Error
- *  @description Error indicates an invalid Merkle tree being passed
+ *  Error indicates an invalid Merkle tree being passed
  */
 export declare class InvalidMerkleTreeError extends ParameterValidationError {
     readonly root: string;
@@ -18,7 +21,7 @@ export declare class InvalidMerkleTreeError extends ParameterValidationError {
 }
 /**
  *  @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
  */
 export declare class TreeConstructionFailure extends TaquitoError {
     readonly message: string;
@@ -26,7 +29,7 @@ export declare class TreeConstructionFailure extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error indicates the memo is invalid
+ *  Error indicates the memo is invalid
  */
 export declare class InvalidMemo extends ParameterValidationError {
     readonly memo: string;
@@ -35,7 +38,7 @@ export declare class InvalidMemo extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error indicates not enough balance to prepare the sapling transaction
+ *  Error indicates not enough balance to prepare the sapling transaction
  */
 export declare class InsufficientBalance extends TaquitoError {
     readonly realBalance: string;
@@ -44,7 +47,7 @@ export declare class InsufficientBalance extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error indicates SaplingTransactionViewer failure
+ *  Error indicates SaplingTransactionViewer failure
  */
 export declare class SaplingTransactionViewerError extends TaquitoError {
     readonly message: string;

package/dist/types/sapling-forger/sapling-forger.d.ts

@@ -1,7 +1,7 @@
 import { SaplingTransactionInput, SaplingTransaction, SaplingTransactionOutput, SaplingTransactionPlaintext } from '../types';
 export declare 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
@@ -11,19 +11,19 @@ export declare class SaplingForger {
      */
     forgeSaplingTransaction(tx: SaplingTransaction): Buffer;
     /**
-     * @description Forge list of spend descriptions
+     * Forge list of spend descriptions
      * @param spendDescriptions list of spend descriptions
      * @returns concatenated forged bytes of type Buffer
      */
     forgeSpendDescriptions(spendDescriptions: SaplingTransactionInput[]): Buffer;
     forgeSpendDescription(desc: SaplingTransactionInput): Buffer;
     /**
-     * @description Forge list of output descriptions
+     * Forge list of output descriptions
      * @param outputDescriptions list of output descriptions
      * @returns concatenated forged bytes of type Buffer
      */
     forgeOutputDescriptions(outputDescriptions: SaplingTransactionOutput[]): Buffer;
     forgeOutputDescription(desc: SaplingTransactionOutput): Buffer;
-    forgeUnsignedTxInput(unsignedSpendDescription: Omit<SaplingTransactionInput, 'signature'>): Buffer;
-    forgeTransactionPlaintext(txPlainText: SaplingTransactionPlaintext): Buffer;
+    forgeUnsignedTxInput(unsignedSpendDescription: Omit<SaplingTransactionInput, 'signature'>): Buffer<ArrayBuffer>;
+    forgeTransactionPlaintext(txPlainText: SaplingTransactionPlaintext): Buffer<ArrayBuffer>;
 }

package/dist/types/sapling-keys/helpers.d.ts

@@ -1 +1 @@
-export declare function decryptKey(spendingKey: string, password?: string): Buffer;
+export declare function decryptKey(spendingKey: string, password?: string): Buffer<ArrayBufferLike>;

package/dist/types/sapling-keys/in-memory-proving-key.d.ts

@@ -1,13 +1,13 @@
 import { ParametersSpendProof, SaplingSpendDescription } from '../types';
 /**
- * @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
  */
 export declare class InMemoryProvingKey {
     #private;
     constructor(provingKey: string);
     /**
-     * @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
@@ -19,7 +19,7 @@ export declare class InMemoryProvingKey {
      */
     static fromSpendingKey(spendingKey: string, password?: string): Promise<InMemoryProvingKey>;
     /**
-     * @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
@@ -28,7 +28,6 @@ export declare class InMemoryProvingKey {
      * @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: Omit<ParametersSpendProof, 'spendingKey'>): Promise<Omit<SaplingSpendDescription, 'signature'>>;

package/dist/types/sapling-keys/in-memory-spending-key.d.ts

@@ -1,7 +1,7 @@
 import { InMemoryViewingKey } from './in-memory-viewing-key';
 import { ParametersSpendProof, ParametersSpendSig, SaplingSpendDescription, SaplingTransactionInput } from '../types';
 /**
- * @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
  */
@@ -26,7 +26,7 @@ export declare class InMemorySpendingKey {
      */
     getSaplingViewingKeyProvider(): Promise<InMemoryViewingKey>;
     /**
-     * @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
@@ -34,12 +34,11 @@ export declare class InMemorySpendingKey {
      * @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: ParametersSpendProof): Promise<Omit<SaplingSpendDescription, 'signature'>>;
     /**
-     * @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
@@ -47,7 +46,7 @@ export declare class InMemorySpendingKey {
      */
     signSpendDescription(parametersSpendSig: ParametersSpendSig): Promise<SaplingTransactionInput>;
     /**
-     * @description Return a proof authorizing key from the configured spending key
+     * Return a proof authorizing key from the configured spending key
      */
     getProvingKey(): Promise<string>;
 }

package/dist/types/sapling-keys/in-memory-viewing-key.d.ts

@@ -1,11 +1,11 @@
 /**
- * @description Holds the viewing key
+ * Holds the viewing key
  */
 export declare class InMemoryViewingKey {
     #private;
     constructor(fullViewingKey: string);
     /**
-     * @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
@@ -17,25 +17,25 @@ export declare class InMemoryViewingKey {
      */
     static fromSpendingKey(spendingKey: string, password?: string): Promise<InMemoryViewingKey>;
     /**
-     * @description Retrieve the full viewing key
+     * Retrieve the full viewing key
      * @returns Buffer representing the full viewing key
      *
      */
-    getFullViewingKey(): Buffer;
+    getFullViewingKey(): Buffer<ArrayBufferLike>;
     /**
-     * @description Retrieve the outgoing viewing key
+     * Retrieve the outgoing viewing key
      * @returns Buffer representing the outgoing viewing key
      *
      */
-    getOutgoingViewingKey(): Promise<Buffer>;
+    getOutgoingViewingKey(): Promise<Buffer<ArrayBufferLike>>;
     /**
-     * @description Retrieve the incoming viewing key
+     * Retrieve the incoming viewing key
      * @returns Buffer representing the incoming viewing key
      *
      */
-    getIncomingViewingKey(): Promise<Buffer>;
+    getIncomingViewingKey(): Promise<Buffer<ArrayBufferLike>>;
     /**
-     * @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
      *

package/dist/types/sapling-module-wrapper.d.ts

@@ -1,18 +1,18 @@
 import { ParametersOutputProof } from './types';
 export declare class SaplingWrapper {
     withProvingContext<T>(action: (context: number) => Promise<T>): Promise<T>;
-    getRandomBytes(length: number): Uint8Array;
-    randR(): Promise<Buffer>;
-    getOutgoingViewingKey(vk: Buffer): Promise<Buffer>;
+    getRandomBytes(length: number): Uint8Array<ArrayBufferLike>;
+    randR(): Promise<Buffer<ArrayBufferLike>>;
+    getOutgoingViewingKey(vk: Buffer): Promise<Buffer<ArrayBufferLike>>;
     preparePartialOutputDescription(parametersOutputProof: ParametersOutputProof): Promise<{
-        commitmentValue: Buffer;
-        commitment: Buffer;
-        proof: Buffer;
+        commitmentValue: Buffer<ArrayBufferLike>;
+        commitment: Buffer<ArrayBufferLike>;
+        proof: Buffer<ArrayBufferLike>;
     }>;
-    getDiversifiedFromRawPaymentAddress(decodedDestination: Uint8Array): Promise<Buffer>;
-    deriveEphemeralPublicKey(diversifier: Buffer, esk: Buffer): Promise<Buffer>;
-    getPkdFromRawPaymentAddress(destination: Uint8Array): Promise<Buffer>;
-    keyAgreement(p: Buffer, sk: Buffer): Promise<Buffer>;
-    createBindingSignature(saplingContext: number, balance: string, transactionSigHash: Uint8Array): Promise<Buffer>;
+    getDiversifiedFromRawPaymentAddress(decodedDestination: Uint8Array): Promise<Buffer<ArrayBufferLike>>;
+    deriveEphemeralPublicKey(diversifier: Buffer, esk: Buffer): Promise<Buffer<ArrayBufferLike>>;
+    getPkdFromRawPaymentAddress(destination: Uint8Array): Promise<Buffer<ArrayBufferLike>>;
+    keyAgreement(p: Buffer, sk: Buffer): Promise<Buffer<ArrayBufferLike>>;
+    createBindingSignature(saplingContext: number, balance: string, transactionSigHash: Uint8Array): Promise<Buffer<ArrayBufferLike>>;
     initSaplingParameters(): Promise<void>;
 }

package/dist/types/sapling-state/sapling-state.d.ts

@@ -7,7 +7,7 @@ import { SaplingDiffResponse } from '@taquito/rpc';
 import BigNumber from 'bignumber.js';
 import { SaplingStateTree } from '../types';
 /**
- * @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
  *
  */
 export declare class SaplingState {

package/dist/types/sapling-state/utils.d.ts

@@ -5,7 +5,7 @@
  */
 export declare function pairNodes<T>(leaves: T[]): (T | undefined)[][];
 /**
- * @description helper function to assist in Lazy initializing an object
+ * helper function to assist in Lazy initializing an object
  */
 export declare class Lazy<T> {
     private readonly init;

package/dist/types/sapling-tx-builder/sapling-transactions-builder.d.ts

@@ -15,7 +15,7 @@ export declare class SaplingTransactionBuilder {
     createSaplingTx(saplingTransactionParams: SaplingTransactionParams[], txTotalAmount: BigNumber, boundData: Buffer, chosenInputs: ChosenSpendableInputs): Promise<{
         inputs: SaplingTransactionInput[];
         outputs: SaplingTransactionOutput[];
-        signature: Buffer;
+        signature: Buffer<ArrayBufferLike>;
         balance: BigNumber;
     }>;
     calculateTransactionBalance(inputTotal: string, outputTotal: string): BigNumber;
@@ -26,6 +26,6 @@ export declare class SaplingTransactionBuilder {
         payBackOutput: SaplingTransactionOutput;
         payBackAmount: string;
     }>;
-    createBindingSignature(parametersBindingSig: ParametersBindingSig): Promise<Buffer>;
-    getAntiReplay(): Promise<Buffer>;
+    createBindingSignature(parametersBindingSig: ParametersBindingSig): Promise<Buffer<ArrayBufferLike>>;
+    getAntiReplay(): Promise<Buffer<ArrayBuffer>>;
 }

package/dist/types/sapling-tx-viewer/helpers.d.ts

@@ -7,4 +7,4 @@ export declare function readableFormat(saplingTransactionProperties: Omit<Input,
     paymentAddress: string;
 };
 export declare function convertValueToBigNumber(value: Uint8Array): BigNumber;
-export declare function bufToUint8Array(buffer: Buffer): Uint8Array;
+export declare function bufToUint8Array(buffer: Buffer): Uint8Array<ArrayBufferLike>;

package/dist/types/sapling-tx-viewer/sapling-transaction-viewer.d.ts

@@ -3,7 +3,7 @@ import { InMemoryViewingKey } from '../sapling-keys/in-memory-viewing-key';
 import { Input, SaplingContractId, SaplingIncomingAndOutgoingTransaction } from '../types';
 import { TzReadProvider } from '@taquito/taquito';
 /**
- * @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
@@ -13,14 +13,14 @@ export declare class SaplingTransactionViewer {
     #private;
     constructor(inMemoryViewingKey: InMemoryViewingKey, saplingContractId: SaplingContractId, readProvider: TzReadProvider);
     /**
-     * @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(): Promise<BigNumber>;
     /**
-     * @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
      *
      */
@@ -36,7 +36,7 @@ export declare class SaplingTransactionViewer {
         outgoing: Omit<Input, "position">[];
     }>;
     /**
-     * @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(): Promise<SaplingIncomingAndOutgoingTransaction>;

package/dist/types/taquito-sapling.d.ts

@@ -14,7 +14,7 @@ export { InMemoryViewingKey } from './sapling-keys/in-memory-viewing-key';
 export { InMemorySpendingKey } from './sapling-keys/in-memory-spending-key';
 export { InMemoryProvingKey } from './sapling-keys/in-memory-proving-key';
 /**
- * @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
@@ -42,11 +42,11 @@ export declare class SaplingToolkit {
         saplingProver?: InMemoryProvingKey;
     }, saplingContractDetails: SaplingContractDetails, readProvider: TzReadProvider, packer?: MichelCodecPacker, saplingForger?: SaplingForger, saplingTxBuilder?: SaplingTransactionBuilder);
     /**
-     * @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(): Promise<SaplingTransactionViewer>;
     /**
-     * @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.
@@ -55,7 +55,7 @@ export declare class SaplingToolkit {
      */
     prepareShieldedTransaction(shieldedTxParams: ParametersSaplingTransaction[]): Promise<string>;
     /**
-     * @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.
@@ -63,7 +63,7 @@ export declare class SaplingToolkit {
      */
     prepareUnshieldedTransaction(unshieldedTxParams: ParametersUnshieldedTransaction): Promise<string>;
     /**
-     * @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.

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "@taquito/sapling",
-  "version": "24.2.0-beta.1",
-  "description": "Allows reading and preparing sapling transactions",
+  "version": "24.3.0-beta.0",
+  "description": "Sapling transaction building and viewing support for Taquito.",
   "keywords": [
+    "taquito",
     "tezos",
-    "sapling"
+    "typescript",
+    "sapling",
+    "privacy",
+    "shielded"
   ],
   "main": "dist/taquito-sapling.umd.js",
   "module": "dist/taquito-sapling.es6.js",
@@ -17,14 +21,24 @@
   "publishConfig": {
     "access": "public"
   },
-  "author": "Roxane Letourneau <roxane@ecadlabs.com>",
+  "author": "ECAD Labs Inc <info@ecadlabs.com>",
+  "contributors": [
+    "Davis Sawali <davis.sawali@ecadlabs.com>",
+    "hui-an.yang <hui-an.yang@ecadlabs.com>",
+    "Roxane Letourneau <roxane@ecadlabs.com>",
+    "Jev Björsell (jevonearth)"
+  ],
+  "homepage": "https://taquito.io/",
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "git+https://github.com/ecadlabs/taquito.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ecadlabs/taquito/issues"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "scripts": {
     "test": "jest --coverage",
@@ -68,10 +82,10 @@
     "@airgap/sapling-wasm": "0.0.9",
     "@stablelib/nacl": "^1.0.4",
     "@stablelib/random": "^1.0.2",
-    "@taquito/core": "^24.2.0-beta.1",
-    "@taquito/rpc": "^24.2.0-beta.1",
-    "@taquito/taquito": "^24.2.0-beta.1",
-    "@taquito/utils": "^24.2.0-beta.1",
+    "@taquito/core": "^24.3.0-beta.0",
+    "@taquito/rpc": "^24.3.0-beta.0",
+    "@taquito/taquito": "^24.3.0-beta.0",
+    "@taquito/utils": "^24.3.0-beta.0",
     "bignumber.js": "^9.1.2",
     "bip39": "3.1.0",
     "blakejs": "^1.2.1",
@@ -103,7 +117,6 @@
     "shelljs": "^0.8.5",
     "ts-jest": "^29.2.3",
     "ts-node": "^10.9.2",
-    "typescript": "~5.5.4"
-  },
-  "gitHead": "96cefc251b1f16b14f9dedfb2eecda3dbeb2a829"
+    "typescript": "^5.9.3"
+  }
 }