thirdweb 5.88.4 → 5.88.5-nightly-52cbcd2d57abf4d69ee417fe98fca815e19f2f34-20250216000400

package/dist/types/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,WAAW,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,2EAA2E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thirdweb",
-  "version": "5.88.4",
+  "version": "5.88.5-nightly-52cbcd2d57abf4d69ee417fe98fca815e19f2f34-20250216000400",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/thirdweb-dev/js.git#main"

package/src/contract/deployment/deploy-via-autofactory.test.ts

@@ -2,9 +2,15 @@ import { describe, expect, it } from "vitest";
 import { ANVIL_CHAIN } from "../../../test/src/chains.js";
 import { TEST_CLIENT } from "../../../test/src/test-clients.js";
 import { TEST_ACCOUNT_A } from "../../../test/src/test-wallets.js";
+import { parseEventLogs } from "../../event/actions/parse-logs.js";
 import { initialize } from "../../extensions/prebuilts/__generated__/DropERC721/write/initialize.js";
+import { deployContractfromDeployMetadata } from "../../extensions/prebuilts/deploy-published.js";
+import { proxyDeployedV2Event } from "../../extensions/thirdweb/__generated__/IContractFactory/events/ProxyDeployedV2.js";
+import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { sendTransaction } from "../../transaction/actions/send-transaction.js";
+import { keccakId } from "../../utils/any-evm/keccak-id.js";
 import { prepareAutoFactoryDeployTransaction } from "./deploy-via-autofactory.js";
+import { fetchPublishedContractMetadata } from "./publisher.js";
 import { deployCloneFactory, deployImplementation } from "./utils/bootstrap.js";
 import { getDeployedCloneFactoryContract } from "./utils/clone-factory.js";
 import { getDeployedInfraContract } from "./utils/infra.js";
@@ -118,4 +124,164 @@ describe.runIf(process.env.TW_SECRET_KEY)("deployFromMetadata", () => {
       expect(hash.transactionHash).toBeDefined();
     },
   );
+
+  it.sequential("should deploy with crosschain option", async () => {
+    const cloneFactoryContract = await getDeployedCloneFactoryContract({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+    });
+    if (!cloneFactoryContract) {
+      throw new Error("Clone factory not found");
+    }
+    const implementationContract = await getDeployedInfraContract({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      contractId: "DropERC721",
+    });
+    if (!implementationContract) {
+      throw new Error("Clone factory not found");
+    }
+
+    const initializeTransaction = initialize({
+      contract: implementationContract,
+      name: "NFTDrop unified",
+      symbol: "NFTD",
+      defaultAdmin: TEST_ACCOUNT_A.address,
+      platformFeeBps: 0n,
+      platformFeeRecipient: TEST_ACCOUNT_A.address,
+      royaltyBps: 0n,
+      royaltyRecipient: TEST_ACCOUNT_A.address,
+      saleRecipient: TEST_ACCOUNT_A.address,
+      trustedForwarders: [],
+      contractURI: "",
+    });
+
+    const transaction = prepareAutoFactoryDeployTransaction({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      cloneFactoryContract,
+      initializeTransaction,
+    });
+    const receipt = await sendAndConfirmTransaction({
+      transaction,
+      account: TEST_ACCOUNT_A,
+    });
+    const proxyEvent = proxyDeployedV2Event();
+    const decodedEvent = parseEventLogs({
+      events: [proxyEvent],
+      logs: receipt.logs,
+    });
+
+    const deployMetadata = await fetchPublishedContractMetadata({
+      client: TEST_CLIENT,
+      contractId: "DropERC721",
+    });
+    const deployed = await deployContractfromDeployMetadata({
+      account: TEST_ACCOUNT_A,
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      deployMetadata,
+      isCrosschain: true,
+      initializeData: decodedEvent[0]?.args.data,
+    });
+
+    expect(deployed).toBeDefined();
+  });
+
+  it.sequential("should generate salt based on input params", async () => {
+    const cloneFactoryContract = await getDeployedCloneFactoryContract({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+    });
+    if (!cloneFactoryContract) {
+      throw new Error("Clone factory not found");
+    }
+    const implementationContract = await getDeployedInfraContract({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      contractId: "DropERC721",
+    });
+    if (!implementationContract) {
+      throw new Error("Clone factory not found");
+    }
+
+    const initializeTransaction = initialize({
+      contract: implementationContract,
+      name: "NFTDrop unified",
+      symbol: "NFTD",
+      defaultAdmin: TEST_ACCOUNT_A.address,
+      platformFeeBps: 0n,
+      platformFeeRecipient: TEST_ACCOUNT_A.address,
+      royaltyBps: 0n,
+      royaltyRecipient: TEST_ACCOUNT_A.address,
+      saleRecipient: TEST_ACCOUNT_A.address,
+      trustedForwarders: [],
+      contractURI: "",
+    });
+
+    let salt = "test";
+    let transaction = prepareAutoFactoryDeployTransaction({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      cloneFactoryContract,
+      initializeTransaction,
+      salt,
+    });
+    let receipt = await sendAndConfirmTransaction({
+      transaction,
+      account: TEST_ACCOUNT_A,
+    });
+    let proxyEvent = proxyDeployedV2Event();
+    let decodedEvent = parseEventLogs({
+      events: [proxyEvent],
+      logs: receipt.logs,
+    });
+
+    expect(decodedEvent[0]?.args.inputSalt).to.equal(keccakId("test"));
+
+    salt = keccakId("test1");
+    transaction = prepareAutoFactoryDeployTransaction({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      cloneFactoryContract,
+      initializeTransaction,
+      salt,
+    });
+    receipt = await sendAndConfirmTransaction({
+      transaction,
+      account: TEST_ACCOUNT_A,
+    });
+    proxyEvent = proxyDeployedV2Event();
+    decodedEvent = parseEventLogs({
+      events: [proxyEvent],
+      logs: receipt.logs,
+    });
+
+    expect(decodedEvent[0]?.args.inputSalt).to.equal(keccakId("test1"));
+
+    // deploy with crosschain option
+    transaction = prepareAutoFactoryDeployTransaction({
+      chain: ANVIL_CHAIN,
+      client: TEST_CLIENT,
+      cloneFactoryContract,
+      initializeData: decodedEvent[0]?.args.data,
+      implementationAddress: implementationContract.address,
+      isCrosschain: true,
+      salt: keccakId("test2"),
+    });
+    receipt = await sendAndConfirmTransaction({
+      transaction,
+      account: TEST_ACCOUNT_A,
+    });
+    proxyEvent = proxyDeployedV2Event();
+    decodedEvent = parseEventLogs({
+      events: [proxyEvent],
+      logs: receipt.logs,
+    });
+
+    expect(decodedEvent[0]?.args.inputSalt).to.equal(keccakId("test2"));
+    expect(decodedEvent[0]?.args.implementation.toLowerCase()).to.equal(
+      implementationContract.address.toLowerCase(),
+    );
+  });
 });

package/src/contract/deployment/deploy-via-autofactory.ts

@@ -1,6 +1,6 @@
 import { parseEventLogs } from "../../event/actions/parse-logs.js";
-import { proxyDeployedEvent } from "../../extensions/thirdweb/__generated__/IContractFactory/events/ProxyDeployed.js";
-import { deployProxyByImplementation } from "../../extensions/thirdweb/__generated__/IContractFactory/write/deployProxyByImplementation.js";
+import { proxyDeployedV2Event } from "../../extensions/thirdweb/__generated__/IContractFactory/events/ProxyDeployedV2.js";
+import { deployProxyByImplementationV2 } from "../../extensions/thirdweb/__generated__/IContractFactory/write/deployProxyByImplementationV2.js";
 import { eth_blockNumber } from "../../rpc/actions/eth_blockNumber.js";
 import { getRpcClient } from "../../rpc/rpc.js";
 import { encode } from "../../transaction/actions/encode.js";
@@ -23,11 +23,14 @@ import { zkDeployProxy } from "./zksync/zkDeployProxy.js";
 export function prepareAutoFactoryDeployTransaction(
   args: ClientAndChain & {
     cloneFactoryContract: ThirdwebContract;
-    initializeTransaction: PreparedTransaction;
+    initializeTransaction?: PreparedTransaction;
+    initializeData?: `0x${string}`;
+    implementationAddress?: string;
+    isCrosschain?: boolean;
     salt?: string;
   },
 ) {
-  return deployProxyByImplementation({
+  return deployProxyByImplementationV2({
     contract: args.cloneFactoryContract,
     async asyncParams() {
       const rpcRequest = getRpcClient({
@@ -35,10 +38,32 @@ export function prepareAutoFactoryDeployTransaction(
       });
       const blockNumber = await eth_blockNumber(rpcRequest);
       const salt = args.salt
-        ? keccakId(args.salt)
-        : toHex(blockNumber, {
-            size: 32,
-          });
+        ? args.salt.startsWith("0x") && args.salt.length === 66
+          ? (args.salt as `0x${string}`)
+          : keccakId(args.salt)
+        : (`0x03${toHex(blockNumber, {
+            size: 31,
+          }).replace(/^0x/, "")}` as `0x${string}`);
+
+      if (args.isCrosschain) {
+        if (!args.initializeData || !args.implementationAddress) {
+          throw new Error(
+            "initializeData or implementationAddress can't be undefined",
+          );
+        }
+
+        return {
+          data: args.initializeData,
+          implementation: args.implementationAddress,
+          salt,
+          extraData: "0x",
+        } as const;
+      }
+
+      if (!args.initializeTransaction) {
+        throw new Error("initializeTransaction can't be undefined");
+      }
+
       const implementation = await resolvePromisedValue(
         args.initializeTransaction.to,
       );
@@ -49,6 +74,7 @@ export function prepareAutoFactoryDeployTransaction(
         data: await encode(args.initializeTransaction),
         implementation,
         salt,
+        extraData: "0x",
       } as const;
     },
   });
@@ -60,7 +86,10 @@ export function prepareAutoFactoryDeployTransaction(
 export async function deployViaAutoFactory(
   options: ClientAndChainAndAccount & {
     cloneFactoryContract: ThirdwebContract;
-    initializeTransaction: PreparedTransaction;
+    initializeTransaction?: PreparedTransaction;
+    initializeData?: `0x${string}`;
+    implementationAddress?: string;
+    isCrosschain?: boolean;
     salt?: string;
   },
 ): Promise<string> {
@@ -70,10 +99,16 @@ export async function deployViaAutoFactory(
     account,
     cloneFactoryContract,
     initializeTransaction,
+    initializeData,
+    implementationAddress,
+    isCrosschain,
     salt,
   } = options;
 
   if (await isZkSyncChain(chain)) {
+    if (!initializeTransaction) {
+      throw new Error("initializeTransaction can't be undefined");
+    }
     return zkDeployProxy({
       chain,
       client,
@@ -89,14 +124,19 @@ export async function deployViaAutoFactory(
     client,
     cloneFactoryContract,
     initializeTransaction,
+    initializeData,
+    implementationAddress,
+    isCrosschain,
     salt,
   });
   const receipt = await sendAndConfirmTransaction({
     transaction: tx,
     account,
   });
+
+  const proxyEvent = proxyDeployedV2Event();
   const decodedEvent = parseEventLogs({
-    events: [proxyDeployedEvent()],
+    events: [proxyEvent],
     logs: receipt.logs,
   });
   if (decodedEvent.length === 0 || !decodedEvent[0]) {

package/src/exports/contract.ts

@@ -43,3 +43,4 @@ export { prepareAutoFactoryDeployTransaction } from "../contract/deployment/depl
 export { prepareMethod } from "../utils/abi/prepare-method.js";
 
 export { getCompilerMetadata } from "../contract/actions/get-compiler-metadata.js";
+export { getDeployedCloneFactoryContract } from "../contract/deployment/utils/clone-factory.js";

package/src/exports/modules.ts

@@ -178,3 +178,4 @@ export {
   uninstallModuleByProxy,
   type UninstallModuleByProxyOptions,
 } from "../extensions/modules/common/uninstallModuleByProxy.js";
+export { moduleInstalledEvent } from "../extensions/modules/__generated__/IModularCore/events/ModuleInstalled.js";

package/src/extensions/modules/common/installPublishedModule.ts

@@ -14,6 +14,7 @@ export type InstallPublishedModuleOptions = {
   version?: string;
   constructorParams?: Record<string, unknown>;
   moduleData?: `0x${string}`;
+  nonce?: number;
 };
 
 /**
@@ -43,10 +44,14 @@ export function installPublishedModule(options: InstallPublishedModuleOptions) {
     constructorParams,
     publisher,
     moduleData,
+    nonce,
   } = options;
 
   return installModule({
     contract,
+    overrides: {
+      nonce,
+    },
     asyncParams: async () => {
       const deployedModule = await getOrDeployInfraForPublishedContract({
         chain: contract.chain,

package/src/extensions/prebuilts/deploy-published.ts

@@ -125,7 +125,9 @@ export type DeployContractfromDeployMetadataOptions = {
   account: Account;
   deployMetadata: FetchDeployMetadataResult;
   initializeParams?: Record<string, unknown>;
+  initializeData?: `0x${string}`;
   implementationConstructorParams?: Record<string, unknown>;
+  isCrosschain?: boolean;
   modules?: {
     deployMetadata: FetchDeployMetadataResult;
     initializeParams?: Record<string, unknown>;
@@ -144,7 +146,9 @@ export async function deployContractfromDeployMetadata(
     account,
     chain,
     initializeParams,
+    initializeData,
     deployMetadata,
+    isCrosschain,
     implementationConstructorParams,
     modules,
     salt,
@@ -217,16 +221,28 @@ export async function deployContractfromDeployMetadata(
           version: deployMetadata.version,
         });
 
+      if (isCrosschain) {
+        return deployViaAutoFactory({
+          client,
+          chain,
+          account,
+          cloneFactoryContract,
+          implementationAddress: implementationContract.address,
+          initializeData,
+          salt,
+          isCrosschain,
+        });
+      }
+
       const initializeTransaction = await getInitializeTransaction({
         client,
         chain,
-        deployMetadata: deployMetadata,
+        deployMetadata,
         implementationContract,
         initializeParams: processedInitializeParams,
         account,
         modules,
       });
-
       return deployViaAutoFactory({
         client,
         chain,

package/src/extensions/thirdweb/__generated__/IContractFactory/events/ProxyDeployedV2.ts

@@ -0,0 +1,55 @@
+import { prepareEvent } from "../../../../../event/prepare-event.js";
+import type { AbiParameterToPrimitiveType } from "abitype";
+
+/**
+ * Represents the filters for the "ProxyDeployedV2" event.
+ */
+export type ProxyDeployedV2EventFilters = Partial<{
+  implementation: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "implementation";
+    indexed: true;
+  }>;
+  proxy: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "proxy";
+    indexed: true;
+  }>;
+  deployer: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "deployer";
+    indexed: true;
+  }>;
+}>;
+
+/**
+ * Creates an event object for the ProxyDeployedV2 event.
+ * @param filters - Optional filters to apply to the event.
+ * @returns The prepared event object.
+ * @extension THIRDWEB
+ * @example
+ * ```ts
+ * import { getContractEvents } from "thirdweb";
+ * import { proxyDeployedV2Event } from "thirdweb/extensions/thirdweb";
+ *
+ * const events = await getContractEvents({
+ * contract,
+ * events: [
+ *  proxyDeployedV2Event({
+ *  implementation: ...,
+ *  proxy: ...,
+ *  deployer: ...,
+ * })
+ * ],
+ * });
+ * ```
+ */
+export function proxyDeployedV2Event(
+  filters: ProxyDeployedV2EventFilters = {},
+) {
+  return prepareEvent({
+    signature:
+      "event ProxyDeployedV2(address indexed implementation, address indexed proxy, address indexed deployer, bytes32 inputSalt, bytes data, bytes extraData)",
+    filters,
+  });
+}

package/src/extensions/thirdweb/__generated__/IContractFactory/write/deployProxyByImplementationV2.ts

@@ -0,0 +1,184 @@
+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 { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+/**
+ * Represents the parameters for the "deployProxyByImplementationV2" function.
+ */
+export type DeployProxyByImplementationV2Params = WithOverrides<{
+  implementation: AbiParameterToPrimitiveType<{
+    type: "address";
+    name: "implementation";
+  }>;
+  data: AbiParameterToPrimitiveType<{ type: "bytes"; name: "data" }>;
+  salt: AbiParameterToPrimitiveType<{ type: "bytes32"; name: "salt" }>;
+  extraData: AbiParameterToPrimitiveType<{ type: "bytes"; name: "extraData" }>;
+}>;
+
+export const FN_SELECTOR = "0xd057c8b1" as const;
+const FN_INPUTS = [
+  {
+    type: "address",
+    name: "implementation",
+  },
+  {
+    type: "bytes",
+    name: "data",
+  },
+  {
+    type: "bytes32",
+    name: "salt",
+  },
+  {
+    type: "bytes",
+    name: "extraData",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    type: "address",
+  },
+] as const;
+
+/**
+ * Checks if the `deployProxyByImplementationV2` method is supported by the given contract.
+ * @param availableSelectors An array of 4byte function selectors of the contract. You can get this in various ways, such as using "whatsabi" or if you have the ABI of the contract available you can use it to generate the selectors.
+ * @returns A boolean indicating if the `deployProxyByImplementationV2` method is supported.
+ * @extension THIRDWEB
+ * @example
+ * ```ts
+ * import { isDeployProxyByImplementationV2Supported } from "thirdweb/extensions/thirdweb";
+ *
+ * const supported = isDeployProxyByImplementationV2Supported(["0x..."]);
+ * ```
+ */
+export function isDeployProxyByImplementationV2Supported(
+  availableSelectors: string[],
+) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "deployProxyByImplementationV2" function.
+ * @param options - The options for the deployProxyByImplementationV2 function.
+ * @returns The encoded ABI parameters.
+ * @extension THIRDWEB
+ * @example
+ * ```ts
+ * import { encodeDeployProxyByImplementationV2Params } from "thirdweb/extensions/thirdweb";
+ * const result = encodeDeployProxyByImplementationV2Params({
+ *  implementation: ...,
+ *  data: ...,
+ *  salt: ...,
+ *  extraData: ...,
+ * });
+ * ```
+ */
+export function encodeDeployProxyByImplementationV2Params(
+  options: DeployProxyByImplementationV2Params,
+) {
+  return encodeAbiParameters(FN_INPUTS, [
+    options.implementation,
+    options.data,
+    options.salt,
+    options.extraData,
+  ]);
+}
+
+/**
+ * Encodes the "deployProxyByImplementationV2" function into a Hex string with its parameters.
+ * @param options - The options for the deployProxyByImplementationV2 function.
+ * @returns The encoded hexadecimal string.
+ * @extension THIRDWEB
+ * @example
+ * ```ts
+ * import { encodeDeployProxyByImplementationV2 } from "thirdweb/extensions/thirdweb";
+ * const result = encodeDeployProxyByImplementationV2({
+ *  implementation: ...,
+ *  data: ...,
+ *  salt: ...,
+ *  extraData: ...,
+ * });
+ * ```
+ */
+export function encodeDeployProxyByImplementationV2(
+  options: DeployProxyByImplementationV2Params,
+) {
+  // 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 +
+    encodeDeployProxyByImplementationV2Params(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Prepares a transaction to call the "deployProxyByImplementationV2" function on the contract.
+ * @param options - The options for the "deployProxyByImplementationV2" function.
+ * @returns A prepared transaction object.
+ * @extension THIRDWEB
+ * @example
+ * ```ts
+ * import { sendTransaction } from "thirdweb";
+ * import { deployProxyByImplementationV2 } from "thirdweb/extensions/thirdweb";
+ *
+ * const transaction = deployProxyByImplementationV2({
+ *  contract,
+ *  implementation: ...,
+ *  data: ...,
+ *  salt: ...,
+ *  extraData: ...,
+ *  overrides: {
+ *    ...
+ *  }
+ * });
+ *
+ * // Send the transaction
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function deployProxyByImplementationV2(
+  options: BaseTransactionOptions<
+    | DeployProxyByImplementationV2Params
+    | {
+        asyncParams: () => Promise<DeployProxyByImplementationV2Params>;
+      }
+  >,
+) {
+  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.implementation,
+        resolvedOptions.data,
+        resolvedOptions.salt,
+        resolvedOptions.extraData,
+      ] 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,
+    erc20Value: async () => (await asyncOptions()).overrides?.erc20Value,
+  });
+}