@enbox/dwn-sdk-js 0.4.6 → 0.4.8

package/src/store/blockstore-level.ts

@@ -1,7 +1,15 @@
-import { CID } from 'multiformats';
-import type { AbortOptions, AwaitIterable } from 'interface-store';
-import type { Blockstore, Pair } from 'interface-blockstore';
+import type { Blockstore, InputPair, Pair } from 'interface-blockstore';
+import type { BlockstoreAbortOptions, BlockstoreInput, BlockstoreSource } from './blockstore-utils.js';
 
+import { CID } from 'multiformats';
+import { NotFoundError } from 'interface-store';
+import {
+  collectBlockstoreBytes,
+  deleteManyBlockstoreItems,
+  getManyBlockstoreItems,
+  putManyBlockstoreItems,
+  yieldBlockstoreBytes,
+} from './blockstore-utils.js';
 import { createLevelDatabase, LevelWrapper } from './level-wrapper.js';
 
 // `level` works in Node.js 12+ and Electron 5+ on Linux, Mac OS, Windows and
@@ -40,63 +48,51 @@ export class BlockstoreLevel implements Blockstore {
     return new BlockstoreLevel({ ...this.config, location: '' }, db);
   }
 
-  async put(key: CID | string, val: Uint8Array, options?: AbortOptions): Promise<CID> {
-    await this.db.put(String(key), val, options);
+  async put(key: CID | string, val: BlockstoreInput, options?: BlockstoreAbortOptions): Promise<CID> {
+    const bytes = await collectBlockstoreBytes(val);
+    await this.db.put(String(key), bytes, options);
     return CID.parse(key.toString());
   }
 
-  async get(key: CID | string, options?: AbortOptions): Promise<Uint8Array> {
+  async * get(key: CID | string, options?: BlockstoreAbortOptions): AsyncGenerator<Uint8Array> {
     const result = await this.db.get(String(key), options);
-    return result!;
+    if (result === undefined) {
+      throw new NotFoundError();
+    }
+
+    yield result;
   }
 
-  async has(key: CID | string, options?: AbortOptions): Promise<boolean> {
+  async has(key: CID | string, options?: BlockstoreAbortOptions): Promise<boolean> {
     return this.db.has(String(key), options);
   }
 
-  async delete(key: CID | string, options?: AbortOptions): Promise<void> {
+  async delete(key: CID | string, options?: BlockstoreAbortOptions): Promise<void> {
     return this.db.delete(String(key), options);
   }
 
-  async isEmpty(options?: AbortOptions): Promise<boolean> {
+  async isEmpty(options?: BlockstoreAbortOptions): Promise<boolean> {
     return this.db.isEmpty(options);
   }
 
-  async * putMany(source: AwaitIterable<Pair>, options?: AbortOptions): AsyncIterable<CID> {
-    for await (const entry of source) {
-      await this.put(entry.cid, entry.block, options);
-
-      yield entry.cid;
-    }
+  async * putMany(source: BlockstoreSource<InputPair>, options?: BlockstoreAbortOptions): AsyncGenerator<CID> {
+    yield * putManyBlockstoreItems(this, source, options);
   }
 
-  async * getMany(source: AwaitIterable<CID>, options?: AbortOptions): AsyncIterable<Pair> {
-    for await (const key of source) {
-      yield {
-        cid   : key,
-        block : await this.get(key, options)
-      };
-    }
+  async * getMany(source: BlockstoreSource<CID>, options?: BlockstoreAbortOptions): AsyncGenerator<Pair> {
+    yield * getManyBlockstoreItems(this, source, options);
   }
 
-  async * getAll(options?: AbortOptions): AsyncIterable<Pair> {
-    // @ts-expect-error keyEncoding is 'buffer' but types for db.iterator always return the key type as 'string'
-    const li: AsyncGenerator<[Uint8Array, Uint8Array]> = this.db.iterator({
-      keys        : true,
-      keyEncoding : 'buffer'
-    }, options);
+  async * getAll(options?: BlockstoreAbortOptions): AsyncGenerator<Pair> {
+    const li: AsyncGenerator<[string, Uint8Array]> = this.db.iterator({ keys: true }, options);
 
     for await (const [key, value] of li) {
-      yield { cid: CID.decode(key), block: value };
+      yield { cid: CID.parse(key), bytes: yieldBlockstoreBytes(value) };
     }
   }
 
-  async * deleteMany(source: AwaitIterable<CID>, options?: AbortOptions): AsyncIterable<CID> {
-    for await (const key of source) {
-      await this.delete(key, options);
-
-      yield key;
-    }
+  async * deleteMany(source: BlockstoreSource<CID>, options?: BlockstoreAbortOptions): AsyncGenerator<CID> {
+    yield * deleteManyBlockstoreItems(this, source, options);
   }
 
   /**
@@ -110,4 +106,4 @@ export class BlockstoreLevel implements Blockstore {
 export type BlockstoreLevelConfig = {
   location: string,
   createLevelDatabase?: typeof createLevelDatabase,
-};
+};

package/src/store/blockstore-mock.ts

@@ -1,6 +1,12 @@
-import { CID } from 'multiformats';
-import type { AbortOptions, AwaitIterable } from 'interface-store';
-import type { Blockstore, Pair } from 'interface-blockstore';
+import type { CID } from 'multiformats';
+import type { Blockstore, InputPair, Pair } from 'interface-blockstore';
+import type { BlockstoreAbortOptions, BlockstoreInput, BlockstoreSource } from './blockstore-utils.js';
+
+import {
+  deleteManyBlockstoreItems,
+  getManyBlockstoreItems,
+  putManyBlockstoreItems,
+} from './blockstore-utils.js';
 
 /**
  * Mock implementation for the Blockstore interface.
@@ -16,60 +22,40 @@ export class BlockstoreMock implements Blockstore {
   async close(): Promise<void> {
   }
 
-  async put(key: CID, _val: Uint8Array, _options?: AbortOptions): Promise<CID> {
+  async put(key: CID, _val: BlockstoreInput, _options?: BlockstoreAbortOptions): Promise<CID> {
     return key;
   }
 
-  async get(_key: CID, _options?: AbortOptions): Promise<Uint8Array> {
-    return new Uint8Array();
+  async * get(_key: CID, _options?: BlockstoreAbortOptions): AsyncGenerator<Uint8Array> {
+    yield new Uint8Array();
   }
 
-  async has(_key: CID, _options?: AbortOptions): Promise<boolean> {
+  async has(_key: CID, _options?: BlockstoreAbortOptions): Promise<boolean> {
     return false;
   }
 
-  async delete(_key: CID, _options?: AbortOptions): Promise<void> {
+  async delete(_key: CID, _options?: BlockstoreAbortOptions): Promise<void> {
+    return;
   }
 
-  async isEmpty(_options?: AbortOptions): Promise<boolean> {
+  async isEmpty(_options?: BlockstoreAbortOptions): Promise<boolean> {
     return true;
   }
 
-  async * putMany(source: AwaitIterable<Pair>, options?: AbortOptions): AsyncIterable<CID> {
-    for await (const entry of source) {
-      await this.put(entry.cid, entry.block, options);
-
-      yield entry.cid;
-    }
+  async * putMany(source: BlockstoreSource<InputPair>, options?: BlockstoreAbortOptions): AsyncGenerator<CID> {
+    yield * putManyBlockstoreItems(this, source, options);
   }
 
-  async * getMany(source: AwaitIterable<CID>, options?: AbortOptions): AsyncIterable<Pair> {
-    for await (const key of source) {
-      yield {
-        cid   : key,
-        block : await this.get(key, options)
-      };
-    }
+  async * getMany(source: BlockstoreSource<CID>, options?: BlockstoreAbortOptions): AsyncGenerator<Pair> {
+    yield * getManyBlockstoreItems(this, source, options);
   }
 
-  async * getAll(options?: AbortOptions): AsyncIterable<Pair> {
-    // @ts-expect-error keyEncoding is 'buffer' but types for db.iterator always return the key type as 'string'
-    const li: AsyncGenerator<[Uint8Array, Uint8Array]> = this.db.iterator({
-      keys        : true,
-      keyEncoding : 'buffer'
-    }, options);
-
-    for await (const [key, value] of li) {
-      yield { cid: CID.decode(key), block: value };
-    }
+  async * getAll(_options?: BlockstoreAbortOptions): AsyncGenerator<Pair> {
+    yield * [];
   }
 
-  async * deleteMany(source: AwaitIterable<CID>, options?: AbortOptions): AsyncIterable<CID> {
-    for await (const key of source) {
-      await this.delete(key, options);
-
-      yield key;
-    }
+  async * deleteMany(source: BlockstoreSource<CID>, options?: BlockstoreAbortOptions): AsyncGenerator<CID> {
+    yield * deleteManyBlockstoreItems(this, source, options);
   }
 
   /**

package/src/store/blockstore-utils.ts

@@ -0,0 +1,85 @@
+import type { CID } from 'multiformats';
+import type { InputPair, Pair } from 'interface-blockstore';
+
+export type BlockstoreAbortOptions = { signal?: AbortSignal };
+export type BlockstoreInput = Uint8Array | Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
+export type BlockstoreSource<T> = Iterable<T> | AsyncIterable<T>;
+
+type BlockstorePutDelegate = {
+  put(key: CID, val: BlockstoreInput, options?: BlockstoreAbortOptions): Promise<CID>;
+};
+
+type BlockstoreGetDelegate = {
+  get(key: CID, options?: BlockstoreAbortOptions): AsyncGenerator<Uint8Array>;
+};
+
+type BlockstoreDeleteDelegate = {
+  delete(key: CID, options?: BlockstoreAbortOptions): Promise<void>;
+};
+
+export async function collectBlockstoreBytes(input: BlockstoreInput): Promise<Uint8Array> {
+  if (input instanceof Uint8Array) {
+    return input;
+  }
+
+  const chunks: Uint8Array[] = [];
+  let byteLength = 0;
+  for await (const chunk of input) {
+    chunks.push(chunk);
+    byteLength += chunk.byteLength;
+  }
+
+  if (chunks.length === 1) {
+    return chunks[0];
+  }
+
+  const bytes = new Uint8Array(byteLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+
+  return bytes;
+}
+
+export async function* yieldBlockstoreBytes(bytes: Uint8Array): AsyncGenerator<Uint8Array> {
+  yield bytes;
+}
+
+export async function* putManyBlockstoreItems(
+  blockstore: BlockstorePutDelegate,
+  source: BlockstoreSource<InputPair>,
+  options?: BlockstoreAbortOptions,
+): AsyncGenerator<CID> {
+  for await (const entry of source) {
+    await blockstore.put(entry.cid, entry.bytes, options);
+
+    yield entry.cid;
+  }
+}
+
+export async function* getManyBlockstoreItems(
+  blockstore: BlockstoreGetDelegate,
+  source: BlockstoreSource<CID>,
+  options?: BlockstoreAbortOptions,
+): AsyncGenerator<Pair> {
+  for await (const key of source) {
+    yield {
+      cid   : key,
+      bytes : blockstore.get(key, options),
+    };
+  }
+}
+
+export async function* deleteManyBlockstoreItems(
+  blockstore: BlockstoreDeleteDelegate,
+  source: BlockstoreSource<CID>,
+  options?: BlockstoreAbortOptions,
+): AsyncGenerator<CID> {
+  for await (const key of source) {
+    await blockstore.delete(key, options);
+
+    yield key;
+  }
+}

package/src/store/blockstore.ts

@@ -0,0 +1,8 @@
+export {
+  collectBlockstoreBytes,
+  deleteManyBlockstoreItems,
+  getManyBlockstoreItems,
+  putManyBlockstoreItems,
+  yieldBlockstoreBytes,
+} from './blockstore-utils.js';
+export type { BlockstoreAbortOptions, BlockstoreInput, BlockstoreSource } from './blockstore-utils.js';

package/src/store/data-store-level.ts

@@ -118,18 +118,11 @@ export class DataStoreLevel implements DataStore {
 
     // Data is chunked into DAG-PB UnixFS blocks. Re-inflate the chunks.
     const dataDagRoot = await exporter(dataCid, blocksPartition);
-    const contentIterator = dataDagRoot.content();
-
-    const dataStream = new ReadableStream<Uint8Array>({
-      async pull(controller): Promise<void> {
-        const result = await contentIterator.next();
-        if (result.done) {
-          controller.close();
-        } else {
-          controller.enqueue(result.value);
-        }
-      }
-    });
+    if (dataDagRoot.type !== 'file' && dataDagRoot.type !== 'raw' && dataDagRoot.type !== 'identity') {
+      throw new Error(`DataStoreLevel: Expected UnixFS file content for '${dataCid}', got '${dataDagRoot.type}'.`);
+    }
+
+    const dataStream = DataStream.fromAsyncIterable(dataDagRoot.content());
 
     return { dataSize, dataStream };
   }

package/src/store/level.ts

@@ -0,0 +1,19 @@
+export { BlockstoreLevel } from './blockstore-level.js';
+export type { BlockstoreLevelConfig } from './blockstore-level.js';
+export { DataStoreLevel } from './data-store-level.js';
+export type { DataStoreLevelConfig } from './data-store-level.js';
+export { IndexLevel } from './index-level.js';
+export type { CompoundIndexDefinition, IndexLevelConfig, IndexedItem, IndexLevelOptions } from './index-level.js';
+export { createLevelDatabase, LevelWrapper } from './level-wrapper.js';
+export type {
+  CreateLevelDatabaseOptions,
+  LevelDatabase,
+  LevelWrapperBatchOperation,
+  LevelWrapperConfig,
+  LevelWrapperIteratorOptions,
+  LevelWrapperOptions,
+} from './level-wrapper.js';
+export { MessageStoreLevel } from './message-store-level.js';
+export type { MessageStoreLevelConfig } from './message-store-level.js';
+export { ResumableTaskStoreLevel } from './resumable-task-store-level.js';
+export type { ResumableTaskStoreLevelConfig } from './resumable-task-store-level.js';

package/src/types/cache.ts

@@ -6,11 +6,11 @@ export interface Cache {
   /**
    * Sets a key-value pair. Does not throw error.
    */
-  set(key: string, value: any): Promise<void>;
+  set<T = unknown>(key: string, value: T): Promise<void>;
 
   /**
    * Gets the value corresponding to the given key.
    * @returns value stored corresponding to the given key; `undefined` if key is not found or expired
    */
-  get(key: string): Promise<any | undefined>;
-}
+  get<T = unknown>(key: string): Promise<T | undefined>;
+}

package/src/types/encryption-types.ts

@@ -1,6 +1,43 @@
 import type { KeyDerivationScheme } from '../utils/hd-key.js';
-import type { KeyUnwrapPayload } from '../utils/encryption.js';
-import type { PublicKeyJwk } from './jose-types.js';
+import type { KeyUnwrapPayload, SealKeyWrap } from '../utils/encryption.js';
+import type { PrivateKeyJwk, PublicKeyJwk } from './jose-types.js';
+
+export type RoleAudienceTuple = {
+  protocol: string;
+  rolePath: string;
+  contextId: string;
+};
+
+export type RoleAudienceKeyId = RoleAudienceTuple & {
+  keyId: string;
+};
+
+export enum EncryptionControlDeliveryRecipientAuthority {
+  RoleHolder = 'roleHolder',
+}
+
+export type EncryptionControlDeliveryTags = RoleAudienceKeyId & {
+  recipientAuthority: EncryptionControlDeliveryRecipientAuthority | `${EncryptionControlDeliveryRecipientAuthority}`;
+};
+
+export type EncryptionControlSeal = SealKeyWrap;
+
+export type EncryptionControlAudiencePayload = RoleAudienceKeyId & {
+  publicKeyJwk: PublicKeyJwk;
+  sealedPrivateKey: EncryptionControlSeal;
+};
+
+export type RoleAudienceKeyMaterial = {
+  algorithm: 'X25519-HKDF-SHA256+A256KW';
+  derivationScheme: 'roleAudience';
+  keyId: string;
+  publicKeyJwk: PublicKeyJwk;
+  privateKeyJwk: PrivateKeyJwk;
+};
+
+export type EncryptionControlDeliveryPayload = RoleAudienceKeyId & {
+  keyMaterial: RoleAudienceKeyMaterial;
+};
 
 export type KeyDecrypterDerivationScheme = KeyDerivationScheme | 'roleAudience';
 

package/src/types/validation-state-reader.ts

@@ -79,15 +79,13 @@ export interface ValidationStateReader {
   }): Promise<RecordsWriteMessage[]>;
 
   /**
-   * Queries accepted audience epoch records in the Encryption Protocol.
-   * The optional `keyId` narrows the lookup to one published audience key.
+   * Queries accepted source-protocol-native audience control records by role-audience coordinates.
    */
-  queryAudienceEpochs(input: {
+  queryAudienceRecords(input: {
     tenant: string;
     protocol: string;
+    rolePath: string;
     contextId: string;
-    role: string;
-    epoch: number;
     keyId?: string;
   }): Promise<RecordsWriteMessage[]>;
 

package/src/utils/data-stream.ts

@@ -76,6 +76,28 @@ export class DataStream {
     });
   }
 
+  /**
+   * Adapts an iterable or async iterable of byte chunks into a Web ReadableStream.
+   */
+  public static fromAsyncIterable(iterable: AsyncIterable<Uint8Array> | Iterable<Uint8Array>): ReadableStream<Uint8Array> {
+    const iterator = DataStream.toAsyncGenerator(iterable);
+
+    return new ReadableStream<Uint8Array>({
+      async pull(controller): Promise<void> {
+        const result = await iterator.next();
+        if (result.done) {
+          controller.close();
+        } else {
+          controller.enqueue(result.value);
+        }
+      },
+
+      async cancel(): Promise<void> {
+        await iterator.return(undefined);
+      }
+    });
+  }
+
   /**
    * Creates a readable stream from the object given.
    */
@@ -106,6 +128,12 @@ export class DataStream {
     }
   }
 
+  private static async * toAsyncGenerator<T>(iterable: AsyncIterable<T> | Iterable<T>): AsyncGenerator<T> {
+    for await (const item of iterable) {
+      yield item;
+    }
+  }
+
   /**
    * Duplicates the given data stream into the number of streams specified so that multiple handlers can consume the same data stream.
    * Uses the native `ReadableStream.tee()` method for 2 copies, or a custom fan-out for N copies.
@@ -133,4 +161,4 @@ export class DataStream {
 
     return streams;
   }
-}
+}