thirdweb 5.29.1 → 5.29.2-nightly-fb6a07d4b84ba8ea6389ca04c73625f670a0d9c4-20240614172741

package/src/extensions/modular/ModularCore/write/uninstallExtensionByProxy.ts

@@ -0,0 +1,40 @@
+import type { Chain } from "../../../../chains/types.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
+import {
+  type ThirdwebContract,
+  getContract,
+} from "../../../../contract/contract.js";
+import { resolveImplementation } from "../../../../utils/bytecode/resolveImplementation.js";
+import { uninstallExtension } from "../../__generated__/ModularCore/write/uninstallExtension.js";
+
+export type UninstallExtensionByProxyOptions = {
+  client: ThirdwebClient;
+  chain: Chain;
+  contract: ThirdwebContract;
+  extensionProxyAddress: string;
+  extensionData?: `0x${string}`;
+};
+
+export function uninstallExtensionByProxy(
+  options: UninstallExtensionByProxyOptions,
+) {
+  const { client, chain, contract, extensionProxyAddress, extensionData } =
+    options;
+
+  return uninstallExtension({
+    contract,
+    asyncParams: async () => {
+      const extensionImplementation = await resolveImplementation(
+        getContract({
+          chain,
+          client,
+          address: extensionProxyAddress,
+        }),
+      );
+      return {
+        extension: extensionImplementation.address,
+        data: extensionData || "0x",
+      };
+    },
+  });
+}

package/src/extensions/modular/ModularCore/write/uninstallPublishedExtension.ts

@@ -0,0 +1,47 @@
+import type { Chain } from "../../../../chains/types.js";
+import type { ThirdwebClient } from "../../../../client/client.js";
+import type { ThirdwebContract } from "../../../../contract/contract.js";
+import { getDeployedInfraContract } from "../../../../contract/deployment/utils/infra.js";
+import { uninstallExtension } from "../../__generated__/ModularCore/write/uninstallExtension.js";
+
+export type UninstallPublishedExtensionOptions = {
+  client: ThirdwebClient;
+  chain: Chain;
+  contract: ThirdwebContract;
+  extensionName: string;
+  publisherAddress: string;
+  version?: string;
+  constructorParams?: unknown[];
+  extensionData?: `0x${string}`;
+};
+
+export function uninstallPublishedExtension(
+  options: UninstallPublishedExtensionOptions,
+) {
+  const {
+    client,
+    chain,
+    contract,
+    extensionName,
+    publisherAddress,
+    constructorParams,
+    extensionData,
+  } = options;
+
+  return uninstallExtension({
+    contract,
+    asyncParams: async () => {
+      const deployedExtension = await getDeployedInfraContract({
+        chain,
+        client,
+        contractId: extensionName,
+        constructorParams: constructorParams || [],
+        publisher: publisherAddress,
+      });
+      return {
+        extension: deployedExtension?.address as string,
+        data: extensionData || "0x",
+      };
+    },
+  });
+}

package/src/extensions/modular/__generated__/IModularCore/read/getInstalledExtensions.ts

@@ -0,0 +1,134 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.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";
+
+export const FN_SELECTOR = "0x5357aa5e" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    name: "",
+    type: "tuple[]",
+    internalType: "struct IModularCore.InstalledExtension[]",
+    components: [
+      {
+        name: "implementation",
+        type: "address",
+        internalType: "address",
+      },
+      {
+        name: "config",
+        type: "tuple",
+        internalType: "struct IExtensionConfig.ExtensionConfig",
+        components: [
+          {
+            name: "registerInstallationCallback",
+            type: "bool",
+            internalType: "bool",
+          },
+          {
+            name: "requiredInterfaces",
+            type: "bytes4[]",
+            internalType: "bytes4[]",
+          },
+          {
+            name: "supportedInterfaces",
+            type: "bytes4[]",
+            internalType: "bytes4[]",
+          },
+          {
+            name: "callbackFunctions",
+            type: "tuple[]",
+            internalType: "struct IExtensionConfig.CallbackFunction[]",
+            components: [
+              {
+                name: "selector",
+                type: "bytes4",
+                internalType: "bytes4",
+              },
+            ],
+          },
+          {
+            name: "fallbackFunctions",
+            type: "tuple[]",
+            internalType: "struct IExtensionConfig.FallbackFunction[]",
+            components: [
+              {
+                name: "selector",
+                type: "bytes4",
+                internalType: "bytes4",
+              },
+              {
+                name: "permissionBits",
+                type: "uint256",
+                internalType: "uint256",
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+] as const;
+
+/**
+ * Checks if the `getInstalledExtensions` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `getInstalledExtensions` method is supported.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { isGetInstalledExtensionsSupported } from "thirdweb/extensions/modular";
+ *
+ * const supported = await isGetInstalledExtensionsSupported(contract);
+ * ```
+ */
+export async function isGetInstalledExtensionsSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the getInstalledExtensions function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { decodeGetInstalledExtensionsResult } from "thirdweb/extensions/modular";
+ * const result = decodeGetInstalledExtensionsResult("...");
+ * ```
+ */
+export function decodeGetInstalledExtensionsResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "getInstalledExtensions" function on the contract.
+ * @param options - The options for the getInstalledExtensions function.
+ * @returns The parsed result of the function call.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { getInstalledExtensions } from "thirdweb/extensions/modular";
+ *
+ * const result = await getInstalledExtensions({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function getInstalledExtensions(options: BaseTransactionOptions) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}

package/src/extensions/modular/__generated__/IModularCore/read/getSupportedCallbackFunctions.ts

@@ -0,0 +1,90 @@
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.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";
+
+export const FN_SELECTOR = "0xf147db8a" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [
+  {
+    name: "",
+    type: "tuple[]",
+    internalType: "struct IModularCore.SupportedCallbackFunction[]",
+    components: [
+      {
+        name: "selector",
+        type: "bytes4",
+        internalType: "bytes4",
+      },
+      {
+        name: "mode",
+        type: "uint8",
+        internalType: "enum IModularCore.CallbackMode",
+      },
+    ],
+  },
+] as const;
+
+/**
+ * Checks if the `getSupportedCallbackFunctions` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `getSupportedCallbackFunctions` method is supported.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { isGetSupportedCallbackFunctionsSupported } from "thirdweb/extensions/modular";
+ *
+ * const supported = await isGetSupportedCallbackFunctionsSupported(contract);
+ * ```
+ */
+export async function isGetSupportedCallbackFunctionsSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Decodes the result of the getSupportedCallbackFunctions function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { decodeGetSupportedCallbackFunctionsResult } from "thirdweb/extensions/modular";
+ * const result = decodeGetSupportedCallbackFunctionsResult("...");
+ * ```
+ */
+export function decodeGetSupportedCallbackFunctionsResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "getSupportedCallbackFunctions" function on the contract.
+ * @param options - The options for the getSupportedCallbackFunctions function.
+ * @returns The parsed result of the function call.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { getSupportedCallbackFunctions } from "thirdweb/extensions/modular";
+ *
+ * const result = await getSupportedCallbackFunctions({
+ *  contract,
+ * });
+ *
+ * ```
+ */
+export async function getSupportedCallbackFunctions(
+  options: BaseTransactionOptions,
+) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [],
+  });
+}

package/src/extensions/modular/__generated__/IModularCore/read/supportsInterface.ts

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

package/src/extensions/modular/__generated__/IModularCore/write/installExtension.ts

@@ -0,0 +1,160 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import type {
+  BaseTransactionOptions,
+  WithOverrides,
+} from "../../../../../transaction/types.js";
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { once } from "../../../../../utils/promise/once.js";
+import type { ThirdwebContract } from "../../../../../contract/contract.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "installExtension" function.
+ */
+export type InstallExtensionParams = WithOverrides<{
+  extensionContract: AbiParameterToPrimitiveType<{
+    name: "extensionContract";
+    type: "address";
+    internalType: "address";
+  }>;
+  data: AbiParameterToPrimitiveType<{
+    name: "data";
+    type: "bytes";
+    internalType: "bytes";
+  }>;
+}>;
+
+export const FN_SELECTOR = "0xaca696f5" as const;
+const FN_INPUTS = [
+  {
+    name: "extensionContract",
+    type: "address",
+    internalType: "address",
+  },
+  {
+    name: "data",
+    type: "bytes",
+    internalType: "bytes",
+  },
+] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `installExtension` method is supported by the given contract.
+ * @param contract The ThirdwebContract.
+ * @returns A promise that resolves to a boolean indicating if the `installExtension` method is supported.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { isInstallExtensionSupported } from "thirdweb/extensions/modular";
+ *
+ * const supported = await isInstallExtensionSupported(contract);
+ * ```
+ */
+export async function isInstallExtensionSupported(
+  contract: ThirdwebContract<any>,
+) {
+  return detectMethod({
+    contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "installExtension" function.
+ * @param options - The options for the installExtension function.
+ * @returns The encoded ABI parameters.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { encodeInstallExtensionParams } "thirdweb/extensions/modular";
+ * const result = encodeInstallExtensionParams({
+ *  extensionContract: ...,
+ *  data: ...,
+ * });
+ * ```
+ */
+export function encodeInstallExtensionParams(options: InstallExtensionParams) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.extensionContract,
+    options.data,
+  ]);
+}
+
+/**
+ * Encodes the "installExtension" function into a Hex string with its parameters.
+ * @param options - The options for the installExtension function.
+ * @returns The encoded hexadecimal string.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { encodeInstallExtension } "thirdweb/extensions/modular";
+ * const result = encodeInstallExtension({
+ *  extensionContract: ...,
+ *  data: ...,
+ * });
+ * ```
+ */
+export function encodeInstallExtension(options: InstallExtensionParams) {
+  // 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 +
+    encodeInstallExtensionParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "installExtension" function on the contract.
+ * @param options - The options for the "installExtension" function.
+ * @returns A prepared transaction object.
+ * @extension MODULAR
+ * @example
+ * ```ts
+ * import { installExtension } from "thirdweb/extensions/modular";
+ *
+ * const transaction = installExtension({
+ *  contract,
+ *  extensionContract: ...,
+ *  data: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * ...
+ *
+ * ```
+ */
+export function installExtension(
+  options: BaseTransactionOptions<
+    | InstallExtensionParams
+    | {
+        asyncParams: () => Promise<InstallExtensionParams>;
+      }
+  >,
+) {
+  const asyncOptions = once(async () => {
+    return "asyncParams" in options ? await options.asyncParams() : options;
+  });
+
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: async () => {
+      const resolvedOptions = await asyncOptions();
+      return [resolvedOptions.extensionContract, resolvedOptions.data] as const;
+    },
+    value: async () => (await asyncOptions()).overrides?.value,
+    accessList: async () => (await asyncOptions()).overrides?.accessList,
+    gas: async () => (await asyncOptions()).overrides?.gas,
+    gasPrice: async () => (await asyncOptions()).overrides?.gasPrice,
+    maxFeePerGas: async () => (await asyncOptions()).overrides?.maxFeePerGas,
+    maxPriorityFeePerGas: async () =>
+      (await asyncOptions()).overrides?.maxPriorityFeePerGas,
+    nonce: async () => (await asyncOptions()).overrides?.nonce,
+    extraGas: async () => (await asyncOptions()).overrides?.extraGas,
+  });
+}