@beam-network/sdk 0.2.17 → 0.2.19

package/README.md

@@ -95,6 +95,6 @@ For low-level raw transfer configs, use `createRawTransfer`; lifecycle transport
 
 ## Route Streaming And Payload Size
 
-Provider transfers stream signed routes over NATS in target batches of 512 routes. The SDK still splits a batch earlier when the encoded MessagePack request would exceed `maxPayloadBytes`, which defaults to 24 MiB.
+Provider transfers stream signed routes over NATS in target batches of 128 routes. Signing continues while completed batches are sent in order. The SDK still splits a batch earlier when the encoded MessagePack request would exceed `maxPayloadBytes`, which defaults to 24 MiB.
 
 NATS requires this guard because the broker rejects messages above its configured `max_payload`. This limit applies only to lifecycle/control metadata; transfer file bytes do not flow through NATS.

package/dist/client.js

@@ -113,7 +113,7 @@ export class BeamClient {
         });
         await stream.begin();
         for (const route of input.chunkRoutes) {
-            await stream.addRoute(route);
+            stream.addRoute(route);
         }
         return stream.complete();
     }
@@ -223,7 +223,7 @@ export class BeamClient {
                         }
                         multipartUploads.set(multipartKey, upload);
                     }
-                    await routeStream.addRoute(await this.signProviderRoute({
+                    routeStream.addRoute(await this.signProviderRoute({
                         chunk,
                         target,
                         source,
@@ -245,6 +245,7 @@ export class BeamClient {
             }
         }
         catch (error) {
+            routeStream.abort();
             this.stopRecoverySigner(prepared.transfer_id);
             await abortCreatedUploads(multipartUploads);
             if (routeStreamStarted) {
@@ -440,9 +441,9 @@ export class BeamClient {
         }
     }
 }
-// Target route-stream batches at 512 signed routes. The transport still splits
+// Target route-stream batches at 128 signed routes. The transport still splits
 // earlier when the encoded NATS request would exceed maxPayloadBytes.
-const ROUTE_STREAM_TARGET_BATCH_ROUTES = 512;
+const ROUTE_STREAM_TARGET_BATCH_ROUTES = 128;
 class RouteStreamSender {
     control;
     options;
@@ -450,6 +451,8 @@ class RouteStreamSender {
     checksum = new RouteKeysChecksum();
     batch = [];
     batchIndex = 0;
+    sendTail = Promise.resolve();
+    sendError = null;
     constructor(control, options) {
         this.control = control;
         this.options = options;
@@ -465,15 +468,17 @@ class RouteStreamSender {
             auto_distribute: this.options.autoDistribute
         }), this.options.transferId);
     }
-    async addRoute(route) {
-        await this.checksum.add(routeKeyForSignedRoute(route));
+    addRoute(route) {
         this.batch.push(route);
         if (this.batch.length >= ROUTE_STREAM_TARGET_BATCH_ROUTES) {
-            await this.flush();
+            this.enqueueFlush();
         }
     }
     async complete() {
-        await this.flush();
+        this.enqueueFlush();
+        await this.sendTail;
+        if (this.sendError)
+            throw this.sendError;
         return this.control.request("transfer.route_stream.complete", {
             transfer_id: this.options.transferId,
             stream_id: this.streamId,
@@ -482,7 +487,7 @@ class RouteStreamSender {
             route_keys_checksum: this.checksum.value()
         }, this.options.transferId);
     }
-    async flush() {
+    enqueueFlush() {
         if (!this.batch.length)
             return;
         const routes = this.batch.splice(0, this.batch.length);
@@ -495,39 +500,55 @@ class RouteStreamSender {
         for (const chunk of chunks) {
             const batchIndex = this.batchIndex;
             this.batchIndex += 1;
-            await this.control.request("transfer.route_stream.batch", {
-                transfer_id: this.options.transferId,
-                stream_id: this.streamId,
-                batch_id: `${this.streamId}:${batchIndex}`,
-                batch_index: batchIndex,
-                chunk_routes: chunk,
-                route_count: chunk.length,
-                route_keys_checksum: await routeKeysChecksum(chunk.map(routeKeyForSignedRoute))
-            }, this.options.transferId);
+            this.sendTail = this.sendTail.then(async () => {
+                if (this.sendError)
+                    return;
+                try {
+                    const chunkChecksum = new RouteKeysChecksum();
+                    await chunkChecksum.addMany(chunk.map(routeKeyForSignedRoute));
+                    this.checksum.merge(chunkChecksum);
+                    await this.control.request("transfer.route_stream.batch", {
+                        transfer_id: this.options.transferId,
+                        stream_id: this.streamId,
+                        batch_id: `${this.streamId}:${batchIndex}`,
+                        batch_index: batchIndex,
+                        chunk_routes: chunk,
+                        route_count: chunk.length,
+                        route_keys_checksum: chunkChecksum.value()
+                    }, this.options.transferId);
+                }
+                catch (error) {
+                    this.sendError = error;
+                }
+            });
         }
     }
+    abort() {
+        this.sendError ??= new Error("route_stream_aborted");
+    }
 }
 class RouteKeysChecksum {
     bytes = new Uint8Array(32);
     count = 0;
-    async add(routeKeyValue) {
-        const digest = await sha256Bytes(routeKeyValue);
+    async addMany(routeKeys) {
+        const digests = await Promise.all(routeKeys.map(sha256Bytes));
+        for (const digest of digests) {
+            for (let index = 0; index < this.bytes.length; index += 1) {
+                this.bytes[index] ^= digest[index] ?? 0;
+            }
+        }
+        this.count += routeKeys.length;
+    }
+    merge(other) {
         for (let index = 0; index < this.bytes.length; index += 1) {
-            this.bytes[index] ^= digest[index] ?? 0;
+            this.bytes[index] ^= other.bytes[index] ?? 0;
         }
-        this.count += 1;
+        this.count += other.count;
     }
     value() {
         return `sha256-xor-v1:${this.count}:${hex(this.bytes)}`;
     }
 }
-async function routeKeysChecksum(routeKeys) {
-    const checksum = new RouteKeysChecksum();
-    for (const routeKeyValue of routeKeys) {
-        await checksum.add(routeKeyValue);
-    }
-    return checksum.value();
-}
 function routeKeyForSignedRoute(route) {
     return `${route.source_id}:${route.destination_id}:${route.chunk_index}`;
 }

package/dist/nats-control.js

@@ -7,6 +7,25 @@ export const BEAM_DEFAULT_NATS_WS_URL = "wss://nats.b1m.ai:443";
 // messages before the broker rejects them; transfer bytes never flow through NATS.
 export const BEAM_DEFAULT_MAX_PAYLOAD_BYTES = 24 * 1024 * 1024;
 export const ROUTE_RECOVERY_SIGN_MESSAGE_TYPE = "transfer.route_recovery.sign";
+function buildConnectionOptions(options) {
+    const connectionOptions = {
+        servers: options.natsUrl,
+        user: options.keyPrefix,
+        pass: options.apiKey,
+        name: `beam-sdk-${options.keyPrefix}`
+    };
+    if (options.natsUrl.startsWith("tls://")) {
+        const tlsOptions = { handshakeFirst: true };
+        try {
+            tlsOptions.servername = new URL(options.natsUrl).hostname;
+        }
+        catch {
+            // URL validation stays with the NATS client; TLS-first is still required.
+        }
+        connectionOptions.tls = tlsOptions;
+    }
+    return connectionOptions;
+}
 export class BeamTransferControl {
     environment;
     keyPrefix;
@@ -145,12 +164,11 @@ export class BeamTransferControl {
     async connection() {
         if (this.nc && !this.nc.isClosed())
             return this.nc;
-        this.nc = await connect({
-            servers: this.natsUrl,
-            user: this.keyPrefix,
-            pass: this.apiKey,
-            name: `beam-sdk-${this.keyPrefix}`
-        });
+        this.nc = await connect(buildConnectionOptions({
+            natsUrl: this.natsUrl,
+            apiKey: this.apiKey,
+            keyPrefix: this.keyPrefix
+        }));
         return this.nc;
     }
     async resolveAuthToken() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@beam-network/sdk",
-    "version": "0.2.17",
+    "version": "0.2.19",
     "description": "TypeScript SDK for BEAM transfer creation and management.",
     "type": "module",
     "license": "MIT",