@taquito/sapling 17.3.2 → 17.4.0-beta-RC.0

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

@@ -1,53 +1,53 @@
-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
- * can instantiate from mnemonic word list or decrypt a encrypted spending key
- * with access to instantiate a InMemoryViewingKey
- */
-export declare class InMemorySpendingKey {
-    #private;
-    /**
-     *
-     * @param spendingKey unencrypted sask... or encrypted MMXj...
-     * @param password required for MMXj encrypted keys
-     */
-    constructor(spendingKey: string, password?: string);
-    /**
-     *
-     * @param mnemonic string of words
-     * @param derivationPath tezos current standard 'm/'
-     * @returns InMemorySpendingKey class instantiated
-     */
-    static fromMnemonic(mnemonic: string, derivationPath?: string): Promise<InMemorySpendingKey>;
-    /**
-     *
-     * @returns InMemoryViewingKey instantiated class
-     */
-    getSaplingViewingKeyProvider(): Promise<InMemoryViewingKey>;
-    /**
-     * @description 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
-     * @param parametersSpendProof.publicKeyReRandomization The re-randomization of the public key
-     * @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
-     * @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: ParametersSpendSig): Promise<SaplingTransactionInput>;
-    /**
-     * @description Return a proof authorizing key from the configured spending key
-     */
-    getProvingKey(): Promise<string>;
-}
+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
+ * can instantiate from mnemonic word list or decrypt a encrypted spending key
+ * with access to instantiate a InMemoryViewingKey
+ */
+export declare class InMemorySpendingKey {
+    #private;
+    /**
+     *
+     * @param spendingKey unencrypted sask... or encrypted MMXj...
+     * @param password required for MMXj encrypted keys
+     */
+    constructor(spendingKey: string, password?: string);
+    /**
+     *
+     * @param mnemonic string of words
+     * @param derivationPath tezos current standard 'm/'
+     * @returns InMemorySpendingKey class instantiated
+     */
+    static fromMnemonic(mnemonic: string, derivationPath?: string): Promise<InMemorySpendingKey>;
+    /**
+     *
+     * @returns InMemoryViewingKey instantiated class
+     */
+    getSaplingViewingKeyProvider(): Promise<InMemoryViewingKey>;
+    /**
+     * @description 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
+     * @param parametersSpendProof.publicKeyReRandomization The re-randomization of the public key
+     * @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
+     * @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: ParametersSpendSig): Promise<SaplingTransactionInput>;
+    /**
+     * @description 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,48 +1,48 @@
-/// <reference types="node" />
-/**
- * @description Holds the viewing key
- */
-export declare class InMemoryViewingKey {
-    #private;
-    constructor(fullViewingKey: string);
-    /**
-     * @description 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
-     * @example
-     * ```
-     * await InMemoryViewingKey.fromSpendingKey('sask27SLmU9herddHz4qFJBLMjWYMbJF8RtS579w9ej9mfCYK7VUdyCJPHK8AzW9zMsopGZEkYeNjAY7Zz1bkM7CGu8eKLzrjBLTMC5wWJDhxiK91ahA29rhDRsHdJDV2u2jFwb2MNUix8JW7sAkAqYVaJpCehTBPgRQ1KqKwqqUaNmuD8kazd4Q8MCWmgbWs21Yuomdqyi9FLigjRp7oY4m5adaVU19Nj1AHvsMY2tePeU2L')
-     * ```
-     *
-     */
-    static fromSpendingKey(spendingKey: string, password?: string): Promise<InMemoryViewingKey>;
-    /**
-     * @description Retrieve the full viewing key
-     * @returns Buffer representing the full viewing key
-     *
-     */
-    getFullViewingKey(): Buffer;
-    /**
-     * @description Retrieve the outgoing viewing key
-     * @returns Buffer representing the outgoing viewing key
-     *
-     */
-    getOutgoingViewingKey(): Promise<Buffer>;
-    /**
-     * @description Retrieve the incoming viewing key
-     * @returns Buffer representing the incoming viewing key
-     *
-     */
-    getIncomingViewingKey(): Promise<Buffer>;
-    /**
-     * @description 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?: number): Promise<{
-        address: string;
-        addressIndex: number;
-    }>;
-}
+/// <reference types="node" />
+/**
+ * @description Holds the viewing key
+ */
+export declare class InMemoryViewingKey {
+    #private;
+    constructor(fullViewingKey: string);
+    /**
+     * @description 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
+     * @example
+     * ```
+     * await InMemoryViewingKey.fromSpendingKey('sask27SLmU9herddHz4qFJBLMjWYMbJF8RtS579w9ej9mfCYK7VUdyCJPHK8AzW9zMsopGZEkYeNjAY7Zz1bkM7CGu8eKLzrjBLTMC5wWJDhxiK91ahA29rhDRsHdJDV2u2jFwb2MNUix8JW7sAkAqYVaJpCehTBPgRQ1KqKwqqUaNmuD8kazd4Q8MCWmgbWs21Yuomdqyi9FLigjRp7oY4m5adaVU19Nj1AHvsMY2tePeU2L')
+     * ```
+     *
+     */
+    static fromSpendingKey(spendingKey: string, password?: string): Promise<InMemoryViewingKey>;
+    /**
+     * @description Retrieve the full viewing key
+     * @returns Buffer representing the full viewing key
+     *
+     */
+    getFullViewingKey(): Buffer;
+    /**
+     * @description Retrieve the outgoing viewing key
+     * @returns Buffer representing the outgoing viewing key
+     *
+     */
+    getOutgoingViewingKey(): Promise<Buffer>;
+    /**
+     * @description Retrieve the incoming viewing key
+     * @returns Buffer representing the incoming viewing key
+     *
+     */
+    getIncomingViewingKey(): Promise<Buffer>;
+    /**
+     * @description 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?: number): Promise<{
+        address: string;
+        addressIndex: number;
+    }>;
+}

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

@@ -1,19 +1,19 @@
-/// <reference types="node" />
-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>;
-    preparePartialOutputDescription(parametersOutputProof: ParametersOutputProof): Promise<{
-        commitmentValue: Buffer;
-        commitment: Buffer;
-        proof: Buffer;
-    }>;
-    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>;
-    initSaplingParameters(): Promise<void>;
-}
+/// <reference types="node" />
+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>;
+    preparePartialOutputDescription(parametersOutputProof: ParametersOutputProof): Promise<{
+        commitmentValue: Buffer;
+        commitment: Buffer;
+        proof: Buffer;
+    }>;
+    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>;
+    initSaplingParameters(): Promise<void>;
+}

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

@@ -1,56 +1,56 @@
-/**
- * Some code in this file was originally written or inspired by Airgap-it
- * https://github.com/airgap-it/airgap-coin-lib/blob/master/LICENSE.md
- *
- */
-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
- *
- */
-export declare class SaplingState {
-    readonly height: number;
-    private stateTree;
-    private readonly uncommittedMerkleHash;
-    private readonly uncommittedMerkleHashes;
-    constructor(height: number);
-    getStateTree(stateDiff: SaplingDiffResponse, constructTree?: boolean): Promise<SaplingStateTree>;
-    /**
-     *
-     * @param stateTree stateTree parameter that holds information details on our Merkle tree
-     * @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: SaplingStateTree, position: BigNumber): Promise<string>;
-    /**
-     *
-     * @param leaves array of leaves or nodes that we want to construct the Merkle tree from
-     * @param height height of the desired Merkle tree
-     * @returns a promise of MerkleTree type object
-     */
-    private constructMerkleTree;
-    private getMerkleHash;
-    /**
-     *
-     * @returns hashes of empty or null values to fill in the Merkle tree
-     */
-    private createUncommittedMerkleHashes;
-    /**
-     *
-     * @param tree Merkle tree to validate
-     * @param expectedRoot the expected merkle root to validate against
-     * @throws {@link InvalidMerkleTreeError}
-     */
-    private validateMerkleTree;
-    /**
-     *
-     * @param acc accumulator variable for the recursive function
-     * @param height height of the tree
-     * @param position position of the hash we would like find the neighbours of
-     * @param tree the Merkle tree that we want to traverse
-     * @returns the accumulated Buffer array of neighbouring hashes
-     */
-    private getNeighbouringHashes;
-}
+/**
+ * Some code in this file was originally written or inspired by Airgap-it
+ * https://github.com/airgap-it/airgap-coin-lib/blob/master/LICENSE.md
+ *
+ */
+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
+ *
+ */
+export declare class SaplingState {
+    readonly height: number;
+    private stateTree;
+    private readonly uncommittedMerkleHash;
+    private readonly uncommittedMerkleHashes;
+    constructor(height: number);
+    getStateTree(stateDiff: SaplingDiffResponse, constructTree?: boolean): Promise<SaplingStateTree>;
+    /**
+     *
+     * @param stateTree stateTree parameter that holds information details on our Merkle tree
+     * @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: SaplingStateTree, position: BigNumber): Promise<string>;
+    /**
+     *
+     * @param leaves array of leaves or nodes that we want to construct the Merkle tree from
+     * @param height height of the desired Merkle tree
+     * @returns a promise of MerkleTree type object
+     */
+    private constructMerkleTree;
+    private getMerkleHash;
+    /**
+     *
+     * @returns hashes of empty or null values to fill in the Merkle tree
+     */
+    private createUncommittedMerkleHashes;
+    /**
+     *
+     * @param tree Merkle tree to validate
+     * @param expectedRoot the expected merkle root to validate against
+     * @throws {@link InvalidMerkleTreeError}
+     */
+    private validateMerkleTree;
+    /**
+     *
+     * @param acc accumulator variable for the recursive function
+     * @param height height of the tree
+     * @param position position of the hash we would like find the neighbours of
+     * @param tree the Merkle tree that we want to traverse
+     * @returns the accumulated Buffer array of neighbouring hashes
+     */
+    private getNeighbouringHashes;
+}

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

@@ -1,22 +1,22 @@
-/**
- *
- * @param leaves nodes in the tree that we would like to make pairs from
- * @returns a paired/chunked array: [a, b, c, d] => [[a, b], [c, d]]
- */
-export declare function pairNodes<T>(leaves: T[]): (T | undefined)[][];
-/**
- * @description helper function to assist in Lazy initializing an object
- */
-export declare class Lazy<T> {
-    private readonly init;
-    private isInitialized;
-    private value?;
-    constructor(init: () => Promise<T>);
-    get(): Promise<T>;
-}
-/**
- *
- * @param hex hexadecimal string we would like to swap
- * @returns a hexadecimal string with swapped endians
- */
-export declare const changeEndianness: (hex: string) => string;
+/**
+ *
+ * @param leaves nodes in the tree that we would like to make pairs from
+ * @returns a paired/chunked array: [a, b, c, d] => [[a, b], [c, d]]
+ */
+export declare function pairNodes<T>(leaves: T[]): (T | undefined)[][];
+/**
+ * @description helper function to assist in Lazy initializing an object
+ */
+export declare class Lazy<T> {
+    private readonly init;
+    private isInitialized;
+    private value?;
+    constructor(init: () => Promise<T>);
+    get(): Promise<T>;
+}
+/**
+ *
+ * @param hex hexadecimal string we would like to swap
+ * @returns a hexadecimal string with swapped endians
+ */
+export declare const changeEndianness: (hex: string) => string;

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

@@ -1,32 +1,32 @@
-/// <reference types="node" />
-import { SaplingForger } from '../sapling-forger/sapling-forger';
-import BigNumber from 'bignumber.js';
-import { Input, SaplingTransactionOutput, SaplingTransactionInput, ParametersBindingSig, ChosenSpendableInputs, ParametersOutputDescription, ParametersCiphertext, Ciphertext, SaplingContractDetails, SaplingTransaction, SaplingTransactionParams } from '../types';
-import { TzReadProvider } from '@taquito/taquito';
-import { SaplingWrapper } from '../sapling-module-wrapper';
-import { InMemorySpendingKey } from '../sapling-keys/in-memory-spending-key';
-import { InMemoryProvingKey } from '../sapling-keys/in-memory-proving-key';
-export declare class SaplingTransactionBuilder {
-    #private;
-    constructor(keys: {
-        saplingSigner: InMemorySpendingKey;
-        saplingProver?: InMemoryProvingKey;
-    }, saplingForger: SaplingForger, saplingContractDetails: SaplingContractDetails, readProvider: TzReadProvider, saplingWrapper?: SaplingWrapper);
-    createShieldedTx(saplingTransactionParams: SaplingTransactionParams[], txTotalAmount: BigNumber, boundData: Buffer): Promise<Pick<SaplingTransaction, 'inputs' | 'outputs' | 'signature' | 'balance'>>;
-    createSaplingTx(saplingTransactionParams: SaplingTransactionParams[], txTotalAmount: BigNumber, boundData: Buffer, chosenInputs: ChosenSpendableInputs): Promise<{
-        inputs: SaplingTransactionInput[];
-        outputs: SaplingTransactionOutput[];
-        signature: Buffer;
-        balance: BigNumber;
-    }>;
-    calculateTransactionBalance(inputTotal: string, outputTotal: string): BigNumber;
-    prepareSaplingOutputDescription(parametersOutputDescription: ParametersOutputDescription): Promise<SaplingTransactionOutput>;
-    prepareSaplingSpendDescription(saplingContext: number, inputsToSpend: Input[]): Promise<SaplingTransactionInput[]>;
-    encryptCiphertext(parametersCiphertext: ParametersCiphertext): Promise<Pick<Ciphertext, 'payloadEnc' | 'nonceEnc' | 'payloadOut' | 'nonceOut'>>;
-    createPaybackOutput(params: ParametersOutputDescription, sumSelectedInputs: BigNumber): Promise<{
-        payBackOutput: SaplingTransactionOutput;
-        payBackAmount: string;
-    }>;
-    createBindingSignature(parametersBindingSig: ParametersBindingSig): Promise<Buffer>;
-    getAntiReplay(): Promise<Buffer>;
-}
+/// <reference types="node" />
+import { SaplingForger } from '../sapling-forger/sapling-forger';
+import BigNumber from 'bignumber.js';
+import { Input, SaplingTransactionOutput, SaplingTransactionInput, ParametersBindingSig, ChosenSpendableInputs, ParametersOutputDescription, ParametersCiphertext, Ciphertext, SaplingContractDetails, SaplingTransaction, SaplingTransactionParams } from '../types';
+import { TzReadProvider } from '@taquito/taquito';
+import { SaplingWrapper } from '../sapling-module-wrapper';
+import { InMemorySpendingKey } from '../sapling-keys/in-memory-spending-key';
+import { InMemoryProvingKey } from '../sapling-keys/in-memory-proving-key';
+export declare class SaplingTransactionBuilder {
+    #private;
+    constructor(keys: {
+        saplingSigner: InMemorySpendingKey;
+        saplingProver?: InMemoryProvingKey;
+    }, saplingForger: SaplingForger, saplingContractDetails: SaplingContractDetails, readProvider: TzReadProvider, saplingWrapper?: SaplingWrapper);
+    createShieldedTx(saplingTransactionParams: SaplingTransactionParams[], txTotalAmount: BigNumber, boundData: Buffer): Promise<Pick<SaplingTransaction, 'inputs' | 'outputs' | 'signature' | 'balance'>>;
+    createSaplingTx(saplingTransactionParams: SaplingTransactionParams[], txTotalAmount: BigNumber, boundData: Buffer, chosenInputs: ChosenSpendableInputs): Promise<{
+        inputs: SaplingTransactionInput[];
+        outputs: SaplingTransactionOutput[];
+        signature: Buffer;
+        balance: BigNumber;
+    }>;
+    calculateTransactionBalance(inputTotal: string, outputTotal: string): BigNumber;
+    prepareSaplingOutputDescription(parametersOutputDescription: ParametersOutputDescription): Promise<SaplingTransactionOutput>;
+    prepareSaplingSpendDescription(saplingContext: number, inputsToSpend: Input[]): Promise<SaplingTransactionInput[]>;
+    encryptCiphertext(parametersCiphertext: ParametersCiphertext): Promise<Pick<Ciphertext, 'payloadEnc' | 'nonceEnc' | 'payloadOut' | 'nonceOut'>>;
+    createPaybackOutput(params: ParametersOutputDescription, sumSelectedInputs: BigNumber): Promise<{
+        payBackOutput: SaplingTransactionOutput;
+        payBackAmount: string;
+    }>;
+    createBindingSignature(parametersBindingSig: ParametersBindingSig): Promise<Buffer>;
+    getAntiReplay(): Promise<Buffer>;
+}

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

@@ -1,11 +1,11 @@
-/// <reference types="node" />
-import BigNumber from 'bignumber.js';
-import { Input } from '../types';
-export declare function memoHexToUtf8(memo: string): string;
-export declare function readableFormat(saplingTransactionProperties: Omit<Input, 'position'>): {
-    value: BigNumber;
-    memo: string;
-    paymentAddress: string;
-};
-export declare function convertValueToBigNumber(value: Uint8Array): BigNumber;
-export declare function bufToUint8Array(buffer: Buffer): Uint8Array;
+/// <reference types="node" />
+import BigNumber from 'bignumber.js';
+import { Input } from '../types';
+export declare function memoHexToUtf8(memo: string): string;
+export declare function readableFormat(saplingTransactionProperties: Omit<Input, 'position'>): {
+    value: BigNumber;
+    memo: string;
+    paymentAddress: string;
+};
+export declare function convertValueToBigNumber(value: Uint8Array): BigNumber;
+export declare function bufToUint8Array(buffer: Buffer): Uint8Array;

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

@@ -1,50 +1,50 @@
-import BigNumber from 'bignumber.js';
-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
- *
- * @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
- * @param readProvider Allows to read data from the blockchain
- */
-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
-     *
-     * @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.
-     * The response properties are in Uint8Array format; use the getIncomingAndOutgoingTransactions method for readable properties
-     *
-     */
-    getIncomingAndOutgoingTransactionsRaw(): Promise<{
-        incoming: {
-            isSpent: boolean;
-            position: number;
-            value: Uint8Array;
-            memo: Uint8Array;
-            paymentAddress: Uint8Array;
-            randomCommitmentTrapdoor: Uint8Array;
-        }[];
-        outgoing: Omit<Input, "position">[];
-    }>;
-    /**
-     * @description Retrieve all the incoming and outgoing decoded transactions associated with the configured viewing key
-     *
-     */
-    getIncomingAndOutgoingTransactions(): Promise<SaplingIncomingAndOutgoingTransaction>;
-    private getSaplingDiff;
-    private decryptCiphertextAsReceiver;
-    private decryptCiphertextAsSender;
-    private decryptCiphertext;
-    private extractTransactionProperties;
-    private extractPkdAndEsk;
-    private isSpent;
-}
+import BigNumber from 'bignumber.js';
+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
+ *
+ * @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
+ * @param readProvider Allows to read data from the blockchain
+ */
+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
+     *
+     * @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.
+     * The response properties are in Uint8Array format; use the getIncomingAndOutgoingTransactions method for readable properties
+     *
+     */
+    getIncomingAndOutgoingTransactionsRaw(): Promise<{
+        incoming: {
+            isSpent: boolean;
+            position: number;
+            value: Uint8Array;
+            memo: Uint8Array;
+            paymentAddress: Uint8Array;
+            randomCommitmentTrapdoor: Uint8Array;
+        }[];
+        outgoing: Omit<Input, "position">[];
+    }>;
+    /**
+     * @description Retrieve all the incoming and outgoing decoded transactions associated with the configured viewing key
+     *
+     */
+    getIncomingAndOutgoingTransactions(): Promise<SaplingIncomingAndOutgoingTransaction>;
+    private getSaplingDiff;
+    private decryptCiphertextAsReceiver;
+    private decryptCiphertextAsSender;
+    private decryptCiphertext;
+    private extractTransactionProperties;
+    private extractPkdAndEsk;
+    private isSpent;
+}