@midnight-ntwrk/wallet-sdk-facade 1.0.0-beta.16 → 1.0.0-beta.17

package/dist/index.d.ts

@@ -4,6 +4,16 @@ import { type UnshieldedWallet, UnshieldedWalletState } from '@midnight-ntwrk/wa
 import { AnyTransaction, DustWallet, DustWalletState, CoinsAndBalances as DustCoinsAndBalances } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
 export type UnboundTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.PreBinding>;
+type TokenKind = 'dust' | 'shielded' | 'unshielded';
+type TokenKindsToBalance = 'all' | TokenKind[];
+declare const TokenKindsToBalance: {
+    allTokenKinds: string[];
+    toFlags: (tokenKinds: TokenKindsToBalance) => {
+        shouldBalanceUnshielded: boolean;
+        shouldBalanceShielded: boolean;
+        shouldBalanceDust: boolean;
+    };
+};
 export type FinalizedTransactionRecipe = {
     type: 'FINALIZED_TRANSACTION';
     originalTransaction: ledger.FinalizedTransaction;
@@ -12,7 +22,7 @@ export type FinalizedTransactionRecipe = {
 export type UnboundTransactionRecipe = {
     type: 'UNBOUND_TRANSACTION';
     baseTransaction: UnboundTransaction;
-    balancingTransaction: ledger.UnprovenTransaction;
+    balancingTransaction?: ledger.UnprovenTransaction | undefined;
 };
 export type UnprovenTransactionRecipe = {
     type: 'UNPROVEN_TRANSACTION';
@@ -58,22 +68,54 @@ export declare class WalletFacade {
     state(): Observable<FacadeState>;
     waitForSyncedState(): Promise<FacadeState>;
     submitTransaction(tx: ledger.FinalizedTransaction): Promise<TransactionIdentifier>;
-    balanceFinalizedTransaction(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKeys: ledger.DustSecretKey, tx: ledger.FinalizedTransaction, ttl: Date): Promise<FinalizedTransactionRecipe>;
-    balanceUnboundTransaction(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKeys: ledger.DustSecretKey, tx: UnboundTransaction, ttl: Date): Promise<UnboundTransactionRecipe>;
-    balanceUnprovenTransaction(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKeys: ledger.DustSecretKey, tx: ledger.UnprovenTransaction, ttl: Date): Promise<UnprovenTransactionRecipe>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction, secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        tokenKindsToBalance?: TokenKindsToBalance;
+    }): Promise<FinalizedTransactionRecipe>;
+    balanceUnboundTransaction(tx: UnboundTransaction, secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        tokenKindsToBalance?: TokenKindsToBalance;
+    }): Promise<UnboundTransactionRecipe>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction, secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        tokenKindsToBalance?: TokenKindsToBalance;
+    }): Promise<UnprovenTransactionRecipe>;
     finalizeRecipe(recipe: BalancingRecipe): Promise<ledger.FinalizedTransaction>;
     signRecipe(recipe: BalancingRecipe, signSegment: (data: Uint8Array) => ledger.Signature): Promise<BalancingRecipe>;
-    signTransaction(tx: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    signUnprovenTransaction(tx: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    signUnboundTransaction(tx: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;
     finalizeTransaction(tx: ledger.UnprovenTransaction): Promise<ledger.FinalizedTransaction>;
     calculateTransactionFee(tx: AnyTransaction): Promise<bigint>;
-    transferTransaction(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKey: ledger.DustSecretKey, outputs: CombinedTokenTransfer[], ttl: Date): Promise<UnprovenTransactionRecipe>;
+    transferTransaction(outputs: CombinedTokenTransfer[], secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        payFees?: boolean;
+    }): Promise<UnprovenTransactionRecipe>;
     estimateRegistration(nightUtxos: readonly UtxoWithMeta[]): Promise<{
         fee: bigint;
         dustGenerationEstimations: ReadonlyArray<DustCoinsAndBalances.UtxoWithFullDustDetails>;
     }>;
-    initSwap(zswapSecretKeys: ledger.ZswapSecretKeys, desiredInputs: CombinedSwapInputs, desiredOutputs: CombinedSwapOutputs[], ttl: Date): Promise<UnprovenTransactionRecipe>;
+    initSwap(desiredInputs: CombinedSwapInputs, desiredOutputs: CombinedSwapOutputs[], secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        payFees?: boolean;
+    }): Promise<UnprovenTransactionRecipe>;
     registerNightUtxosForDustGeneration(nightUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature, dustReceiverAddress?: string): Promise<UnprovenTransactionRecipe>;
     deregisterFromDustGeneration(nightUtxos: UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature): Promise<UnprovenTransactionRecipe>;
-    start(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKey: ledger.DustSecretKey): Promise<void>;
+    start(shieldedSecretKeys: ledger.ZswapSecretKeys, dustSecretKey: ledger.DustSecretKey): Promise<void>;
     stop(): Promise<void>;
 }
+export {};

package/dist/index.js

@@ -13,6 +13,16 @@
 import { combineLatest, map } from 'rxjs';
 import { Array as Arr, pipe } from 'effect';
 import * as ledger from '@midnight-ntwrk/ledger-v7';
+const TokenKindsToBalance = new (class {
+    allTokenKinds = ['shielded', 'unshielded', 'dust'];
+    toFlags = (tokenKinds) => {
+        return pipe(tokenKinds, (kinds) => (kinds === 'all' ? this.allTokenKinds : kinds), (kinds) => ({
+            shouldBalanceUnshielded: kinds.includes('unshielded'),
+            shouldBalanceShielded: kinds.includes('shielded'),
+            shouldBalanceDust: kinds.includes('dust'),
+        }));
+    };
+})();
 export class FacadeState {
     shielded;
     unshielded;
@@ -72,53 +82,89 @@ export class WalletFacade {
         await this.shielded.submitTransaction(tx, 'Finalized');
         return tx.identifiers().at(-1);
     }
-    async balanceFinalizedTransaction(zswapSecretKeys, dustSecretKeys, tx, ttl) {
-        const unshieldedBalancing = await this.unshielded.balanceFinalizedTransaction(tx);
-        const shieldedBalancing = await this.shielded.balanceTransaction(zswapSecretKeys, tx);
-        const mergedBalancing = this.mergeUnprovenTransactions(shieldedBalancing, unshieldedBalancing);
-        const feeBalancingTransaction = await this.dust.balanceTransactions(dustSecretKeys, mergedBalancing ? [tx, mergedBalancing] : [tx], ttl);
-        const balancingTransaction = mergedBalancing
-            ? mergedBalancing.merge(feeBalancingTransaction)
-            : feeBalancingTransaction;
+    async balanceFinalizedTransaction(tx, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, tokenKindsToBalance = 'all' } = options;
+        const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+        // Step 1: Run unshielded and shielded balancing
+        const unshieldedBalancingTx = shouldBalanceUnshielded
+            ? await this.unshielded.balanceFinalizedTransaction(tx)
+            : undefined;
+        const shieldedBalancingTx = shouldBalanceShielded
+            ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx)
+            : undefined;
+        // Step 2: Merge unshielded and shielded balancing
+        const mergedBalancingTx = this.mergeUnprovenTransactions(shieldedBalancingTx, unshieldedBalancingTx);
+        // Step 3: Conditionally add dust/fee balancing
+        const feeBalancingTx = shouldBalanceDust
+            ? await this.dust.balanceTransactions(dustSecretKey, mergedBalancingTx ? [tx, mergedBalancingTx] : [tx], ttl)
+            : undefined;
+        // Step 4: Merge fee balancing and create final recipe
+        const balancingTx = this.mergeUnprovenTransactions(mergedBalancingTx, feeBalancingTx);
+        if (!balancingTx) {
+            throw new Error('No balancing transaction was created. Please check your transaction.');
+        }
         return {
             type: 'FINALIZED_TRANSACTION',
             originalTransaction: tx,
-            balancingTransaction,
+            balancingTransaction: balancingTx,
         };
     }
-    async balanceUnboundTransaction(zswapSecretKeys, dustSecretKeys, tx, ttl) {
+    async balanceUnboundTransaction(tx, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, tokenKindsToBalance = 'all' } = options;
+        const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+        // Step 1: Run unshielded and shielded balancing
+        const shieldedBalancingTx = shouldBalanceShielded
+            ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx)
+            : undefined;
         // For unbound transactions, unshielded balancing happens in place not with a balancing transaction
-        const balancedUnshieldedTx = await this.unshielded.balanceUnboundTransaction(tx);
-        const shieldedBalancingTx = await this.shielded.balanceTransaction(zswapSecretKeys, tx);
-        // unbound unshielded tx are balanced in place, check if balancedUnshieldedTx is present and use it as base tx
+        const balancedUnshieldedTx = shouldBalanceUnshielded
+            ? await this.unshielded.balanceUnboundTransaction(tx)
+            : undefined;
+        // Step 2: Unbound unshielded tx are balanced in place, use it as base tx if present
         const baseTx = balancedUnshieldedTx ?? tx;
-        // Add fee payment - pass shielded balancing if present, otherwise just calculate fee for base tx
-        const transactionsToPayFeesFor = shieldedBalancingTx ? [baseTx, shieldedBalancingTx] : [baseTx];
-        const feeBalancingTransaction = await this.dust.balanceTransactions(dustSecretKeys, transactionsToPayFeesFor, ttl);
-        // Create the final balancing transaction
-        const balancingTransaction = shieldedBalancingTx
-            ? shieldedBalancingTx.merge(feeBalancingTransaction)
-            : feeBalancingTransaction;
+        // Step 3: Conditionally add dust/fee balancing
+        const feeBalancingTransaction = shouldBalanceDust
+            ? await this.dust.balanceTransactions(dustSecretKey, shieldedBalancingTx ? [baseTx, shieldedBalancingTx] : [baseTx], ttl)
+            : undefined;
+        // Step 4: Create the final balancing transaction
+        const balancingTransaction = this.mergeUnprovenTransactions(shieldedBalancingTx, feeBalancingTransaction);
+        // if there is no balancingTransaction and there was no unshielded tx balancing (in place) throw an error.
+        if (!balancingTransaction && !balancedUnshieldedTx) {
+            throw new Error('No balancing transaction was created. Please check your transaction.');
+        }
         return {
             type: 'UNBOUND_TRANSACTION',
             baseTransaction: baseTx,
-            balancingTransaction,
+            balancingTransaction: balancingTransaction ?? undefined,
         };
     }
-    async balanceUnprovenTransaction(zswapSecretKeys, dustSecretKeys, tx, ttl) {
+    async balanceUnprovenTransaction(tx, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, tokenKindsToBalance = 'all' } = options;
+        const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+        // Step 1: Run unshielded and shielded balancing
+        const shieldedBalancingTx = shouldBalanceShielded
+            ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx)
+            : undefined;
         // For unproven transactions, unshielded balancing happens in place
-        const balancedUnshieldedTx = await this.unshielded.balanceUnprovenTransaction(tx);
-        const shieldedBalancingTx = await this.shielded.balanceTransaction(zswapSecretKeys, tx);
-        // Use the balanced unshielded tx if present, otherwise use the original tx
+        const balancedUnshieldedTx = shouldBalanceUnshielded
+            ? await this.unshielded.balanceUnprovenTransaction(tx)
+            : undefined;
+        // Step 2: Use the balanced unshielded tx if present, otherwise use the original tx
         const baseTx = balancedUnshieldedTx ?? tx;
-        // Merge shielded balancing into base tx if present
-        const mergedTx = shieldedBalancingTx ? baseTx.merge(shieldedBalancingTx) : baseTx;
-        // Add fee payment
-        const feeBalancingTransaction = await this.dust.balanceTransactions(dustSecretKeys, [mergedTx], ttl);
-        const balancedTransaction = mergedTx.merge(feeBalancingTransaction);
+        // Step 3: Merge shielded balancing into base tx if present
+        const mergedTx = this.mergeUnprovenTransactions(baseTx, shieldedBalancingTx);
+        // Step 4: Conditionally add dust/fee balancing
+        const feeBalancingTx = shouldBalanceDust
+            ? await this.dust.balanceTransactions(dustSecretKey, [mergedTx], ttl)
+            : undefined;
+        // Step 5: Merge fee balancing if present
+        const balancedTx = this.mergeUnprovenTransactions(mergedTx, feeBalancingTx);
         return {
             type: 'UNPROVEN_TRANSACTION',
-            transaction: balancedTransaction,
+            transaction: balancedTx,
         };
     }
     async finalizeRecipe(recipe) {
@@ -128,9 +174,11 @@ export class WalletFacade {
                 return recipe.originalTransaction.merge(finalizedBalancing);
             }
             case 'UNBOUND_TRANSACTION': {
-                const finalizedBalancingTx = await this.finalizeTransaction(recipe.balancingTransaction);
+                const finalizedBalancingTx = recipe.balancingTransaction
+                    ? await this.finalizeTransaction(recipe.balancingTransaction)
+                    : undefined;
                 const finalizedTransaction = recipe.baseTransaction.bind();
-                return finalizedTransaction.merge(finalizedBalancingTx);
+                return finalizedBalancingTx ? finalizedTransaction.merge(finalizedBalancingTx) : finalizedTransaction;
             }
             case 'UNPROVEN_TRANSACTION': {
                 return await this.finalizeTransaction(recipe.transaction);
@@ -140,32 +188,38 @@ export class WalletFacade {
     async signRecipe(recipe, signSegment) {
         switch (recipe.type) {
             case 'FINALIZED_TRANSACTION': {
-                const signedBalancing = await this.signTransaction(recipe.balancingTransaction, signSegment);
+                const signedBalancingTx = await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment);
                 return {
                     type: 'FINALIZED_TRANSACTION',
                     originalTransaction: recipe.originalTransaction,
-                    balancingTransaction: signedBalancing,
+                    balancingTransaction: signedBalancingTx,
                 };
             }
             case 'UNBOUND_TRANSACTION': {
-                const signedBalancing = await this.signTransaction(recipe.balancingTransaction, signSegment);
+                const signedBalancingTx = recipe.balancingTransaction
+                    ? await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment)
+                    : undefined;
+                const signedBaseTx = await this.signUnboundTransaction(recipe.baseTransaction, signSegment);
                 return {
                     type: 'UNBOUND_TRANSACTION',
-                    baseTransaction: recipe.baseTransaction,
-                    balancingTransaction: signedBalancing,
+                    baseTransaction: signedBaseTx,
+                    balancingTransaction: signedBalancingTx,
                 };
             }
             case 'UNPROVEN_TRANSACTION': {
-                const signedTransaction = await this.signTransaction(recipe.transaction, signSegment);
+                const signedTx = await this.signUnprovenTransaction(recipe.transaction, signSegment);
                 return {
                     type: 'UNPROVEN_TRANSACTION',
-                    transaction: signedTransaction,
+                    transaction: signedTx,
                 };
             }
         }
     }
-    async signTransaction(tx, signSegment) {
-        return await this.unshielded.signTransaction(tx, signSegment);
+    async signUnprovenTransaction(tx, signSegment) {
+        return await this.unshielded.signUnprovenTransaction(tx, signSegment);
+    }
+    async signUnboundTransaction(tx, signSegment) {
+        return await this.unshielded.signUnboundTransaction(tx, signSegment);
     }
     async finalizeTransaction(tx) {
         return await this.shielded.finalizeTransaction(tx);
@@ -173,7 +227,9 @@ export class WalletFacade {
     async calculateTransactionFee(tx) {
         return await this.dust.calculateFee([tx]);
     }
-    async transferTransaction(zswapSecretKeys, dustSecretKey, outputs, ttl) {
+    async transferTransaction(outputs, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, payFees = true } = options;
         const unshieldedOutputs = outputs
             .filter((output) => output.type === 'unshielded')
             .flatMap((output) => output.outputs);
@@ -181,20 +237,17 @@ export class WalletFacade {
         if (unshieldedOutputs.length === 0 && shieldedOutputs.length === 0) {
             throw Error('At least one shielded or unshielded output is required.');
         }
-        let shieldedTx;
-        let unshieldedTx;
-        if (unshieldedOutputs.length > 0) {
-            unshieldedTx = await this.unshielded.transferTransaction(unshieldedOutputs, ttl);
-        }
-        if (shieldedOutputs.length > 0) {
-            shieldedTx = await this.shielded.transferTransaction(zswapSecretKeys, shieldedOutputs);
-        }
+        const shieldedTx = shieldedOutputs.length > 0
+            ? await this.shielded.transferTransaction(shieldedSecretKeys, shieldedOutputs)
+            : undefined;
+        const unshieldedTx = unshieldedOutputs.length > 0 ? await this.unshielded.transferTransaction(unshieldedOutputs, ttl) : undefined;
         const mergedTxs = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
         // Add fee payment
-        const feeBalancingTransaction = await this.dust.balanceTransactions(dustSecretKey, [mergedTxs], ttl);
+        const feeBalancingTx = payFees ? await this.dust.balanceTransactions(dustSecretKey, [mergedTxs], ttl) : undefined;
+        const finalTx = this.mergeUnprovenTransactions(mergedTxs, feeBalancingTx);
         return {
             type: 'UNPROVEN_TRANSACTION',
-            transaction: mergedTxs.merge(feeBalancingTransaction),
+            transaction: finalTx,
         };
     }
     async estimateRegistration(nightUtxos) {
@@ -211,7 +264,9 @@ export class WalletFacade {
             dustGenerationEstimations,
         };
     }
-    async initSwap(zswapSecretKeys, desiredInputs, desiredOutputs, ttl) {
+    async initSwap(desiredInputs, desiredOutputs, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, payFees = false } = options;
         const { shielded: shieldedInputs, unshielded: unshieldedInputs } = desiredInputs;
         const shieldedOutputs = desiredOutputs
             .filter((output) => output.type === 'shielded')
@@ -225,7 +280,7 @@ export class WalletFacade {
             throw Error('At least one shielded or unshielded swap is required.');
         }
         const shieldedTx = hasShieldedPart && shieldedInputs !== undefined
-            ? await this.shielded.initSwap(zswapSecretKeys, shieldedInputs, shieldedOutputs)
+            ? await this.shielded.initSwap(shieldedSecretKeys, shieldedInputs, shieldedOutputs)
             : undefined;
         const unshieldedTx = hasUnshieldedPart && unshieldedInputs !== undefined
             ? await this.unshielded.initSwap(unshieldedInputs, unshieldedOutputs, ttl)
@@ -234,9 +289,11 @@ export class WalletFacade {
         if (!combinedTx) {
             throw Error('Unexpected transaction state.');
         }
+        const feeBalancingTx = payFees ? await this.dust.balanceTransactions(dustSecretKey, [combinedTx], ttl) : undefined;
+        const finalTx = this.mergeUnprovenTransactions(combinedTx, feeBalancingTx);
         return {
             type: 'UNPROVEN_TRANSACTION',
-            transaction: combinedTx,
+            transaction: finalTx,
         };
     }
     async registerNightUtxosForDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration, dustReceiverAddress) {
@@ -258,8 +315,12 @@ export class WalletFacade {
             transaction: dustDeregistrationTx,
         };
     }
-    async start(zswapSecretKeys, dustSecretKey) {
-        await Promise.all([this.shielded.start(zswapSecretKeys), this.unshielded.start(), this.dust.start(dustSecretKey)]);
+    async start(shieldedSecretKeys, dustSecretKey) {
+        await Promise.all([
+            this.shielded.start(shieldedSecretKeys),
+            this.unshielded.start(),
+            this.dust.start(dustSecretKey),
+        ]);
     }
     async stop() {
         await Promise.all([this.shielded.stop(), this.unshielded.stop(), this.dust.stop()]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-facade",
-  "version": "1.0.0-beta.16",
+  "version": "1.0.0-beta.17",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -24,17 +24,17 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v7": "7.0.0-rc.1",
+    "@midnight-ntwrk/ledger-v7": "7.0.0",
     "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.11",
-    "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0-beta.15",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.12",
+    "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0-beta.16",
     "@midnight-ntwrk/wallet-sdk-hd": "3.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.16",
-    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0-beta.18",
+    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.17",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0-beta.19",
     "rxjs": "^7.5"
   },
   "devDependencies": {
-    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.13",
+    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.14",
     "eslint": "^9.37.0",
     "prettier": "^3.7.0",
     "publint": "~0.3.14",