thirdweb 5.37.0 → 5.38.0

package/src/extensions/lens/__generated__/ModuleRegistry/read/isModuleRegisteredAs.ts

@@ -0,0 +1,150 @@
+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 "isModuleRegisteredAs" function.
+ */
+export type IsModuleRegisteredAsParams = {
+  moduleAddress: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "moduleAddress";
+  }>;
+  moduleType: AbiParameterToPrimitiveType<{
+    type: "uint256";
+    name: "moduleType";
+  }>;
+};
+
+export const FN_SELECTOR = "0xc2b62fdd" as const;
+const FN_INPUTS = [
+  {
+    type: "address",
+    name: "moduleAddress",
+  },
+  {
+    type: "uint256",
+    name: "moduleType",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "bool",
+  },
+] as const;
+
+/**
+ * Checks if the `isModuleRegisteredAs` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `isModuleRegisteredAs` method is supported.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { isIsModuleRegisteredAsSupported } from "thirdweb/extensions/lens";
+ *
+ * const supported = await isIsModuleRegisteredAsSupported(contract);
+ * ```
+ */
+export async function isIsModuleRegisteredAsSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "isModuleRegisteredAs" function.
+ * @param options - The options for the isModuleRegisteredAs function.
+ * @returns The encoded ABI parameters.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeIsModuleRegisteredAsParams } "thirdweb/extensions/lens";
+ * const result = encodeIsModuleRegisteredAsParams({
+ *  moduleAddress: ...,
+ *  moduleType: ...,
+ * });
+ * ```
+ */
+export function encodeIsModuleRegisteredAsParams(
+  options: IsModuleRegisteredAsParams,
+) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.moduleAddress,
+    options.moduleType,
+  ]);
+}
+
+/**
+ * Encodes the "isModuleRegisteredAs" function into a Hex string with its parameters.
+ * @param options - The options for the isModuleRegisteredAs function.
+ * @returns The encoded hexadecimal string.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeIsModuleRegisteredAs } "thirdweb/extensions/lens";
+ * const result = encodeIsModuleRegisteredAs({
+ *  moduleAddress: ...,
+ *  moduleType: ...,
+ * });
+ * ```
+ */
+export function encodeIsModuleRegisteredAs(
+  options: IsModuleRegisteredAsParams,
+) {
+  // 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 +
+    encodeIsModuleRegisteredAsParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the isModuleRegisteredAs function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { decodeIsModuleRegisteredAsResult } from "thirdweb/extensions/lens";
+ * const result = decodeIsModuleRegisteredAsResult("...");
+ * ```
+ */
+export function decodeIsModuleRegisteredAsResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "isModuleRegisteredAs" function on the contract.
+ * @param options - The options for the isModuleRegisteredAs function.
+ * @returns The parsed result of the function call.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { isModuleRegisteredAs } from "thirdweb/extensions/lens";
+ *
+ * const result = await isModuleRegisteredAs({
+ *  contract,
+ *  moduleAddress: ...,
+ *  moduleType: ...,
+ * });
+ *
+ * ```
+ */
+export async function isModuleRegisteredAs(
+  options: BaseTransactionOptions<IsModuleRegisteredAsParams>,
+) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.moduleAddress, options.moduleType],
+  });
+}

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

@@ -0,0 +1,132 @@
+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 "getDefaultHandle" function.
+ */
+export type GetDefaultHandleParams = {
+  profileId: AbiParameterToPrimitiveType<{
+    type: "uint256";
+    name: "profileId";
+  }>;
+};
+
+export const FN_SELECTOR = "0xe524488d" as const;
+const FN_INPUTS = [
+  {
+    type: "uint256",
+    name: "profileId",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "uint256",
+  },
+] as const;
+
+/**
+ * Checks if the `getDefaultHandle` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `getDefaultHandle` method is supported.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { isGetDefaultHandleSupported } from "thirdweb/extensions/lens";
+ *
+ * const supported = await isGetDefaultHandleSupported(contract);
+ * ```
+ */
+export async function isGetDefaultHandleSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "getDefaultHandle" function.
+ * @param options - The options for the getDefaultHandle function.
+ * @returns The encoded ABI parameters.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeGetDefaultHandleParams } "thirdweb/extensions/lens";
+ * const result = encodeGetDefaultHandleParams({
+ *  profileId: ...,
+ * });
+ * ```
+ */
+export function encodeGetDefaultHandleParams(options: GetDefaultHandleParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.profileId]);
+}
+
+/**
+ * Encodes the "getDefaultHandle" function into a Hex string with its parameters.
+ * @param options - The options for the getDefaultHandle function.
+ * @returns The encoded hexadecimal string.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeGetDefaultHandle } "thirdweb/extensions/lens";
+ * const result = encodeGetDefaultHandle({
+ *  profileId: ...,
+ * });
+ * ```
+ */
+export function encodeGetDefaultHandle(options: GetDefaultHandleParams) {
+  // 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 +
+    encodeGetDefaultHandleParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the getDefaultHandle function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { decodeGetDefaultHandleResult } from "thirdweb/extensions/lens";
+ * const result = decodeGetDefaultHandleResult("...");
+ * ```
+ */
+export function decodeGetDefaultHandleResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "getDefaultHandle" function on the contract.
+ * @param options - The options for the getDefaultHandle function.
+ * @returns The parsed result of the function call.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { getDefaultHandle } from "thirdweb/extensions/lens";
+ *
+ * const result = await getDefaultHandle({
+ *  contract,
+ *  profileId: ...,
+ * });
+ *
+ * ```
+ */
+export async function getDefaultHandle(
+  options: BaseTransactionOptions<GetDefaultHandleParams>,
+) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.profileId],
+  });
+}

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

@@ -0,0 +1,124 @@
+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 "nonces" function.
+ */
+export type NoncesParams = {
+  signer: AbiParameterToPrimitiveType<{ type: "address"; name: "signer" }>;
+};
+
+export const FN_SELECTOR = "0x7ecebe00" as const;
+const FN_INPUTS = [
+  {
+    type: "address",
+    name: "signer",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "uint256",
+    name: "nonce",
+  },
+] as const;
+
+/**
+ * Checks if the `nonces` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `nonces` method is supported.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { isNoncesSupported } from "thirdweb/extensions/lens";
+ *
+ * const supported = await isNoncesSupported(contract);
+ * ```
+ */
+export async function isNoncesSupported(contract: ThirdwebContract<any>) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "nonces" function.
+ * @param options - The options for the nonces function.
+ * @returns The encoded ABI parameters.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeNoncesParams } "thirdweb/extensions/lens";
+ * const result = encodeNoncesParams({
+ *  signer: ...,
+ * });
+ * ```
+ */
+export function encodeNoncesParams(options: NoncesParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.signer]);
+}
+
+/**
+ * Encodes the "nonces" function into a Hex string with its parameters.
+ * @param options - The options for the nonces function.
+ * @returns The encoded hexadecimal string.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { encodeNonces } "thirdweb/extensions/lens";
+ * const result = encodeNonces({
+ *  signer: ...,
+ * });
+ * ```
+ */
+export function encodeNonces(options: NoncesParams) {
+  // 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 +
+    encodeNoncesParams(options).slice(2)) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the nonces function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { decodeNoncesResult } from "thirdweb/extensions/lens";
+ * const result = decodeNoncesResult("...");
+ * ```
+ */
+export function decodeNoncesResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "nonces" function on the contract.
+ * @param options - The options for the nonces function.
+ * @returns The parsed result of the function call.
+ * @extension LENS
+ * @example
+ * ```ts
+ * import { nonces } from "thirdweb/extensions/lens";
+ *
+ * const result = await nonces({
+ *  contract,
+ *  signer: ...,
+ * });
+ *
+ * ```
+ */
+export async function nonces(options: BaseTransactionOptions<NoncesParams>) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.signer],
+  });
+}

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");
+  });
+});