thirdweb 5.37.0 → 5.37.1-nightly-26d825bc4f0475523ea761aa18ab979557295c28-20240722000339

package/src/extensions/lens/__generated__/TokenHandleRegistry/read/resolve.ts

@@ -0,0 +1,123 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { decodeAbiParameters } from "viem";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "resolve" function.
+ */
+export type ResolveParams = {
+  handleId: AbiParameterToPrimitiveType<{ type: "uint256"; name: "handleId" }>;
+};
+
+export const FN_SELECTOR = "0x4f896d4f" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "handleId",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "uint256",
+  },
+] as const;
+
+/**
+ * Checks if the `resolve` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `resolve` method is supported.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { isResolveSupported } from "thirdweb/extensions/lens";
+ *
+ * const supported = await isResolveSupported(contract);
+ * ```
+ */
+export async function isResolveSupported(contract: ThirdwebContract<any>) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "resolve" function.
+ * @param options - The options for the resolve function.
+ * @returns The encoded ABI parameters.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeResolveParams } "thirdweb/extensions/lens";
+ * const result = encodeResolveParams({
+ *  handleId: ...,
+ * });
+ * ```
+ */
+export function encodeResolveParams(options: ResolveParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.handleId]);
+}
+
+/**
+ * Encodes the "resolve" function into a Hex string with its parameters.
+ * @param options - The options for the resolve function.
+ * @returns The encoded hexadecimal string.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeResolve } "thirdweb/extensions/lens";
+ * const result = encodeResolve({
+ *  handleId: ...,
+ * });
+ * ```
+ */
+export function encodeResolve(options: ResolveParams) {
+  // we do a "manual" concat here to avoid the overhead of the "concatHex" function
+  // we can do this because we know the specific formats of the values
+  return (FN_SELECTOR +
+    encodeResolveParams(options).slice(2)) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the resolve function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { decodeResolveResult } from "thirdweb/extensions/lens";
+ * const result = decodeResolveResult("...");
+ * ```
+ */
+export function decodeResolveResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "resolve" function on the contract.
+ * @param options - The options for the resolve function.
+ * @returns The parsed result of the function call.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { resolve } from "thirdweb/extensions/lens";
+ *
+ * const result = await resolve({
+ *  contract,
+ *  handleId: ...,
+ * });
+ *
+ * ```
+ */
+export async function resolve(options: BaseTransactionOptions<ResolveParams>) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.handleId],
+  });
+}

package/src/extensions/lens/consts.ts

@@ -0,0 +1,35 @@
+/**
+ * List of Lens's contracts on both polygon mainnet and polygon amoy testnet
+ * Update to the latest data here: https://www.lens.xyz/docs/resources/smart-contracts
+ *
+ * In our Lens extensions we will default to using these hard-coded values on mainnet
+ * to simplify the code for users, however they can override anytime
+ */
+
+// ------------------- Mainnet Polygon (137) ------------------- //
+
+// Core contracts
+export const LENS_HUB_ADDRESS = "0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d";
+export const LENS_HANDLE_ADDRESS = "0xe7E7EaD361f3AaCD73A61A9bD6C10cA17F38E945";
+export const LENS_TOKEN_HANDLE_REGISTRY_ADDRESS =
+  "0xD4F2F33680FCCb36748FA9831851643781608844";
+export const LENS_FOLLOW_NFT_ADDRESS =
+  "0x288715E67B7b184fD299143280CA6c1Eb7F31e1B";
+export const LENS_COLLECT_NFT_ADDRESS =
+  "0x0c2a7761E2971D906338F5da1ecF0027E4247fd7";
+export const LENS_MODULE_REGISTRY_ADDRESS =
+  "0x1eD5983F0c883B96f7C35528a1e22EEA67DE3Ff9";
+
+// ------------------- Polygon Amoy Testnet (80002) ------------------- //
+export const LENS_HUB_ADDRESS_TESTNET =
+  "0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d";
+export const LENS_HANDLE_ADDRESS_TESTNET =
+  "0xe7E7EaD361f3AaCD73A61A9bD6C10cA17F38E945";
+export const LENS_TOKEN_HANDLE_REGISTRY_ADDRESS_TESTNET =
+  "0xD4F2F33680FCCb36748FA9831851643781608844";
+export const LENS_FOLLOW_NFT_ADDRESS_TESTNET =
+  "0x288715E67B7b184fD299143280CA6c1Eb7F31e1B";
+export const LENS_COLLECT_NFT_ADDRESS_TESTNET =
+  "0x0c2a7761E2971D906338F5da1ecF0027E4247fd7";
+export const LENS_MODULE_REGISTRY_ADDRESS_TESTNET =
+  "0x1eD5983F0c883B96f7C35528a1e22EEA67DE3Ff9";

package/src/extensions/lens/read/getFullProfile.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { MAX_UINT256 } from "~test/test-consts.js";
+import { getFullProfile } from "./getFullProfile.js";
+
+/**
+ * For Lens protocol, each profileId is an ERC721 tokenId.
+ * So any bigint from 0 to (current max profile id) should return a valid profile + handle
+ */
+
+const profileId = 1000n;
+const client = TEST_CLIENT;
+
+describe("lens/getFullProfile", () => {
+  it("should return a full profile with handle and (maybe) profile metadata", async () => {
+    const profile = await getFullProfile({ profileId, client });
+
+    // Although there is a profile, the metadata of that profile might still be "null"
+    // if user hasn't set up any metadata like avatar, coverPicture, name, bio etc.
+    expect(typeof profile).toBe("object");
+    expect(profile?.handle.startsWith("lens/@")).toBe(true);
+    expect(typeof profile?.profileData).toBe("object");
+  });
+
+  it("should return null for invalid profileId", async () => {
+    // As of Jul 2024 Lens has about 465k profiles | So trying to get profile of a max-unit256 profileId should return "null"
+    // gotta be a very long before this number is reached so we should be safe
+    const profile = await getFullProfile({ profileId: MAX_UINT256, client });
+    expect(profile === null).toBe(true);
+  });
+
+  it("should return joinDate", async () => {
+    const profile = await getFullProfile({
+      profileId,
+      client,
+      includeJoinDate: true,
+    });
+    expect(typeof profile?.joinDate).toBe("bigint");
+  });
+});

package/src/extensions/lens/read/getFullProfile.ts

@@ -0,0 +1,106 @@
+import { polygon } from "../../../chains/chain-definitions/polygon.js";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { getContract } from "../../../contract/contract.js";
+import type { Hex } from "../../../utils/encoding/hex.js";
+import { getProfile } from "../__generated__/LensHub/read/getProfile.js";
+import { getDefaultHandle } from "../__generated__/TokenHandleRegistry/read/getDefaultHandle.js";
+import {
+  LENS_HANDLE_ADDRESS,
+  LENS_HUB_ADDRESS,
+  LENS_TOKEN_HANDLE_REGISTRY_ADDRESS,
+} from "../consts.js";
+import type { LensProfileSchema } from "./type.js";
+
+export type GetFullProfileParams = {
+  profileId: bigint;
+  client: ThirdwebClient;
+  includeJoinDate?: boolean;
+  overrides?: {
+    lensHubAddress?: Hex;
+    lensHandleAddress?: Hex;
+    tokenHandleRegistryAddress?: Hex;
+    chain?: Chain;
+  };
+};
+
+export type FullProfileResponse = {
+  handle: string;
+  // Timestamp of the join date
+  joinDate: bigint | null;
+  profileData: LensProfileSchema | null;
+} | null;
+
+/**
+ * Return the profile data _with Lens handle_ and optional join date
+ *
+ * In Lens Protocol, each profile is associated with an ERC721 token,
+ * thus, the tokenId represent profileId and the 2 terms can be used interchangeably
+ * @extension LENS
+ *
+ * @example
+ * ```ts
+ * import { getFullProfile } from "thirdweb/extension/lens";
+ *
+ * const profileId = 10000n; // profileId is the tokenId of the NFT
+ * const lensProfile = await getFullProfile({ profileId, client });
+ * ```
+ */
+export async function getFullProfile(
+  options: GetFullProfileParams,
+): Promise<FullProfileResponse> {
+  const { profileId, overrides, includeJoinDate, client } = options;
+  const lensHubContract = getContract({
+    address: overrides?.lensHubAddress || LENS_HUB_ADDRESS,
+    chain: overrides?.chain || polygon,
+    client,
+  });
+  const tokenHandleRegistryContract = getContract({
+    address:
+      overrides?.tokenHandleRegistryAddress ||
+      LENS_TOKEN_HANDLE_REGISTRY_ADDRESS,
+    chain: overrides?.chain || polygon,
+    client,
+  });
+  const [profile, handleTokenId, { download }] = await Promise.all([
+    getProfile({ contract: lensHubContract, profileId }),
+    getDefaultHandle({
+      contract: tokenHandleRegistryContract,
+      profileId,
+    }).catch(() => null),
+    import("../../../storage/download.js"),
+  ]);
+
+  // A profile data should always pair with a handle, so we exit if either is missing
+  if (!profile || !handleTokenId) {
+    return null;
+  }
+
+  const [{ getHandle }, { mintTimestampOf }, profileData] = await Promise.all([
+    import("../__generated__/LensHandle/read/getHandle.js"),
+    import("../__generated__/LensHub/read/mintTimestampOf.js"),
+    profile?.metadataURI
+      ? (await download({ uri: profile.metadataURI, client })).json()
+      : null,
+  ]);
+
+  const lensHandleContract = getContract({
+    address: overrides?.lensHandleAddress || LENS_HANDLE_ADDRESS,
+    chain: overrides?.chain || polygon,
+    client,
+  });
+  const [handle, joinDate] = await Promise.all([
+    getHandle({ contract: lensHandleContract, tokenId: handleTokenId }),
+    includeJoinDate
+      ? mintTimestampOf({ contract: lensHubContract, tokenId: profileId })
+      : null,
+  ]);
+
+  const result: FullProfileResponse = {
+    profileData,
+    handle,
+    joinDate,
+  };
+
+  return result;
+}

package/src/extensions/lens/read/getHandleFromProfileId.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { MAX_UINT256 } from "~test/test-consts.js";
+import { getHandleFromProfileId } from "./getHandleFromProfileId.js";
+
+/**
+ * For Lens protocol, each profileId is an ERC721 tokenId.
+ * So any bigint from 0 to (current max id) should return a valid profile + handle
+ */
+
+const profileId = 1000n;
+const client = TEST_CLIENT;
+
+describe("lens/getHandleFromProfileId should return a handle for a valid profileId", () => {
+  it("should return a string in this format: lens/@<handle>", async () => {
+    const handle = await getHandleFromProfileId({ profileId, client });
+    expect(typeof handle).toBe("string");
+    // @ts-ignore expected
+    expect(handle.startsWith("lens/")).toBe(true);
+  });
+
+  it("should return `null` for an invalid profileId", async () => {
+    // As of Jul 2024 Lens has about 465k profiles | So trying to get handle of a max-unit256 profileId should return "null"
+    // gotta be a very long before this number is reached so we should be safe
+    const handle = await getHandleFromProfileId({
+      profileId: MAX_UINT256,
+      client,
+    });
+    expect(handle).toBe(null);
+  });
+
+  it("should work with overrides", async () => {
+    const handle = await getHandleFromProfileId({
+      profileId,
+      client,
+      overrides: {
+        lensHandleAddress: "0xe7E7EaD361f3AaCD73A61A9bD6C10cA17F38E945",
+        tokenHandleRegistryAddress:
+          "0xD4F2F33680FCCb36748FA9831851643781608844",
+      },
+    });
+    // @ts-ignore expected
+    expect(handle.startsWith("lens/")).toBe(true);
+  });
+});

package/src/extensions/lens/read/getHandleFromProfileId.ts

@@ -0,0 +1,67 @@
+import { polygon } from "../../../chains/chain-definitions/polygon.js";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { getContract } from "../../../contract/contract.js";
+import type { Hex } from "../../../utils/encoding/hex.js";
+import { getHandle } from "../__generated__/LensHandle/read/getHandle.js";
+import { getDefaultHandle } from "../__generated__/TokenHandleRegistry/read/getDefaultHandle.js";
+import {
+  LENS_HANDLE_ADDRESS,
+  LENS_TOKEN_HANDLE_REGISTRY_ADDRESS,
+} from "../consts.js";
+
+export type GetHandleFromProfileIdParams = {
+  profileId: bigint;
+  client: ThirdwebClient;
+  overrides?: {
+    lensHandleAddress?: Hex;
+    tokenHandleRegistryAddress?: Hex;
+    chain?: Chain;
+  };
+};
+
+/**
+ * Return the Lens handle of a profile in the format: lens/@<name-of-user>
+ * @param options
+ * @returns
+ * @extension LENS
+ *
+ * @example
+ * ```ts
+ * import { getHandleFromProfileId } from "thirdweb/extensions/lens";
+ *
+ * const profileId = 461662n;
+ * const handle = await getHandleFromProfileId({ profileId, client }); // "lens/@captain_jack"
+ * ```
+ */
+export async function getHandleFromProfileId(
+  options: GetHandleFromProfileIdParams,
+) {
+  const { profileId, overrides, client } = options;
+  const lensHandleContract = getContract({
+    address: overrides?.lensHandleAddress || LENS_HANDLE_ADDRESS,
+    chain: overrides?.chain || polygon,
+    client,
+  });
+  const tokenHandleRegistryContract = getContract({
+    address:
+      overrides?.tokenHandleRegistryAddress ||
+      LENS_TOKEN_HANDLE_REGISTRY_ADDRESS,
+    chain: overrides?.chain || polygon,
+    client,
+  });
+  const handleTokenId = await getDefaultHandle({
+    contract: tokenHandleRegistryContract,
+    profileId,
+  }).catch(() => null);
+  if (handleTokenId === null) {
+    return null;
+  }
+  // e.g: "lens/@JuanWick"
+  const handle = await getHandle({
+    contract: lensHandleContract,
+    tokenId: handleTokenId,
+  }).catch(() => null);
+
+  return handle;
+}

package/src/extensions/lens/read/getProfileMetadata.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { TEST_CLIENT } from "~test/test-clients.js";
+import { MAX_UINT256 } from "~test/test-consts.js";
+import { getProfileMetadata } from "./getProfileMetadata.js";
+
+/**
+ * For Lens protocol, each profileId is an ERC721 tokenId.
+ * So any bigint from 0 to (current max profile id) should return a valid profile + handle
+ */
+
+const profileId = 1000n;
+const client = TEST_CLIENT;
+
+describe("lens/getProfileMetadata", () => {
+  it("should return a profile object or null for valid profileId", async () => {
+    const profile = await getProfileMetadata({ profileId, client });
+
+    // Although there is a profile, the metadata of that profile might still be "missing"
+    // if user hasn't set up any metadata like avatar, coverPicture, name, bio etc.
+    expect(typeof profile).toBe("object");
+  });
+
+  it("should return null for invalid profileId", async () => {
+    // As of Jul 2024 Lens has about 465k profiles | So trying to get profile of a max-unit256 profileId should return nothing
+    // gotta be a very long before this number is reached so we should be safe
+    const profile = await getProfileMetadata({
+      profileId: MAX_UINT256,
+      client,
+    });
+    expect(profile === null).toBe(true);
+  });
+
+  it("should work with overrides", async () => {
+    const profile = await getProfileMetadata({
+      profileId,
+      client,
+      overrides: {
+        lensHubAddress: "0xDb46d1Dc155634FbC732f92E853b10B288AD5a1d",
+      },
+    });
+    expect(typeof profile).toBe("object");
+  });
+});

package/src/extensions/lens/read/getProfileMetadata.ts

@@ -0,0 +1,67 @@
+import { polygon } from "../../../chains/chain-definitions/polygon.js";
+import type { Chain } from "../../../chains/types.js";
+import type { ThirdwebClient } from "../../../client/client.js";
+import { getContract } from "../../../contract/contract.js";
+import type { Hex } from "../../../utils/encoding/hex.js";
+import { getProfile } from "../__generated__/LensHub/read/getProfile.js";
+import { LENS_HUB_ADDRESS } from "../consts.js";
+import type { LensProfileSchema } from "./type.js";
+
+export type GetProfileMetadataParams = {
+  profileId: bigint;
+  client: ThirdwebClient;
+  overrides?: {
+    lensHubAddress?: Hex;
+    chain?: Chain;
+  };
+};
+
+/**
+ * Download user lens profile from Arweave
+ * This method does NOT give you the user handle & join-time - consider using `getFullProfileData` instead
+ * It is useful & cost efficient if you only want to get user's name, bio, picture, coverPicture etc.
+ *
+ * @important The contract here is the LensHub contract
+ * @param options
+ * @returns LensProfileSchema | null
+ * @extension LENS
+ *
+ * @example
+ * ```ts
+ * import { getProfileMetadata } from "thirdweb/extensions/lens";
+ *
+ * const profileData = await getProfileMetadata({ profileId, client });
+ *
+ * if (profileData) {
+ *   console.log("Display name: ", profileData.lens.name);
+ *   console.log("Bio: ", profileData.lens.bio);
+ * }
+ * ```
+ */
+export async function getProfileMetadata(
+  options: GetProfileMetadataParams,
+): Promise<LensProfileSchema | null> {
+  const { client, profileId, overrides } = options;
+  const lensHubContract = getContract({
+    address: overrides?.lensHubAddress || LENS_HUB_ADDRESS,
+    chain: overrides?.chain || polygon,
+    client,
+  });
+  const profile = await getProfile({
+    contract: lensHubContract,
+    profileId,
+  }).catch(() => null);
+  if (profile === null) {
+    return profile;
+  }
+  if (!profile?.metadataURI) {
+    return null;
+  }
+  const { download } = await import("../../../storage/download.js");
+  const res = await download({
+    uri: profile.metadataURI,
+    client,
+  });
+  const profileData = ((await res.json()) as LensProfileSchema) || null;
+  return profileData;
+}

package/src/extensions/lens/read/type.ts

@@ -0,0 +1,50 @@
+export type LensProfileSchema = {
+  // A cryptographic signature of the Lens metadata
+  signature: string;
+  lens: {
+    // lens id
+    id: string;
+    // The profile display name
+    name: string;
+    // The profile bio as markdown
+    bio: string;
+    // The profile picture (avatar)
+    picture: string;
+    // The profile cover picture
+    coverPicture: string;
+    // extra metadata
+    attributes: MetadataAttribute[];
+    // The App Id, if omitted considered as global Profile data
+    appId?: string;
+  };
+};
+
+/**
+ * @internal
+ */
+export type MetadataAttribute =
+  | {
+      type: "Boolean";
+      key: string;
+      value: "true" | "false";
+    }
+  | {
+      type: "Date";
+      key: string;
+      value: string; // should be a valid ISO 8601 date string
+    }
+  | {
+      type: "Number";
+      key: string;
+      value: string; // should be a valid JS number serialized as string
+    }
+  | {
+      type: "String";
+      key: string;
+      value: string;
+    }
+  | {
+      type: "JSON";
+      key: string;
+      value: string; // should be a JSON string
+    };

package/src/extensions/permissions/utils.ts

@@ -2,7 +2,10 @@ import { keccakId } from "../../utils/any-evm/keccak-id.js";
 import { LruMap } from "../../utils/caching/lru.js";
 import { type Hex, isHex, padHex } from "../../utils/encoding/hex.js";
 
-const roleMap = {
+/**
+ * A map of all current thirdweb's smart contract roles
+ */
+export const roleMap = {
   admin: "",
   transfer: "TRANSFER_ROLE",
   minter: "MINTER_ROLE",
@@ -32,6 +35,17 @@ export type RoleInput = ThirdwebContractRole | Hex | (string & {});
 
 const roleCache = new LruMap<Hex>(128);
 
+/**
+ * Get a hex value of a smart contract role
+ * You need the hex value to interact with the smart contracts.
+ * @param role string
+ * @returns hex value of the contract role
+ *
+ * @example
+ * ```ts
+ * const adminRoleHash = getRoleHash("admin"); // 0x0000000...000000
+ * ```
+ */
 export function getRoleHash(role: RoleInput) {
   if (roleCache.has(role)) {
     // biome-ignore lint/style/noNonNullAssertion: we know it's in the cache

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.37.0";
+export const version = "5.37.1-nightly-26d825bc4f0475523ea761aa18ab979557295c28-20240722000339";