thirdweb 5.37.0 → 5.37.1-nightly-26d825bc4f0475523ea761aa18ab979557295c28-20240722000339

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

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

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

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

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