@midnight-ntwrk/wallet-sdk-shielded 1.0.0-beta.9 → 2.0.0-rc.0

package/README.md

@@ -0,0 +1,131 @@
+# @midnight-ntwrk/wallet-sdk-shielded
+
+Manages shielded tokens on the Midnight network using zero-knowledge proofs.
+
+## Installation
+
+```bash
+npm install @midnight-ntwrk/wallet-sdk-shielded
+```
+
+## Overview
+
+The Shielded Wallet handles private token operations where transaction values and addresses are hidden from observers
+while maintaining verifiability. It provides:
+
+- Zero-knowledge proof generation
+- Coin commitment tracking
+- Encrypted output decryption
+- Shielded transfer transactions
+- Transaction balancing for shielded tokens
+
+## Usage
+
+### Starting the Wallet
+
+```typescript
+import { ShieldedWallet } from '@midnight-ntwrk/wallet-sdk-shielded';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+import { randomBytes } from 'node:crypto';
+
+// Configuration for the wallet
+const configuration = {
+  networkId: 'preview',
+  provingServerUrl: new URL('http://localhost:6300'),
+  relayURL: new URL('ws://localhost:9944'),
+  indexerClientConnection: {
+    indexerHttpUrl: 'http://localhost:8088/api/v3/graphql',
+    indexerWsUrl: 'ws://localhost:8088/api/v3/graphql/ws',
+  },
+};
+
+// Create secret keys from a shielded seed
+const seed = randomBytes(32);
+const shieldedSecretKeys = ledger.ZswapSecretKeys.fromSeed(seed);
+
+// Create and start the wallet
+const shieldedWallet = ShieldedWallet(configuration).startWithSecretKeys(shieldedSecretKeys);
+
+// Start syncing with the network
+await shieldedWallet.start(shieldedSecretKeys);
+```
+
+### Alternative: Start with Seed Directly
+
+```typescript
+// Start directly with a shielded seed
+const shieldedWallet = ShieldedWallet(configuration).startWithSeed(seed);
+await shieldedWallet.start(ledger.ZswapSecretKeys.fromSeed(seed));
+```
+
+### Restoring from Serialized State
+
+```typescript
+// Restore a wallet from previously serialized state
+const shieldedWallet = ShieldedWallet(configuration).restore(serializedState);
+await shieldedWallet.start(shieldedSecretKeys);
+```
+
+### Observing State
+
+```typescript
+wallet.state.subscribe((state) => {
+  console.log('Progress:', state.state.progress);
+  console.log('Coins:', state.state.coins);
+});
+```
+
+### Creating Transfer Transactions
+
+```typescript
+const tx = await wallet.transferTransaction(shieldedSecretKeys, [
+  { type: 'NIGHT', receiverAddress: 'mn_shield-addr1...', amount: 1000n },
+]);
+```
+
+### Balancing Transactions
+
+```typescript
+const balancingTx = await wallet.balanceTransaction(shieldedSecretKeys, transactionToBalance);
+```
+
+### Finalizing Transactions
+
+```typescript
+// Generates ZK proofs and finalizes the transaction
+const finalizedTx = await wallet.finalizeTransaction(unprovenTx);
+```
+
+### Creating Swap Offers
+
+```typescript
+const swapTx = await wallet.initSwap(
+  shieldedSecretKeys,
+  { NIGHT: 500n }, // inputs
+  [{ type: 'TOKEN_A', receiverAddress: shieldedAddress, amount: 100n }], // outputs
+);
+```
+
+## Privacy Model
+
+Shielded transactions use zero-knowledge proofs to hide:
+
+- Transaction amounts
+- Sender addresses
+- Receiver addresses
+
+While still proving:
+
+- The sender has sufficient balance
+- No tokens are created or destroyed
+- The transaction is valid
+
+## Exports
+
+- `ShieldedWallet` - Main wallet class
+- `ShieldedWalletState` - Wallet state type
+- Version 1 exports via `@midnight-ntwrk/wallet-sdk-shielded/v1`
+
+## License
+
+Apache-2.0

package/dist/ShieldedWallet.d.ts

@@ -1,23 +1,23 @@
-import { ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet } from './v1/index.js';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { type ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type BaseV1Configuration, type DefaultV1Configuration, type V1Variant, CoreWallet } from './v1/index.js';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import * as rx from 'rxjs';
-import { ProvingRecipe } from './v1/ProvingRecipe.js';
-import { SerializationCapability } from './v1/Serialization.js';
-import { ProgressUpdate, TransactionHistoryCapability } from './v1/TransactionHistory.js';
-import { AvailableCoin, CoinsAndBalancesCapability, PendingCoin } from './v1/CoinsAndBalances.js';
-import { KeysCapability } from './v1/Keys.js';
-import { ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
-import { SubmissionEvent, SubmissionEventCases } from './v1/Submission.js';
-import { TokenTransfer } from './v1/Transacting.js';
-import { WalletSyncUpdate } from './v1/Sync.js';
-import { Variant, VariantBuilder, WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { type BalancingResult } from './v1/Transacting.js';
+import { type SerializationCapability } from './v1/Serialization.js';
+import { type ProgressUpdate, type TransactionHistoryCapability } from './v1/TransactionHistory.js';
+import { type AvailableCoin, type CoinsAndBalancesCapability, type PendingCoin } from './v1/CoinsAndBalances.js';
+import { type KeysCapability } from './v1/Keys.js';
+import { type ShieldedAddress, type ShieldedCoinPublicKey, type ShieldedEncryptionPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { type TokenTransfer } from './v1/Transacting.js';
+import { type WalletSyncUpdate } from './v1/Sync.js';
+import { type Variant, type VariantBuilder, type WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 export type ShieldedWalletCapabilities<TSerialized = string, TTransaction = ledger.FinalizedTransaction> = {
     serialization: SerializationCapability<CoreWallet, null, TSerialized>;
     coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
     keys: KeysCapability<CoreWallet>;
     transactionHistory: TransactionHistoryCapability<CoreWallet, TTransaction>;
 };
+export type UnboundTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.PreBinding>;
 export declare class ShieldedWalletState<TSerialized = string, TTransaction = ledger.FinalizedTransaction> {
     static readonly mapState: <TSerialized_1 = string, TTransaction_1 = ledger.FinalizedTransaction>(capabilities: ShieldedWalletCapabilities<TSerialized_1, TTransaction_1>) => (state: ProtocolState.ProtocolState<CoreWallet>) => ShieldedWalletState<TSerialized_1, TTransaction_1>;
     readonly protocolVersion: ProtocolVersion.ProtocolVersion;
@@ -31,38 +31,36 @@ export declare class ShieldedWalletState<TSerialized = string, TTransaction = le
     get encryptionPublicKey(): ShieldedEncryptionPublicKey;
     get address(): ShieldedAddress;
     get progress(): ProgressUpdate;
-    get transactionHistory(): readonly TTransaction[];
+    /**
+     * Transaction history for the wallet.
+     * @throws Error - Not yet implemented
+     */
+    get transactionHistory(): never;
     constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: ShieldedWalletCapabilities<TSerialized, TTransaction>);
     serialize(): TSerialized;
 }
-export type SubmitTransactionMethod<TTransaction> = {
-    (transaction: TTransaction, waitForStatus: 'Submitted'): Promise<SubmissionEventCases.Submitted>;
-    (transaction: TTransaction, waitForStatus: 'InBlock'): Promise<SubmissionEventCases.InBlock>;
-    (transaction: TTransaction, waitForStatus: 'Finalized'): Promise<SubmissionEventCases.Finalized>;
-    (transaction: TTransaction): Promise<SubmissionEventCases.InBlock>;
-    (transaction: TTransaction, waitForStatus?: 'Submitted' | 'InBlock' | 'Finalized'): Promise<SubmissionEvent>;
-};
 export type ShieldedWallet = CustomizedShieldedWallet<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
 export type ShieldedWalletClass = CustomizedShieldedWalletClass<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
-export interface CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[
-    Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
-]> {
+export type ShieldedWalletAPI<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSerialized = string> = {
     readonly state: rx.Observable<ShieldedWalletState<TSerialized, TTransaction>>;
     start(secretKeys: TStartAux): Promise<void>;
-    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>, newCoins: readonly ledger.ShieldedCoinInfo[]): Promise<ProvingRecipe<TTransaction>>;
-    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: readonly TokenTransfer[]): Promise<ProvingRecipe<TTransaction>>;
-    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[]): Promise<ProvingRecipe<TTransaction>>;
-    finalizeTransaction(recipe: ProvingRecipe<TTransaction>): Promise<TTransaction>;
-    readonly submitTransaction: SubmitTransactionMethod<TTransaction>;
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Promise<BalancingResult>;
+    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: readonly TokenTransfer[]): Promise<ledger.UnprovenTransaction>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[]): Promise<ledger.UnprovenTransaction>;
+    finalizeTransaction(transaction: ledger.UnprovenTransaction): Promise<TTransaction>;
     serializeState(): Promise<TSerialized>;
     waitForSyncedState(allowedGap?: bigint): Promise<ShieldedWalletState<TSerialized, TTransaction>>;
     getAddress(): Promise<ShieldedAddress>;
-}
-export interface CustomizedShieldedWalletClass<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[
+    revertTransaction(transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Promise<void>;
+    stop(): Promise<void>;
+};
+export type CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string> = ShieldedWalletAPI<TStartAux, TTransaction, TSerialized> & WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>]>;
+export type DefaultShieldedConfiguration = DefaultV1Configuration;
+export interface CustomizedShieldedWalletClass<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultShieldedConfiguration> extends WalletLike.BaseWalletClass<[
     Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
 ]> {
     configuration: TConfig;
-    startWithShieldedSeed(seed: Uint8Array): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+    startWithSeed(seed: Uint8Array): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
     startWithSecretKeys(secretKeys: ledger.ZswapSecretKeys): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
     restore(serializedState: TSerialized): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
 }

package/dist/ShieldedWallet.js

@@ -1,6 +1,18 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { V1Builder, V1Tag, CoreWallet } from './v1/index.js';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { V1Builder, V1Tag, CoreWallet, } from './v1/index.js';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Effect, Either } from 'effect';
 import * as rx from 'rxjs';
 import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
@@ -35,8 +47,12 @@ export class ShieldedWalletState {
     get progress() {
         return this.capabilities.transactionHistory.progress(this.state);
     }
+    /**
+     * Transaction history for the wallet.
+     * @throws Error - Not yet implemented
+     */
     get transactionHistory() {
-        return this.capabilities.transactionHistory.transactionHistory(this.state);
+        throw new Error('Transaction history is not yet implemented for ShieldedWallet');
     }
     constructor(state, capabilities) {
         this.protocolVersion = state.version;
@@ -59,7 +75,7 @@ export function CustomShieldedWallet(configuration, builder) {
         static startWithSecretKeys(secretKeys) {
             return CustomShieldedWalletImplementation.startFirst(CustomShieldedWalletImplementation, CoreWallet.initEmpty(secretKeys, CustomShieldedWalletImplementation.configuration.networkId));
         }
-        static startWithShieldedSeed(seed) {
+        static startWithSeed(seed) {
             const secretKeys = ledger.ZswapSecretKeys.fromSeed(seed);
             return CustomShieldedWalletImplementation.startWithSecretKeys(secretKeys);
         }
@@ -95,18 +111,20 @@ export function CustomShieldedWallet(configuration, builder) {
                 .dispatch({ [V1Tag]: (v1) => v1.initSwap(secretKeys, desiredInputs, desiredOutputs) })
                 .pipe(Effect.runPromise);
         }
-        finalizeTransaction(recipe) {
+        finalizeTransaction(transaction) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.finalizeTransaction(recipe),
+                [V1Tag]: (v1) => v1.finalizeTransaction(transaction),
             })
                 .pipe(Effect.runPromise);
         }
-        submitTransaction = ((tx, waitForStatus = 'InBlock') => {
+        revertTransaction(transaction) {
             return this.runtime
-                .dispatch({ [V1Tag]: (v1) => v1.submitTransaction(tx, waitForStatus) })
+                .dispatch({
+                [V1Tag]: (v1) => v1.revertTransaction(transaction),
+            })
                 .pipe(Effect.runPromise);
-        });
+        }
         waitForSyncedState(allowedGap = 0n) {
             return rx.firstValueFrom(this.state.pipe(rx.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
         }

package/dist/index.js

@@ -1 +1,13 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 export * from './ShieldedWallet.js';

package/dist/v1/CoinsAndBalances.d.ts

@@ -1,5 +1,5 @@
 import { CoreWallet } from './CoreWallet.js';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 export type AvailableCoin = {
     coin: ledger.QualifiedShieldedCoinInfo;
     commitment: ledger.CoinCommitment;

package/dist/v1/CoreWallet.d.ts

@@ -1,4 +1,4 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Either } from 'effect';
 import { SyncProgress, SyncProgressData } from './SyncProgress.js';
@@ -28,22 +28,21 @@ export type CoreWallet = Readonly<{
     protocolVersion: ProtocolVersion.ProtocolVersion;
     progress: SyncProgress;
     networkId: string;
-    txHistoryArray: readonly ledger.FinalizedTransaction[];
     coinHashes: CoinHashesMap;
 }>;
 export declare const CoreWallet: {
     init(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, networkId: string): CoreWallet;
     empty(publicKeys: PublicKeys, networkId: string): CoreWallet;
-    restore(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, txHistory: readonly ledger.FinalizedTransaction[], syncProgress: Omit<SyncProgressData, "isConnected">, protocolVersion: bigint, networkId: string): CoreWallet;
-    restoreWithCoinHashes(publicKeys: PublicKeys, localState: ledger.ZswapLocalState, txHistory: readonly ledger.FinalizedTransaction[], coinHashes: CoinHashesMap, syncProgress: SyncProgressData, protocolVersion: bigint, networkId: string): Either.Either<CoreWallet, WalletError>;
+    restore(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, syncProgress: Omit<SyncProgressData, "isConnected">, protocolVersion: bigint, networkId: string): CoreWallet;
+    restoreWithCoinHashes(publicKeys: PublicKeys, localState: ledger.ZswapLocalState, coinHashes: CoinHashesMap, syncProgress: SyncProgressData, protocolVersion: bigint, networkId: string): Either.Either<CoreWallet, WalletError>;
     initEmpty(keys: ledger.ZswapSecretKeys, networkId: string): CoreWallet;
     applyCollapsedUpdate(wallet: CoreWallet, collapsed: ledger.MerkleTreeCollapsedUpdate): CoreWallet;
     apply<TOffer extends ledger.ZswapOffer<ledger.Proofish>>(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, offer: TOffer): CoreWallet;
     replayEvents(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, events: ledger.Event[]): CoreWallet;
     updateProgress(wallet: CoreWallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }: Partial<SyncProgressData>): CoreWallet;
-    addTransaction(wallet: CoreWallet, tx: ledger.FinalizedTransaction): CoreWallet;
+    addTransaction(wallet: CoreWallet, _tx: ledger.FinalizedTransaction): CoreWallet;
     revertTransaction<TTx extends ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>>(wallet: CoreWallet, _tx: TTx): CoreWallet;
-    updateTxHistory(wallet: CoreWallet, newTxs: readonly ledger.FinalizedTransaction[]): CoreWallet;
+    updateTxHistory(wallet: CoreWallet, _newTxs: readonly ledger.FinalizedTransaction[]): CoreWallet;
     spendCoins(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, coins: ReadonlyArray<ledger.QualifiedShieldedCoinInfo>, segment: number): [ReadonlyArray<ledger.ZswapOffer<ledger.PreProof>>, CoreWallet];
     watchCoins(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, coins: ReadonlyArray<ledger.ShieldedCoinInfo>): CoreWallet;
 };

package/dist/v1/CoreWallet.js

@@ -1,4 +1,16 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Either, Iterable, pipe, Record, Array as Arr } from 'effect';
 import { createSyncProgress } from './SyncProgress.js';
@@ -46,7 +58,7 @@ export const CoreWallet = {
         const coinHashes = CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState));
         const progress = createSyncProgress();
         const protocolVersion = ProtocolVersion.MinSupportedVersion;
-        return { state: localState, publicKeys, networkId, coinHashes, txHistoryArray: [], progress, protocolVersion };
+        return { state: localState, publicKeys, networkId, coinHashes, progress, protocolVersion };
     },
     empty(publicKeys, networkId) {
         return {
@@ -54,12 +66,11 @@ export const CoreWallet = {
             publicKeys,
             networkId,
             coinHashes: CoinHashesMap.empty,
-            txHistoryArray: [],
             progress: createSyncProgress(),
             protocolVersion: ProtocolVersion.MinSupportedVersion,
         };
     },
-    restore(localState, secretKeys, txHistory, syncProgress, protocolVersion, networkId) {
+    restore(localState, secretKeys, syncProgress, protocolVersion, networkId) {
         const publicKeys = PublicKeys.fromSecretKeys(secretKeys);
         const coinHashes = CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState));
         return {
@@ -67,12 +78,11 @@ export const CoreWallet = {
             publicKeys,
             networkId,
             coinHashes,
-            txHistoryArray: txHistory,
             progress: createSyncProgress(syncProgress),
             protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
         };
     },
-    restoreWithCoinHashes(publicKeys, localState, txHistory, coinHashes, syncProgress, protocolVersion, networkId) {
+    restoreWithCoinHashes(publicKeys, localState, coinHashes, syncProgress, protocolVersion, networkId) {
         return CoinHashesMap.assertValid(coinHashes, localState).pipe(Either.mapBoth({
             onLeft: (missingNonces) => new InvalidCoinHashesError({ message: 'Missing coin hashes for coins present in the state', missingNonces }),
             onRight: () => ({
@@ -80,7 +90,6 @@ export const CoreWallet = {
                 publicKeys,
                 networkId,
                 coinHashes,
-                txHistoryArray: txHistory,
                 progress: createSyncProgress(syncProgress),
                 protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
             }),
@@ -113,15 +122,17 @@ export const CoreWallet = {
         });
         return { ...wallet, progress: updatedProgress };
     },
-    addTransaction(wallet, tx) {
-        return { ...wallet, txHistoryArray: [...wallet.txHistoryArray, tx] };
+    // TODO: Remove after tx history is implemented
+    addTransaction(wallet, _tx) {
+        return wallet;
     },
     /* not implemented until this is done https://shielded.atlassian.net/browse/PM-19678 */
     revertTransaction(wallet, _tx) {
         return wallet;
     },
-    updateTxHistory(wallet, newTxs) {
-        return { ...wallet, txHistoryArray: [...wallet.txHistoryArray, ...newTxs] };
+    // TODO: Remove after tx history is implemented
+    updateTxHistory(wallet, _newTxs) {
+        return wallet;
     },
     spendCoins(wallet, secretKeys, coins, segment) {
         const [offers, newLocalState] = pipe(coins, Arr.reduce([[], wallet.state], ([accOffers, localState], coinToSpend) => {

package/dist/v1/Proving.d.ts

@@ -1,12 +1,21 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
-import { Effect } from 'effect';
-import { ProvingRecipe } from './ProvingRecipe.js';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+import type { KeyMaterialProvider } from '@midnight-ntwrk/zkir-v2';
+import { ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
+import { InvalidProtocolSchemeError } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import { Effect, Layer } from 'effect';
 import { WalletError } from './WalletError.js';
 export interface ProvingService<TTransaction> {
-    prove(recipe: ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError>;
+    prove(transaction: ledger.UnprovenTransaction): Effect.Effect<TTransaction, WalletError>;
 }
-export type DefaultProvingConfiguration = {
+export declare const makeProvingService: (clientLayer: Layer.Layer<ProverClient.ProverClient, InvalidProtocolSchemeError>) => ProvingService<ledger.FinalizedTransaction>;
+export type WasmProvingConfiguration = {
+    keyMaterialProvider?: KeyMaterialProvider;
+};
+export type ProvingServerConfiguration = {
     provingServerUrl: URL;
 };
+export type DefaultProvingConfiguration = ProvingServerConfiguration;
 export declare const makeDefaultProvingService: (configuration: DefaultProvingConfiguration) => ProvingService<ledger.FinalizedTransaction>;
+export declare const makeServerProvingService: (configuration: ProvingServerConfiguration) => ProvingService<ledger.FinalizedTransaction>;
+export declare const makeWasmProvingService: (configuration: WasmProvingConfiguration) => ProvingService<ledger.FinalizedTransaction>;
 export declare const makeSimulatorProvingService: () => ProvingService<ledger.ProofErasedTransaction>;

package/dist/v1/Proving.js

@@ -1,41 +1,46 @@
-import { HttpProverClient, ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+import { HttpProverClient, WasmProver, ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
 import { Effect, pipe } from 'effect';
 import { ProvingError } from './WalletError.js';
-export const makeDefaultProvingService = (configuration) => {
-    const clientLayer = HttpProverClient.layer({
-        url: configuration.provingServerUrl,
-    });
+export const makeProvingService = (clientLayer) => {
     return {
-        prove(recipe) {
-            switch (recipe.type) {
-                case 'BalanceTransactionToProve':
-                    return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(recipe.transactionToProve, ledger.CostModel.initialCostModel())), Effect.map((provenTx) => recipe.transactionToBalance.merge(provenTx.bind())), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
-                        message: error.message,
-                        cause: error,
-                    }))));
-                case 'TransactionToProve':
-                    return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(recipe.transaction, ledger.CostModel.initialCostModel())), Effect.map((proven) => proven.bind()), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
-                        message: error.message,
-                        cause: error,
-                    }))));
-                case 'NothingToProve':
-                    return Effect.succeed(recipe.transaction);
-            }
+        prove(transaction) {
+            return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(transaction, ledger.CostModel.initialCostModel())), Effect.map((transaction) => transaction.bind()), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
+                message: error.message,
+                cause: error,
+            }))));
         },
     };
 };
+export const makeDefaultProvingService = (configuration) => makeServerProvingService(configuration);
+export const makeServerProvingService = (configuration) => {
+    const clientLayer = HttpProverClient.layer({
+        url: configuration.provingServerUrl,
+    });
+    return makeProvingService(clientLayer);
+};
+export const makeWasmProvingService = (configuration) => {
+    const proverLayer = WasmProver.layer({
+        keyMaterialProvider: configuration.keyMaterialProvider ?? WasmProver.makeDefaultKeyMaterialProvider(),
+    });
+    return makeProvingService(proverLayer);
+};
 export const makeSimulatorProvingService = () => {
     return {
-        prove(recipe) {
-            switch (recipe.type) {
-                case 'BalanceTransactionToProve':
-                    return pipe(Effect.succeed(recipe.transactionToProve.eraseProofs()), Effect.map((proven) => recipe.transactionToBalance.merge(proven)));
-                case 'TransactionToProve':
-                    return Effect.succeed(recipe.transaction.eraseProofs());
-                case 'NothingToProve':
-                    return Effect.succeed(recipe.transaction);
-            }
+        prove(transaction) {
+            return Effect.succeed(transaction.eraseProofs());
         },
     };
 };

package/dist/v1/RunningV1Variant.d.ts

@@ -1,18 +1,16 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import type * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Effect, Scope, Stream } from 'effect';
-import { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
-import { ProvingService } from './Proving.js';
-import { ProvingRecipe } from './ProvingRecipe.js';
-import { SerializationCapability } from './Serialization.js';
-import { EventsSyncUpdate, SyncCapability, SyncService } from './Sync.js';
-import { TransactingCapability, TokenTransfer } from './Transacting.js';
-import { WalletError } from './WalletError.js';
-import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
-import { KeysCapability } from './Keys.js';
-import { SubmissionService, SubmitTransactionMethod } from './Submission.js';
-import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { CoreWallet } from './CoreWallet.js';
-import { TransactionHistoryCapability } from './TransactionHistory.js';
+import { type WalletRuntimeError, type Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { type ProvingService } from './Proving.js';
+import { type SerializationCapability } from './Serialization.js';
+import { type EventsSyncUpdate, type SyncCapability, type SyncService } from './Sync.js';
+import { type TransactingCapability, type TokenTransfer, type BalancingResult } from './Transacting.js';
+import { type WalletError } from './WalletError.js';
+import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { type KeysCapability } from './Keys.js';
+import { type CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { type CoreWallet } from './CoreWallet.js';
+import { type TransactionHistoryCapability } from './TransactionHistory.js';
 export declare namespace RunningV1Variant {
     type Context<TSerialized, TSyncUpdate, TTransaction, TStartAux> = {
         serializationCapability: SerializationCapability<CoreWallet, null, TSerialized>;
@@ -22,7 +20,6 @@ export declare namespace RunningV1Variant {
         provingService: ProvingService<TTransaction>;
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
-        submissionService: SubmissionService<TTransaction>;
         coinSelection: CoinSelection<ledger.QualifiedShieldedCoinInfo>;
         transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, TTransaction>;
     };
@@ -37,10 +34,10 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TS
     constructor(scope: Scope.Scope, context: Variant.VariantContext<CoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction, TStartAux>);
     startSyncInBackground(startAux: TStartAux): Effect.Effect<void>;
     startSync(startAux: TStartAux): Stream.Stream<void, WalletError, Scope.Scope>;
-    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
-    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
-    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
-    finalizeTransaction(recipe: ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError>;
-    submitTransaction: SubmitTransactionMethod<TTransaction>;
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Effect.Effect<BalancingResult, WalletError>;
+    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    finalizeTransaction(transaction: ledger.UnprovenTransaction): Effect.Effect<TTransaction, WalletError>;
+    revertTransaction(transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Effect.Effect<void, WalletError>;
     serializeState(state: CoreWallet): TSerialized;
 }