@midnight-ntwrk/wallet-sdk-shielded 2.1.0 → 3.0.1

package/dist/ShieldedWallet.d.ts

@@ -1,28 +1,31 @@
-import { type ProtocolState, ProtocolVersion, SyncProgress } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type ProtocolState, ProtocolVersion, type SyncProgress } 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-v8';
 import * as rx from 'rxjs';
 import { type BalancingResult } from './v1/Transacting.js';
 import { type SerializationCapability } from './v1/Serialization.js';
-import { type TransactionHistoryCapability } from './v1/TransactionHistory.js';
+import { type TransactionHistoryService } 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> = {
+export type ShieldedWalletCapabilities<TSerialized = string> = {
     serialization: SerializationCapability<CoreWallet, null, TSerialized>;
     coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
     keys: KeysCapability<CoreWallet>;
-    transactionHistory: TransactionHistoryCapability<CoreWallet, TTransaction>;
+};
+export type ShieldedWalletServices = {
+    transactionHistory: TransactionHistoryService;
 };
 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>;
+export declare class ShieldedWalletState<TSerialized = string, _TTransaction = ledger.FinalizedTransaction> {
+    static readonly mapState: <TSerialized_1 = string>(variant: ShieldedWalletCapabilities<TSerialized_1> & ShieldedWalletServices) => (state: ProtocolState.ProtocolState<CoreWallet>) => ShieldedWalletState<TSerialized_1>;
     readonly protocolVersion: ProtocolVersion.ProtocolVersion;
     readonly state: CoreWallet;
-    readonly capabilities: ShieldedWalletCapabilities<TSerialized, TTransaction>;
+    readonly capabilities: ShieldedWalletCapabilities<TSerialized>;
+    readonly services: ShieldedWalletServices;
     get balances(): Record<ledger.RawTokenType, bigint>;
     get totalCoins(): readonly (AvailableCoin | PendingCoin)[];
     get availableCoins(): readonly AvailableCoin[];
@@ -31,12 +34,7 @@ export declare class ShieldedWalletState<TSerialized = string, TTransaction = le
     get encryptionPublicKey(): ShieldedEncryptionPublicKey;
     get address(): ShieldedAddress;
     get progress(): SyncProgress.SyncProgress;
-    /**
-     * Transaction history for the wallet.
-     * @throws Error - Not yet implemented
-     */
-    get transactionHistory(): never;
-    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: ShieldedWalletCapabilities<TSerialized, TTransaction>);
+    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: ShieldedWalletCapabilities<TSerialized>, services: ShieldedWalletServices);
     serialize(): TSerialized;
 }
 export type ShieldedWallet = CustomizedShieldedWallet<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;

package/dist/ShieldedWallet.js

@@ -17,12 +17,15 @@ import { Effect, Either } from 'effect';
 import * as rx from 'rxjs';
 import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
 export class ShieldedWalletState {
-    static mapState = (capabilities) => (state) => {
-        return new ShieldedWalletState(state, capabilities);
+    static mapState = (variant) => (state) => {
+        const { serialization, coinsAndBalances, keys } = variant;
+        const { transactionHistory } = variant;
+        return new ShieldedWalletState(state, { serialization, coinsAndBalances, keys }, { transactionHistory });
     };
     protocolVersion;
     state;
     capabilities;
+    services;
     get balances() {
         return this.capabilities.coinsAndBalances.getAvailableBalances(this.state);
     }
@@ -47,17 +50,11 @@ export class ShieldedWalletState {
     get progress() {
         return this.state.progress;
     }
-    /**
-     * Transaction history for the wallet.
-     * @throws Error - Not yet implemented
-     */
-    get transactionHistory() {
-        throw new Error('Transaction history is not yet implemented for ShieldedWallet');
-    }
-    constructor(state, capabilities) {
+    constructor(state, capabilities, services) {
         this.protocolVersion = state.version;
         this.state = state.state;
         this.capabilities = capabilities;
+        this.services = services;
     }
     serialize() {
         return this.capabilities.serialization.serialize(this.state);
@@ -122,8 +119,8 @@ export function CustomShieldedWallet(configuration, builder) {
             return rx.firstValueFrom(this.state.pipe(rx.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
         }
         /**
-         * Serializes the most recent state
-         * It's preferable to use [[ShieldedWalletState.serialize]] instead, to know exactly, which state is serialized
+         * Serializes the most recent state It's preferable to use [[ShieldedWalletState.serialize]] instead, to know
+         * exactly, which state is serialized
          */
         serializeState() {
             return rx.firstValueFrom(this.state).then((state) => state.serialize());

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './ShieldedWallet.js';
+export { type ShieldedTransactionHistoryEntry, ShieldedSectionSchema, mergeShieldedSections, } from './v1/TransactionHistory.js';

package/dist/index.js

@@ -11,3 +11,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 export * from './ShieldedWallet.js';
+export { ShieldedSectionSchema, mergeShieldedSections, } from './v1/TransactionHistory.js';

package/dist/v1/CoinsAndBalances.d.ts

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

package/dist/v1/CoreWallet.d.ts

@@ -1,7 +1,7 @@
 import * as ledger from '@midnight-ntwrk/ledger-v8';
 import { ProtocolVersion, SyncProgress } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Either } from 'effect';
-import { WalletError } from './WalletError.js';
+import { type WalletError } from './WalletError.js';
 export type PublicKeys = {
     coinPublicKey: ledger.CoinPublicKey;
     encryptionPublicKey: ledger.EncPublicKey;
@@ -37,7 +37,7 @@ export declare const CoreWallet: {
     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;
+    replayEventsWithChanges(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, events: ledger.Event[]): [CoreWallet, ledger.ZswapStateChanges[]];
     updateProgress(wallet: CoreWallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }: Partial<SyncProgress.SyncProgressData>): CoreWallet;
     addTransaction(wallet: CoreWallet, _tx: ledger.FinalizedTransaction): CoreWallet;
     revertTransaction<TTx extends ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>>(wallet: CoreWallet, tx: TTx): CoreWallet;

package/dist/v1/CoreWallet.js

@@ -106,10 +106,12 @@ export const CoreWallet = {
         const newCoinHashes = CoinHashesMap.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap.pickAllCoins(newState));
         return { ...wallet, state: newState, coinHashes: newCoinHashes };
     },
-    replayEvents(wallet, secretKeys, events) {
-        const newState = wallet.state.replayEvents(secretKeys, events);
+    replayEventsWithChanges(wallet, secretKeys, events) {
+        const stateWithChanges = wallet.state.replayEventsWithChanges(secretKeys, events);
+        const newState = stateWithChanges.state;
         const newCoinHashes = CoinHashesMap.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap.pickAllCoins(newState));
-        return { ...wallet, state: newState, coinHashes: newCoinHashes };
+        const updatedWallet = { ...wallet, state: newState, coinHashes: newCoinHashes };
+        return [updatedWallet, stateWithChanges.changes];
     },
     updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }) {
         const updatedProgress = SyncProgress.createSyncProgress({

package/dist/v1/RunningV1Variant.d.ts

@@ -2,24 +2,24 @@ import type * as ledger from '@midnight-ntwrk/ledger-v8';
 import { Effect, Scope, Stream } from 'effect';
 import { type WalletRuntimeError, type Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 import { type SerializationCapability } from './Serialization.js';
-import { type EventsSyncUpdate, type SyncCapability, type SyncService } from './Sync.js';
+import { type ChangesResult, 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';
+import { type TransactionHistoryService } from './TransactionHistory.js';
 export declare namespace RunningV1Variant {
     type Context<TSerialized, TSyncUpdate, TTransaction, TStartAux> = {
         serializationCapability: SerializationCapability<CoreWallet, null, TSerialized>;
         syncService: SyncService<CoreWallet, TStartAux, TSyncUpdate>;
-        syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
+        syncCapability: SyncCapability<CoreWallet, TSyncUpdate, ChangesResult>;
         transactingCapability: TransactingCapability<ledger.ZswapSecretKeys, CoreWallet, TTransaction>;
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
         coinSelection: CoinSelection<ledger.QualifiedShieldedCoinInfo>;
-        transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, TTransaction>;
+        transactionHistoryService: TransactionHistoryService;
     };
     type AnyContext = Context<any, any, any, any>;
 }

package/dist/v1/RunningV1Variant.js

@@ -49,15 +49,16 @@ export class RunningV1Variant {
         return this.startSync(startAux).pipe(Stream.runScoped(Sink.drain), Effect.forkScoped, Effect.provideService(Scope.Scope, this.#scope));
     }
     startSync(startAux) {
-        return pipe(SubscriptionRef.get(this.#context.stateRef), Stream.fromEffect, Stream.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), Stream.mapEffect((update) => {
-            return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => Effect.try({
-                try: () => this.#v1Context.syncCapability.applyUpdate(state, update),
-                catch: (err) => new OtherWalletError({
-                    message: 'Error while applying sync update',
-                    cause: err,
-                }),
-            }));
-        }), Stream.tapError((error) => Console.error(error)), Stream.retry(pipe(Schedule.exponential(Duration.seconds(1), 2), Schedule.map((delay) => {
+        return pipe(SubscriptionRef.get(this.#context.stateRef), Stream.fromEffect, Stream.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), Stream.mapEffect((update) => SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => Effect.try({
+            try: () => {
+                const [newState, changesResult] = this.#v1Context.syncCapability.applyUpdate(state, update);
+                return [changesResult, newState];
+            },
+            catch: (err) => new OtherWalletError({
+                message: 'Error while applying sync update',
+                cause: err,
+            }),
+        })).pipe(Effect.flatMap(({ changes, protocolVersion }) => pipe(Effect.forEach(changes, (change) => pipe(this.#v1Context.transactionHistoryService.getTransactionDetails(change.source), Effect.flatMap((metadata) => this.#v1Context.transactionHistoryService.put(change, metadata, protocolVersion)), Effect.catchAllCause((cause) => Console.error('Error processing tx history metadata', cause))), { discard: true, concurrency: 'unbounded' }), Effect.forkScoped)), Effect.provideService(Scope.Scope, this.#scope))), Stream.tapError((error) => Console.error(error)), Stream.retry(pipe(Schedule.exponential(Duration.seconds(1), 2), Schedule.map((delay) => {
             const maxDelay = Duration.minutes(2);
             const jitter = Duration.millis(Math.floor(Math.random() * 1000));
             const delayWithJitter = Duration.toMillis(delay) + Duration.toMillis(jitter);

package/dist/v1/Serialization.d.ts

@@ -1,7 +1,7 @@
 import { Either } from 'effect';
 import { WalletError } from './WalletError.js';
 import { CoreWallet } from './CoreWallet.js';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 export type SerializationCapability<TWallet, TAux, TSerialized> = {
     serialize(wallet: TWallet): TSerialized;
     deserialize(aux: TAux, data: TSerialized): Either.Either<TWallet, WalletError>;

package/dist/v1/Sync.d.ts

@@ -1,26 +1,52 @@
 import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { Schema, Scope, Stream } from 'effect';
+import { Schema, type Scope, Stream } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
-import { Simulator, SimulatorState } from './Simulator.js';
-import { WalletError } from './WalletError.js';
-import { TransactionHistoryCapability } from './TransactionHistory.js';
+import { type Simulator, type SimulatorState } from '@midnight-ntwrk/wallet-sdk-capabilities/simulation';
+import { type WalletError } from './WalletError.js';
+import { type TransactionHistoryService } from './TransactionHistory.js';
 export interface SyncService<TState, TStartAux, TUpdate> {
     updates: (state: TState, auxData: TStartAux) => Stream.Stream<TUpdate, WalletError, Scope.Scope>;
 }
-export interface SyncCapability<TState, TUpdate> {
-    applyUpdate: (state: TState, update: TUpdate) => TState;
+export type ChangesResult = {
+    readonly changes: ledger.ZswapStateChanges[];
+    readonly protocolVersion: number;
+};
+export interface SyncCapability<TState, TUpdate, TResult> {
+    applyUpdate: (state: TState, update: TUpdate) => [TState, TResult];
 }
 export type IndexerClientConnection = {
     indexerHttpUrl: string;
     indexerWsUrl?: string;
     keepAlive?: number;
 };
+export type BatchUpdatesConfig = {
+    /**
+     * Maximum number of events to collect into a single batch before emitting.
+     *
+     * @default 10
+     */
+    readonly size?: number;
+    /**
+     * Maximum time in milliseconds to wait for a full batch before emitting a partial one. Controls the `groupedWithin`
+     * timeout — lower values mean more responsive (but smaller) batches when events arrive slowly.
+     *
+     * @default 1
+     */
+    readonly timeout?: number;
+    /**
+     * Minimum delay in milliseconds injected between consecutive batches. Prevents the sync stream from saturating
+     * downstream consumers when many events are available at once. Set to 0 to disable spacing entirely.
+     *
+     * @default 4
+     */
+    readonly spacing?: number;
+};
 export type DefaultSyncConfiguration = {
     indexerClientConnection: IndexerClientConnection;
-    batchSize?: number;
+    batchUpdates?: BatchUpdatesConfig;
 };
 export type DefaultSyncContext = {
-    transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;
+    transactionHistoryService: TransactionHistoryService;
 };
 export type SecretKeysResource = <A>(cb: (keys: ledger.ZswapSecretKeys) => A) => A;
 export declare const SecretKeysResource: {
@@ -35,12 +61,13 @@ export declare const WalletSyncUpdate: {
 };
 export declare const EventsSyncUpdate: Schema.TaggedStruct<"EventsSyncUpdate", {
     id: typeof Schema.Number;
+    protocolVersion: typeof Schema.Number;
     maxId: typeof Schema.Number;
     event: Schema.declare<ledger.Event, ledger.Event, readonly [], never>;
 }>;
 export type EventsSyncUpdate = Schema.Schema.Type<typeof EventsSyncUpdate>;
 export declare const makeEventsSyncService: (config: DefaultSyncConfiguration) => SyncService<CoreWallet, ledger.ZswapSecretKeys, WalletSyncUpdate>;
-export declare const makeEventsSyncCapability: () => SyncCapability<CoreWallet, WalletSyncUpdate>;
+export declare const makeEventsSyncCapability: () => SyncCapability<CoreWallet, WalletSyncUpdate, ChangesResult>;
 export type SimulatorSyncConfiguration = {
     simulator: Simulator;
 };
@@ -49,4 +76,4 @@ export type SimulatorSyncUpdate = {
     secretKeys: ledger.ZswapSecretKeys;
 };
 export declare const makeSimulatorSyncService: (config: SimulatorSyncConfiguration) => SyncService<CoreWallet, ledger.ZswapSecretKeys, SimulatorSyncUpdate>;
-export declare const makeSimulatorSyncCapability: () => SyncCapability<CoreWallet, SimulatorSyncUpdate>;
+export declare const makeSimulatorSyncCapability: () => SyncCapability<CoreWallet, SimulatorSyncUpdate, ChangesResult>;

package/dist/v1/Sync.js

@@ -13,6 +13,7 @@
 import * as ledger from '@midnight-ntwrk/ledger-v8';
 import { Chunk, Duration, Effect, Either, ParseResult, pipe, Schedule, Schema, Stream } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
+import { getLastBlock, getBlockEventsFrom, } from '@midnight-ntwrk/wallet-sdk-capabilities/simulation';
 import { ZswapEvents } from '@midnight-ntwrk/wallet-sdk-indexer-client';
 import { ConnectionHelper, WsSubscriptionClient } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
 import { SyncWalletError } from './WalletError.js';
@@ -55,10 +56,12 @@ const HexedLedgerEvent = pipe(Schema.Uint8ArrayFromHex, Schema.compose(LedgerEve
 const EventsSyncUpdatePayload = Schema.Struct({
     id: Schema.Number,
     raw: Schema.String,
+    protocolVersion: Schema.Number,
     maxId: Schema.Number,
 });
 export const EventsSyncUpdate = Schema.TaggedStruct('EventsSyncUpdate', {
     id: Schema.Number,
+    protocolVersion: Schema.Number,
     maxId: Schema.Number,
     event: LedgerEventSchema,
 });
@@ -66,12 +69,14 @@ const EventsSyncUpdateFromPayload = Schema.transformOrFail(EventsSyncUpdatePaylo
     decode: (input) => pipe(Schema.decodeUnknownEither(HexedLedgerEvent)(input.raw), Either.map((event) => ({
         _tag: 'EventsSyncUpdate',
         id: input.id,
+        protocolVersion: input.protocolVersion,
         maxId: input.maxId,
         event,
     })), Either.mapLeft((error) => new ParseResult.Unexpected(error, 'Failed to decode ledger event payload')), EitherOps.toEffect),
     encode: (output) => pipe(Schema.encodeEither(HexedLedgerEvent)(output.event), Either.map((raw) => ({
         id: output.id,
         raw,
+        protocolVersion: output.protocolVersion,
         maxId: output.maxId,
     })), Either.mapLeft((error) => new ParseResult.Unexpected(error, 'Failed to encode ledger event payload')), EitherOps.toEffect),
 });
@@ -89,8 +94,13 @@ export const makeEventsSyncService = (config) => {
             }
             const indexerWsUrl = indexerWsUrlResult.right;
             const appliedIndex = state.progress?.appliedIndex ?? 0n;
-            const batchSize = config.batchSize ?? 10;
-            return pipe(ZswapEvents.run({ id: Number(appliedIndex) }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerWsUrl, keepAlive: config.indexerClientConnection.keepAlive })), 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))));
+            const batchSize = config.batchUpdates?.size ?? 10;
+            const batchTimeout = Duration.millis(config.batchUpdates?.timeout ?? 1);
+            const batchSpacing = config.batchUpdates?.spacing ?? 4;
+            const eventsStream = pipe(ZswapEvents.run({ id: Number(appliedIndex) }), Stream.provideLayer(WsSubscriptionClient.layer({ url: indexerWsUrl, keepAlive: config.indexerClientConnection.keepAlive })), 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, batchTimeout), Stream.map(Chunk.toArray), Stream.map((data) => WalletSyncUpdate.create(data, secretKeys)));
+            return batchSpacing > 0
+                ? Stream.schedule(eventsStream, Schedule.spaced(Duration.millis(batchSpacing)))
+                : eventsStream;
         },
     };
 };
@@ -98,7 +108,7 @@ export const makeEventsSyncCapability = () => {
     return {
         applyUpdate: (state, wrappedUpdate) => {
             if (wrappedUpdate.updates.length === 0) {
-                return state;
+                return [state, { changes: [], protocolVersion: Number(state.protocolVersion) }];
             }
             const lastUpdate = wrappedUpdate.updates.at(-1);
             const nextIndex = BigInt(lastUpdate.id);
@@ -106,29 +116,67 @@ export const makeEventsSyncCapability = () => {
             // in case the nextIndex is less than or equal to the appliedIndex
             // just update highestRelevantWalletIndex
             if (nextIndex <= state.progress.appliedIndex) {
-                return CoreWallet.updateProgress(state, {
-                    highestRelevantWalletIndex,
-                    isConnected: true,
-                });
+                return [
+                    CoreWallet.updateProgress(state, {
+                        highestRelevantWalletIndex,
+                        isConnected: true,
+                    }),
+                    { changes: [], protocolVersion: lastUpdate.protocolVersion },
+                ];
             }
-            return CoreWallet.updateProgress(CoreWallet.replayEvents(state, wrappedUpdate.secretKeys, wrappedUpdate.updates.map((u) => u.event)), {
+            const [newState, newChanges] = CoreWallet.replayEventsWithChanges(state, wrappedUpdate.secretKeys, wrappedUpdate.updates.map((u) => u.event));
+            const updatedState = CoreWallet.updateProgress(newState, {
                 highestRelevantWalletIndex,
                 appliedIndex: nextIndex,
                 isConnected: true,
             });
+            return [updatedState, { changes: newChanges, protocolVersion: lastUpdate.protocolVersion }];
         },
     };
 };
 export const makeSimulatorSyncService = (config) => {
     return {
-        updates: (_state, secretKeys) => config.simulator.state$.pipe(Stream.map((state) => ({ update: state, secretKeys: secretKeys }))),
+        updates: (_state, secretKeys) => {
+            // Get the initial state immediately to ensure we process the genesis block.
+            // Then subscribe to state$ for subsequent changes, but deduplicate by block number
+            // to avoid processing the same block twice.
+            let lastSeenBlockNumber;
+            return pipe(Stream.fromEffect(config.simulator.getLatestState()), Stream.concat(config.simulator.state$), Stream.filter((state) => {
+                const lastBlock = getLastBlock(state);
+                if (lastBlock === undefined) {
+                    return false; // Skip blank state
+                }
+                const blockNumber = lastBlock.number;
+                // Skip if we've already seen this block (deduplication)
+                if (lastSeenBlockNumber !== undefined && blockNumber <= lastSeenBlockNumber) {
+                    return false;
+                }
+                lastSeenBlockNumber = blockNumber;
+                return true;
+            }), Stream.map((state) => ({ update: state, secretKeys })));
+        },
     };
 };
 export const makeSimulatorSyncCapability = () => {
     return {
         applyUpdate: (state, update) => {
-            const { update: { lastTxResult: { events }, }, secretKeys, } = update;
-            return CoreWallet.replayEvents(state, secretKeys, events);
+            const { update: simulatorState, secretKeys } = update;
+            const lastBlock = getLastBlock(simulatorState);
+            if (lastBlock === undefined) {
+                return [state, { changes: [], protocolVersion: Number(state.protocolVersion) }];
+            }
+            // Get all events from blocks starting at appliedIndex (the next block to process).
+            // appliedIndex semantics: the first block number we haven't processed yet.
+            // Initial: appliedIndex = 0 (haven't processed any blocks)
+            // After processing block N: appliedIndex = N + 1 (next block to process)
+            const events = [...getBlockEventsFrom(simulatorState, state.progress.appliedIndex)];
+            const [newState, newChanges] = CoreWallet.replayEventsWithChanges(state, secretKeys, events);
+            return [
+                CoreWallet.updateProgress(newState, {
+                    appliedIndex: lastBlock.number + 1n,
+                }),
+                { changes: newChanges, protocolVersion: Number(state.protocolVersion) },
+            ];
         },
     };
 };

package/dist/v1/Transacting.d.ts

@@ -1,14 +1,14 @@
 import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Array as Arr, Either } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
-import { WalletError } from './WalletError.js';
-import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { ShieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { type WalletError } from './WalletError.js';
+import { type CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { type ShieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 import { TransactionImbalances } from './TransactionImbalances.js';
 import { TransactionOps } from './TransactionOps.js';
-import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
-import { KeysCapability } from './Keys.js';
+import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { type KeysCapability } from './Keys.js';
 export interface TokenTransfer {
     readonly amount: bigint;
     readonly type: ledger.RawTokenType;
@@ -44,7 +44,7 @@ export declare class TransactingCapabilityImplementation<TTransaction extends le
     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;
+        fallibleOffers: Map<number, ledger.ZswapOffer<ledger.PreProof>>;
         newState: CoreWallet;
     }, WalletError>;
 }

package/dist/v1/Transacting.js

@@ -44,9 +44,10 @@ export class TransactingCapabilityImplementation {
             if (TransactionImbalances.areBalanced(initialImbalances)) {
                 return [undefined, state];
             }
-            const { newState: afterFallible, offer: maybeFallible } = yield* this.balanceFallibleSection(secretKeys, state, initialImbalances, coinSelection);
+            const { newState: afterFallible, fallibleOffers } = yield* this.balanceFallibleSection(secretKeys, state, initialImbalances, coinSelection);
             const { newState: afterGuaranteed, offer: guaranteed } = yield* this.#balanceGuaranteedSection(secretKeys, afterFallible, initialImbalances, coinSelection, Imbalances.empty());
-            return [ledger.Transaction.fromParts(this.networkId, guaranteed, maybeFallible), afterGuaranteed];
+            const balancedTx = Array.from(fallibleOffers.entries()).reduce((tx, [segment, offer]) => tx.addZswapOffer({ tag: 'specific', value: segment }, offer), ledger.Transaction.fromParts(this.networkId, guaranteed));
+            return [balancedTx, afterGuaranteed];
         });
     }
     makeTransfer(secretKeys, state, transfers) {
@@ -120,43 +121,44 @@ export class TransactingCapabilityImplementation {
         }), Option.map((offer) => ({ offer, newState: stateAfterWatches })));
     }
     balanceFallibleSection(secretKeys, state, imbalances, coinSelection) {
-        return Either.try({
+        return Array.from(imbalances.fallible.entries()).reduce((acc, [segment, segmentImbalances]) => Either.flatMap(acc, ({ fallibleOffers, newState }) => pipe(Either.try({
             try: () => {
                 const fallibleBalanceRecipe = getBalanceRecipe({
                     coins: this.getCoins()
-                        .getAvailableCoins(state)
+                        .getAvailableCoins(newState)
                         .map((c) => c.coin),
-                    initialImbalances: imbalances.fallible,
+                    initialImbalances: segmentImbalances,
                     transactionCostModel: ShieldedCostModel,
                     feeTokenType: '',
                     coinSelection,
                     createOutput: (coin) => ledger.createShieldedCoinInfo(coin.type, coin.value),
                     isCoinEqual: (a, b) => a.type === b.type && a.value === b.value,
                 });
-                return pipe(this.#prepareOffer(secretKeys, state, fallibleBalanceRecipe, 1), Option.match({
-                    onNone: () => ({
-                        newState: state,
-                        offer: undefined,
-                    }),
-                    onSome: (res) => res,
-                }));
+                return this.#prepareOffer(secretKeys, newState, fallibleBalanceRecipe, segment);
             },
             catch: (err) => {
                 if (err instanceof BalancingInsufficientFundsError) {
                     return new InsufficientFundsError({
-                        message: 'Insufficient funds',
+                        message: `Insufficient funds for fallible segment ${segment}`,
                         tokenType: err.tokenType,
-                        amount: imbalances.fallible.get(err.tokenType) ?? 0n,
-                    });
-                }
-                else {
-                    return new OtherWalletError({
-                        message: 'Balancing fallible section failed',
-                        cause: err,
+                        amount: segmentImbalances.get(err.tokenType) ?? 0n,
                     });
                 }
+                return new OtherWalletError({
+                    message: `Balancing fallible segment ${segment} failed`,
+                    cause: err,
+                });
             },
-        });
+        }), Either.map(Option.match({
+            onNone: () => ({ fallibleOffers, newState }),
+            onSome: (res) => ({
+                fallibleOffers: new Map([...fallibleOffers, [segment, res.offer]]),
+                newState: res.newState,
+            }),
+        })))), Either.right({
+            fallibleOffers: new Map(),
+            newState: state,
+        }));
     }
     #balanceGuaranteedSection(secretKeys, state, imbalances, coinSelection, targetImbalances) {
         return Either.gen(this, function* () {

package/dist/v1/TransactionHistory.d.ts

@@ -1,9 +1,64 @@
-import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { CoreWallet } from './CoreWallet.js';
-export type TransactionHistoryCapability<TState, TTransaction> = {
-    updateTxHistory(state: TState, newTxs: TTransaction[]): TState;
-    transactionHistory(state: TState): readonly TTransaction[];
+import { TransactionHistoryStorage } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { Effect, Schema } from 'effect';
+import { TransactionHistoryError } from './WalletError.js';
+export declare const QualifiedShieldedCoinInfoSchema: Schema.Struct<{
+    type: typeof Schema.String;
+    nonce: typeof Schema.String;
+    value: typeof Schema.BigInt;
+    mtIndex: typeof Schema.BigInt;
+}>;
+export declare const ShieldedSectionSchema: Schema.Struct<{
+    receivedCoins: Schema.Array$<Schema.Struct<{
+        type: typeof Schema.String;
+        nonce: typeof Schema.String;
+        value: typeof Schema.BigInt;
+        mtIndex: typeof Schema.BigInt;
+    }>>;
+    spentCoins: Schema.Array$<Schema.Struct<{
+        type: typeof Schema.String;
+        nonce: typeof Schema.String;
+        value: typeof Schema.BigInt;
+        mtIndex: typeof Schema.BigInt;
+    }>>;
+}>;
+type ShieldedSection = Schema.Schema.Type<typeof ShieldedSectionSchema>;
+export declare const ShieldedTransactionHistoryEntrySchema: Schema.Struct<{
+    hash: typeof Schema.String;
+    protocolVersion: typeof Schema.Number;
+    status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
+    shielded: Schema.Struct<{
+        receivedCoins: Schema.Array$<Schema.Struct<{
+            type: typeof Schema.String;
+            nonce: typeof Schema.String;
+            value: typeof Schema.BigInt;
+            mtIndex: typeof Schema.BigInt;
+        }>>;
+        spentCoins: Schema.Array$<Schema.Struct<{
+            type: typeof Schema.String;
+            nonce: typeof Schema.String;
+            value: typeof Schema.BigInt;
+            mtIndex: typeof Schema.BigInt;
+        }>>;
+    }>;
+}>;
+export type ShieldedTransactionHistoryEntry = Schema.Schema.Type<typeof ShieldedTransactionHistoryEntrySchema>;
+export type DefaultTransactionHistoryConfiguration = {
+    txHistoryStorage: TransactionHistoryStorage.TransactionHistoryStorage<TransactionHistoryStorage.TransactionHistoryEntryWithHash>;
+    indexerClientConnection: {
+        indexerHttpUrl: string;
+    };
 };
-export declare const makeDefaultTransactionHistoryCapability: () => TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;
-export declare const makeSimulatorTransactionHistoryCapability: () => TransactionHistoryCapability<CoreWallet, ledger.ProofErasedTransaction>;
-export declare const makeDiscardTransactionHistoryCapability: () => TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;
+export type TransactionDetails = {
+    hash: string;
+    timestamp: number;
+    status: 'SUCCESS' | 'FAILURE' | 'PARTIAL_SUCCESS';
+};
+export type TransactionHistoryService = {
+    put(changes: ledger.ZswapStateChanges, metadata: TransactionDetails, protocolVersion: number): Effect.Effect<void, TransactionHistoryError>;
+    getTransactionDetails(hash: TransactionHistoryStorage.TransactionHash): Effect.Effect<TransactionDetails, TransactionHistoryError>;
+};
+export declare const mergeShieldedSections: (existing: ShieldedSection, incoming: ShieldedSection) => ShieldedSection;
+export declare const makeDefaultTransactionHistoryService: (config: DefaultTransactionHistoryConfiguration, _getContext: () => unknown) => TransactionHistoryService;
+export declare const makeSimulatorTransactionHistoryService: (config: DefaultTransactionHistoryConfiguration, _getContext: () => unknown) => TransactionHistoryService;
+export {};