@midnight-ntwrk/wallet-sdk-shielded 1.0.0-beta.9 → 1.0.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).startWithShieldedSeed(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,8 +1,8 @@
 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 * as ledger from '@midnight-ntwrk/ledger-v7';
 import * as rx from 'rxjs';
-import { ProvingRecipe } from './v1/ProvingRecipe.js';
+import { BalancingResult } from './v1/Transacting.js';
 import { SerializationCapability } from './v1/Serialization.js';
 import { ProgressUpdate, TransactionHistoryCapability } from './v1/TransactionHistory.js';
 import { AvailableCoin, CoinsAndBalancesCapability, PendingCoin } from './v1/CoinsAndBalances.js';
@@ -18,6 +18,7 @@ export type ShieldedWalletCapabilities<TSerialized = string, TTransaction = ledg
     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;
@@ -49,10 +50,10 @@ export interface CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TT
 ]> {
     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>;
+    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>;
     readonly submitTransaction: SubmitTransactionMethod<TTransaction>;
     serializeState(): Promise<TSerialized>;
     waitForSyncedState(allowedGap?: bigint): Promise<ShieldedWalletState<TSerialized, TTransaction>>;

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 * 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';
@@ -95,10 +107,10 @@ 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);
         }

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';

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';

package/dist/v1/Proving.d.ts

@@ -1,9 +1,8 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Effect } from 'effect';
-import { ProvingRecipe } from './ProvingRecipe.js';
 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 = {
     provingServerUrl: URL;

package/dist/v1/Proving.js

@@ -1,5 +1,17 @@
+// 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 { HttpProverClient, ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Effect, pipe } from 'effect';
 import { ProvingError } from './WalletError.js';
 export const makeDefaultProvingService = (configuration) => {
@@ -7,35 +19,18 @@ export const makeDefaultProvingService = (configuration) => {
         url: configuration.provingServerUrl,
     });
     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 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,11 +1,10 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * 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 { TransactingCapability, TokenTransfer, BalancingResult } from './Transacting.js';
 import { WalletError } from './WalletError.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
@@ -37,10 +36,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>;
+    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>;
     submitTransaction: SubmitTransactionMethod<TTransaction>;
     serializeState(state: CoreWallet): TSerialized;
 }

package/dist/v1/RunningV1Variant.js

@@ -66,28 +66,28 @@ export class RunningV1Variant {
     }
     balanceTransaction(secretKeys, tx) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.balanceTransaction(secretKeys, state, tx), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.transactingCapability.balanceTransaction(secretKeys, state, tx), EitherOps.toEffect);
         });
     }
     transferTransaction(secretKeys, outputs) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.makeTransfer(secretKeys, state, outputs), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.transactingCapability.makeTransfer(secretKeys, state, outputs), EitherOps.toEffect);
         });
     }
     initSwap(secretKeys, desiredInputs, desiredOutputs) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), EitherOps.toEffect);
         });
     }
-    finalizeTransaction(recipe) {
+    finalizeTransaction(transaction) {
         return this.#v1Context.provingService
-            .prove(recipe)
-            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertRecipe(state, recipe)))));
+            .prove(transaction)
+            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertTransaction(state, transaction)))));
     }
     submitTransaction = ((transaction, waitForStatus = 'InBlock') => {
         return this.#v1Context.submissionService
             .submitTransaction(transaction, waitForStatus)
-            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revert(state, transaction)))));
+            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertTransaction(state, transaction)))));
     });
     serializeState(state) {
         return this.#v1Context.serializationCapability.serialize(state);

package/dist/v1/Serialization.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 { Effect, ParseResult, Either, pipe, Schema } from 'effect';
 import { WalletError } from './WalletError.js';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { CoreWallet } from './CoreWallet.js';
 const TxSchema = Schema.declare((input) => input instanceof ledger.Transaction).annotations({
     identifier: 'ledger.Transaction',

package/dist/v1/Simulator.d.ts

@@ -1,4 +1,4 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Array as Arr, Effect, Scope, Stream, SubscriptionRef } from 'effect';
 export type SimulatorState = Readonly<{
     ledger: ledger.LedgerState;

package/dist/v1/Simulator.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 { Array as Arr, Effect, Encoding, pipe, Stream, SubscriptionRef, Clock } from 'effect';
 import { ArrayOps, EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import * as crypto from 'crypto';

package/dist/v1/Submission.d.ts

@@ -1,5 +1,5 @@
 import { Effect } from 'effect';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { WalletError } from './WalletError.js';
 import { Simulator } from './Simulator.js';
 import { SubmissionEvent as SubmissionEventImported } from '@midnight-ntwrk/wallet-sdk-node-client/effect';

package/dist/v1/Submission.js

@@ -1,3 +1,15 @@
+// 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 { Deferred, Effect, Encoding, Exit, pipe, Scope } from 'effect';
 import { WalletError } from './WalletError.js';
 import { NodeClient, PolkadotNodeClient, SubmissionEvent as SubmissionEventImported, } from '@midnight-ntwrk/wallet-sdk-node-client/effect';

package/dist/v1/Sync.d.ts

@@ -1,5 +1,5 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
-import { Scope, Stream, Schema } from 'effect';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+import { Schema, Scope, Stream } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { Simulator, SimulatorState } from './Simulator.js';
 import { WalletError } from './WalletError.js';
@@ -16,6 +16,7 @@ export type IndexerClientConnection = {
 };
 export type DefaultSyncConfiguration = {
     indexerClientConnection: IndexerClientConnection;
+    batchSize?: number;
 };
 export type DefaultSyncContext = {
     transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;
@@ -25,11 +26,11 @@ export declare const SecretKeysResource: {
     create: (secretKeys: ledger.ZswapSecretKeys) => SecretKeysResource;
 };
 export type WalletSyncUpdate = {
-    update: EventsSyncUpdate;
+    updates: EventsSyncUpdate[];
     secretKeys: SecretKeysResource;
 };
 export declare const WalletSyncUpdate: {
-    create: (update: EventsSyncUpdate, secretKeys: ledger.ZswapSecretKeys) => WalletSyncUpdate;
+    create: (updates: EventsSyncUpdate[], secretKeys: ledger.ZswapSecretKeys) => WalletSyncUpdate;
 };
 export declare const EventsSyncUpdate: Schema.TaggedStruct<"EventsSyncUpdate", {
     id: typeof Schema.Number;

package/dist/v1/Sync.js

@@ -1,8 +1,20 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
-import { Effect, ParseResult, Stream, Schema, pipe, Either } from 'effect';
+// 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 { Chunk, Duration, Effect, Either, ParseResult, pipe, Schedule, Schema, Stream } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { ZswapEvents } from '@midnight-ntwrk/wallet-sdk-indexer-client';
-import { WsSubscriptionClient, ConnectionHelper } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
+import { ConnectionHelper, WsSubscriptionClient } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
 import { SyncWalletError } from './WalletError.js';
 import { WsURL } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
 import { EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
@@ -27,9 +39,9 @@ export const SecretKeysResource = {
     },
 };
 export const WalletSyncUpdate = {
-    create: (update, secretKeys) => {
+    create: (updates, secretKeys) => {
         return {
-            update,
+            updates,
             secretKeys: SecretKeysResource.create(secretKeys),
         };
     },
@@ -85,15 +97,20 @@ export const makeEventsSyncService = (config) => {
             }
             const indexerWsUrl = indexerWsUrlResult.right;
             const appliedIndex = state.progress?.appliedIndex ?? 0n;
-            return pipe(ZswapEvents.run({ id: Number(appliedIndex) }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerWsUrl })), Stream.mapError((error) => new SyncWalletError(error)), Stream.mapEffect((subscription) => pipe(Schema.decodeUnknownEither(EventsSyncUpdateFromPayload)(subscription.zswapLedgerEvents), Either.mapLeft((err) => new SyncWalletError(err)), EitherOps.toEffect)), Stream.map((data) => WalletSyncUpdate.create(data, secretKeys)));
+            const batchSize = config.batchSize ?? 10;
+            return pipe(ZswapEvents.run({ id: Number(appliedIndex) }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerWsUrl })), Stream.mapError((error) => new SyncWalletError(error)), Stream.mapEffect((subscription) => pipe(subscription.zswapLedgerEvents, Schema.decodeUnknownEither(EventsSyncUpdateFromPayload), Either.mapLeft((err) => new SyncWalletError(err)), EitherOps.toEffect)), Stream.groupedWithin(batchSize, Duration.millis(1)), Stream.map(Chunk.toArray), Stream.map((data) => WalletSyncUpdate.create(data, secretKeys)), Stream.schedule(Schedule.spaced(Duration.millis(4))));
         },
     };
 };
 export const makeEventsSyncCapability = () => {
     return {
         applyUpdate: (state, wrappedUpdate) => {
-            const nextIndex = BigInt(wrappedUpdate.update.id);
-            const highestRelevantWalletIndex = BigInt(wrappedUpdate.update.maxId);
+            if (wrappedUpdate.updates.length === 0) {
+                return state;
+            }
+            const lastUpdate = wrappedUpdate.updates.at(-1);
+            const nextIndex = BigInt(lastUpdate.id);
+            const highestRelevantWalletIndex = BigInt(lastUpdate.maxId);
             // in case the nextIndex is less than or equal to the appliedIndex
             // just update highestRelevantWalletIndex
             if (nextIndex <= state.progress.appliedIndex) {
@@ -103,7 +120,7 @@ export const makeEventsSyncCapability = () => {
                 });
             }
             return wrappedUpdate.secretKeys((keys) => {
-                return CoreWallet.updateProgress(CoreWallet.replayEvents(state, keys, [wrappedUpdate.update.event]), {
+                return CoreWallet.updateProgress(CoreWallet.replayEvents(state, keys, wrappedUpdate.updates.map((u) => u.event)), {
                     highestRelevantWalletIndex,
                     appliedIndex: nextIndex,
                     isConnected: true,

package/dist/v1/Transacting.d.ts

@@ -1,12 +1,11 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Array as Arr, Either } from 'effect';
-import { ProvingRecipe } from './ProvingRecipe.js';
 import { CoreWallet } from './CoreWallet.js';
 import { WalletError } from './WalletError.js';
 import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { TransactionImbalances } from './TransactionImbalances.js';
-import { TransactionTrait } from './Transaction.js';
+import { TransactionOps } from './TransactionOps.js';
 import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
 export interface TokenTransfer {
@@ -14,21 +13,12 @@ export interface TokenTransfer {
     readonly type: ledger.RawTokenType;
     readonly receiverAddress: string;
 }
+export type BalancingResult = ledger.UnprovenTransaction | undefined;
 export interface TransactingCapability<TSecrets, TState, TTransaction> {
-    balanceTransaction(secrets: TSecrets, state: TState, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: TState;
-    }, WalletError>;
-    makeTransfer(secrets: TSecrets, state: TState, outputs: ReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: TState;
-    }, WalletError>;
-    initSwap(secrets: TSecrets, state: TState, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: TState;
-    }, WalletError>;
-    revert(state: TState, tx: TTransaction): Either.Either<TState, WalletError>;
-    revertRecipe(state: TState, recipe: ProvingRecipe<TTransaction>): Either.Either<TState, WalletError>;
+    balanceTransaction(secrets: TSecrets, state: TState, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Either.Either<[BalancingResult, TState], WalletError>;
+    makeTransfer(secrets: TSecrets, state: TState, outputs: ReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, TState], WalletError>;
+    initSwap(secrets: TSecrets, state: TState, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, TState], WalletError>;
+    revertTransaction(state: TState, transaction: TTransaction | ledger.UnprovenTransaction): Either.Either<TState, WalletError>;
 }
 export type DefaultTransactingConfiguration = {
     networkId: NetworkId.NetworkId;
@@ -44,24 +34,14 @@ export declare class TransactingCapabilityImplementation<TTransaction extends le
     #private;
     readonly networkId: NetworkId.NetworkId;
     readonly getCoinSelection: () => CoinSelection<ledger.QualifiedShieldedCoinInfo>;
-    readonly txTrait: TransactionTrait<TTransaction>;
+    readonly txOps: TransactionOps<TTransaction>;
     readonly getCoins: () => CoinsAndBalancesCapability<CoreWallet>;
     readonly getKeys: () => KeysCapability<CoreWallet>;
-    constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.QualifiedShieldedCoinInfo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txTrait: TransactionTrait<TTransaction>);
-    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, tx: TTransaction): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: CoreWallet;
-    }, WalletError>;
-    makeTransfer(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, transfers: Arr.NonEmptyReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: CoreWallet;
-    }, WalletError>;
-    initSwap(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<{
-        recipe: ProvingRecipe<TTransaction>;
-        newState: CoreWallet;
-    }, WalletError>;
-    revert(state: CoreWallet, tx: TTransaction): Either.Either<CoreWallet, WalletError>;
-    revertRecipe(state: CoreWallet, recipe: ProvingRecipe<TTransaction>): Either.Either<CoreWallet, WalletError>;
+    constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.QualifiedShieldedCoinInfo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txOps: TransactionOps<TTransaction>);
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, tx: TTransaction): Either.Either<[BalancingResult, CoreWallet], WalletError>;
+    makeTransfer(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, transfers: Arr.NonEmptyReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, CoreWallet], WalletError>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Either.Either<[ledger.UnprovenTransaction, CoreWallet], WalletError>;
+    revertTransaction(state: CoreWallet, transaction: TTransaction | ledger.UnprovenTransaction): Either.Either<CoreWallet, WalletError>;
     balanceFallibleSection(secretKeys: ledger.ZswapSecretKeys, state: CoreWallet, imbalances: TransactionImbalances, coinSelection: CoinSelection<ledger.QualifiedShieldedCoinInfo>): Either.Either<{
         offer: ledger.ZswapOffer<ledger.PreProof> | undefined;
         newState: CoreWallet;

package/dist/v1/Transacting.js

@@ -1,58 +1,53 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
-import { Array as Arr, Data, Either, Option, pipe, Record } from 'effect';
-import { ArrayOps, EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
-import { BALANCE_TRANSACTION_TO_PROVE, NOTHING_TO_PROVE, TRANSACTION_TO_PROVE, } from './ProvingRecipe.js';
+// 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 { Array as Arr, Either, Option, pipe, Record } from 'effect';
+import { ArrayOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { CoreWallet } from './CoreWallet.js';
 import { AddressError, InsufficientFundsError, OtherWalletError } from './WalletError.js';
 import { getBalanceRecipe, Imbalances, InsufficientFundsError as BalancingInsufficientFundsError, } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { MidnightBech32m, ShieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 import { ShieldedCostModel, TransactionImbalances } from './TransactionImbalances.js';
-import { TransactionTrait } from './Transaction.js';
+import { TransactionOps } from './TransactionOps.js';
 export const makeDefaultTransactingCapability = (config, getContext) => {
-    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionTrait.default);
+    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps.default);
 };
 export const makeSimulatorTransactingCapability = (config, getContext) => {
-    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionTrait.proofErased);
+    return new TransactingCapabilityImplementation(config.networkId, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability, TransactionOps.proofErased);
 };
-class NoSelfOutputsError extends Data.TaggedError('NoSelfOutputs') {
-}
 export class TransactingCapabilityImplementation {
     networkId;
     getCoinSelection;
-    txTrait;
+    txOps;
     getCoins;
     getKeys;
-    constructor(networkId, getCoinSelection, getCoins, getKeys, txTrait) {
+    constructor(networkId, getCoinSelection, getCoins, getKeys, txOps) {
         this.getCoins = getCoins;
         this.networkId = networkId;
         this.getCoinSelection = getCoinSelection;
         this.getKeys = getKeys;
-        this.txTrait = txTrait;
+        this.txOps = txOps;
     }
     balanceTransaction(secretKeys, state, tx) {
         return Either.gen(this, function* () {
             const coinSelection = this.getCoinSelection();
-            const networkId = this.networkId;
-            const initialImbalances = this.txTrait.getImbalances(tx);
+            const initialImbalances = this.txOps.getImbalances(tx);
             if (TransactionImbalances.areBalanced(initialImbalances)) {
-                return {
-                    recipe: {
-                        type: NOTHING_TO_PROVE,
-                        transaction: tx,
-                    },
-                    newState: state,
-                };
+                return [undefined, state];
             }
             const { newState: afterFallible, offer: maybeFallible } = yield* this.balanceFallibleSection(secretKeys, state, initialImbalances, coinSelection);
-            const { newState: afterGuaranteed, offer: guaranteed } = yield* this.#balanceGuaranteedSection(secretKeys, afterFallible, initialImbalances, coinSelection, 0, Imbalances.empty());
-            return {
-                newState: afterGuaranteed,
-                recipe: {
-                    type: BALANCE_TRANSACTION_TO_PROVE,
-                    transactionToBalance: tx,
-                    transactionToProve: ledger.Transaction.fromParts(networkId, guaranteed, maybeFallible),
-                },
-            };
+            const { newState: afterGuaranteed, offer: guaranteed } = yield* this.#balanceGuaranteedSection(secretKeys, afterFallible, initialImbalances, coinSelection, Imbalances.empty());
+            return [ledger.Transaction.fromParts(this.networkId, guaranteed, maybeFallible), afterGuaranteed];
         });
     }
     makeTransfer(secretKeys, state, transfers) {
@@ -67,17 +62,11 @@ export class TransactingCapabilityImplementation {
             const { initialOffersAndCoins, selfCoins } = yield* this.#processDesiredOutputs(state, positiveTransfers);
             const offerToBalance = pipe(initialOffersAndCoins, Arr.map((o) => o.outputOffer), ArrayOps.fold((a, b) => a.merge(b)));
             const unprovenTxToBalance = ledger.Transaction.fromParts(networkId, offerToBalance);
-            const imbalances = TransactionTrait.unproven.getImbalances(unprovenTxToBalance);
-            const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, imbalances, this.getCoinSelection(), selfCoins.length, Imbalances.empty());
+            const imbalances = TransactionOps.unproven.getImbalances(unprovenTxToBalance);
+            const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, imbalances, this.getCoinSelection(), Imbalances.empty());
             const finalState = CoreWallet.watchCoins(newState, secretKeys, selfCoins);
             const finalTx = unprovenTxToBalance.merge(ledger.Transaction.fromParts(networkId, offer));
-            return {
-                newState: finalState,
-                recipe: {
-                    type: TRANSACTION_TO_PROVE,
-                    transaction: finalTx,
-                },
-            };
+            return [finalTx, finalState];
         });
     }
     initSwap(secretKeys, state, desiredInputs, desiredOutputs) {
@@ -97,57 +86,28 @@ export class TransactingCapabilityImplementation {
             const outputsParseResult = yield* this.#processDesiredOutputsPossiblyEmpty(state, desiredOutputs);
             const inputsParseResult = Imbalances.fromEntries(Record.toEntries(desiredInputs));
             const networkId = this.networkId;
-            const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, TransactionImbalances.empty(), this.getCoinSelection(), outputsParseResult.selfCoins.length, inputsParseResult);
+            const { offer, newState } = yield* this.#balanceGuaranteedSection(secretKeys, state, TransactionImbalances.empty(), this.getCoinSelection(), inputsParseResult);
             const finalState = CoreWallet.watchCoins(newState, secretKeys, outputsParseResult.selfCoins);
             const balancingTx = ledger.Transaction.fromParts(networkId, offer);
             const finalTx = outputsParseResult.unprovenTxToBalance
                 ? outputsParseResult.unprovenTxToBalance.merge(balancingTx)
                 : balancingTx;
-            return {
-                newState: finalState,
-                recipe: {
-                    type: TRANSACTION_TO_PROVE,
-                    transaction: finalTx,
-                },
-            };
+            return [finalTx, finalState];
         });
     }
-    revert(state, tx) {
+    revertTransaction(state, transaction) {
         return Either.try({
             try: () => {
-                return CoreWallet.revertTransaction(state, tx);
+                return CoreWallet.revertTransaction(state, transaction);
             },
             catch: (err) => {
                 return new OtherWalletError({
-                    message: `Error while reverting transaction ${this.txTrait.id(tx)}`,
+                    message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
                     cause: err,
                 });
             },
         });
     }
-    revertRecipe(state, recipe) {
-        const doRevert = (tx) => {
-            return Either.try({
-                try: () => {
-                    return CoreWallet.revertTransaction(state, tx);
-                },
-                catch: (err) => {
-                    return new OtherWalletError({
-                        message: `Error while reverting transaction ${TransactionTrait.unproven.id(tx)}`,
-                        cause: err,
-                    });
-                },
-            });
-        };
-        switch (recipe.type) {
-            case TRANSACTION_TO_PROVE:
-                return doRevert(recipe.transaction);
-            case BALANCE_TRANSACTION_TO_PROVE:
-                return doRevert(recipe.transactionToProve);
-            case NOTHING_TO_PROVE:
-                return Either.right(state);
-        }
-    }
     #prepareOffer(secretKeys, state, recipe, segment) {
         const [inputOffers, stateAfterSpends] = CoreWallet.spendCoins(state, secretKeys, recipe.inputs, segment);
         const stateAfterWatches = CoreWallet.watchCoins(stateAfterSpends, secretKeys, recipe.outputs);
@@ -199,7 +159,7 @@ export class TransactingCapabilityImplementation {
             },
         });
     }
-    #balanceGuaranteedSection(secretKeys, state, imbalances, coinSelection, knownSelfOutputs, targetImbalances) {
+    #balanceGuaranteedSection(secretKeys, state, imbalances, coinSelection, targetImbalances) {
         return Either.gen(this, function* () {
             const balanceRecipe = yield* Either.try({
                 try: () => getBalanceRecipe({
@@ -230,69 +190,11 @@ export class TransactingCapabilityImplementation {
                     }
                 },
             });
-            if (balanceRecipe.outputs.length + knownSelfOutputs == 0) {
-                return yield* Either.left(new NoSelfOutputsError({}));
-            }
             return yield* pipe(this.#prepareOffer(secretKeys, state, balanceRecipe, 0), Either.fromOption(() => {
                 return new OtherWalletError({
                     message: 'Could not create a valid guaranteed offer',
                 });
             }));
-        }).pipe(EitherOps.flatMapLeft((err) => {
-            if (err instanceof NoSelfOutputsError) {
-                return this.#balanceGuaranteedWithSelfOutput(secretKeys, state, imbalances, coinSelection, targetImbalances);
-            }
-            else {
-                return Either.left(err);
-            }
-        }));
-    }
-    #balanceGuaranteedWithSelfOutput(secretKeys, state, imbalances, coinSelection, targetImbalances) {
-        return Either.gen(this, function* () {
-            const additionalOutputValue = 100000n;
-            const balanceRecipe = yield* Either.try({
-                try: () => {
-                    return getBalanceRecipe({
-                        coins: this.getCoins()
-                            .getAvailableCoins(state)
-                            .map((c) => c.coin),
-                        initialImbalances: Imbalances.merge(imbalances.guaranteed, Imbalances.fromEntry(ledger.shieldedToken().raw, -1n * additionalOutputValue)),
-                        transactionCostModel: ShieldedCostModel,
-                        feeTokenType: '',
-                        coinSelection,
-                        targetImbalances,
-                        createOutput: (coin) => ledger.createShieldedCoinInfo(coin.type, coin.value),
-                        isCoinEqual: (a, b) => a.nonce === b.nonce,
-                    });
-                },
-                catch: (err) => {
-                    if (err instanceof BalancingInsufficientFundsError) {
-                        return new InsufficientFundsError({
-                            message: 'Insufficient funds',
-                            tokenType: err.tokenType,
-                            amount: imbalances.guaranteed.get(err.tokenType) ?? 0n,
-                        });
-                    }
-                    else {
-                        return new OtherWalletError({
-                            message: 'Balancing guaranteed section failed',
-                            cause: err,
-                        });
-                    }
-                },
-            });
-            const additionalCoin = ledger.createShieldedCoinInfo(ledger.shieldedToken().raw, additionalOutputValue);
-            const additionalOffer = pipe(additionalCoin, (coin) => ledger.ZswapOutput.new(coin, 0, this.getKeys().getCoinPublicKey(state).toHexString(), this.getKeys().getEncryptionPublicKey(state).toHexString()), (output) => ledger.ZswapOffer.fromOutput(output, ledger.shieldedToken().raw, additionalOutputValue));
-            return yield* pipe(this.#prepareOffer(secretKeys, state, balanceRecipe, 0), Option.map(({ newState, offer }) => {
-                return {
-                    newState: CoreWallet.watchCoins(newState, secretKeys, [additionalCoin]),
-                    offer: offer.merge(additionalOffer),
-                };
-            }), Either.fromOption(() => {
-                return new OtherWalletError({
-                    message: 'Balancing guaranteed section failed',
-                });
-            }));
         });
     }
     #parseAddress(addr) {
@@ -349,7 +251,7 @@ export class TransactingCapabilityImplementation {
                     const networkId = this.networkId;
                     const offerToBalance = pipe(initialOffersAndCoins, Arr.map((o) => o.outputOffer), ArrayOps.fold((a, b) => a.merge(b)));
                     const unprovenTxToBalance = ledger.Transaction.fromParts(networkId, offerToBalance);
-                    const imbalances = TransactionTrait.unproven.getImbalances(unprovenTxToBalance);
+                    const imbalances = TransactionOps.unproven.getImbalances(unprovenTxToBalance);
                     return {
                         imbalances,
                         selfCoins,

package/dist/v1/TransactionHistory.d.ts

@@ -1,4 +1,4 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { CoreWallet } from './CoreWallet.js';
 export type ProgressUpdate = {
     appliedIndex: bigint | undefined;

package/dist/v1/TransactionImbalances.js

@@ -1,3 +1,15 @@
+// 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 { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
 export const ShieldedCostModel = {
     inputFeeOverhead: 0n,

package/dist/v1/{Transaction.d.ts → TransactionOps.d.ts}

@@ -1,14 +1,14 @@
 import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { TransactionImbalances } from './TransactionImbalances.js';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
-export type TransactionTrait<Tx> = {
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+export type TransactionOps<Tx> = {
     getImbalances(tx: Tx): TransactionImbalances;
     id(tx: Tx): string;
 };
-export declare const TransactionTrait: {
-    default: TransactionTrait<ledger.FinalizedTransaction>;
-    proofErased: TransactionTrait<ledger.ProofErasedTransaction>;
-    unproven: TransactionTrait<ledger.UnprovenTransaction>;
+export declare const TransactionOps: {
+    default: TransactionOps<ledger.FinalizedTransaction>;
+    proofErased: TransactionOps<ledger.ProofErasedTransaction>;
+    unproven: TransactionOps<ledger.UnprovenTransaction>;
     shared: {
         getImbalances(tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction): TransactionImbalances;
         getGuaranteedImbalances: (tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction) => Imbalances;

package/dist/v1/{Transaction.js → TransactionOps.js}

@@ -1,9 +1,21 @@
+// 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 { pipe } from 'effect';
 import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-export const TransactionTrait = new (class {
+export const TransactionOps = new (class {
     default = {
         getImbalances(tx) {
-            return TransactionTrait.shared.getImbalances(tx);
+            return TransactionOps.shared.getImbalances(tx);
         },
         id(tx) {
             return tx.identifiers().at(0);
@@ -11,7 +23,7 @@ export const TransactionTrait = new (class {
     };
     proofErased = {
         getImbalances(tx) {
-            return TransactionTrait.shared.getImbalances(tx);
+            return TransactionOps.shared.getImbalances(tx);
         },
         id(tx) {
             return tx.identifiers().at(0);
@@ -19,7 +31,7 @@ export const TransactionTrait = new (class {
     };
     unproven = {
         getImbalances(tx) {
-            return TransactionTrait.shared.getImbalances(tx);
+            return TransactionOps.shared.getImbalances(tx);
         },
         id(tx) {
             return tx.identifiers().at(0);
@@ -27,8 +39,8 @@ export const TransactionTrait = new (class {
     };
     shared = {
         getImbalances(tx) {
-            const guaranteedImbalances = TransactionTrait.shared.getGuaranteedImbalances(tx);
-            const fallibleImbalances = TransactionTrait.shared.getFallibleImbalances(tx);
+            const guaranteedImbalances = TransactionOps.shared.getGuaranteedImbalances(tx);
+            const fallibleImbalances = TransactionOps.shared.getFallibleImbalances(tx);
             return pipe({
                 guaranteed: guaranteedImbalances,
                 fallible: fallibleImbalances,

package/dist/v1/V1Builder.d.ts

@@ -1,4 +1,4 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { Either, Types } from 'effect';
 import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Variant, VariantBuilder } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';

package/dist/v1/V1Builder.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 { Effect, Scope } from 'effect';
 import { WalletSeed } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { makeDefaultProvingService } from './Proving.js';

package/dist/v1/WalletError.d.ts

@@ -1,4 +1,4 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 export declare const WalletError: {
     proving(err: Error): WalletError;

package/dist/v1/WalletError.js

@@ -1,3 +1,15 @@
+// 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 { Data } from 'effect';
 export const WalletError = {
     proving(err) {

package/dist/v1/index.d.ts

@@ -5,7 +5,6 @@ export * as Transacting from './Transacting.js';
 export * as TransactionHistory from './TransactionHistory.js';
 export * as Serialization from './Serialization.js';
 export * as Proving from './Proving.js';
-export * as ProvingRecipe from './ProvingRecipe.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
@@ -13,4 +12,4 @@ export * as Simulator from './Simulator.js';
 export * as Submission from './Submission.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
-export * from './Transaction.js';
+export * from './TransactionOps.js';

package/dist/v1/index.js

@@ -1,3 +1,15 @@
+// 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 './V1Builder.js';
 export * as Sync from './Sync.js';
 export * as SyncProgress from './SyncProgress.js';
@@ -5,7 +17,6 @@ export * as Transacting from './Transacting.js';
 export * as TransactionHistory from './TransactionHistory.js';
 export * as Serialization from './Serialization.js';
 export * as Proving from './Proving.js';
-export * as ProvingRecipe from './ProvingRecipe.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
@@ -13,4 +24,4 @@ export * as Simulator from './Simulator.js';
 export * as Submission from './Submission.js';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
-export * from './Transaction.js';
+export * from './TransactionOps.js';

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-shielded",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "author": "IOHK",
+  "author": "Midnight Foundation",
   "license": "Apache-2.0",
   "publishConfig": {
     "registry": "https://npm.pkg.github.com/"
@@ -28,17 +28,17 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.5",
-    "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.7",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.7",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.11",
-    "@midnight-ntwrk/wallet-sdk-node-client": "1.0.0-beta.9",
-    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-runtime": "1.0.0-beta.7",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.7",
+    "@midnight-ntwrk/ledger-v7": "7.0.0",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-node-client": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-runtime": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0",
     "@scure/base": "^1.1.9",
-    "effect": "^3.17.3",
+    "effect": "^3.19.14",
     "isomorphic-ws": "^5.0.0",
     "node-fetch": "3.3.2",
     "rxjs": "^7.5",
@@ -49,7 +49,8 @@
     "typecheck": "tsc -b ./tsconfig.json --noEmit",
     "test": "vitest run",
     "lint": "eslint --max-warnings 0",
-    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml}\"",
+    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml,md}\"",
     "dist": "tsc -b ./tsconfig.build.json",
     "dist:publish": "tsc -b ./tsconfig.publish.json",
     "clean": "rimraf --glob dist 'tsconfig.*.tsbuildinfo' && date +%s > .clean-timestamp",
@@ -66,11 +67,12 @@
     "@polkadot/types": "^16.4.1",
     "eslint": "^9.37.0",
     "fast-check": "^4.2.0",
+    "prettier": "^3.7.0",
     "publint": "~0.3.14",
     "rimraf": "^6.0.1",
-    "testcontainers": "^11.4.0",
+    "testcontainers": "^11.10.0",
     "to-words": "^4.5.1",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.16"
   }
 }

package/dist/v1/ProvingRecipe.d.ts

@@ -1,18 +0,0 @@
-import * as ledger from '@midnight-ntwrk/ledger-v6';
-export declare const TRANSACTION_TO_PROVE = "TransactionToProve";
-export declare const BALANCE_TRANSACTION_TO_PROVE = "BalanceTransactionToProve";
-export declare const NOTHING_TO_PROVE = "NothingToProve";
-export type TransactionToProve = {
-    readonly type: typeof TRANSACTION_TO_PROVE;
-    readonly transaction: ledger.UnprovenTransaction;
-};
-export type BalanceTransactionToProve<Transaction> = {
-    readonly type: typeof BALANCE_TRANSACTION_TO_PROVE;
-    readonly transactionToProve: ledger.UnprovenTransaction;
-    readonly transactionToBalance: Transaction;
-};
-export type NothingToProve<Transaction> = {
-    readonly type: typeof NOTHING_TO_PROVE;
-    readonly transaction: Transaction;
-};
-export type ProvingRecipe<Transaction> = TransactionToProve | BalanceTransactionToProve<Transaction> | NothingToProve<Transaction>;

package/dist/v1/ProvingRecipe.js

@@ -1,3 +0,0 @@
-export const TRANSACTION_TO_PROVE = 'TransactionToProve';
-export const BALANCE_TRANSACTION_TO_PROVE = 'BalanceTransactionToProve';
-export const NOTHING_TO_PROVE = 'NothingToProve';