@storacha/encrypt-upload-client 1.1.58 → 1.1.60

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

@@ -2,32 +2,27 @@
  * 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,71 +1,63 @@
-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,13 +36,10 @@ 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
  *
@@ -50,16 +47,14 @@ export function testEncryptionWithMemoryHandling(
  * @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
+    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);
     }
-    chunks.push(chunk)
-  }
-  return new Blob(chunks, { type: 'application/octet-stream' })
+    return new Blob(chunks, { type: 'application/octet-stream' });
 }
 /**
  * Convert ReadableStream to Uint8Array
@@ -32,36 +32,37 @@ 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.)
@@ -70,13 +71,11 @@ 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
@@ -85,25 +84,24 @@ 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
@@ -112,13 +110,13 @@ export async function testEncryptionWithMemoryHandling(
  * @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
@@ -127,15 +125,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