@midnight-ntwrk/wallet-sdk-shielded 3.0.0 → 3.0.2

package/README.md

@@ -1,3 +1,10 @@
+> [!IMPORTANT]
+> **This package has moved.** The `@midnight-ntwrk` scope is published only
+> during the migration window and will stop receiving updates. Please migrate to
+> [`@midnightntwrk/wallet-sdk-shielded`](https://www.npmjs.com/package/@midnightntwrk/wallet-sdk-shielded).
+
+---
+
 # @midnight-ntwrk/wallet-sdk-shielded
 
 Manages shielded tokens on the Midnight network using zero-knowledge proofs.

package/dist/v1/RunningV1Variant.js

@@ -58,7 +58,14 @@ export class RunningV1Variant {
                 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) => {
+        })).pipe(Effect.flatMap(({ changes, protocolVersion }) => 
+        // Skip the tx-history fork entirely when there are no changes.
+        // Forking unconditionally allocates a fiber per apply call (one
+        // for every batch the sync emits, even the all-progress ones),
+        // which adds up fast during catch-up.
+        changes.length === 0
+            ? Effect.void
+            : 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/Sync.d.ts

@@ -18,6 +18,10 @@ export type IndexerClientConnection = {
     indexerHttpUrl: string;
     indexerWsUrl?: string;
     keepAlive?: number;
+    /** Cap on the in-flight event queue between the WebSocket push and the apply loop. Default: 10000. */
+    bufferSize?: number;
+    /** In-flight count at which the disposed WS subscription is reopened. Default: 100. */
+    resumeThreshold?: number;
 };
 export type BatchUpdatesConfig = {
     /**

package/dist/v1/Sync.js

@@ -94,10 +94,36 @@ export const makeEventsSyncService = (config) => {
             }
             const indexerWsUrl = indexerWsUrlResult.right;
             const appliedIndex = state.progress?.appliedIndex ?? 0n;
+            // The boundary is load-bearing, not waste: this subscription emits only events (no tip/progress
+            // sentinel), and `isConnected`/the tip (`maxId`) are set only when an event is received. So the
+            // cursor must stay `<= appliedIndex` — never `appliedIndex + 1`. Requesting one event later would
+            // deliver nothing to a wallet already at the tip, so `applyUpdate` would never run and sync would
+            // hang.
+            //
+            // A fresh wallet has `appliedIndex === 0n` (the "nothing applied yet" sentinel), so `resumeFrom`
+            // is `-1n` and the `variables` mapping below opens the subscription with no `id` — the indexer
+            // streams from the very start. A restored wallet has `appliedIndex >= 1`, so `resumeFrom` is
+            // `appliedIndex - 1` and the inclusive cursor re-delivers the boundary event.
+            const resumeFrom = appliedIndex - 1n;
             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)));
+            const bufferSize = config.indexerClientConnection.bufferSize ?? 10000;
+            const resumeThreshold = config.indexerClientConnection.resumeThreshold ?? 100;
+            const eventsStream = pipe(
+            // Backpressure caps the in-flight queue between the WS push and the
+            // apply loop. Without it the JS heap grows linearly with catch-up
+            // depth, since `Stream.asyncPush({ bufferSize: 'unbounded' })`
+            // buffers every event the indexer pushes regardless of apply rate.
+            ZswapEvents.runWithBackpressure({
+                bufferSize,
+                resumeThreshold,
+                from: resumeFrom,
+                // `resumeFrom < 0n` means a fresh wallet: send no `id` so the indexer streams from the very
+                // start, rather than relying on `id: 0` sorting below the first real event id.
+                variables: (cursor) => ({ id: cursor < 0n ? null : Number(cursor) }),
+                key: (r) => BigInt(r.zswapLedgerEvents.id),
+            }), 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;
@@ -110,24 +136,22 @@ export const makeEventsSyncCapability = () => {
             if (wrappedUpdate.updates.length === 0) {
                 return [state, { changes: [], protocolVersion: Number(state.protocolVersion) }];
             }
+            // The subscription resumes at the last-applied index and its cursor is inclusive, so the
+            // boundary event (id === appliedIndex) is re-delivered. Replaying it would re-insert
+            // commitments already in the zswap state ("non-linear insertion" error), so only events
+            // strictly after the applied index are replayed. The boundary is still used (below) to
+            // refresh the tip and mark the wallet connected — that is how an already-caught-up wallet
+            // learns it is synced when no new events exist.
+            const appliedIndex = state.progress?.appliedIndex ?? 0n;
+            const freshUpdates = wrappedUpdate.updates.filter((u) => BigInt(u.id) > appliedIndex);
             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) {
-                return [
-                    CoreWallet.updateProgress(state, {
-                        highestRelevantWalletIndex,
-                        isConnected: true,
-                    }),
-                    { changes: [], protocolVersion: lastUpdate.protocolVersion },
-                ];
-            }
-            const [newState, newChanges] = CoreWallet.replayEventsWithChanges(state, wrappedUpdate.secretKeys, wrappedUpdate.updates.map((u) => u.event));
+            const [newState, newChanges] = freshUpdates.length === 0
+                ? [state, []]
+                : CoreWallet.replayEventsWithChanges(state, wrappedUpdate.secretKeys, freshUpdates.map((u) => u.event));
             const updatedState = CoreWallet.updateProgress(newState, {
                 highestRelevantWalletIndex,
-                appliedIndex: nextIndex,
+                appliedIndex: freshUpdates.length === 0 ? appliedIndex : BigInt(freshUpdates.at(-1).id),
                 isConnected: true,
             });
             return [updatedState, { changes: newChanges, protocolVersion: lastUpdate.protocolVersion }];

package/dist/v1/Transacting.js

@@ -46,9 +46,7 @@ export class TransactingCapabilityImplementation {
             }
             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());
-            const balancedTx = ledger.Transaction.fromParts(this.networkId, guaranteed);
-            // workaround as Transaction.fromParts does not accept fallible offers with specific segments
-            balancedTx.fallibleOffer = fallibleOffers.size > 0 ? fallibleOffers : undefined;
+            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];
         });
     }
@@ -193,10 +191,11 @@ export class TransactingCapabilityImplementation {
                     }
                 },
             });
-            return yield* pipe(this.#prepareOffer(secretKeys, state, balanceRecipe, 0), Either.fromOption(() => {
-                return new OtherWalletError({
-                    message: 'Could not create a valid guaranteed offer',
-                });
+            // An empty recipe (e.g. the guaranteed section is already balanced) yields no offer.
+            // Treat that as "nothing to add" rather than a failure, mirroring the fallible section.
+            return pipe(this.#prepareOffer(secretKeys, state, balanceRecipe, 0), Option.match({
+                onNone: () => ({ offer: undefined, newState: state }),
+                onSome: (result) => result,
             }));
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-shielded",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -8,14 +8,16 @@
   "author": "Midnight Foundation",
   "license": "Apache-2.0",
   "publishConfig": {
-    "registry": "https://npm.pkg.github.com/"
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
   },
   "files": [
     "dist/"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/midnight-ntwrk/artifacts.git"
+    "url": "git+https://github.com/midnightntwrk/midnight-wallet.git",
+    "directory": "packages/shielded-wallet"
   },
   "exports": {
     ".": {
@@ -28,13 +30,13 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v8": "^8.0.3",
-    "@midnight-ntwrk/wallet-sdk-abstractions": "2.1.0",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.1.1",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.3.0",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.2.1",
-    "@midnight-ntwrk/wallet-sdk-runtime": "1.0.3",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.1.1",
+    "@midnight-ntwrk/ledger-v8": "^8.1.0",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "^2.1.0",
+    "@midnight-ntwrk/wallet-sdk-address-format": "^3.1.2",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "^3.3.1",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "^1.2.3",
+    "@midnight-ntwrk/wallet-sdk-runtime": "^1.0.5",
+    "@midnight-ntwrk/wallet-sdk-utilities": "^1.2.0",
     "effect": "^3.19.19",
     "rxjs": "^7.8.2"
   },