@storacha/encrypt-upload-client 1.1.58 → 1.1.60

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,31 +13,17 @@ 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
  *
@@ -47,46 +33,33 @@ export const encryptAndUpload = async (
  * @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.
@@ -98,27 +71,18 @@ const buildAndUploadEncryptedMetadata = async (
  * @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,22 +1,13 @@
 /**
  * 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.
@@ -25,25 +16,10 @@ export function getSessionSigs(
  * @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,15 +1,10 @@
-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.
@@ -18,85 +13,68 @@ 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,
-    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,
+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,
-        resources: resourceAbilityRequests,
-        walletAddress: wallet.address,
-        nonce: await litClient.getLatestBlockhash(),
-        litNodeClient: litClient,
-      })
-      return await generateAuthSig({
-        signer: wallet,
-        toSign,
-      })
-    },
-  })
-  return sessionSigs
+        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;
 }
 /**
  * Get session signatures for a PKP key and auth method.
@@ -106,39 +84,25 @@ export async function getSessionSigs(
  * @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;
 }
 /**
  *
@@ -147,24 +111,24 @@ export async function getPkpSessionSigs(
  * @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