Gated Content

Learn how to create and access Gated Publications.

Lens Protocol, utilizing the decentralized capabilities of Lit Protocol, supports gated content.

When creating a new Gated Publication, Lens users can define access conditions. These conditions determine who can decrypt the content and media within the publication. For example, access could be granted to:

You can also combine these conditions using boolean AND and OR operators.

Create an instance of the gated LensClient class using the constructor from the secondary package entry point @lens-protocol/client/gated. See JavaScript SDK Getting Started) for more information on setting up the base LensClient class.

import { development, LensClient } from "@lens-protocol/client/gated";
const client = new LensClient({  environment: development,
  authentication: {    domain: process.env.DOMAIN,    uri: process.env.URI,  },
  signer,});

This constructor accepts the same parameters as the base LensClient class, with few additional parameters:

Like the base LensClient class, you can specify an optional storage that complies with the IStorageProvider interface. By default, if not provided, it will fall back to an InMemoryStorage instance (which keeps any stored information in a temporary location in system memory). The gated LensClient uses the same storage to save Lit Protocol credentials so that signing of SIWE messages happens only when needed.

To create a Gated Publication, the process is the same as creating a regular publication, with the addition of encrypting the metadata beforehand.

import { article } from "@lens-protocol/metadata";
const metadata = article({ content: "..." });

import { erc721OwnershipCondition } from "@lens-protocol/metadata";
const condition = erc721OwnershipCondition({  contract: { address: "0x...", chainId: 1 },});

const result = await client.gated.encryptPublicationMetadata(  metadata,  condition);
// handle encryption errorsif (result.isFailure()) {  console.error(result.error);  return; // bail out}
const encrypted = result.value;

const contentURI = await upload(encrypted);
const result = await client.publication.postOnchain({ contentURI });

That's it—you've just learned how to create a Gated Publication in Lens Protocol.

The @lens-protocol/metadata package provides helper functions for the following access conditions:

You can define an access condition that requires the collection of the current publication. However, at the time of encryption, the publication hasn't been created yet. In this case, you can use client.publication.predictNextOnChainPublicationId to predict the publication ID.

const condition = collectCondition({  publicationId: await client.publication.predictNextOnChainPublicationId({    from: profile.id,  }),  thisPublication: true, // flag to indicate that the current publication is the one to collect});

You can combine multiple criteria using the orCondition and andCondition helper functions.

const result = await client.gated.encryptPublicationMetadata(  metadata,  orCondition([    profileOwnershipCondition({      profileId: profile.id,    }),    erc721OwnershipCondition({      contract: { address: "0x...", chainId: 1 },    }),  ]));

Supported compound conditions are:

You can decrypt publication metadata using the client.gated.decryptPublicationMetadataFragment method. This method is compatible with publications returned by any LensClient method. Additionally, the LensClient SDK supports the decryption of metadata from previous publication standards, specifically version 2.

import { isEncryptedPublicationMetadata } from "@lens-protocol/client/gated";
// fetch a publication, works with publications returned by any LensClient methodconst post = await client.publication.fetch({ forId: "..." });
// check if the publication metadata is encryptedif (isEncryptedPublicationMetadata(post.metadata)) {  // decrypt the metadata  const result = await client.gated.decryptPublicationMetadataFragment(    post.metadata  );
  // handle decryption errors  if (result.isFailure()) {    console.error(result.error);    return; // bail out  }
  // use the decrypted metadata  console.log(result.value);}

If you're using this feature with a publication metadata fragment not originating from the LensClient, it's your responsibility to ensure the PublicationMetadata fragment is valid. Specifically, it should:

That's it—you've just learned how to decrypt Gated Publications in Lens Protocol.