@storacha/encrypt-upload-client 1.1.56 → 1.1.58

package/dist/handlers/encrypt-handler.js

@@ -1,7 +1,7 @@
-import { CARWriterStream } from 'carstream';
-import { createFileEncoderStream } from '@storacha/upload-client/unixfs';
-import * as Type from '../types.js';
-import { createFileWithMetadata } from '../utils/file-metadata.js';
+import { CARWriterStream } from 'carstream'
+import { createFileEncoderStream } from '@storacha/upload-client/unixfs'
+import * as Type from '../types.js'
+import { createFileWithMetadata } from '../utils/file-metadata.js'
 /**
  * Encrypt and upload a file to the Storacha network
  *
@@ -13,17 +13,31 @@ import { createFileWithMetadata } from '../utils/file-metadata.js';
  * @param {Type.UploadOptions} [uploadOptions] - User-provided upload options
  * @returns {Promise<Type.AnyLink>} - The link to the uploaded file
  */
-export const encryptAndUpload = async (storachaClient, cryptoAdapter, file, encryptionConfig, uploadOptions = {}) => {
-    // Step 1: Validate required configuration
-    if (!encryptionConfig.spaceDID)
-        throw new Error('No space selected!');
-    // Step 2: Encrypt the file using the crypto adapter
-    const encryptedPayload = await encryptFile(cryptoAdapter, file, encryptionConfig);
-    // Step 3: Build and upload the encrypted metadata to the Storacha network
-    const rootCid = await buildAndUploadEncryptedMetadata(storachaClient, encryptedPayload, cryptoAdapter, uploadOptions);
-    // Step 4: Return the root CID of the encrypted metadata
-    return rootCid;
-};
+export const encryptAndUpload = async (
+  storachaClient,
+  cryptoAdapter,
+  file,
+  encryptionConfig,
+  uploadOptions = {}
+) => {
+  // Step 1: Validate required configuration
+  if (!encryptionConfig.spaceDID) throw new Error('No space selected!')
+  // Step 2: Encrypt the file using the crypto adapter
+  const encryptedPayload = await encryptFile(
+    cryptoAdapter,
+    file,
+    encryptionConfig
+  )
+  // Step 3: Build and upload the encrypted metadata to the Storacha network
+  const rootCid = await buildAndUploadEncryptedMetadata(
+    storachaClient,
+    encryptedPayload,
+    cryptoAdapter,
+    uploadOptions
+  )
+  // Step 4: Return the root CID of the encrypted metadata
+  return rootCid
+}
 /**
  * Upload encrypted metadata to the Storacha network
  *
@@ -33,33 +47,46 @@ export const encryptAndUpload = async (storachaClient, cryptoAdapter, file, encr
  * @param {Type.UploadOptions} [uploadOptions] - The upload options
  * @returns {Promise<Type.AnyLink>} - The link to the uploaded metadata
  */
-const buildAndUploadEncryptedMetadata = async (storachaClient, encryptedPayload, cryptoAdapter, uploadOptions) => {
-    const { encryptedKey, metadata, encryptedBlobLike } = encryptedPayload;
-    return storachaClient.uploadCAR({
-        stream() {
-            /** @type {any} */
-            let root;
-            return createFileEncoderStream(encryptedBlobLike)
-                .pipeThrough(new TransformStream({
-                transform(block, controller) {
-                    root = block;
-                    controller.enqueue(block);
-                },
-                async flush(controller) {
-                    if (!root)
-                        throw new Error('missing root block');
-                    const { cid, bytes } = await cryptoAdapter.encodeMetadata(root.cid.toString(), encryptedKey, metadata);
-                    controller.enqueue({ cid, bytes });
-                },
-            }))
-                .pipeThrough(new CARWriterStream());
-        },
-    }, {
-        ...uploadOptions,
-        // the encrypted data won't be published to Filecoin, so we need to set pieceHasher to undefined
-        pieceHasher: undefined,
-    });
-};
+const buildAndUploadEncryptedMetadata = async (
+  storachaClient,
+  encryptedPayload,
+  cryptoAdapter,
+  uploadOptions
+) => {
+  const { encryptedKey, metadata, encryptedBlobLike } = encryptedPayload
+  return storachaClient.uploadCAR(
+    {
+      stream() {
+        /** @type {any} */
+        let root
+        return createFileEncoderStream(encryptedBlobLike)
+          .pipeThrough(
+            new TransformStream({
+              transform(block, controller) {
+                root = block
+                controller.enqueue(block)
+              },
+              async flush(controller) {
+                if (!root) throw new Error('missing root block')
+                const { cid, bytes } = await cryptoAdapter.encodeMetadata(
+                  root.cid.toString(),
+                  encryptedKey,
+                  metadata
+                )
+                controller.enqueue({ cid, bytes })
+              },
+            })
+          )
+          .pipeThrough(new CARWriterStream())
+      },
+    },
+    {
+      ...uploadOptions,
+      // the encrypted data won't be published to Filecoin, so we need to set pieceHasher to undefined
+      pieceHasher: undefined,
+    }
+  )
+}
 /**
  * Encrypt a file with embedded metadata using the crypto adapter and return the encrypted payload.
  * The encrypted payload contains the encrypted file, the encrypted symmetric key, and the metadata.
@@ -71,18 +98,27 @@ const buildAndUploadEncryptedMetadata = async (storachaClient, encryptedPayload,
  * @returns {Promise<Type.EncryptionPayload>} - The encrypted file
  */
 const encryptFile = async (cryptoAdapter, file, encryptionConfig) => {
-    // Step 1: Embed metadata in file content if provided
-    const fileWithMetadata = createFileWithMetadata(file, encryptionConfig.fileMetadata);
-    // Step 2: Encrypt the file (with embedded metadata) using the crypto adapter
-    const { key, iv, encryptedStream } = await cryptoAdapter.encryptStream(fileWithMetadata);
-    // Step 3: Use crypto adapter to encrypt the symmetric key
-    const keyResult = await cryptoAdapter.encryptSymmetricKey(key, iv, encryptionConfig);
-    // Step 4: Return the encrypted payload (no separate metadata needed)
-    return {
-        strategy: keyResult.strategy,
-        encryptedKey: keyResult.encryptedKey,
-        metadata: keyResult.metadata,
-        encryptedBlobLike: { stream: () => encryptedStream },
-    };
-};
-//# sourceMappingURL=encrypt-handler.js.map
+  // Step 1: Embed metadata in file content if provided
+  const fileWithMetadata = createFileWithMetadata(
+    file,
+    encryptionConfig.fileMetadata
+  )
+  // Step 2: Encrypt the file (with embedded metadata) using the crypto adapter
+  const { key, iv, encryptedStream } = await cryptoAdapter.encryptStream(
+    fileWithMetadata
+  )
+  // Step 3: Use crypto adapter to encrypt the symmetric key
+  const keyResult = await cryptoAdapter.encryptSymmetricKey(
+    key,
+    iv,
+    encryptionConfig
+  )
+  // Step 4: Return the encrypted payload (no separate metadata needed)
+  return {
+    strategy: keyResult.strategy,
+    encryptedKey: keyResult.encryptedKey,
+    metadata: keyResult.metadata,
+    encryptedBlobLike: { stream: () => encryptedStream },
+  }
+}
+//# sourceMappingURL=encrypt-handler.js.map

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { create } from "./core/client.js";
-//# sourceMappingURL=index.d.ts.map
+export { create } from './core/client.js'
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,2 +1,2 @@
-export { create } from './core/client.js';
-//# sourceMappingURL=index.js.map
+export { create } from './core/client.js'
+//# sourceMappingURL=index.js.map

package/dist/protocols/lit.d.ts

@@ -1,13 +1,22 @@
 /**
  * Get a LitClient instance.
  */
-export function getLitClient(): Promise<LitNodeClient>;
+export function getLitClient(): Promise<LitNodeClient>
 /**
  * @param {LitNodeClient} litClient
  * @param {Type.SessionSignatureOptions} param0
  * @returns {Promise<import('@lit-protocol/types').SessionSigsMap>}
  */
-export function getSessionSigs(litClient: LitNodeClient, { wallet, accessControlConditions, dataToEncryptHash, expiration, capabilityAuthSigs, }: Type.SessionSignatureOptions): Promise<import("@lit-protocol/types").SessionSigsMap>;
+export function getSessionSigs(
+  litClient: LitNodeClient,
+  {
+    wallet,
+    accessControlConditions,
+    dataToEncryptHash,
+    expiration,
+    capabilityAuthSigs,
+  }: Type.SessionSignatureOptions
+): Promise<import('@lit-protocol/types').SessionSigsMap>
 /**
  * Get session signatures for a PKP key and auth method.
  * There is not need to execute the auth callback for this function, because the auth method provided.
@@ -16,10 +25,25 @@ export function getSessionSigs(litClient: LitNodeClient, { wallet, accessControl
  * @param {Type.PkpSessionSignatureOptions} options
  * @returns {Promise<import('@lit-protocol/types').SessionSigsMap>}
  */
-export function getPkpSessionSigs(litClient: LitNodeClient, { pkpPublicKey, authMethod, accessControlConditions, dataToEncryptHash, expiration, capabilityAuthSigs, }: Type.PkpSessionSignatureOptions): Promise<import("@lit-protocol/types").SessionSigsMap>;
-export { encryptString } from "@lit-protocol/encryption";
-export function getAccessControlConditions(spaceDID: Type.SpaceDID): import("@lit-protocol/types").AccessControlConditions;
-export function executeUcanValidationAction(litClient: LitNodeClient, options: Type.ExecuteUcanValidationOptions): Promise<any>;
-import { LitNodeClient } from '@lit-protocol/lit-node-client';
-import * as Type from '../types.js';
-//# sourceMappingURL=lit.d.ts.map
+export function getPkpSessionSigs(
+  litClient: LitNodeClient,
+  {
+    pkpPublicKey,
+    authMethod,
+    accessControlConditions,
+    dataToEncryptHash,
+    expiration,
+    capabilityAuthSigs,
+  }: Type.PkpSessionSignatureOptions
+): Promise<import('@lit-protocol/types').SessionSigsMap>
+export { encryptString } from '@lit-protocol/encryption'
+export function getAccessControlConditions(
+  spaceDID: Type.SpaceDID
+): import('@lit-protocol/types').AccessControlConditions
+export function executeUcanValidationAction(
+  litClient: LitNodeClient,
+  options: Type.ExecuteUcanValidationOptions
+): Promise<any>
+import { LitNodeClient } from '@lit-protocol/lit-node-client'
+import * as Type from '../types.js'
+//# sourceMappingURL=lit.d.ts.map

package/dist/protocols/lit.js

@@ -1,10 +1,15 @@
-import { LitNodeClient } from '@lit-protocol/lit-node-client';
-import { LIT_ABILITY } from '@lit-protocol/constants';
-import { generateAuthSig, LitActionResource, createSiweMessage, LitAccessControlConditionResource, } from '@lit-protocol/auth-helpers';
-import env from '../config/env.js';
-import * as Type from '../types.js';
-import { STORACHA_LIT_ACTION_CID } from '../config/constants.js';
-export { encryptString } from '@lit-protocol/encryption';
+import { LitNodeClient } from '@lit-protocol/lit-node-client'
+import { LIT_ABILITY } from '@lit-protocol/constants'
+import {
+  generateAuthSig,
+  LitActionResource,
+  createSiweMessage,
+  LitAccessControlConditionResource,
+} from '@lit-protocol/auth-helpers'
+import env from '../config/env.js'
+import * as Type from '../types.js'
+import { STORACHA_LIT_ACTION_CID } from '../config/constants.js'
+export { encryptString } from '@lit-protocol/encryption'
 /**
  * Create access control conditions required to use Lit Protocol.
  * This ensures that the Storacha Lit Action is used to validate decryption permissions for the specified space DID.
@@ -13,68 +18,85 @@ export { encryptString } from '@lit-protocol/encryption';
  * @returns {import('@lit-protocol/types').AccessControlConditions} - The access control conditions
  */
 export const getAccessControlConditions = (spaceDID) => {
-    return [
-        {
-            contractAddress: '',
-            standardContractType: '',
-            chain: 'ethereum',
-            method: '',
-            parameters: [':currentActionIpfsId', spaceDID],
-            returnValueTest: {
-                comparator: '=',
-                value: STORACHA_LIT_ACTION_CID,
-            },
-        },
-    ];
-};
+  return [
+    {
+      contractAddress: '',
+      standardContractType: '',
+      chain: 'ethereum',
+      method: '',
+      parameters: [':currentActionIpfsId', spaceDID],
+      returnValueTest: {
+        comparator: '=',
+        value: STORACHA_LIT_ACTION_CID,
+      },
+    },
+  ]
+}
 /**
  * Get a LitClient instance.
  */
 export async function getLitClient() {
-    const litNodeClient = new LitNodeClient({
-        litNetwork: env.LIT_NETWORK,
-        debug: env.LIT_DEBUG,
-    });
-    await litNodeClient.connect();
-    return litNodeClient;
+  const litNodeClient = new LitNodeClient({
+    litNetwork: env.LIT_NETWORK,
+    debug: env.LIT_DEBUG,
+  })
+  await litNodeClient.connect()
+  return litNodeClient
 }
 /**
  * @param {LitNodeClient} litClient
  * @param {Type.SessionSignatureOptions} param0
  * @returns {Promise<import('@lit-protocol/types').SessionSigsMap>}
  */
-export async function getSessionSigs(litClient, { wallet, accessControlConditions, dataToEncryptHash, expiration, capabilityAuthSigs, }) {
-    const accsResourceString = await LitAccessControlConditionResource.generateResourceString(accessControlConditions, dataToEncryptHash);
-    const sessionSigs = await litClient.getSessionSigs({
-        chain: 'ethereum',
-        capabilityAuthSigs,
+export async function getSessionSigs(
+  litClient,
+  {
+    wallet,
+    accessControlConditions,
+    dataToEncryptHash,
+    expiration,
+    capabilityAuthSigs,
+  }
+) {
+  const accsResourceString =
+    await LitAccessControlConditionResource.generateResourceString(
+      accessControlConditions,
+      dataToEncryptHash
+    )
+  const sessionSigs = await litClient.getSessionSigs({
+    chain: 'ethereum',
+    capabilityAuthSigs,
+    expiration,
+    resourceAbilityRequests: [
+      {
+        resource: new LitAccessControlConditionResource(accsResourceString),
+        ability: LIT_ABILITY.AccessControlConditionDecryption,
+      },
+      {
+        resource: new LitActionResource('*'),
+        ability: LIT_ABILITY.LitActionExecution,
+      },
+    ],
+    authNeededCallback: async ({
+      uri,
+      expiration,
+      resourceAbilityRequests,
+    }) => {
+      const toSign = await createSiweMessage({
+        uri,
         expiration,
-        resourceAbilityRequests: [
-            {
-                resource: new LitAccessControlConditionResource(accsResourceString),
-                ability: LIT_ABILITY.AccessControlConditionDecryption,
-            },
-            {
-                resource: new LitActionResource('*'),
-                ability: LIT_ABILITY.LitActionExecution,
-            },
-        ],
-        authNeededCallback: async ({ uri, expiration, resourceAbilityRequests, }) => {
-            const toSign = await createSiweMessage({
-                uri,
-                expiration,
-                resources: resourceAbilityRequests,
-                walletAddress: wallet.address,
-                nonce: await litClient.getLatestBlockhash(),
-                litNodeClient: litClient,
-            });
-            return await generateAuthSig({
-                signer: wallet,
-                toSign,
-            });
-        },
-    });
-    return sessionSigs;
+        resources: resourceAbilityRequests,
+        walletAddress: wallet.address,
+        nonce: await litClient.getLatestBlockhash(),
+        litNodeClient: litClient,
+      })
+      return await generateAuthSig({
+        signer: wallet,
+        toSign,
+      })
+    },
+  })
+  return sessionSigs
 }
 /**
  * Get session signatures for a PKP key and auth method.
@@ -84,25 +106,39 @@ export async function getSessionSigs(litClient, { wallet, accessControlCondition
  * @param {Type.PkpSessionSignatureOptions} options
  * @returns {Promise<import('@lit-protocol/types').SessionSigsMap>}
  */
-export async function getPkpSessionSigs(litClient, { pkpPublicKey, authMethod, accessControlConditions, dataToEncryptHash, expiration, capabilityAuthSigs, }) {
-    const accsResourceString = await LitAccessControlConditionResource.generateResourceString(accessControlConditions, dataToEncryptHash);
-    const sessionSigs = await litClient.getPkpSessionSigs({
-        pkpPublicKey,
-        authMethods: [authMethod],
-        resourceAbilityRequests: [
-            {
-                resource: new LitAccessControlConditionResource(accsResourceString),
-                ability: LIT_ABILITY.AccessControlConditionDecryption,
-            },
-            {
-                resource: new LitActionResource('*'),
-                ability: LIT_ABILITY.LitActionExecution,
-            },
-        ],
-        expiration,
-        capabilityAuthSigs,
-    });
-    return sessionSigs;
+export async function getPkpSessionSigs(
+  litClient,
+  {
+    pkpPublicKey,
+    authMethod,
+    accessControlConditions,
+    dataToEncryptHash,
+    expiration,
+    capabilityAuthSigs,
+  }
+) {
+  const accsResourceString =
+    await LitAccessControlConditionResource.generateResourceString(
+      accessControlConditions,
+      dataToEncryptHash
+    )
+  const sessionSigs = await litClient.getPkpSessionSigs({
+    pkpPublicKey,
+    authMethods: [authMethod],
+    resourceAbilityRequests: [
+      {
+        resource: new LitAccessControlConditionResource(accsResourceString),
+        ability: LIT_ABILITY.AccessControlConditionDecryption,
+      },
+      {
+        resource: new LitActionResource('*'),
+        ability: LIT_ABILITY.LitActionExecution,
+      },
+    ],
+    expiration,
+    capabilityAuthSigs,
+  })
+  return sessionSigs
 }
 /**
  *
@@ -111,24 +147,24 @@ export async function getPkpSessionSigs(litClient, { pkpPublicKey, authMethod, a
  * @returns
  */
 export const executeUcanValidationAction = async (litClient, options) => {
-    const { sessionSigs, ...jsParams } = options;
-    const litActionResponse = await litClient.executeJs({
-        ipfsId: STORACHA_LIT_ACTION_CID,
-        sessionSigs,
-        jsParams,
-    });
-    if (!litActionResponse.response) {
-        throw new Error('Error getting lit action response.');
-    }
-    const parsedResponse = JSON.parse(
-    /** @type string*/ (litActionResponse.response));
-    const decryptedData = parsedResponse.decryptedString;
-    if (!decryptedData) {
-        let errorMsg;
-        if (parsedResponse.error)
-            errorMsg = parsedResponse.error;
-        throw new Error(`Decrypted data does not exist! Error message: ${errorMsg}`);
-    }
-    return decryptedData;
-};
-//# sourceMappingURL=lit.js.map
+  const { sessionSigs, ...jsParams } = options
+  const litActionResponse = await litClient.executeJs({
+    ipfsId: STORACHA_LIT_ACTION_CID,
+    sessionSigs,
+    jsParams,
+  })
+  if (!litActionResponse.response) {
+    throw new Error('Error getting lit action response.')
+  }
+  const parsedResponse = JSON.parse(
+    /** @type string*/ (litActionResponse.response)
+  )
+  const decryptedData = parsedResponse.decryptedString
+  if (!decryptedData) {
+    let errorMsg
+    if (parsedResponse.error) errorMsg = parsedResponse.error
+    throw new Error(`Decrypted data does not exist! Error message: ${errorMsg}`)
+  }
+  return decryptedData
+}
+//# sourceMappingURL=lit.js.map

package/dist/test/cid-verification.spec.d.ts

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