@matter/protocol 0.16.0-alpha.0-20251217-038f88085 → 0.16.0-alpha.0-20251221-21acf226d

package/src/bdx/BdxProtocol.ts

@@ -4,9 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Logger, MatterError, StorageContext } from "#general";
+import { BdxError } from "#bdx/BdxError.js";
+import { FileDesignator } from "#bdx/FileDesignator.js";
+import { PersistedFileDesignator } from "#bdx/PersistedFileDesignator.js";
+import { ScopedStorage } from "#bdx/ScopedStorage.js";
+import { Duration, Environment, Environmental, isDeepEqual, Logger, MatterError, Observable } from "#general";
+import { PeerAddress } from "#peer/PeerAddress.js";
+import { ExchangeManager } from "#protocol/ExchangeManager.js";
 import { MessageExchange } from "#protocol/MessageExchange.js";
 import { ProtocolHandler } from "#protocol/ProtocolHandler.js";
+import { SecureSession } from "#session/SecureSession.js";
 import { BDX_PROTOCOL_ID, BdxMessageType, BdxStatusCode } from "#types";
 import { Message } from "../codec/MessageCodec.js";
 import { BdxMessenger } from "./BdxMessenger.js";
@@ -20,23 +27,68 @@ const logger = Logger.get("BdxProtocol");
 export class BdxProtocol implements ProtocolHandler {
     readonly id = BDX_PROTOCOL_ID;
     readonly requiresSecureSession = true;
-    readonly #activeBdxSessions = new Map<MessageExchange, BdxSession>();
-    #storage: StorageContext;
-    #bdxLimits?: BdxSessionConfiguration.Config;
-
-    /**
-     * Create a new BDX protocol handler.
-     * @param storage StorageContext to read or write files from/to.
-     * @param options BDX options/limits to use for this session. us this to control how the transfer should behave.
-     */
-    constructor(storage: StorageContext, options?: BdxSessionConfiguration.Config) {
-        this.#storage = storage;
-        this.#bdxLimits = options;
+    readonly #activeBdxSessions = new Map<MessageExchange, { session: BdxSession; scope: string }>();
+    #peerScopes = new Map<string, { peer: PeerAddress; storage: ScopedStorage; config?: BdxProtocol.Config }>();
+    #sessionStarted = Observable<[session: BdxSession, scope: string]>();
+    #sessionClosed = Observable<[session: BdxSession, scope: string]>();
+
+    static [Environmental.create](env: Environment) {
+        const instance = new BdxProtocol();
+        env.get(ExchangeManager).addProtocolHandler(instance);
+        env.set(BdxProtocol, instance);
+        return instance;
+    }
+
+    get sessionStarted() {
+        return this.#sessionStarted;
+    }
+
+    get sessionClosed() {
+        return this.#sessionClosed;
+    }
+
+    #peerScopeKey(peer: PeerAddress, scope?: string) {
+        if (scope === undefined) {
+            throw new MatterError("StorageContext must have a defined scope to be used with enableScope");
+        }
+        return `${peer.toString()}-${scope}`;
+    }
+
+    enablePeerForScope(peer: PeerAddress, storage: ScopedStorage, config?: BdxProtocol.Config) {
+        const peerScopeStr = this.#peerScopeKey(peer, storage.scope);
+        const peerDetails = this.#peerScopes.get(peerScopeStr);
+        if (peerDetails !== undefined) {
+            const { storage: existingStorage, config: existingConfig } = peerDetails;
+            logger.warn(config, "vs", existingConfig);
+            if (existingStorage !== storage || isDeepEqual(config, existingConfig)) {
+                return false;
+            }
+        } else {
+            this.#peerScopes.set(peerScopeStr, { peer, storage, config });
+        }
+        return true;
+    }
+
+    async disablePeerForScope(peer: PeerAddress, storage: ScopedStorage, force = false) {
+        if (this.#activeBdxSessions.size > 0) {
+            for (const { session, scope } of this.#activeBdxSessions.values()) {
+                if (storage.scope === scope && PeerAddress.is(peer, session.peerAddress)) {
+                    if (force) {
+                        await session.close(new MatterError("BDX protocol scope disabled"));
+                        break;
+                    }
+                    throw new MatterError(
+                        `Cannot disable BDX for peer "${peer}" (scope: ${scope}) because there are active BDX sessions using it`,
+                    );
+                }
+            }
+        }
+        this.#peerScopes.delete(this.#peerScopeKey(peer, storage.scope));
     }
 
     async onNewExchange(exchange: MessageExchange, message: Message) {
         const initMessageType = message.payloadHeader.messageType;
-        const messenger = new BdxMessenger(exchange);
+        SecureSession.assert(exchange.session);
 
         switch (initMessageType) {
             case BdxMessageType.SendInit:
@@ -44,13 +96,32 @@ export class BdxProtocol implements ProtocolHandler {
                 logger.debug(
                     `Initialize Session for ${BdxMessageType[initMessageType]} message on BDX protocol for exchange ${exchange.id}`,
                 );
+                await exchange.nextMessage(); // Read the message we just know
+
                 const { payload } = message;
-                const bdxSession = BdxSession.fromMessage(this.#storage, messenger, {
+
+                const initMessage = new BdxInitMessageSchema().decode(payload);
+                const { fileDesignator: messageFileDesignator } = initMessage;
+                const fd = new FileDesignator(messageFileDesignator);
+                const [storageScope, fileDesignator] = fd.text.split("/");
+                const { storage, config } =
+                    this.#peerScopes.get(this.#peerScopeKey(exchange.session.peerAddress, storageScope)) ?? {};
+                if (storage === undefined || fileDesignator === undefined) {
+                    throw new BdxError(
+                        `No storage context found for BDX file designator "${fd.text}"`,
+                        BdxStatusCode.FileDesignatorUnknown,
+                    );
+                }
+
+                const messenger = new BdxMessenger(exchange, config?.messageTimeout);
+
+                const bdxSession = BdxSession.fromMessage(messenger, {
                     initMessageType,
-                    initMessage: new BdxInitMessageSchema().decode(payload),
-                    ...this.#bdxLimits,
+                    initMessage,
+                    fileDesignator: new PersistedFileDesignator(fileDesignator, storage),
+                    ...config,
                 });
-                await this.#registerSession(messenger, bdxSession);
+                await this.#registerSession(messenger, bdxSession, storageScope);
 
                 try {
                     await bdxSession.processTransfer();
@@ -63,31 +134,42 @@ export class BdxProtocol implements ProtocolHandler {
                 logger.warn(
                     `Unexpected BDX message type ${BdxMessageType[initMessageType]} on new exchange ${exchange.id}`,
                 );
-                await messenger.sendError(BdxStatusCode.UnexpectedMessage);
+                await new BdxMessenger(exchange).sendError(BdxStatusCode.UnexpectedMessage);
         }
     }
 
     /** Make sure only one BDX session can be active per exchange and that the exchange is closed with the BDX session. */
-    async #registerSession(messenger: BdxMessenger, bdxSession: BdxSession) {
+    async #registerSession(messenger: BdxMessenger, bdxSession: BdxSession, scope: string) {
         const exchange = messenger.exchange;
         if (this.#activeBdxSessions.has(exchange)) {
             logger.warn(`BDX session for exchange ${exchange.id} already exists, sending error`);
             await messenger.sendError(BdxStatusCode.UnexpectedMessage);
             return;
         }
-        this.#activeBdxSessions.set(exchange, bdxSession);
+        this.#activeBdxSessions.set(exchange, { session: bdxSession, scope });
+
+        this.#sessionStarted.emit(bdxSession, scope);
+
         bdxSession.closed.on(async () => {
             logger.debug(`BDX session for exchange ${exchange.id} closed`);
             this.#activeBdxSessions.delete(exchange);
             await exchange.close();
+
+            this.#sessionClosed.emit(bdxSession, scope);
         });
     }
 
     async close() {
         logger.debug(`Closing BDX protocol handler with ${this.#activeBdxSessions.size} active sessions`);
-        for (const session of this.#activeBdxSessions.values()) {
+        for (const { session } of this.#activeBdxSessions.values()) {
             await session.close(new MatterError("BDX protocol handler closed"));
         }
         this.#activeBdxSessions.clear();
     }
 }
+
+export namespace BdxProtocol {
+    export interface Config extends BdxSessionConfiguration.Config {
+        messageTimeout?: Duration;
+    }
+}

package/src/bdx/BdxSession.ts

@@ -4,7 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { AsyncObservable, ClassExtends, Diagnostic, Logger, StorageContext } from "#general";
+import { AsyncObservable, ClassExtends, Diagnostic, Logger, Observable } from "#general";
+import { SecureSession } from "#session/SecureSession.js";
 import { BdxMessageType, BdxStatusCode } from "#types";
 import { bdxSessionInitiator } from "./bdx-session-initiator.js";
 import { BdxError } from "./BdxError.js";
@@ -15,7 +16,6 @@ import { DrivingReceivingFlow } from "./flow/DrivingReceivingFlow.js";
 import { Flow } from "./flow/Flow.js";
 import { FollowingReceivingFlow } from "./flow/FollowingReceivingFlow.js";
 import { FollowingSendingFlow } from "./flow/FollowingSendingFlow.js";
-import { PersistedFileDesignator } from "./PersistedFileDesignator.js";
 
 const logger = Logger.get("BdxSession");
 
@@ -36,10 +36,10 @@ export class BdxSession {
     #started = false;
     #closed = AsyncObservable();
     #isClosed = false;
-
     #config: BdxSessionConfiguration;
-
     #transferFlow?: Flow;
+    #progressInfo = Observable<[bytesTransferred: number, totalBytesLength: number | undefined]>();
+    #progressFinished = Observable<[totalBytesTransferred: number]>();
 
     /** Initializes a BdxSession as a sender, means that we upload data to the peer. */
     static asSender(messenger: BdxMessenger, options: BdxSessionConfiguration.SenderInitiatorOptions): BdxSession {
@@ -51,13 +51,13 @@ export class BdxSession {
         return new BdxSession(messenger, { isSender: false, ...options });
     }
 
-    /** Initializes a BdxSession from an incoming *Init message. The message determines the direction of the transfer. */
-    static fromMessage(
-        storage: StorageContext,
-        messenger: BdxMessenger,
-        options: BdxSessionConfiguration.ReceiverOptions,
-    ): BdxSession {
-        const { initMessageType, initMessage } = options;
+    /**
+     * Initializes a BdxSession from an incoming *Init message. The message determines the direction of the transfer.
+     * The provided storages allow to map the file designator to a storage context depending on the path prefix in the
+     * file designator.
+     */
+    static fromMessage(messenger: BdxMessenger, options: BdxSessionConfiguration.ReceiverOptions): BdxSession {
+        const { initMessageType } = options;
         if (initMessageType !== BdxMessageType.SendInit && initMessageType !== BdxMessageType.ReceiveInit) {
             throw new BdxError(
                 `Invalid message type for BDX session initialization: ${BdxMessageType[initMessageType]} (${initMessageType})`,
@@ -65,11 +65,8 @@ export class BdxSession {
             );
         }
 
-        const { fileDesignator } = initMessage;
-
         return new BdxSession(messenger, {
             isSender: initMessageType === BdxMessageType.ReceiveInit,
-            fileDesignator: new PersistedFileDesignator(fileDesignator, storage),
             ...options,
         });
     }
@@ -80,15 +77,26 @@ export class BdxSession {
         this.#config = new BdxSessionConfiguration(options);
 
         const exchange = messenger.exchange;
-        if (!exchange.channel.isReliable) {
-            throw new BdxError("Bdx Protocol requires a reliable channel for message exchange");
+        if (!exchange.session.isSecure) {
+            throw new BdxError("Bdx Protocol requires a secure session.");
         }
         exchange.closed.on(async () => {
+            if (this.#isClosed) {
+                return;
+            }
             logger.debug(`Closing BDX session for exchange ${exchange.id}`);
             await this.close();
         });
     }
 
+    get progressInfo() {
+        return this.#progressInfo;
+    }
+
+    get progressFinished() {
+        return this.#progressFinished;
+    }
+
     /** Method called to start the session. It will end with a successful Transfer or with an error */
     async processTransfer() {
         if (this.#started) {
@@ -112,6 +120,12 @@ export class BdxSession {
         this.#started = true;
         try {
             this.#transferFlow = this.#initializeFlow(await bdxSessionInitiator(this.#messenger, this.#config));
+            this.#transferFlow.progressInfo.on((bytesTransferred, totalBytesLength) =>
+                this.#progressInfo.emit(bytesTransferred, totalBytesLength),
+            );
+            this.#transferFlow.progressFinished.on(totalBytesTransferred =>
+                this.#progressFinished.emit(totalBytesTransferred),
+            );
 
             await this.#transferFlow.processTransfer();
 
@@ -123,6 +137,9 @@ export class BdxSession {
             logger.warn(`BDX session failed with error:`, error);
 
             await this.close(error);
+
+            error.bytesTransferred = this.#transferFlow?.transferredBytes ?? 0;
+            error.totalBytesLength = this.#transferFlow?.dataLength;
             throw error;
         }
     }
@@ -161,6 +178,11 @@ export class BdxSession {
         return this.#closed;
     }
 
+    get peerAddress() {
+        SecureSession.assert(this.#messenger.exchange.session);
+        return this.#messenger.exchange.session.peerAddress;
+    }
+
     async close(error?: unknown) {
         if (this.#isClosed) {
             return;

package/src/bdx/BdxSessionConfiguration.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { FileDesignator } from "#bdx/FileDesignator.js";
 import { ImplementationError } from "#general";
 import { BdxMessageType } from "#types";
 import { Flow } from "./flow/Flow.js";
@@ -15,10 +16,12 @@ export class BdxSessionConfiguration {
     #initMessage?: BdxInit;
     #transferConfig: BdxSessionConfiguration.Config;
     #fileDesignator: PersistedFileDesignator;
+    #transferFileDesignator: FileDesignator;
 
     constructor(options: BdxSessionConfiguration.Options) {
-        const { isSender, fileDesignator, initMessage } = options;
+        const { isSender, fileDesignator, transferFileDesignator, initMessage } = options;
         this.#fileDesignator = fileDesignator;
+        this.#transferFileDesignator = transferFileDesignator ?? fileDesignator;
         this.#isSender = isSender;
         this.#initMessage = initMessage;
         this.#transferConfig = { ...BdxSessionConfiguration.DefaultConfig, ...options };
@@ -65,6 +68,10 @@ export class BdxSessionConfiguration {
         return this.#fileDesignator;
     }
 
+    get transferFileDesignator(): FileDesignator {
+        return this.#transferFileDesignator;
+    }
+
     get transferConfig(): BdxSessionConfiguration.Config {
         return this.#transferConfig;
     }
@@ -106,6 +113,11 @@ export namespace BdxSessionConfiguration {
     export interface InitiatorOptions extends BdxSessionConfiguration.Config {
         /** FileDesignator to use for the session. The value is usually pre-determined with the peer. */
         fileDesignator: PersistedFileDesignator;
+
+        /**
+         * Optional file designator to use for the transfer. This can be used to separate the file designator used
+         * in BDX messages from the persisted file. */
+        transferFileDesignator?: FileDesignator;
     }
 
     export interface SenderInitiatorOptions extends InitiatorOptions {
@@ -119,15 +131,25 @@ export namespace BdxSessionConfiguration {
     export interface ReceiverOptions extends BdxSessionConfiguration.Config {
         initMessageType: BdxMessageType;
         initMessage: BdxInit; // The initial message received to start the session
+        fileDesignator: PersistedFileDesignator;
     }
 
     export interface Options extends BdxSessionConfiguration.Config {
         /** True if the session is initiated as a sender, false for receiver */
         isSender: boolean;
 
-        /** File designator to use for the session */
+        /**
+         * File designator to use for the session and read from or write to. It points to the persisted blob storage.
+         */
         fileDesignator: PersistedFileDesignator;
 
+        /**
+         * Optional Transfer FileDesignator to use for the transfer, if different from the fileDesignator. This is
+         * mainly useful when receiving data where the fileDesignator used in the BDX messages is defined by the file
+         * sender and when the persisted file is stored under a different designator.
+         */
+        transferFileDesignator?: FileDesignator;
+
         /** The initial message received to start the session */
         initMessage?: BdxInit;
     }

package/src/bdx/FileDesignator.ts

@@ -4,7 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Bytes } from "#general";
+import { Bytes, Diagnostic, ImplementationError } from "#general";
+import { NodeId } from "#types";
 
 /**
  * Class to represent a File designator from Matter.
@@ -14,6 +15,20 @@ import { Bytes } from "#general";
 export class FileDesignator {
     #fd: Bytes;
 
+    /**
+     * Initialize a FileDesignator from a BDX URI string. Also returns the source node ID of the owner of the file.
+     */
+    static fromBdxUri(uri: string) {
+        const bdxParts = uri.match(/^bdx:\/\/([0-9A-F]{16})\/(\S+)$/);
+        if (!bdxParts) {
+            throw new ImplementationError(`Invalid OTA URI "${uri}"`);
+        }
+        return {
+            fileDesignator: new FileDesignator(bdxParts[2]),
+            sourceNodeId: NodeId(BigInt(`0x${bdxParts[1]}`)),
+        };
+    }
+
     /** Create a FileDesignator from a string or bytes object. */
     constructor(fd: string | Bytes) {
         if (typeof fd === "string") {
@@ -38,7 +53,9 @@ export class FileDesignator {
                 (byte >= 0x61 && byte <= 0x7a) || // a-z
                 (byte >= 0x30 && byte <= 0x39) || // 0..9
                 byte === 0x2e || // "."
-                byte === 0x2d, // "-"
+                byte === 0x2d || // "-"
+                byte === 0x5f || // "_"
+                byte === 0x2f, // "/"
         );
         if (isValidName) {
             return fileDesignatorData.reduce((name, byte) => name + String.fromCharCode(byte), "");
@@ -46,4 +63,16 @@ export class FileDesignator {
             return `0x${Bytes.toHex(fileDesignatorData)}`;
         }
     }
+
+    /**
+     * Return the FileDesignator as a BDX URI string. The source node ID of the owner of the file is required to
+     * generate a valid URI.
+     */
+    asBdxUri(sourceNode: NodeId) {
+        return `bdx://${NodeId.strOf(sourceNode).toUpperCase()}/${this.text}`;
+    }
+
+    get [Diagnostic.value](): string {
+        return this.text;
+    }
 }

package/src/bdx/PersistedFileDesignator.ts

@@ -4,32 +4,57 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Bytes, ImplementationError, StorageContext } from "#general";
+import { ScopedStorage } from "#bdx/ScopedStorage.js";
+import { Bytes, ImplementationError, Logger, StorageContext } from "#general";
 import { FileDesignator } from "./FileDesignator.js";
 
-/** A FileDesignator that points to a persisted file in a given StorageContext. */
+const logger = Logger.get("PersistedFileDesignator");
+
+/**
+ * A FileDesignator that points to a persisted file in a given StorageContext.
+ * If the file is supposed to be used for Bdx transfers where it could be requested by a client and is not actively
+ * sent or the location to store a received file, you need to pass a ScopedStorage to allow automatic target detection
+ * for BDX.
+ * The logic supports providing names separated by "." to automatically create sub contexts
+ */
 export class PersistedFileDesignator extends FileDesignator {
     #storage: StorageContext;
     #blob?: Blob;
+    #blobName: string;
 
-    constructor(fd: string | Bytes | FileDesignator, storage: StorageContext) {
+    constructor(fd: string | Bytes | FileDesignator, storage: StorageContext | ScopedStorage) {
         if (fd instanceof FileDesignator) {
             fd = fd.bytes;
         }
+        const blobName = Bytes.isBytes(fd) ? Bytes.toString(fd) : fd;
+        if (storage instanceof ScopedStorage) {
+            fd = Bytes.fromString(`${storage.scope}/${blobName}`);
+            storage = storage.context;
+        }
         super(fd);
+        const subContext = blobName.split(".");
+        this.#blobName = subContext.pop()!;
+        for (const parts of subContext) {
+            storage = storage.createContext(parts);
+        }
+
         this.#storage = storage;
     }
 
     exists() {
-        return this.#storage.has(this.text);
+        return this.#storage.has(this.#blobName);
+    }
+
+    get blobName() {
+        return this.#blobName;
     }
 
     async openBlob() {
         if (this.#blob === undefined) {
-            const blobName = this.text;
+            const blobName = this.#blobName;
             if (!this.#storage.has(blobName)) {
                 throw new ImplementationError(
-                    "File designator must point to an existing file in the storage to send data",
+                    `File designator must point to an existing blob "${blobName}" in the storage to send data`,
                 );
             }
             this.#blob = await this.#storage.openBlob(blobName);
@@ -38,10 +63,12 @@ export class PersistedFileDesignator extends FileDesignator {
     }
 
     writeFromStream(stream: ReadableStream<Bytes>) {
-        return this.#storage.writeBlobFromStream(this.text, stream);
+        logger.debug(`Writing blob "${this.text}" (${this.#blobName}) to storage`);
+        return this.#storage.writeBlobFromStream(this.#blobName, stream);
     }
 
     delete() {
-        return this.#storage.delete(this.text);
+        logger.debug(`Deleting blob "${this.text}" (${this.#blobName}) from storage`);
+        return this.#storage.delete(this.#blobName);
     }
 }

package/src/bdx/ScopedStorage.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2022-2025 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { StorageContext } from "#general";
+
+/**
+ * Storage Scopes allow flagging a context for a specific usage.
+ * This is mainly used for BDX transfers currently to allow separating OTA related storage from log related storage
+ * and to automatically choose the right one based on the incoming file designator.
+ */
+export type StorageScope = "ota" | "log";
+
+export class ScopedStorage {
+    readonly scope: StorageScope;
+
+    constructor(
+        public readonly context: StorageContext,
+        scope: StorageScope,
+    ) {
+        this.scope = scope;
+    }
+}

package/src/bdx/bdx-session-initiator.ts

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import { FileDesignator } from "#bdx/FileDesignator.js";
 import { ImplementationError, InternalError, Logger } from "#general";
 import { BdxStatusCode, TypeFromPartialBitSchema } from "#types";
 import { BdxError } from "./BdxError.js";
@@ -45,6 +46,14 @@ export async function bdxSessionInitiator(messenger: BdxMessenger, config: BdxSe
     }
     logger.debug(`Initialize BDX ${config.isSender ? "ReceiveInit" : "SendInit"} from incoming Message`, initMessage);
 
+    const incomingFileDesignator = new FileDesignator(initMessage.fileDesignator);
+    if (incomingFileDesignator.text !== config.transferFileDesignator.text) {
+        throw new BdxError(
+            `File designator in Init message (${incomingFileDesignator.text}) does not match the configured transfer file designator (${config.transferFileDesignator.text})`,
+            BdxStatusCode.FileDesignatorUnknown,
+        );
+    }
+
     if (config.isSender) {
         // We are Sender and Responder
         if (!config.fileDesignator.exists()) {
@@ -100,7 +109,7 @@ export async function bdxSessionInitiator(messenger: BdxMessenger, config: BdxSe
             preferredDriverModes,
             asynchronousTransferAllowed,
         } = config.transferConfig;
-        const { isSender, fileDesignator } = config;
+        const { isSender, fileDesignator, transferFileDesignator } = config;
 
         let startOffset: number | undefined;
         let maxLength: number | undefined;
@@ -153,7 +162,7 @@ export async function bdxSessionInitiator(messenger: BdxMessenger, config: BdxSe
                 asynchronousTransfer: asynchronousTransferAllowed, // always false for now
             },
             maxBlockSize,
-            fileDesignator: fileDesignator.bytes,
+            fileDesignator: transferFileDesignator.bytes,
             startOffset,
             maxLength,
         };

package/src/bdx/flow/DrivenSendingFlow.ts

@@ -23,12 +23,15 @@ export class DrivenSendingFlow extends OutboundFlow {
         if (done) {
             // Send the last Block and wait for AckEof and close down
             await this.messenger.sendBlockEof({ data: data ?? new Uint8Array(), blockCounter });
+            this.transferredBytes += data?.byteLength ?? 0;
+
             this.finalBlockCounter = blockCounter;
             return true;
         }
 
         // Send the next Block
         await this.messenger.sendBlock({ data, blockCounter });
+        this.transferredBytes += data.byteLength;
 
         // Sync transfer just continues when the Ack is received
         if (!asynchronousTransfer) {

package/src/bdx/flow/DrivingReceivingFlow.ts

@@ -27,6 +27,7 @@ export class DrivingReceivingFlow extends InboundFlow {
             message: { blockCounter: dataBlockCounter, data },
         } = await this.messenger.readBlock();
         this.validateCounter(dataBlockCounter, blockCounter);
+        this.transferredBytes += data.byteLength;
 
         // Write the received data chunk into the writing stream
         if (this.writeDataChunk(writeController, data, messageType)) {