thirdweb 5.105.6-nightly-f1a965b0465f95864cb46c553a95323555c1b5c6-20250704000423 → 5.105.6-nightly-8def4f33f6502ac896012d46ff40ff5d9ea54f8f-20250705000408

package/dist/types/wallets/getAllWalletsList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getAllWalletsList.d.ts","sourceRoot":"","sources":["../../../src/wallets/getAllWalletsList.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAsB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEtC"}
+{"version":3,"file":"getAllWalletsList.d.ts","sourceRoot":"","sources":["../../../src/wallets/getAllWalletsList.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAsB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEtC"}

package/package.json

@@ -13,7 +13,7 @@
   "dependencies": {
     "@coinbase/wallet-sdk": "4.3.0",
     "@emotion/react": "11.14.0",
-    "@emotion/styled": "11.14.0",
+    "@emotion/styled": "11.14.1",
     "@noble/curves": "1.8.2",
     "@noble/hashes": "1.7.2",
     "@passwordless-id/webauthn": "^2.1.2",
@@ -21,8 +21,8 @@
     "@radix-ui/react-focus-scope": "1.1.7",
     "@radix-ui/react-icons": "1.3.2",
     "@radix-ui/react-tooltip": "1.2.7",
-    "@storybook/react": "9.0.8",
-    "@tanstack/react-query": "5.80.7",
+    "@storybook/react": "9.0.15",
+    "@tanstack/react-query": "5.81.5",
     "@walletconnect/ethereum-provider": "2.20.1",
     "@walletconnect/sign-client": "2.20.1",
     "abitype": "1.0.8",
@@ -37,25 +37,25 @@
     "toml": "3.0.0",
     "uqr": "0.1.2",
     "viem": "2.28.1",
-    "zod": "3.25.67",
-    "@thirdweb-dev/insight": "1.1.0",
-    "@thirdweb-dev/engine": "3.2.0"
+    "zod": "3.25.71",
+    "@thirdweb-dev/engine": "3.2.0",
+    "@thirdweb-dev/insight": "1.1.0"
   },
   "devDependencies": {
     "@aws-sdk/client-kms": "3.592.0",
     "@aws-sdk/client-lambda": "3.592.0",
     "@aws-sdk/credential-providers": "3.592.0",
-    "@biomejs/biome": "2.0.4",
-    "@chromatic-com/storybook": "4.0.0",
+    "@biomejs/biome": "2.0.6",
+    "@chromatic-com/storybook": "4.0.1",
     "@codspeed/vitest-plugin": "4.0.1",
     "@coinbase/wallet-mobile-sdk": "1.1.2",
     "@mobile-wallet-protocol/client": "1.0.0",
     "@react-native-async-storage/async-storage": "2.2.0",
     "@size-limit/preset-big-lib": "11.2.0",
-    "@storybook/addon-docs": "9.0.8",
-    "@storybook/addon-links": "9.0.8",
-    "@storybook/addon-onboarding": "9.0.8",
-    "@storybook/react-vite": "9.0.8",
+    "@storybook/addon-docs": "9.0.15",
+    "@storybook/addon-links": "9.0.15",
+    "@storybook/addon-onboarding": "9.0.15",
+    "@storybook/react-vite": "9.0.15",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
@@ -63,9 +63,9 @@
     "@types/prompts": "2.4.9",
     "@types/react": "19.1.8",
     "@viem/anvil": "0.0.10",
-    "@vitejs/plugin-react": "^4.5.2",
-    "@vitest/coverage-v8": "3.2.3",
-    "@vitest/ui": "3.2.3",
+    "@vitejs/plugin-react": "^4.6.0",
+    "@vitest/coverage-v8": "3.2.4",
+    "@vitest/ui": "3.2.4",
     "dotenv-mono": "^1.3.14",
     "ethers5": "npm:ethers@5",
     "ethers6": "npm:ethers@6",
@@ -74,7 +74,7 @@
     "happy-dom": "17.4.4",
     "knip": "5.60.2",
     "msw": "2.7.5",
-    "prettier": "3.5.3",
+    "prettier": "3.6.2",
     "react": "19.1.0",
     "react-dom": "19.1.0",
     "react-native": "0.78.1",
@@ -83,14 +83,14 @@
     "react-native-quick-crypto": "0.7.14",
     "react-native-svg": "15.12.0",
     "rimraf": "6.0.1",
-    "sharp": "^0.33.5",
+    "sharp": "^0.34.2",
     "size-limit": "11.2.0",
-    "storybook": "9.0.8",
+    "storybook": "9.0.15",
     "typedoc": "0.27.9",
     "typedoc-better-json": "0.9.4",
     "typescript": "5.8.3",
-    "vite": "6.3.5",
-    "vitest": "3.2.3"
+    "vite": "7.0.1",
+    "vitest": "3.2.4"
   },
   "engines": {
     "node": ">=18"
@@ -375,7 +375,7 @@
     }
   },
   "typings": "./dist/types/exports/thirdweb.d.ts",
-  "version": "5.105.6-nightly-f1a965b0465f95864cb46c553a95323555c1b5c6-20250704000423",
+  "version": "5.105.6-nightly-8def4f33f6502ac896012d46ff40ff5d9ea54f8f-20250705000408",
   "scripts": {
     "bench": "vitest -c ./test/vitest.config.ts bench",
     "bench:compare": "bun run ./benchmarks/run.ts",

package/src/cli/commands/stylus/builder.ts

@@ -7,11 +7,22 @@ import prompts from "prompts";
 import { parse } from "toml";
 import { createThirdwebClient } from "../../../client/client.js";
 import { upload } from "../../../storage/upload.js";
+import { checkPrerequisites } from "./check-prerequisites.js";
 
 const THIRDWEB_URL = "https://thirdweb.com";
 
 export async function publishStylus(secretKey?: string) {
   const spinner = ora("Checking if this is a Stylus project...").start();
+
+  checkPrerequisites(spinner, "cargo", ["--version"], "Rust (cargo)");
+  checkPrerequisites(spinner, "rustc", ["--version"], "Rust compiler (rustc)");
+  checkPrerequisites(
+    spinner,
+    "solc",
+    ["--version"],
+    "Solidity compiler (solc)",
+  );
+
   const uri = await buildStylus(spinner, secretKey);
 
   const url = getUrl(uri, "publish").toString();
@@ -21,6 +32,16 @@ export async function publishStylus(secretKey?: string) {
 
 export async function deployStylus(secretKey?: string) {
   const spinner = ora("Checking if this is a Stylus project...").start();
+
+  checkPrerequisites(spinner, "cargo", ["--version"], "Rust (cargo)");
+  checkPrerequisites(spinner, "rustc", ["--version"], "Rust compiler (rustc)");
+  checkPrerequisites(
+    spinner,
+    "solc",
+    ["--version"],
+    "Solidity compiler (solc)",
+  );
+
   const uri = await buildStylus(spinner, secretKey);
 
   const url = getUrl(uri, "deploy").toString();
@@ -95,6 +116,20 @@ async function buildStylus(spinner: Ora, secretKey?: string) {
     }
     spinner.succeed("ABI generated.");
 
+    // Step 3.5: detect the constructor
+    spinner.start("Detecting constructor…");
+    const constructorResult = spawnSync("cargo", ["stylus", "constructor"], {
+      encoding: "utf-8",
+    });
+
+    if (constructorResult.status !== 0) {
+      spinner.fail("Failed to get constructor signature.");
+      process.exit(1);
+    }
+
+    const constructorSigRaw = constructorResult.stdout.trim(); // e.g. "constructor(address owner)"
+    spinner.succeed(`Constructor found: ${constructorSigRaw || "none"}`);
+
     // Step 4: Process the output
     const parts = abiContent.split(/======= <stdin>:/g).filter(Boolean);
     const contractNames = extractContractNamesFromExportAbi(abiContent);
@@ -150,11 +185,19 @@ async function buildStylus(spinner: Ora, secretKey?: string) {
       process.exit(1);
     }
 
+    // biome-ignore lint/suspicious/noExplicitAny: <>
+    const abiArray: any[] = JSON.parse(cleanedAbi);
+
+    const constructorAbi = constructorSigToAbi(constructorSigRaw);
+    if (constructorAbi && !abiArray.some((e) => e.type === "constructor")) {
+      abiArray.unshift(constructorAbi); // put it at the top for readability
+    }
+
     const metadata = {
       compiler: {},
       language: "rust",
       output: {
-        abi: JSON.parse(cleanedAbi),
+        abi: abiArray,
         devdoc: {},
         userdoc: {},
       },
@@ -234,3 +277,24 @@ function extractBytecode(rawOutput: string): string {
   }
   return rawOutput.slice(hexStart).trim();
 }
+
+function constructorSigToAbi(sig: string) {
+  if (!sig || !sig.startsWith("constructor")) return undefined;
+
+  const sigClean = sig
+    .replace(/^constructor\s*\(?/, "")
+    .replace(/\)\s*$/, "")
+    .replace(/\s+(payable|nonpayable)\s*$/, "");
+
+  const mutability = sig.includes("payable") ? "payable" : "nonpayable";
+
+  const inputs =
+    sigClean === ""
+      ? []
+      : sigClean.split(",").map((p) => {
+          const [type, name = ""] = p.trim().split(/\s+/);
+          return { internalType: type, name, type };
+        });
+
+  return { inputs, stateMutability: mutability, type: "constructor" };
+}

package/src/cli/commands/stylus/check-prerequisites.ts

@@ -0,0 +1,34 @@
+import { spawnSync } from "node:child_process";
+import type { Ora } from "ora";
+
+export function checkPrerequisites(
+  spinner: Ora,
+  cmd: string,
+  args: string[] = ["--version"],
+  name = cmd,
+) {
+  try {
+    const res = spawnSync(cmd, args, { encoding: "utf-8" });
+
+    if (res.error && (res.error as NodeJS.ErrnoException).code === "ENOENT") {
+      spinner.fail(
+        `Error: ${name} is not installed or not in PATH.\n` +
+          `Install it and try again.`,
+      );
+      process.exit(1);
+    }
+
+    if (res.status !== 0) {
+      spinner.fail(
+        `Error: ${name} returned a non-zero exit code (${res.status}).`,
+      );
+      process.exit(1);
+    }
+
+    const ver = res.stdout.trim().split("\n")[0];
+    spinner.succeed(`${name} detected (${ver}).`);
+  } catch (err) {
+    spinner.fail(`Error while checking ${name}: ${err}`);
+    process.exit(1);
+  }
+}

package/src/cli/commands/stylus/create.ts

@@ -1,10 +1,20 @@
 import { spawnSync } from "node:child_process";
 import ora from "ora";
 import prompts from "prompts";
+import { checkPrerequisites } from "./check-prerequisites.js";
 
 export async function createStylusProject() {
   const spinner = ora();
 
+  checkPrerequisites(spinner, "cargo", ["--version"], "Rust (cargo)");
+  checkPrerequisites(spinner, "rustc", ["--version"], "Rust compiler (rustc)");
+  checkPrerequisites(
+    spinner,
+    "solc",
+    ["--version"],
+    "Solidity compiler (solc)",
+  );
+
   // Step 1: Ensure cargo is installed
   const cargoCheck = spawnSync("cargo", ["--version"]);
   if (cargoCheck.status !== 0) {
@@ -23,7 +33,7 @@ export async function createStylusProject() {
   }
   spinner.succeed("Stylus installed.");
 
-  spawnSync("rustup", ["default", "1.83"], {
+  spawnSync("rustup", ["default", "1.87"], {
     stdio: "inherit",
   });
   spawnSync("rustup", ["target", "add", "wasm32-unknown-unknown"], {
@@ -43,6 +53,11 @@ export async function createStylusProject() {
     choices: [
       { title: "Default", value: "default" },
       { title: "ERC20", value: "erc20" },
+      { title: "ERC721", value: "erc721" },
+      { title: "ERC1155", value: "erc1155" },
+      { title: "Airdrop ERC20", value: "airdrop20" },
+      { title: "Airdrop ERC721", value: "airdrop721" },
+      { title: "Airdrop ERC1155", value: "airdrop1155" },
     ],
     message: "Select a template:",
     name: "projectType",
@@ -50,25 +65,65 @@ export async function createStylusProject() {
   });
 
   // Step 5: Create the project
+  // biome-ignore lint/suspicious/noImplicitAnyLet: <>
+  let newProject;
   if (projectType === "default") {
     spinner.start(`Creating new Stylus project: ${projectName}...`);
-    const newProject = spawnSync("cargo", ["stylus", "new", projectName], {
+    newProject = spawnSync("cargo", ["stylus", "new", projectName], {
       stdio: "inherit",
     });
-    if (newProject.status !== 0) {
-      spinner.fail("Failed to create Stylus project.");
-      process.exit(1);
-    }
   } else if (projectType === "erc20") {
     const repoUrl = "git@github.com:thirdweb-example/stylus-erc20-template.git";
     spinner.start(`Creating new ERC20 Stylus project: ${projectName}...`);
-    const clone = spawnSync("git", ["clone", repoUrl, projectName], {
+    newProject = spawnSync("git", ["clone", repoUrl, projectName], {
+      stdio: "inherit",
+    });
+  } else if (projectType === "erc721") {
+    const repoUrl =
+      "git@github.com:thirdweb-example/stylus-erc721-template.git";
+    spinner.start(`Creating new ERC721 Stylus project: ${projectName}...`);
+    newProject = spawnSync("git", ["clone", repoUrl, projectName], {
+      stdio: "inherit",
+    });
+  } else if (projectType === "erc1155") {
+    const repoUrl =
+      "git@github.com:thirdweb-example/stylus-erc1155-template.git";
+    spinner.start(`Creating new ERC1155 Stylus project: ${projectName}...`);
+    newProject = spawnSync("git", ["clone", repoUrl, projectName], {
+      stdio: "inherit",
+    });
+  } else if (projectType === "airdrop20") {
+    const repoUrl =
+      "git@github.com:thirdweb-example/stylus-airdrop-erc20-template.git";
+    spinner.start(
+      `Creating new Airdrop ERC20 Stylus project: ${projectName}...`,
+    );
+    newProject = spawnSync("git", ["clone", repoUrl, projectName], {
       stdio: "inherit",
     });
-    if (clone.status !== 0) {
-      spinner.fail("Failed to create Stylus project.");
-      process.exit(1);
-    }
+  } else if (projectType === "airdrop721") {
+    const repoUrl =
+      "git@github.com:thirdweb-example/stylus-airdrop-erc721-template.git";
+    spinner.start(
+      `Creating new Airdrop ERC721 Stylus project: ${projectName}...`,
+    );
+    newProject = spawnSync("git", ["clone", repoUrl, projectName], {
+      stdio: "inherit",
+    });
+  } else if (projectType === "airdrop1155") {
+    const repoUrl =
+      "git@github.com:thirdweb-example/stylus-airdrop-erc1155-template.git";
+    spinner.start(
+      `Creating new Airdrop ERC1155 Stylus project: ${projectName}...`,
+    );
+    newProject = spawnSync("git", ["clone", repoUrl, projectName], {
+      stdio: "inherit",
+    });
+  }
+
+  if (!newProject || newProject.status !== 0) {
+    spinner.fail("Failed to create Stylus project.");
+    process.exit(1);
   }
 
   spinner.succeed("Project created successfully.");

package/src/contract/deployment/deploy-with-abi.ts

@@ -1,5 +1,9 @@
 import type { Abi, AbiConstructor } from "abitype";
+import { parseEventLogs } from "../../event/actions/parse-logs.js";
+import { contractDeployedEvent } from "../../extensions/stylus/__generated__/IStylusDeployer/events/ContractDeployed.js";
 import { activateStylusContract } from "../../extensions/stylus/write/activateStylusContract.js";
+import { deployWithStylusConstructor } from "../../extensions/stylus/write/deployWithStylusConstructor.js";
+import { isContractActivated } from "../../extensions/stylus/write/isContractActivated.js";
 import { sendAndConfirmTransaction } from "../../transaction/actions/send-and-confirm-transaction.js";
 import { sendTransaction } from "../../transaction/actions/send-transaction.js";
 import { prepareTransaction } from "../../transaction/prepare-transaction.js";
@@ -171,6 +175,53 @@ export async function deployContract(
         to: info.create2FactoryAddress,
       }),
     });
+  } else if (options.isStylus && options.constructorParams) {
+    const isActivated = await isContractActivated(options);
+
+    if (!isActivated) {
+      // one time deploy to activate the new codehash
+      const impl = await deployContract({
+        ...options,
+        abi: [],
+        constructorParams: undefined,
+      });
+
+      // fetch metadata
+      await fetch(
+        `https://contract.thirdweb.com/metadata/${options.chain.id}/${impl}`,
+        {
+          headers: {
+            "Content-Type": "application/json",
+          },
+          method: "GET",
+        },
+      );
+    }
+
+    const deployTx = deployWithStylusConstructor({
+      abi: options.abi,
+      bytecode: options.bytecode,
+      chain: options.chain,
+      client: options.client,
+      constructorParams: options.constructorParams,
+    });
+
+    const receipt = await sendAndConfirmTransaction({
+      account: options.account,
+      transaction: deployTx,
+    });
+
+    const deployEvent = contractDeployedEvent();
+    const decodedEvent = parseEventLogs({
+      events: [deployEvent],
+      logs: receipt.logs,
+    });
+    if (decodedEvent.length === 0 || !decodedEvent[0]) {
+      throw new Error(
+        `No ContractDeployed event found in transaction: ${receipt.transactionHash}`,
+      );
+    }
+    address = decodedEvent[0]?.args.deployedContract;
   } else {
     const deployTx = prepareDirectDeployTransaction(options);
     const receipt = await sendAndConfirmTransaction({

package/src/exports/extensions/stylus.ts

@@ -5,3 +5,11 @@ export {
   type ActivateStylusContractOptions,
   activateStylusContract,
 } from "../../extensions/stylus/write/activateStylusContract.js";
+export {
+  type DeployWithStylusConstructorOptions,
+  deployWithStylusConstructor,
+} from "../../extensions/stylus/write/deployWithStylusConstructor.js";
+export {
+  type IsContractActivatedOptions,
+  isContractActivated,
+} from "../../extensions/stylus/write/isContractActivated.js";

package/src/extensions/stylus/__generated__/IArbWasm/read/codehashVersion.ts

@@ -0,0 +1,126 @@
+import type { AbiParameterToPrimitiveType } from "abitype";
+import { decodeAbiParameters } from "viem";
+import { readContract } from "../../../../../transaction/read-contract.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+import { encodeAbiParameters } from "../../../../../utils/abi/encodeAbiParameters.js";
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+import type { Hex } from "../../../../../utils/encoding/hex.js";
+
+/**
+ * Represents the parameters for the "codehashVersion" function.
+ */
+export type CodehashVersionParams = {
+  codehash: AbiParameterToPrimitiveType<{ type: "bytes32"; name: "codehash" }>;
+};
+
+export const FN_SELECTOR = "0xd70c0ca7" as const;
+const FN_INPUTS = [
+  {
+    name: "codehash",
+    type: "bytes32",
+  },
+] as const;
+const FN_OUTPUTS = [
+  {
+    name: "version",
+    type: "uint16",
+  },
+] as const;
+
+/**
+ * Checks if the `codehashVersion` 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 `codehashVersion` method is supported.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { isCodehashVersionSupported } from "thirdweb/extensions/stylus";
+ * const supported = isCodehashVersionSupported(["0x..."]);
+ * ```
+ */
+export function isCodehashVersionSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Encodes the parameters for the "codehashVersion" function.
+ * @param options - The options for the codehashVersion function.
+ * @returns The encoded ABI parameters.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { encodeCodehashVersionParams } from "thirdweb/extensions/stylus";
+ * const result = encodeCodehashVersionParams({
+ *  codehash: ...,
+ * });
+ * ```
+ */
+export function encodeCodehashVersionParams(options: CodehashVersionParams) {
+  return encodeAbiParameters(FN_INPUTS, [options.codehash]);
+}
+
+/**
+ * Encodes the "codehashVersion" function into a Hex string with its parameters.
+ * @param options - The options for the codehashVersion function.
+ * @returns The encoded hexadecimal string.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { encodeCodehashVersion } from "thirdweb/extensions/stylus";
+ * const result = encodeCodehashVersion({
+ *  codehash: ...,
+ * });
+ * ```
+ */
+export function encodeCodehashVersion(options: CodehashVersionParams) {
+  // 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 +
+    encodeCodehashVersionParams(options).slice(
+      2,
+    )) as `${typeof FN_SELECTOR}${string}`;
+}
+
+/**
+ * Decodes the result of the codehashVersion function call.
+ * @param result - The hexadecimal result to decode.
+ * @returns The decoded result as per the FN_OUTPUTS definition.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { decodeCodehashVersionResult } from "thirdweb/extensions/stylus";
+ * const result = decodeCodehashVersionResultResult("...");
+ * ```
+ */
+export function decodeCodehashVersionResult(result: Hex) {
+  return decodeAbiParameters(FN_OUTPUTS, result)[0];
+}
+
+/**
+ * Calls the "codehashVersion" function on the contract.
+ * @param options - The options for the codehashVersion function.
+ * @returns The parsed result of the function call.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { codehashVersion } from "thirdweb/extensions/stylus";
+ *
+ * const result = await codehashVersion({
+ *  contract,
+ *  codehash: ...,
+ * });
+ *
+ * ```
+ */
+export async function codehashVersion(
+  options: BaseTransactionOptions<CodehashVersionParams>,
+) {
+  return readContract({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+    params: [options.codehash],
+  });
+}

package/src/extensions/stylus/__generated__/IStylusConstructor/write/stylus_constructor.ts

@@ -0,0 +1,50 @@
+import { prepareContractCall } from "../../../../../transaction/prepare-contract-call.js";
+import type { BaseTransactionOptions } from "../../../../../transaction/types.js";
+
+import { detectMethod } from "../../../../../utils/bytecode/detectExtension.js";
+
+export const FN_SELECTOR = "0x5585258d" as const;
+const FN_INPUTS = [] as const;
+const FN_OUTPUTS = [] as const;
+
+/**
+ * Checks if the `stylus_constructor` 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 `stylus_constructor` method is supported.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { isStylus_constructorSupported } from "thirdweb/extensions/stylus";
+ *
+ * const supported = isStylus_constructorSupported(["0x..."]);
+ * ```
+ */
+export function isStylus_constructorSupported(availableSelectors: string[]) {
+  return detectMethod({
+    availableSelectors,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}
+
+/**
+ * Prepares a transaction to call the "stylus_constructor" function on the contract.
+ * @param options - The options for the "stylus_constructor" function.
+ * @returns A prepared transaction object.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { sendTransaction } from "thirdweb";
+ * import { stylus_constructor } from "thirdweb/extensions/stylus";
+ *
+ * const transaction = stylus_constructor();
+ *
+ * // Send the transaction
+ * await sendTransaction({ transaction, account });
+ * ```
+ */
+export function stylus_constructor(options: BaseTransactionOptions) {
+  return prepareContractCall({
+    contract: options.contract,
+    method: [FN_SELECTOR, FN_INPUTS, FN_OUTPUTS] as const,
+  });
+}

package/src/extensions/stylus/__generated__/IStylusDeployer/events/ContractDeployed.ts

@@ -0,0 +1,24 @@
+import { prepareEvent } from "../../../../../event/prepare-event.js";
+
+/**
+ * Creates an event object for the ContractDeployed event.
+ * @returns The prepared event object.
+ * @extension STYLUS
+ * @example
+ * ```ts
+ * import { getContractEvents } from "thirdweb";
+ * import { contractDeployedEvent } from "thirdweb/extensions/stylus";
+ *
+ * const events = await getContractEvents({
+ * contract,
+ * events: [
+ *  contractDeployedEvent()
+ * ],
+ * });
+ * ```
+ */
+export function contractDeployedEvent() {
+  return prepareEvent({
+    signature: "event ContractDeployed(address deployedContract)",
+  });
+}