thirdweb 5.37.0 → 5.38.0

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/react/web/wallets/shared/openOauthSignInWindow.ts

@@ -1,5 +1,5 @@
 import type { ThirdwebClient } from "../../../../client/client.js";
-import { getDiscordLoginPath } from "../../../../wallets/in-app/core/authentication/getLoginPath.js";
+import { getSocialAuthLoginPath } from "../../../../wallets/in-app/core/authentication/getLoginPath.js";
 import type { InAppWalletSocialAuth } from "../../../../wallets/in-app/core/wallet/types.js";
 import type { Ecosystem } from "../../../../wallets/in-app/web/types.js";
 import type { Theme } from "../../../core/design-system/index.js";
@@ -30,8 +30,11 @@ function getOauthLoginPath(
   ecosystem?: Ecosystem,
 ) {
   switch (authOption) {
+    case "apple":
+    case "facebook":
+    case "google":
     case "discord":
-      return getDiscordLoginPath(client, ecosystem);
+      return getSocialAuthLoginPath(authOption, client, ecosystem);
     default:
       return "";
   }

package/src/utils/any-evm/compute-published-contract-deploy-info.ts

@@ -24,6 +24,7 @@ export async function computeDeploymentInfoFromContractId(args: {
     client,
     contractId,
     publisher: args.publisher,
+    version: args.version,
   });
   return computeDeploymentInfoFromMetadata({
     client,

package/src/utils/bytecode/resolveImplementation.test.ts

@@ -0,0 +1,53 @@
+import type { AbiConstructor } from "abitype";
+import { describe, expect, it } from "vitest";
+import {
+  DUMMY_BYTECODE,
+  ERC1967_PROXY_BYTECODE,
+  ERC1967_PROXY_CONSTRUCTOR_ABI,
+} from "../../../test/src/abis/proxy.js";
+import { ANVIL_CHAIN } from "../../../test/src/chains.js";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import {
+  NFT_DROP_CONTRACT,
+  NFT_DROP_IMPLEMENTATION,
+} from "../../../test/src/test-contracts.js";
+import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
+import { getContract } from "../../contract/contract.js";
+import { deployContract } from "../../contract/deployment/deploy-with-abi.js";
+import { resolveImplementation } from "./resolveImplementation.js";
+
+describe("Resolve implementation", async () => {
+  it("should extract implementation address for minimal proxy contract", async () => {
+    const resolved = resolveImplementation(NFT_DROP_CONTRACT);
+    expect((await resolved).address).to.equal(NFT_DROP_IMPLEMENTATION);
+  });
+
+  it("should extract implementation address for ERC1967 proxy contract", async () => {
+    const implementationAddress = await deployContract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account: TEST_ACCOUNT_A,
+      bytecode: DUMMY_BYTECODE,
+      constructorAbi: {} as AbiConstructor,
+      constructorParams: [],
+    });
+
+    const proxyAddress = await deployContract({
+      client: TEST_CLIENT,
+      chain: ANVIL_CHAIN,
+      account: TEST_ACCOUNT_A,
+      bytecode: ERC1967_PROXY_BYTECODE,
+      constructorAbi: ERC1967_PROXY_CONSTRUCTOR_ABI as AbiConstructor,
+      constructorParams: [implementationAddress, ""],
+    });
+
+    const proxy = getContract({
+      chain: ANVIL_CHAIN,
+      address: proxyAddress,
+      client: TEST_CLIENT,
+    });
+
+    const resolved = await resolveImplementation(proxy);
+    expect(resolved.address).to.equal(implementationAddress);
+  });
+});

package/src/utils/bytecode/resolveImplementation.ts

@@ -42,40 +42,39 @@ export async function resolveImplementation(
   }
 
   // check other proxy types
+  let implementationAddress: string | undefined;
   if (beacon && beacon !== AddressZero) {
     // In case of a BeaconProxy, it is setup as BeaconProxy --> Beacon --> Implementation
     // Hence we replace the proxy address with Beacon address, and continue further resolving below
     // biome-ignore lint/style/noParameterAssign: we purposefully mutate the contract object here
     contract = { ...contract, address: beacon };
+
+    implementationAddress = await getImplementationFromContractCall(contract);
+  } else {
+    implementationAddress = await getImplementationFromStorageSlot(contract);
   }
-  const implementations = await Promise.all([
-    getImplementationFromStorageSlot(contract),
-    getImplementationFromContractCall(contract),
-  ]);
-  // this seems inefficient
-  for (const implementationAddress of implementations) {
-    if (
-      implementationAddress &&
-      isAddress(implementationAddress) &&
-      implementationAddress !== AddressZero
-    ) {
-      const implementationBytecode = await getBytecode({
-        ...contract,
-        address: implementationAddress,
-      });
-      // return the original contract bytecode if the implementation bytecode is empty
-      if (implementationBytecode === "0x") {
-        return {
-          address: contract.address,
-          bytecode: originalBytecode,
-        };
-      }
 
+  if (
+    implementationAddress &&
+    isAddress(implementationAddress) &&
+    implementationAddress !== AddressZero
+  ) {
+    const implementationBytecode = await getBytecode({
+      ...contract,
+      address: implementationAddress,
+    });
+    // return the original contract bytecode if the implementation bytecode is empty
+    if (implementationBytecode === "0x") {
       return {
-        address: implementationAddress,
-        bytecode: implementationBytecode,
+        address: contract.address,
+        bytecode: originalBytecode,
       };
     }
+
+    return {
+      address: implementationAddress,
+      bytecode: implementationBytecode,
+    };
   }
 
   return { address: contract.address, bytecode: originalBytecode };

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.37.0";
+export const version = "5.38.0";

package/src/wallets/in-app/core/authentication/getLoginPath.ts

@@ -1,13 +1,14 @@
 import type { ThirdwebClient } from "../../../../client/client.js";
 import { getThirdwebBaseUrl } from "../../../../utils/domains.js";
+import type { SocialAuthOption } from "../../../../wallets/types.js";
 import type { Ecosystem } from "../../web/types.js";
 
-// TODO: make this generic for all auth providers
-export const getDiscordLoginPath = (
+export const getSocialAuthLoginPath = (
+  authOption: SocialAuthOption,
   client: ThirdwebClient,
   ecosystem?: Ecosystem,
 ) => {
-  const baseUrl = `${getThirdwebBaseUrl("inAppWallet")}/api/2024-05-05/login/discord?clientId=${client.clientId}`;
+  const baseUrl = `${getThirdwebBaseUrl("inAppWallet")}/api/2024-05-05/login/${authOption}?clientId=${client.clientId}`;
   if (ecosystem?.partnerId) {
     return `${baseUrl}&ecosystemId=${ecosystem.id}&ecosystemPartnerId=${ecosystem.partnerId}`;
   }

package/src/wallets/in-app/core/authentication/type.ts

@@ -65,7 +65,7 @@ export enum AuthProvider {
 }
 
 export type OauthOption = {
-  provider: AuthProvider;
+  strategy: SocialAuthOption;
   redirectUrl: string;
 };
 
@@ -207,13 +207,3 @@ export type GetUser =
 export type GetAuthenticatedUserParams = {
   client: ThirdwebClient;
 };
-
-export const oauthStrategyToAuthProvider: Record<
-  SocialAuthOption,
-  AuthProvider
-> = {
-  google: AuthProvider.GOOGLE,
-  facebook: AuthProvider.FACEBOOK,
-  apple: AuthProvider.APPLE,
-  discord: AuthProvider.DISCORD,
-};