thirdweb 5.53.1-nightly-865c5e3b16af70c3660f30ba8cffc5d6e360a389-20240911000352 → 5.54.0-nightly-c3800d6c0765a9a0b69ac0a4a390d20cec932419-20240912000413

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

@@ -1,16 +1,22 @@
-import type { AbiConstructor, AbiFunction } from "abitype";
+import type { AbiFunction } from "abitype";
 import type { Chain } from "../../chains/types.js";
 import type { ThirdwebClient } from "../../client/client.js";
-import { getContract } from "../../contract/contract.js";
+import { type ThirdwebContract, getContract } from "../../contract/contract.js";
 import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
+import { getOrDeployInfraContractFromMetadata } from "../../contract/deployment/utils/bootstrap.js";
+import {} from "../../contract/deployment/utils/infra.js";
 import { zkDeployContract } from "../../contract/deployment/zksync/zkDeployContract.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { simulateTransaction } from "../../transaction/actions/simulate.js";
 import { prepareContractCall } from "../../transaction/prepare-contract-call.js";
 import { resolveMethod } from "../../transaction/resolve-method.js";
+import { encodeAbiParameters } from "../../utils/abi/encodeAbiParameters.js";
+import { normalizeFunctionParams } from "../../utils/abi/normalizeFunctionParams.js";
+import { getAddress } from "../../utils/address.js";
 import type { CompilerMetadata } from "../../utils/any-evm/deploy-metadata.js";
 import type { FetchDeployMetadataResult } from "../../utils/any-evm/deploy-metadata.js";
 import { isZkSyncChain } from "../../utils/any-evm/zksync/isZkSyncChain.js";
+import type { Hex } from "../../utils/encoding/hex.js";
 import type { Account } from "../../wallets/interfaces/wallet.js";
 
 /**
@@ -21,10 +27,11 @@ export type DeployPublishedContractOptions = {
   chain: Chain;
   account: Account;
   contractId: string;
-  contractParams: unknown[];
+  contractParams?: Record<string, unknown>;
   publisher?: string;
   version?: string;
-  implementationConstructorParams?: unknown[];
+  implementationConstructorParams?: Record<string, unknown>;
+  salt?: string;
 };
 
 /**
@@ -32,6 +39,27 @@ export type DeployPublishedContractOptions = {
  * @param options - the deploy options
  * @returns a promise that resolves to the deployed contract address
  * @example
+ *
+ * ## Deploying a published contract
+ *
+ * ```ts
+ * import { deployPublishedContract } from "thirdweb/deploys";
+ *
+ * const address = await deployedPublishedContract({
+ *   client,
+ *   chain,
+ *   account,
+ *   contractId: "MyPublishedContract",
+ *   contractParams: {
+ *     param1: "value1",
+ *     param2: 123,
+ *   },
+ *   publisher: "0x...", // optional, defaults to the thirdweb deployer
+ * });
+ * ```
+ *
+ *  ## Deploying a published contract deterministically
+ *
  * ```ts
  * import { deployPublishedContract } from "thirdweb/deploys";
  *
@@ -40,8 +68,12 @@ export type DeployPublishedContractOptions = {
  *   chain,
  *   account,
  *   contractId: "MyPublishedContract",
- *   contractParams: [...],
+ *   contractParams: {
+ *     param1: "value1",
+ *     param2: 123,
+ *   },
  *   publisher: "0x...",
+ *   salt: "your-salt", // this will deterministically deploy the contract at the same address on all chains
  * });
  * ```
  * @extension DEPLOY
@@ -58,6 +90,7 @@ export async function deployPublishedContract(
     publisher,
     version,
     implementationConstructorParams,
+    salt,
   } = options;
   const deployMetadata = await fetchPublishedContractMetadata({
     client,
@@ -71,8 +104,9 @@ export async function deployPublishedContract(
     chain,
     deployMetadata,
     client,
-    contractParams,
+    initializeParams: contractParams,
     implementationConstructorParams,
+    salt,
   });
 }
 
@@ -84,8 +118,13 @@ export type DeployContractfromDeployMetadataOptions = {
   chain: Chain;
   account: Account;
   deployMetadata: FetchDeployMetadataResult;
-  contractParams: unknown[];
-  implementationConstructorParams?: unknown[];
+  initializeParams?: Record<string, unknown>;
+  implementationConstructorParams?: Record<string, unknown>;
+  modules?: {
+    deployMetadata: FetchDeployMetadataResult;
+    initializeParams?: Record<string, unknown>;
+  }[];
+  salt?: string;
 };
 
 /**
@@ -93,14 +132,16 @@ export type DeployContractfromDeployMetadataOptions = {
  */
 export async function deployContractfromDeployMetadata(
   options: DeployContractfromDeployMetadataOptions,
-) {
+): Promise<string> {
   const {
     client,
     account,
     chain,
-    contractParams,
+    initializeParams,
     deployMetadata,
     implementationConstructorParams,
+    modules,
+    salt,
   } = options;
   switch (deployMetadata?.deployType) {
     case "standard": {
@@ -109,7 +150,8 @@ export async function deployContractfromDeployMetadata(
         client,
         chain,
         compilerMetadata: deployMetadata,
-        contractParams,
+        contractParams: initializeParams,
+        salt,
       });
     }
     case "autoFactory": {
@@ -126,32 +168,18 @@ export async function deployContractfromDeployMetadata(
           client,
           account,
           contractId: deployMetadata.name,
-          constructorParams: implementationConstructorParams || [],
+          constructorParams: implementationConstructorParams,
           publisher: deployMetadata.publisher,
         });
-      const initializeFunction = deployMetadata.abi.find(
-        (i) =>
-          i.type === "function" &&
-          i.name ===
-            (deployMetadata.factoryDeploymentData
-              ?.implementationInitializerFunction || "initialize"),
-      ) as AbiFunction;
-      if (!initializeFunction) {
-        throw new Error(
-          `Could not find initialize function for ${deployMetadata.name}`,
-        );
-      }
-      const initializeTransaction = prepareContractCall({
-        contract: getContract({
-          client,
-          chain,
-          address: implementationContract.address,
-        }),
-        method: resolveMethod(
-          deployMetadata.factoryDeploymentData
-            ?.implementationInitializerFunction || "initialize",
-        ),
-        params: contractParams,
+
+      const initializeTransaction = await getInitializeTransaction({
+        client,
+        chain,
+        deployMetadata: deployMetadata,
+        implementationContract,
+        initializeParams,
+        account,
+        modules,
       });
 
       return deployViaAutoFactory({
@@ -160,6 +188,7 @@ export async function deployContractfromDeployMetadata(
         account,
         cloneFactoryContract,
         initializeTransaction,
+        salt,
       });
     }
     case "customFactory": {
@@ -181,20 +210,21 @@ export async function deployContractfromDeployMetadata(
         chain,
         address: factoryAddress,
       });
+      const method = await resolveMethod(factoryFunction)(factory);
       const deployTx = prepareContractCall({
         contract: factory,
-        method: resolveMethod(factoryFunction),
-        params: contractParams,
+        method,
+        params: normalizeFunctionParams(method, initializeParams),
       });
       // asumption here is that the factory address returns the deployed proxy address
-      const address = simulateTransaction({
+      const address = await simulateTransaction({
         transaction: deployTx,
       });
       await sendAndConfirmTransaction({
         transaction: deployTx,
         account,
       });
-      return address;
+      return address as string;
     }
     case undefined: {
       // Default to standard deployment if none was specified
@@ -203,7 +233,8 @@ export async function deployContractfromDeployMetadata(
         client,
         chain,
         compilerMetadata: deployMetadata,
-        contractParams,
+        contractParams: initializeParams,
+        salt,
       });
     }
     default:
@@ -217,9 +248,11 @@ async function directDeploy(options: {
   client: ThirdwebClient;
   chain: Chain;
   compilerMetadata: CompilerMetadata;
-  contractParams: unknown[];
-}) {
-  const { account, client, chain, compilerMetadata, contractParams } = options;
+  contractParams?: Record<string, unknown>;
+  salt?: string;
+}): Promise<string> {
+  const { account, client, chain, compilerMetadata, contractParams, salt } =
+    options;
 
   if (isZkSyncChain(chain)) {
     return zkDeployContract({
@@ -229,6 +262,7 @@ async function directDeploy(options: {
       bytecode: compilerMetadata.bytecode,
       abi: compilerMetadata.abi,
       params: contractParams,
+      salt,
     });
   }
 
@@ -240,10 +274,90 @@ async function directDeploy(options: {
     client,
     chain,
     bytecode: compilerMetadata.bytecode,
-    constructorAbi:
-      (compilerMetadata.abi.find(
-        (i) => i.type === "constructor",
-      ) as AbiConstructor) || [],
+    abi: compilerMetadata.abi,
     constructorParams: contractParams,
+    salt,
+  });
+}
+
+async function getInitializeTransaction(options: {
+  client: ThirdwebClient;
+  chain: Chain;
+  account: Account;
+  implementationContract: ThirdwebContract;
+  deployMetadata: FetchDeployMetadataResult;
+  initializeParams?: Record<string, unknown>;
+  modules?: {
+    deployMetadata: FetchDeployMetadataResult;
+    initializeParams?: Record<string, unknown>;
+  }[];
+}) {
+  const {
+    account,
+    client,
+    chain,
+    deployMetadata: metadata,
+    initializeParams = {},
+    implementationContract,
+    modules = [],
+  } = options;
+
+  const initializeFunction = metadata.abi.find(
+    (i) =>
+      i.type === "function" &&
+      i.name ===
+        (metadata.factoryDeploymentData?.implementationInitializerFunction ||
+          "initialize"),
+  ) as AbiFunction;
+  if (!initializeFunction) {
+    throw new Error(`Could not find initialize function for ${metadata.name}`);
+  }
+
+  const hasModules =
+    initializeFunction.inputs.find(
+      (i) => i.name === "modules" || i.name === "_modules",
+    ) &&
+    initializeFunction.inputs.find(
+      (i) => i.name === "moduleInstallData" || i.name === "_moduleInstallData",
+    );
+  if (hasModules) {
+    const moduleAddresses: Hex[] = [];
+    const moduleInstallData: Hex[] = [];
+    for (const module of modules) {
+      // deploy the module if not already deployed
+      const contract = await getOrDeployInfraContractFromMetadata({
+        client,
+        chain,
+        account,
+        contractMetadata: module.deployMetadata,
+      });
+
+      const installFunction = module.deployMetadata.abi.find(
+        (i) => i.type === "function" && i.name === "encodeBytesOnInstall",
+      ) as AbiFunction | undefined;
+
+      moduleAddresses.push(getAddress(contract.address));
+      moduleInstallData.push(
+        installFunction
+          ? encodeAbiParameters(
+              installFunction.inputs,
+              normalizeFunctionParams(installFunction, module.initializeParams),
+            )
+          : "0x",
+      );
+    }
+    initializeParams.modules = moduleAddresses;
+    initializeParams.moduleInstallData = moduleInstallData;
+  }
+
+  const initializeTransaction = prepareContractCall({
+    contract: getContract({
+      client,
+      chain,
+      address: implementationContract.address,
+    }),
+    method: initializeFunction,
+    params: normalizeFunctionParams(initializeFunction, initializeParams),
   });
+  return initializeTransaction;
 }

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

@@ -83,7 +83,6 @@ export async function deploySplitContract(options: DeploySplitContractOptions) {
       client,
       account,
       contractId: "Split",
-      constructorParams: [],
     });
   const initializeTransaction = await getInitializeTransaction({
     client,

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

@@ -97,7 +97,6 @@ export async function deployVoteContract(options: DeployVoteContractOptions) {
       client,
       account,
       contractId: "VoteERC20",
-      constructorParams: [],
     });
   const initializeTransaction = await getInitializeTransaction({
     client,

package/src/extensions/prebuilts/get-required-transactions.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { CLEAN_ANVIL_CHAIN } from "../../../test/src/chains.js";
+import { TEST_CLIENT } from "../../../test/src/test-clients.js";
+import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
+import { getRequiredTransactionCount } from "./get-required-transactions.js";
+
+describe.runIf(process.env.TW_SECRET_KEY)(
+  "getRequiredTransactions",
+  {
+    timeout: 120000,
+  },
+  () => {
+    it("should count transactions for a published direct deploy contract", async () => {
+      const metadata = await fetchPublishedContractMetadata({
+        client: TEST_CLIENT,
+        contractId: "AccountFactory",
+      });
+      const results = await getRequiredTransactionCount({
+        client: TEST_CLIENT,
+        chain: CLEAN_ANVIL_CHAIN,
+        metadata,
+      });
+      expect(results.length).toBe(1);
+    });
+
+    it("should count transactions for a published autofactory contract", async () => {
+      const metadata = await fetchPublishedContractMetadata({
+        client: TEST_CLIENT,
+        contractId: "Airdrop",
+      });
+      const results = await getRequiredTransactionCount({
+        client: TEST_CLIENT,
+        chain: CLEAN_ANVIL_CHAIN,
+        metadata,
+      });
+      expect(results.length).toBe(4);
+    });
+
+    it("should count transactions for a modular contract with modules", async () => {
+      const metadata = await fetchPublishedContractMetadata({
+        client: TEST_CLIENT,
+        contractId: "ERC721CoreInitializable",
+      });
+      const results = await getRequiredTransactionCount({
+        client: TEST_CLIENT,
+        chain: CLEAN_ANVIL_CHAIN,
+        metadata,
+        modules: await Promise.all(
+          ["ClaimableERC721", "BatchMetadataERC721", "RoyaltyERC721"].map(
+            (contractId) =>
+              fetchPublishedContractMetadata({
+                client: TEST_CLIENT,
+                contractId,
+              }),
+          ),
+        ),
+      });
+      expect(results.length).toBe(7);
+    });
+  },
+);

package/src/extensions/prebuilts/get-required-transactions.ts

@@ -0,0 +1,110 @@
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import { getDeployedCreate2Factory } from "../../contract/deployment/utils/create-2-factory.js";
+import { getDeployedInfraContract } from "../../contract/deployment/utils/infra.js";
+import { getDeployedInfraContractFromMetadata } from "../../contract/deployment/utils/infra.js";
+import { computePublishedContractAddress } from "../../utils/any-evm/compute-published-contract-address.js";
+import type { FetchDeployMetadataResult } from "../../utils/any-evm/deploy-metadata.js";
+
+/**
+ * @internal
+ */
+export type DeployTransactionType =
+  | "infra"
+  | "implementation"
+  | "module"
+  | "proxy";
+
+/**
+ * @internal
+ */
+export type DeployTransactionResult = {
+  type: DeployTransactionType;
+  contractId: string;
+};
+
+/**
+ * @internal
+ */
+export async function getRequiredTransactionCount(options: {
+  chain: Chain;
+  client: ThirdwebClient;
+  metadata: FetchDeployMetadataResult;
+  constructorParams?: Record<string, unknown>;
+  implementationConstructorParams?: Record<string, unknown>;
+  modules?: FetchDeployMetadataResult[];
+}): Promise<DeployTransactionResult[]> {
+  const {
+    chain,
+    client,
+    metadata,
+    implementationConstructorParams,
+    modules = [],
+  } = options;
+
+  if (metadata?.deployType === "autoFactory") {
+    const results: (DeployTransactionResult | null)[] = await Promise.all([
+      getDeployedCreate2Factory({
+        chain,
+        client,
+      }).then((c) =>
+        c ? null : ({ type: "infra", contractId: "Create2Factory" } as const),
+      ),
+      getDeployedInfraContract({
+        chain,
+        client,
+        contractId: "Forwarder",
+      }).then((c) =>
+        c ? null : ({ type: "infra", contractId: "Forwarder" } as const),
+      ),
+      getDeployedInfraContract({
+        chain,
+        client,
+        contractId: "TWCloneFactory",
+        constructorParams: {
+          _trustedForwarder: await computePublishedContractAddress({
+            chain,
+            client,
+            contractId: "Forwarder",
+          }),
+        },
+      }).then((c) =>
+        c ? null : ({ type: "infra", contractId: "TWCloneFactory" } as const),
+      ),
+      // TODO (deploy): add WETH contract check for implementations that need it (check implementation constructor params)
+      getDeployedInfraContract({
+        chain,
+        client,
+        contractId: metadata.name,
+        constructorParams: implementationConstructorParams,
+        publisher: metadata.publisher,
+        version: metadata.version,
+      }).then((c) =>
+        c
+          ? null
+          : ({
+              type: "implementation",
+              contractId: metadata.name,
+            } as const),
+      ),
+      ...modules.map((m) =>
+        getDeployedInfraContractFromMetadata({
+          chain,
+          client,
+          contractMetadata: m,
+        }).then((c) =>
+          c
+            ? null
+            : ({
+                type: "module",
+                contractId: m.name,
+              } as const),
+        ),
+      ),
+    ]);
+    results.push({ type: "proxy", contractId: metadata.name });
+    return results.filter((r) => r !== null);
+  }
+
+  return [{ type: "implementation", contractId: metadata.name }];
+}

package/src/react/core/social/useSocialProfiles.ts

@@ -17,6 +17,8 @@ import { getSocialProfiles } from "../../../social/profiles.js";
  *   address: "0x...",
  * });
  * ```
+ *
+ * @social
  * @beta
  */
 export function useSocialProfiles(options: {

package/src/react/native/ui/components/Address.tsx

@@ -1,6 +1,5 @@
-import Clipboard from "@react-native-clipboard/clipboard";
 import { useState } from "react";
-import { StyleSheet, TouchableOpacity } from "react-native";
+import { Clipboard, StyleSheet, TouchableOpacity } from "react-native";
 import type { Account } from "../../../../wallets/interfaces/wallet.js";
 import type { Theme } from "../../../core/design-system/index.js";
 import { spacing } from "../../design-system/index.js";
@@ -20,7 +19,6 @@ export const Address = ({ account, theme, addressOrENS }: AddressProps) => {
     <TouchableOpacity
       style={styles.addressContainer}
       onPress={() => {
-        // @ts-ignore - missing native types
         Clipboard.setString(account.address);
         setCopySuccess(true);
         setTimeout(() => {

package/src/react/web/ui/ConnectWallet/Details.tsx

@@ -10,6 +10,7 @@ import {
 } from "@radix-ui/react-icons";
 import { useQuery } from "@tanstack/react-query";
 import { useContext, useEffect, useState } from "react";
+import { trackPayEvent } from "../../../../analytics/track.js";
 import type { Chain } from "../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../client/client.js";
 import { getContract } from "../../../../contract/contract.js";
@@ -568,6 +569,12 @@ function DetailsModal(props: {
                     flex: 1,
                   }}
                   onClick={() => {
+                    trackPayEvent({
+                      event: "details_modal_buy_click",
+                      client: client,
+                      walletAddress: activeAccount?.address,
+                      walletType: activeWallet?.id,
+                    });
                     setScreen("buy");
                   }}
                 >

package/src/react/web/ui/ConnectWallet/screens/Buy/BuyScreen.tsx

@@ -1,5 +1,6 @@
 import { IdCardIcon } from "@radix-ui/react-icons";
 import { useCallback, useMemo, useState } from "react";
+import { trackPayEvent } from "../../../../../../analytics/track.js";
 import type { Chain } from "../../../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../../../client/client.js";
 import { NATIVE_TOKEN_ADDRESS } from "../../../../../../constants/addresses.js";
@@ -528,7 +529,13 @@ function BuyScreenContent(props: BuyScreenContentProps) {
               }}
             >
               {screen.id === "select-payment-method" && (
-                <PaymentMethodSelection setScreen={(id) => setScreen({ id })} />
+                <PaymentMethodSelection
+                  mode={payOptions.mode}
+                  client={client}
+                  walletAddress={payer.account.address}
+                  walletType={payer.wallet.id}
+                  setScreen={(id) => setScreen({ id })}
+                />
               )}
 
               {screen.id === "select-wallet" && (
@@ -891,7 +898,11 @@ function TokenSelectedLayout(props: {
 }
 
 function PaymentMethodSelection(props: {
+  client: ThirdwebClient;
+  walletAddress: string;
+  walletType: string;
   setScreen: (screenId: "select-wallet" | "buy-with-fiat") => void;
+  mode?: "transaction" | "direct_payment" | "fund_wallet";
 }) {
   return (
     <Container animate="fadein">
@@ -900,7 +911,15 @@ function PaymentMethodSelection(props: {
         <Button
           variant="outline"
           bg="tertiaryBg"
-          onClick={() => props.setScreen("buy-with-fiat")}
+          onClick={() => {
+            trackPayEvent({
+              event: `pay_with_credit_card_${props.mode || "unknown"}_mode`,
+              client: props.client,
+              walletAddress: props.walletAddress,
+              walletType: props.walletType,
+            });
+            props.setScreen("buy-with-fiat");
+          }}
           gap="sm"
           style={{
             justifyContent: "flex-start",
@@ -928,7 +947,16 @@ function PaymentMethodSelection(props: {
         <Button
           variant="outline"
           bg="tertiaryBg"
-          onClick={() => props.setScreen("select-wallet")}
+          onClick={() => {
+            trackPayEvent({
+              event: `pay_with_crypto_${props.mode || "unknown"}_mode`,
+              client: props.client,
+              walletAddress: props.walletAddress,
+              walletType: props.walletType,
+            });
+
+            props.setScreen("select-wallet");
+          }}
           style={{
             justifyContent: "flex-start",
           }}

package/src/react/web/ui/ConnectWallet/screens/Buy/DirectPaymentModeScreen.tsx

@@ -1,4 +1,5 @@
 import { useQuery } from "@tanstack/react-query";
+import { trackPayEvent } from "../../../../../../analytics/track.js";
 import type { Chain } from "../../../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../../../client/client.js";
 import { NATIVE_TOKEN_ADDRESS } from "../../../../../../constants/addresses.js";
@@ -242,6 +243,12 @@ export function DirectPaymentModeScreen(props: {
           variant="accent"
           fullWidth
           onClick={() => {
+            trackPayEvent({
+              event: "choose_payment_method_direct_payment_mode",
+              client,
+              walletAddress: payerAccount.address,
+              walletType: activeWallet?.id,
+            });
             onContinue(totalCost, paymentInfo.chain, token);
           }}
         >

package/src/react/web/ui/ConnectWallet/screens/Buy/TransactionModeScreen.tsx

@@ -1,3 +1,4 @@
+import { trackPayEvent } from "../../../../../../analytics/track.js";
 import type { Chain } from "../../../../../../chains/types.js";
 import type { ThirdwebClient } from "../../../../../../client/client.js";
 import { NATIVE_TOKEN_ADDRESS } from "../../../../../../constants/addresses.js";
@@ -225,6 +226,12 @@ export function TransactionModeScreen(props: {
             ) {
               totalCostWei += transactionCostAndData.gasCostWei;
             }
+            trackPayEvent({
+              event: "choose_payment_method_transaction_mode",
+              client,
+              walletAddress: payerAccount.address,
+              walletType: activeWallet?.id,
+            });
             onContinue(
               toTokens(totalCostWei, transactionCostAndData.decimals),
               payUiOptions.transaction.chain,