@storacha/encrypt-upload-client 1.1.56 → 1.1.58

package/dist/test/fixtures/test-fixtures.d.ts

@@ -2,27 +2,32 @@
  * Generate mock RSA key pair for testing that works with Web Crypto API
  */
 export function generateMockRSAKeyPair(): Promise<{
-    keyPair: CryptoKeyPair;
-    publicKeyPem: string;
-}>;
+  keyPair: CryptoKeyPair
+  publicKeyPem: string
+}>
 /**
  * Helper to create test fixtures
  */
 export function createTestFixtures(): Promise<{
-    keyManagerServiceDID: ed25519.EdSigner;
-    spaceDID: `did:key:${string}`;
-    spaceSigner: ed25519.EdSigner;
-    issuer: ed25519.EdSigner;
-    keyPair: CryptoKeyPair;
-    publicKeyPem: string;
-    delegationProof: Server.API.Delegation<[{
-        with: `did:key:${string}`;
-        can: "space/encryption/setup";
-    }, {
-        with: `did:key:${string}`;
-        can: "space/encryption/key/decrypt";
-    }]>;
-}>;
-import { ed25519 } from '@ucanto/principal';
-import * as Server from '@ucanto/server';
-//# sourceMappingURL=test-fixtures.d.ts.map
+  keyManagerServiceDID: ed25519.EdSigner
+  spaceDID: `did:key:${string}`
+  spaceSigner: ed25519.EdSigner
+  issuer: ed25519.EdSigner
+  keyPair: CryptoKeyPair
+  publicKeyPem: string
+  delegationProof: Server.API.Delegation<
+    [
+      {
+        with: `did:key:${string}`
+        can: 'space/encryption/setup'
+      },
+      {
+        with: `did:key:${string}`
+        can: 'space/encryption/key/decrypt'
+      }
+    ]
+  >
+}>
+import { ed25519 } from '@ucanto/principal'
+import * as Server from '@ucanto/server'
+//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/test/fixtures/test-fixtures.js

@@ -1,63 +1,71 @@
-import * as Server from '@ucanto/server';
-import { ed25519 } from '@ucanto/principal';
+import * as Server from '@ucanto/server'
+import { ed25519 } from '@ucanto/principal'
 /**
  * Generate mock RSA key pair for testing that works with Web Crypto API
  */
 export async function generateMockRSAKeyPair() {
-    // Generate key pair using Web Crypto API first
-    const keyPair = await globalThis.crypto.subtle.generateKey({
-        name: 'RSA-OAEP',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([1, 0, 1]),
-        hash: 'SHA-256',
-    }, true, ['encrypt', 'decrypt']);
-    // Export public key to SPKI format (this will work with our adapter)
-    const publicKeyBuffer = await globalThis.crypto.subtle.exportKey('spki', keyPair.publicKey);
-    // Convert to proper PEM format using standard base64 (not multibase)
-    const base64String = Buffer.from(publicKeyBuffer).toString('base64');
-    // Format as proper PEM with line breaks every 64 characters like real KMS
-    const formattedBase64 = base64String.match(/.{1,64}/g)?.join('\n') || base64String;
-    const publicKeyPem = `-----BEGIN PUBLIC KEY-----\n${formattedBase64}\n-----END PUBLIC KEY-----`;
-    return {
-        keyPair,
-        publicKeyPem,
-    };
+  // Generate key pair using Web Crypto API first
+  const keyPair = await globalThis.crypto.subtle.generateKey(
+    {
+      name: 'RSA-OAEP',
+      modulusLength: 2048,
+      publicExponent: new Uint8Array([1, 0, 1]),
+      hash: 'SHA-256',
+    },
+    true,
+    ['encrypt', 'decrypt']
+  )
+  // Export public key to SPKI format (this will work with our adapter)
+  const publicKeyBuffer = await globalThis.crypto.subtle.exportKey(
+    'spki',
+    keyPair.publicKey
+  )
+  // Convert to proper PEM format using standard base64 (not multibase)
+  const base64String = Buffer.from(publicKeyBuffer).toString('base64')
+  // Format as proper PEM with line breaks every 64 characters like real KMS
+  const formattedBase64 =
+    base64String.match(/.{1,64}/g)?.join('\n') || base64String
+  const publicKeyPem = `-----BEGIN PUBLIC KEY-----\n${formattedBase64}\n-----END PUBLIC KEY-----`
+  return {
+    keyPair,
+    publicKeyPem,
+  }
 }
 /**
  * Helper to create test fixtures
  */
 export async function createTestFixtures() {
-    // Create mock key manager service DID
-    const keyManagerServiceDID = await ed25519.generate();
-    // Create mock space DID - this will be the issuer
-    const spaceSigner = await ed25519.generate();
-    const spaceDID = spaceSigner.did();
-    // Generate mock RSA key pair
-    const { keyPair, publicKeyPem } = await generateMockRSAKeyPair();
-    // Create mock delegation proof - space delegates to itself (self-issued)
-    const delegationProof = await Server.delegate({
-        issuer: spaceSigner,
-        audience: spaceSigner, // Self-delegation for testing
-        capabilities: [
-            {
-                with: spaceDID,
-                can: 'space/encryption/setup',
-            },
-            {
-                with: spaceDID,
-                can: 'space/encryption/key/decrypt',
-            },
-        ],
-        expiration: Infinity,
-    });
-    return {
-        keyManagerServiceDID,
-        spaceDID,
-        spaceSigner,
-        issuer: spaceSigner, // Use space signer as issuer
-        keyPair,
-        publicKeyPem,
-        delegationProof,
-    };
+  // Create mock key manager service DID
+  const keyManagerServiceDID = await ed25519.generate()
+  // Create mock space DID - this will be the issuer
+  const spaceSigner = await ed25519.generate()
+  const spaceDID = spaceSigner.did()
+  // Generate mock RSA key pair
+  const { keyPair, publicKeyPem } = await generateMockRSAKeyPair()
+  // Create mock delegation proof - space delegates to itself (self-issued)
+  const delegationProof = await Server.delegate({
+    issuer: spaceSigner,
+    audience: spaceSigner, // Self-delegation for testing
+    capabilities: [
+      {
+        with: spaceDID,
+        can: 'space/encryption/setup',
+      },
+      {
+        with: spaceDID,
+        can: 'space/encryption/key/decrypt',
+      },
+    ],
+    expiration: Infinity,
+  })
+  return {
+    keyManagerServiceDID,
+    spaceDID,
+    spaceSigner,
+    issuer: spaceSigner, // Use space signer as issuer
+    keyPair,
+    publicKeyPem,
+    delegationProof,
+  }
 }
-//# sourceMappingURL=test-fixtures.js.map
+//# sourceMappingURL=test-fixtures.js.map

package/dist/test/helpers/test-file-utils.d.ts

@@ -4,31 +4,31 @@
  * @param {number} sizeMB - Size of the test file in megabytes
  * @returns {Blob} A Blob containing test data with predictable patterns
  */
-export function createTestFile(sizeMB: number): Blob;
+export function createTestFile(sizeMB: number): Blob
 /**
  * Convert ReadableStream to Uint8Array
  *
  * @param {ReadableStream} stream - The stream to convert
  * @returns {Promise<Uint8Array>} The stream content as a Uint8Array
  */
-export function streamToUint8Array(stream: ReadableStream): Promise<Uint8Array>;
+export function streamToUint8Array(stream: ReadableStream): Promise<Uint8Array>
 /**
  * @param {Uint8Array} arr
  * @returns {string}
  */
-export function uint8ArrayToString(arr: Uint8Array): string;
+export function uint8ArrayToString(arr: Uint8Array): string
 /**
  * @param {string} str
  * @returns {Uint8Array}
  */
-export function stringToUint8Array(str: string): Uint8Array;
+export function stringToUint8Array(str: string): Uint8Array
 /**
  * Check if an error is a memory-related error (out of heap space, etc.)
  *
  * @param {unknown} error - The error to check
  * @returns {boolean} True if the error appears to be memory-related
  */
-export function isMemoryError(error: unknown): boolean;
+export function isMemoryError(error: unknown): boolean
 /**
  * Test an encryption operation and expect it might fail with memory errors
  *
@@ -36,10 +36,13 @@ export function isMemoryError(error: unknown): boolean;
  * @param {string} operationName - Name of the operation for logging
  * @returns {Promise<{success: boolean, error?: Error}>} Result of the operation
  */
-export function testEncryptionWithMemoryHandling(encryptOperation: Function, operationName: string): Promise<{
-    success: boolean;
-    error?: Error;
-}>;
+export function testEncryptionWithMemoryHandling(
+  encryptOperation: Function,
+  operationName: string
+): Promise<{
+  success: boolean
+  error?: Error
+}>
 /**
  * Create a CAR file with KMS metadata content
  *
@@ -47,14 +50,16 @@ export function testEncryptionWithMemoryHandling(encryptOperation: Function, ope
  * @returns {Promise<{car: Uint8Array, actualRootCID: import('multiformats').UnknownLink}>}
  */
 export function createTestCar(content: any): Promise<{
-    car: Uint8Array;
-    actualRootCID: import("multiformats").UnknownLink;
-}>;
+  car: Uint8Array
+  actualRootCID: import('multiformats').UnknownLink
+}>
 /**
  * Create a mock BlobLike object for testing
  *
  * @param {Uint8Array} data
  * @returns {import('../../src/types.js').BlobLike}
  */
-export function createMockBlob(data: Uint8Array): import("../../src/types.js").BlobLike;
-//# sourceMappingURL=test-file-utils.d.ts.map
+export function createMockBlob(
+  data: Uint8Array
+): import('../../src/types.js').BlobLike
+//# sourceMappingURL=test-file-utils.d.ts.map

package/dist/test/helpers/test-file-utils.js

@@ -1,4 +1,4 @@
-import { KMSMetadata } from '../../src/core/metadata/encrypted-metadata.js';
+import { KMSMetadata } from '../../src/core/metadata/encrypted-metadata.js'
 /**
  * Create test data with specific patterns for easy verification
  *
@@ -6,24 +6,24 @@ import { KMSMetadata } from '../../src/core/metadata/encrypted-metadata.js';
  * @returns {Blob} A Blob containing test data with predictable patterns
  */
 export function createTestFile(sizeMB) {
-    const chunkSize = 64 * 1024; // 64KB chunks
-    const totalSize = sizeMB * 1024 * 1024;
-    const numChunks = Math.ceil(totalSize / chunkSize);
-    const chunks = [];
-    for (let i = 0; i < numChunks; i++) {
-        const isLastChunk = i === numChunks - 1;
-        const currentChunkSize = isLastChunk
-            ? totalSize % chunkSize || chunkSize
-            : chunkSize;
-        const chunk = new Uint8Array(currentChunkSize);
-        // Create pattern: chunk index in first byte, then sequence
-        chunk[0] = i % 256;
-        for (let j = 1; j < currentChunkSize; j++) {
-            chunk[j] = (i + j) % 256;
-        }
-        chunks.push(chunk);
+  const chunkSize = 64 * 1024 // 64KB chunks
+  const totalSize = sizeMB * 1024 * 1024
+  const numChunks = Math.ceil(totalSize / chunkSize)
+  const chunks = []
+  for (let i = 0; i < numChunks; i++) {
+    const isLastChunk = i === numChunks - 1
+    const currentChunkSize = isLastChunk
+      ? totalSize % chunkSize || chunkSize
+      : chunkSize
+    const chunk = new Uint8Array(currentChunkSize)
+    // Create pattern: chunk index in first byte, then sequence
+    chunk[0] = i % 256
+    for (let j = 1; j < currentChunkSize; j++) {
+      chunk[j] = (i + j) % 256
     }
-    return new Blob(chunks, { type: 'application/octet-stream' });
+    chunks.push(chunk)
+  }
+  return new Blob(chunks, { type: 'application/octet-stream' })
 }
 /**
  * Convert ReadableStream to Uint8Array
@@ -32,37 +32,36 @@ export function createTestFile(sizeMB) {
  * @returns {Promise<Uint8Array>} The stream content as a Uint8Array
  */
 export async function streamToUint8Array(stream) {
-    const reader = stream.getReader();
-    const chunks = [];
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        chunks.push(value);
-    }
-    const totalLength = chunks.reduce((acc, val) => acc + val.length, 0);
-    const result = new Uint8Array(totalLength);
-    let offset = 0;
-    for (const chunk of chunks) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-    }
-    return result;
+  const reader = stream.getReader()
+  const chunks = []
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    chunks.push(value)
+  }
+  const totalLength = chunks.reduce((acc, val) => acc + val.length, 0)
+  const result = new Uint8Array(totalLength)
+  let offset = 0
+  for (const chunk of chunks) {
+    result.set(chunk, offset)
+    offset += chunk.length
+  }
+  return result
 }
 /**
  * @param {Uint8Array} arr
  * @returns {string}
  */
 export function uint8ArrayToString(arr) {
-    return new TextDecoder().decode(arr);
+  return new TextDecoder().decode(arr)
 }
 /**
  * @param {string} str
  * @returns {Uint8Array}
  */
 export function stringToUint8Array(str) {
-    return new TextEncoder().encode(str);
+  return new TextEncoder().encode(str)
 }
 /**
  * Check if an error is a memory-related error (out of heap space, etc.)
@@ -71,11 +70,13 @@ export function stringToUint8Array(str) {
  * @returns {boolean} True if the error appears to be memory-related
  */
 export function isMemoryError(error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return (errorMessage.includes('heap') ||
-        errorMessage.includes('memory') ||
-        errorMessage.includes('allocation failed') ||
-        errorMessage.includes('out of memory'));
+  const errorMessage = error instanceof Error ? error.message : String(error)
+  return (
+    errorMessage.includes('heap') ||
+    errorMessage.includes('memory') ||
+    errorMessage.includes('allocation failed') ||
+    errorMessage.includes('out of memory')
+  )
 }
 /**
  * Test an encryption operation and expect it might fail with memory errors
@@ -84,24 +85,25 @@ export function isMemoryError(error) {
  * @param {string} operationName - Name of the operation for logging
  * @returns {Promise<{success: boolean, error?: Error}>} Result of the operation
  */
-export async function testEncryptionWithMemoryHandling(encryptOperation, operationName) {
-    try {
-        await encryptOperation();
-        return { success: true };
-    }
-    catch (error) {
-        if (isMemoryError(error)) {
-            console.log(`✓ ${operationName} failed as expected: Out of memory`);
-            return {
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-            };
-        }
-        else {
-            // Re-throw if it's not a memory error
-            throw error;
-        }
+export async function testEncryptionWithMemoryHandling(
+  encryptOperation,
+  operationName
+) {
+  try {
+    await encryptOperation()
+    return { success: true }
+  } catch (error) {
+    if (isMemoryError(error)) {
+      console.log(`✓ ${operationName} failed as expected: Out of memory`)
+      return {
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error)),
+      }
+    } else {
+      // Re-throw if it's not a memory error
+      throw error
     }
+  }
 }
 /**
  * Create a CAR file with KMS metadata content
@@ -110,13 +112,13 @@ export async function testEncryptionWithMemoryHandling(encryptOperation, operati
  * @returns {Promise<{car: Uint8Array, actualRootCID: import('multiformats').UnknownLink}>}
  */
 export async function createTestCar(content) {
-    // Create KMS metadata and archive it to get the CAR
-    const kmsMetadata = KMSMetadata.create(content);
-    const { cid, bytes } = await kmsMetadata.archiveBlock();
-    // Use UCANTO's CAR encoding to create a proper CAR file
-    const { CAR } = await import('@ucanto/core');
-    const car = CAR.encode({ roots: [{ cid, bytes }] });
-    return { car, actualRootCID: cid };
+  // Create KMS metadata and archive it to get the CAR
+  const kmsMetadata = KMSMetadata.create(content)
+  const { cid, bytes } = await kmsMetadata.archiveBlock()
+  // Use UCANTO's CAR encoding to create a proper CAR file
+  const { CAR } = await import('@ucanto/core')
+  const car = CAR.encode({ roots: [{ cid, bytes }] })
+  return { car, actualRootCID: cid }
 }
 /**
  * Create a mock BlobLike object for testing
@@ -125,15 +127,15 @@ export async function createTestCar(content) {
  * @returns {import('../../src/types.js').BlobLike}
  */
 export function createMockBlob(data) {
-    return {
-        stream() {
-            return new ReadableStream({
-                start(controller) {
-                    controller.enqueue(data);
-                    controller.close();
-                },
-            });
+  return {
+    stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue(data)
+          controller.close()
         },
-    };
+      })
+    },
+  }
 }
-//# sourceMappingURL=test-file-utils.js.map
+//# sourceMappingURL=test-file-utils.js.map

package/dist/test/https-enforcement.spec.d.ts

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=https-enforcement.spec.d.ts.map
+export {}
+//# sourceMappingURL=https-enforcement.spec.d.ts.map