thirdweb 5.92.0 → 5.92.2-nightly-1e8d1e4b5225e7bb378f10e64efb6443b3351444-20250312000323

package/src/extensions/prebuilts/compute-ref-deployments.ts

@@ -0,0 +1,161 @@
+import type { Chain } from "../../chains/types.js";
+import type { ThirdwebClient } from "../../client/client.js";
+import { encodeAbiParameters } from "../../utils/abi/encodeAbiParameters.js";
+import { computePublishedContractAddress } from "../../utils/any-evm/compute-published-contract-address.js";
+import type { ImplementationConstructorParam } from "./process-ref-deployments.js";
+
+type ComputeRefDeploymentsOptions = {
+  client: ThirdwebClient;
+  chain: Chain;
+  paramValue: string | ImplementationConstructorParam;
+};
+
+/**
+ * Computes addresses for published contract references in constructor params.
+ * @returns Param value after processing references.
+ * @internal
+ */
+export async function computeRefDeployments(
+  options: ComputeRefDeploymentsOptions,
+): Promise<string | string[]> {
+  const { client, chain, paramValue } = options;
+
+  if (typeof paramValue === "object") {
+    if (
+      "defaultValue" in paramValue &&
+      paramValue.defaultValue &&
+      paramValue.defaultValue.length > 0
+    ) {
+      return paramValue.defaultValue;
+    }
+
+    if ("dynamicValue" in paramValue && paramValue.dynamicValue) {
+      const dynamicValue = paramValue.dynamicValue;
+      const contracts = dynamicValue.refContracts;
+
+      if (dynamicValue.type === "address") {
+        if (!contracts || contracts.length === 0 || !contracts[0]?.contractId) {
+          throw new Error("Invalid or empty param value");
+        }
+        const salt =
+          contracts[0]?.salt && contracts[0]?.salt.length > 0
+            ? contracts[0]?.salt
+            : "";
+
+        const addr = await computePublishedContractAddress({
+          client,
+          chain,
+          contractId: contracts[0]?.contractId,
+          publisher: contracts[0]?.publisherAddress,
+          version: contracts[0]?.version,
+          salt,
+        });
+
+        return addr;
+      }
+
+      if (dynamicValue.type === "address[]") {
+        if (!contracts || contracts.length === 0) {
+          throw new Error("Invalid or empty param value");
+        }
+        const addressArray: string[] = [];
+
+        for (const c of contracts) {
+          const salt = c?.salt && c?.salt.length > 0 ? c?.salt : "";
+
+          addressArray.push(
+            await computePublishedContractAddress({
+              client,
+              chain,
+              contractId: c.contractId,
+              publisher: c.publisherAddress,
+              version: c.version,
+              salt,
+            }),
+          );
+        }
+
+        return addressArray;
+      }
+
+      if (dynamicValue.type === "bytes") {
+        if (!dynamicValue.paramsToEncode) {
+          throw new Error("Invalid or empty param value");
+        }
+        const paramsToEncode = dynamicValue.paramsToEncode[0];
+
+        if (paramsToEncode) {
+          const types: string[] = [];
+          const values: (string | string[])[] = [];
+          for (const v of paramsToEncode) {
+            types.push(v.type);
+
+            if (v.defaultValue) {
+              values.push(v.defaultValue);
+            } else if (v.dynamicValue) {
+              values.push(
+                await computeRefDeployments({
+                  client,
+                  chain,
+                  paramValue: v,
+                }),
+              );
+            }
+          }
+
+          return encodeAbiParameters(
+            types.map((t) => {
+              return { type: t };
+            }),
+            values,
+          );
+        }
+      }
+
+      if (dynamicValue.type === "bytes[]") {
+        if (!dynamicValue.paramsToEncode) {
+          throw new Error("Invalid or empty param value");
+        }
+        const bytesArray: string[] = [];
+        const paramArray = dynamicValue.paramsToEncode;
+
+        for (const a of paramArray) {
+          const paramsToEncode = a;
+
+          if (paramsToEncode) {
+            const types: string[] = [];
+            const values: (string | string[])[] = [];
+            for (const v of paramsToEncode) {
+              types.push(v.type);
+
+              if (v.defaultValue) {
+                values.push(v.defaultValue);
+              } else if (v.dynamicValue) {
+                values.push(
+                  await computeRefDeployments({
+                    client,
+                    chain,
+                    paramValue: v,
+                  }),
+                );
+              }
+            }
+
+            bytesArray.push(
+              encodeAbiParameters(
+                types.map((t) => {
+                  return { type: t };
+                }),
+                values,
+              ),
+            );
+          }
+        }
+
+        return bytesArray;
+      }
+    }
+  }
+
+  return paramValue as string;
+}

package/src/extensions/prebuilts/process-ref-deployments.test.ts

@@ -3,6 +3,7 @@ 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 { getContract } from "../../contract/contract.js";
+import { getDeployedInfraContract } from "../../contract/deployment/utils/infra.js";
 import { readContract } from "../../transaction/read-contract.js";
 import { getInstalledModules } from "../modules/__generated__/IModularCore/read/getInstalledModules.js";
 import { deployPublishedContract } from "./deploy-published.js";
@@ -29,7 +30,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_A,
         contractId: "MultiSig",
         version: "0.0.4",
-        salt: "tw",
+        salt: "",
         publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
       });
       dummyContractAddress = await deployPublishedContract({
@@ -37,8 +38,8 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         chain: ANVIL_CHAIN,
         account: TEST_ACCOUNT_A,
         contractId: "ContractWithBytes",
-        version: "0.0.1",
-        salt: "tw",
+        version: "0.0.2",
+        salt: "",
         publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
       });
       mintfeeManagerModuleAddress = await deployPublishedContract({
@@ -47,7 +48,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_A,
         contractId: "MintFeeManagerModule",
         version: "0.0.1",
-        salt: "tw",
+        salt: "",
         publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
       });
       mintfeeManagerCoreAddress = await deployPublishedContract({
@@ -55,8 +56,8 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         chain: ANVIL_CHAIN,
         account: TEST_ACCOUNT_A,
         contractId: "MintFeeManagerCore",
-        version: "0.0.25",
-        salt: "tw",
+        version: "0.0.26",
+        salt: "",
         publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
       });
       claimableModuleAddress = await deployPublishedContract({
@@ -64,18 +65,17 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         chain: ANVIL_CHAIN,
         account: TEST_ACCOUNT_A,
         contractId: "ClaimableERC721",
-        version: "0.0.13",
-        salt: "tw",
+        version: "0.0.14",
+        salt: "",
         publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
       });
-
       wethAddress = await deployPublishedContract({
         client: TEST_CLIENT,
         chain: ANVIL_CHAIN,
         account: TEST_ACCOUNT_A,
         contractId: "WETH9",
         version: "0.0.1",
-        salt: "thirdweb",
+        salt: "",
         publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
       });
       forwarderAddress = await deployPublishedContract({
@@ -84,7 +84,7 @@ describe.runIf(process.env.TW_SECRET_KEY)(
         account: TEST_ACCOUNT_A,
         contractId: "Forwarder",
         version: "0.0.1",
-        salt: "thirdweb",
+        salt: "",
         publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
       });
       multiwrapAddress = await deployPublishedContract({
@@ -192,5 +192,67 @@ describe.runIf(process.env.TW_SECRET_KEY)(
       expect(fetchedWethAddress.toLowerCase()).to.eq(wethAddress);
       expect(isTrustedForwarder).to.be.true;
     });
+
+    it("should correctly compute addresses for deployed contracts with refs", async () => {
+      const [
+        multisigAddressComputed,
+        dummyContractAddressComputed,
+        mintfeeManagerModuleAddressComputed,
+        mintfeeManagerCoreAddressComputed,
+        claimableModuleAddressComputed,
+      ] = await Promise.all([
+        getDeployedInfraContract({
+          client: TEST_CLIENT,
+          chain: ANVIL_CHAIN,
+          contractId: "MultiSig",
+          version: "0.0.4",
+          publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+        }),
+        getDeployedInfraContract({
+          client: TEST_CLIENT,
+          chain: ANVIL_CHAIN,
+          contractId: "ContractWithBytes",
+          version: "0.0.2",
+          publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+        }),
+        getDeployedInfraContract({
+          client: TEST_CLIENT,
+          chain: ANVIL_CHAIN,
+          contractId: "MintFeeManagerModule",
+          version: "0.0.1",
+          publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+        }),
+        getDeployedInfraContract({
+          client: TEST_CLIENT,
+          chain: ANVIL_CHAIN,
+          contractId: "MintFeeManagerCore",
+          version: "0.0.26",
+          publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+        }),
+        getDeployedInfraContract({
+          client: TEST_CLIENT,
+          chain: ANVIL_CHAIN,
+          contractId: "ClaimableERC721",
+          version: "0.0.14",
+          publisher: "0x6453a486d52e0EB6E79Ec4491038E2522a926936",
+        }),
+      ]);
+
+      expect(multisigAddressComputed?.address.toLowerCase()).to.eq(
+        multisigAddress,
+      );
+      expect(dummyContractAddressComputed?.address.toLowerCase()).to.eq(
+        dummyContractAddress,
+      );
+      expect(mintfeeManagerModuleAddressComputed?.address.toLowerCase()).to.eq(
+        mintfeeManagerModuleAddress,
+      );
+      expect(mintfeeManagerCoreAddressComputed?.address.toLowerCase()).to.eq(
+        mintfeeManagerCoreAddress,
+      );
+      expect(claimableModuleAddressComputed?.address.toLowerCase()).to.eq(
+        claimableModuleAddress,
+      );
+    });
   },
 );

package/src/extensions/prebuilts/process-ref-deployments.ts

@@ -17,6 +17,11 @@ type ProcessRefDeploymentsOptions = {
   paramValue: string | ImplementationConstructorParam;
 };
 
+/**
+ * Processes published contract references in constructor params. Deploys recursively if needed.
+ * @returns Param value after processing references.
+ * @internal
+ */
 export async function processRefDeployments(
   options: ProcessRefDeploymentsOptions,
 ): Promise<string | string[]> {
@@ -42,7 +47,7 @@ export async function processRefDeployments(
         const salt =
           contracts[0]?.salt && contracts[0]?.salt.length > 0
             ? contracts[0]?.salt
-            : "thirdweb";
+            : "";
 
         const addr = await deployPublishedContract({
           client,
@@ -64,7 +69,7 @@ export async function processRefDeployments(
         const addressArray = [];
 
         for (const c of contracts) {
-          const salt = c?.salt && c?.salt.length > 0 ? c?.salt : "thirdweb";
+          const salt = c?.salt && c?.salt.length > 0 ? c?.salt : "";
 
           addressArray.push(
             await deployPublishedContract({

package/src/react/core/utils/wallet.ts

@@ -157,7 +157,7 @@ export function useConnectedWalletDetails(
  * import { useWalletInfo } from "thirdweb/react";
  *
  * const { data: walletInfo } = useWalletInfo("io.metamask");
- * console.log("Walelt name", walletInfo?.name);
+ * console.log("wallet name", walletInfo?.name);
  * ```
  * @wallet
  */

package/src/utils/any-evm/compute-published-contract-deploy-info.ts

@@ -3,6 +3,8 @@ import type { Chain } from "../../chains/types.js";
 import type { ThirdwebClient } from "../../client/client.js";
 import { fetchPublishedContractMetadata } from "../../contract/deployment/publisher.js";
 import { computeCreate2FactoryAddress } from "../../contract/deployment/utils/create-2-factory.js";
+import { computeRefDeployments } from "../../extensions/prebuilts/compute-ref-deployments.js";
+import type { ImplementationConstructorParam } from "../../extensions/prebuilts/process-ref-deployments.js";
 import { encodeAbiParameters } from "../abi/encodeAbiParameters.js";
 import { normalizeFunctionParams } from "../abi/normalizeFunctionParams.js";
 import { ensureBytecodePrefix } from "../bytecode/prefix.js";
@@ -51,6 +53,23 @@ export async function computeDeploymentInfoFromMetadata(args: {
   constructorParams?: Record<string, unknown>;
   salt?: string;
 }) {
+  const { client, chain, constructorParams, contractMetadata } = args;
+  const definedConstructorParams =
+    constructorParams || contractMetadata.constructorParams;
+  let processedConstructorParams: Record<string, string | string[]> | undefined;
+  if (definedConstructorParams) {
+    processedConstructorParams = {};
+    for (const key in definedConstructorParams) {
+      processedConstructorParams[key] = await computeRefDeployments({
+        client,
+        chain,
+        paramValue: definedConstructorParams[key] as
+          | string
+          | ImplementationConstructorParam,
+      });
+    }
+  }
+
   return computeDeploymentInfoFromBytecode({
     client: args.client,
     chain: args.chain,
@@ -60,7 +79,7 @@ export async function computeDeploymentInfoFromMetadata(args: {
       client: args.client,
       chain: args.chain,
     }),
-    constructorParams: args.constructorParams,
+    constructorParams: processedConstructorParams,
     salt: args.salt,
   });
 }

package/src/version.ts

@@ -1 +1 @@
-export const version = "5.92.0";
+export const version = "5.92.2-nightly-1e8d1e4b5225e7bb378f10e64efb6443b3351444-20250312000323";

package/src/wallets/in-app/core/wallet/enclave-wallet.ts

@@ -5,7 +5,7 @@ import type { ThirdwebClient } from "../../../../client/client.js";
 import { eth_sendRawTransaction } from "../../../../rpc/actions/eth_sendRawTransaction.js";
 import { getRpcClient } from "../../../../rpc/rpc.js";
 import { getAddress } from "../../../../utils/address.js";
-import { type Hex, toHex } from "../../../../utils/encoding/hex.js";
+import { type Hex, isHex, toHex } from "../../../../utils/encoding/hex.js";
 import { parseTypedData } from "../../../../utils/signatures/helpers/parse-typed-data.js";
 import type { Prettify } from "../../../../utils/type-utils.js";
 import type {
@@ -141,39 +141,32 @@ export class EnclaveWallet implements IWebWallet {
       const transaction: Record<string, Hex | number | undefined> = {
         to: tx.to ? getAddress(tx.to) : undefined,
         data: tx.data,
-        value: typeof tx.value === "bigint" ? toHex(tx.value) : undefined,
-        gas:
-          typeof tx.gas === "bigint"
-            ? toHex(tx.gas + tx.gas / BigInt(10))
-            : undefined, // Add a 10% buffer to gas
+        value: hexlify(tx.value),
+        gas: hexlify(tx.gas),
         nonce:
-          typeof tx.nonce === "number"
-            ? toHex(tx.nonce)
-            : toHex(
-                await import(
-                  "../../../../rpc/actions/eth_getTransactionCount.js"
-                ).then(({ eth_getTransactionCount }) =>
-                  eth_getTransactionCount(rpcRequest, {
-                    address: getAddress(this.address),
-                    blockTag: "pending",
-                  }),
-                ),
-              ),
+          hexlify(tx.nonce) ||
+          toHex(
+            await import(
+              "../../../../rpc/actions/eth_getTransactionCount.js"
+            ).then(({ eth_getTransactionCount }) =>
+              eth_getTransactionCount(rpcRequest, {
+                address: getAddress(this.address),
+                blockTag: "pending",
+              }),
+            ),
+          ),
         chainId: toHex(tx.chainId),
       };
 
-      if (typeof tx.maxFeePerGas === "bigint") {
-        transaction.maxFeePerGas = toHex(tx.maxFeePerGas);
-        transaction.maxPriorityFeePerGas =
-          typeof tx.maxPriorityFeePerGas === "bigint"
-            ? toHex(tx.maxPriorityFeePerGas)
-            : undefined;
+      if (hexlify(tx.maxFeePerGas)) {
+        transaction.maxFeePerGas = hexlify(tx.maxFeePerGas);
+        transaction.maxPriorityFeePerGas = hexlify(tx.maxPriorityFeePerGas);
         transaction.type = 2;
       } else {
-        transaction.gasPrice =
-          typeof tx.gasPrice === "bigint" ? toHex(tx.gasPrice) : undefined;
+        transaction.gasPrice = hexlify(tx.gasPrice);
         transaction.type = 0;
       }
+
       return signEnclaveTransaction({
         client,
         storage,
@@ -253,3 +246,7 @@ export class EnclaveWallet implements IWebWallet {
     };
   }
 }
+
+function hexlify(value: string | number | bigint | undefined) {
+  return value === undefined || isHex(value) ? value : toHex(value);
+}

package/src/wallets/smart/smart-wallet-integration-v07.test.ts

@@ -305,6 +305,7 @@ describe.runIf(process.env.TW_SECRET_KEY).sequential(
       const newSmartWallet = smartWallet({
         chain,
         gasless: true,
+        factoryAddress: DEFAULT_ACCOUNT_FACTORY_V0_7,
         overrides: {
           accountSalt: "test",
         },