create-stylus 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-stylus",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": "Q3 Labs",
   "license": "MIT",
   "repository": {

package/templates/base/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ss",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": true,
   "workspaces": {
     "packages": [

package/templates/base/packages/stylus/scripts/deploy.ts

@@ -1,5 +1,9 @@
 import deployStylusContract from "./deploy_contract";
-import { getDeploymentConfig, printDeployedAddresses } from "./utils/";
+import {
+  getDeploymentConfig,
+  getRpcUrlFromChain,
+  printDeployedAddresses,
+} from "./utils/";
 import { DeployOptions } from "./utils/type";
 import { config as dotenvConfig } from "dotenv";
 import * as path from "path";
@@ -16,7 +20,7 @@ if (fs.existsSync(envPath)) {
 export default async function deployScript(deployOptions: DeployOptions) {
   const config = getDeploymentConfig(deployOptions);
 
-  console.log(`📡 Using endpoint: ${config.chain?.rpcUrl}`);
+  console.log(`📡 Using endpoint: ${getRpcUrlFromChain(config.chain)}`);
   if (config.chain) {
     console.log(`🌐 Network: ${config.chain?.name}`);
     console.log(`🔗 Chain ID: ${config.chain?.id}`);
@@ -50,5 +54,5 @@ export default async function deployScript(deployOptions: DeployOptions) {
 
   // Print the deployed addresses
   console.log("\n\n");
-  printDeployedAddresses(config.deploymentDir, config.chain?.id);
+  printDeployedAddresses(config.deploymentDir, config.chain.id.toString());
 }

package/templates/base/packages/stylus/scripts/deploy_contract.ts

@@ -4,17 +4,18 @@ import {
   executeCommand,
   extractDeploymentInfo,
   saveDeployment,
-  ORBIT_CHAINS,
+  getBlockExplorerUrlFromChain,
+  getRpcUrlFromChain,
+  getContractData,
+  contractHasInitializeFunction,
   // estimateGasPrice,
 } from "./utils/";
 import { exportStylusAbi } from "./export_abi";
 import { DeployOptions } from "./utils/type";
 import { buildDeployCommand } from "./utils/command";
-import { Chain, createPublicClient, createWalletClient, http } from "viem";
+import { Abi, createPublicClient, createWalletClient, http } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-
 import { arbitrumNitro } from "../../nextjs/utils/scaffold-stylus/supportedChains";
-import deployedContracts from "../../nextjs/contracts/deployedContracts";
 
 /**
  * Deploy a single contract using cargo stylus
@@ -50,12 +51,13 @@ export default async function deployStylusContract(
     // Extract the actual deployed address from the output
     const deploymentInfo = extractDeploymentInfo(deployOutput);
     if (deploymentInfo) {
-      if (config.chain?.blockExplorerUrl) {
+      const blockExplorerUrl = getBlockExplorerUrlFromChain(config.chain);
+      if (blockExplorerUrl) {
         console.log(
-          `📋 Contract deployed: ${config.chain?.blockExplorerUrl}/address/${deploymentInfo.address}`,
+          `📋 Contract deployed: ${blockExplorerUrl}/address/${deploymentInfo.address}`,
         );
         console.log(
-          `Transaction hash: ${config.chain?.blockExplorerUrl}/tx/${deploymentInfo.txHash}`,
+          `Transaction hash: ${blockExplorerUrl}/tx/${deploymentInfo.txHash}`,
         );
       } else {
         console.log(
@@ -75,32 +77,29 @@ export default async function deployStylusContract(
       config.contractFolder,
       config.contractName,
       false,
-      config.chain?.id,
+      config.chain.id.toString(),
+    );
+
+    // Get contract data from deployed contracts after ABI export
+    const contractData = getContractData(
+      config.chain.id.toString(),
+      config.contractName,
     );
 
     // Call the initialize function if orbit deployment
     if (
       !!deployOptions.isOrbit &&
-      config.chain?.id !== arbitrumNitro?.id.toString()
+      config.chain.id !== arbitrumNitro.id &&
+      contractHasInitializeFunction(contractData)
     ) {
-      const orbitChain = ORBIT_CHAINS.find(
-        (chain) => chain.id.toString() === config.chain?.id,
-      );
-
-      if (!orbitChain) {
-        throw new Error(
-          `Chain ${config.chain?.id} is not supported for orbit deployment`,
-        );
-      }
-
       const publicClient = createPublicClient({
-        chain: orbitChain as unknown as Chain,
+        chain: config.chain,
         transport: http(),
       });
 
       // need wallet client to sign the transaction
       const walletClient = createWalletClient({
-        chain: orbitChain as unknown as Chain,
+        chain: config.chain,
         transport: http(),
       });
 
@@ -109,35 +108,44 @@ export default async function deployStylusContract(
       const { request } = await publicClient.simulateContract({
         account,
         address: deploymentInfo.address,
-        // @ts-expect-error deployed contract is empty at the beginning
-        abi: deployedContracts[config.chain.id][config.contractName].abi,
+        abi: contractData.abi as Abi,
         functionName: "initialize",
-        args: deployOptions.constructorArgs,
+        args: deployOptions.constructorArgs as any[],
       });
 
       const initTxHash = await walletClient.writeContract(request);
 
       console.log("Initialize transaction hash: ", initTxHash);
+    } else {
+      console.log("\nContract does not have an initialize function");
+      console.log("Skipping initialization");
     }
 
     // Step 3: Verify the contract
     if (deployOptions.verify) {
       try {
         const output = await executeCommand(
-          `cargo stylus verify --endpoint=${config.chain?.rpcUrl} --deployment-tx=${deploymentInfo.txHash}`,
+          `cargo stylus verify --endpoint=${getRpcUrlFromChain(config.chain)} --deployment-tx=${deploymentInfo.txHash}`,
           deployOptions.contract!,
           "Verifying contract with cargo stylus",
         );
         console.log(output);
       } catch (error) {
-        console.error(
-          `❌ Verification failed in: ${deployOptions.contract}`,
-          error,
-        );
+        console.error(`❌ Verification failed in: ${deployOptions.contract}`);
+        if (error instanceof Error) {
+          console.error(error.message);
+        } else {
+          console.error(error);
+        }
       }
     }
   } catch (error) {
-    console.error(`❌ Deployment failed in: ${deployOptions.contract}`, error);
+    console.error(`❌ Deployment failed in: ${deployOptions.contract}`);
+    if (error instanceof Error) {
+      console.error(error.message);
+    } else {
+      console.error(error);
+    }
     process.exit(1);
   }
 }

package/templates/base/packages/stylus/scripts/test_network.ts

@@ -1,4 +1,4 @@
-import { getChain } from "./utils/";
+import { getChain, getRpcUrlFromChain } from "./utils/";
 import { SUPPORTED_NETWORKS } from "./utils/";
 
 function testNetworkFunctionality() {
@@ -9,7 +9,7 @@ function testNetworkFunctionality() {
   testNetworks.forEach((network) => {
     const chain = getChain(network);
     if (chain) {
-      console.log(`✅ ${network}: ${chain.rpcUrl}`);
+      console.log(`✅ ${network}: ${getRpcUrlFromChain(chain)}`);
     } else {
       console.log(`❌ ${network}: Not found in viem chains`);
     }

package/templates/base/packages/stylus/scripts/utils/command.ts

@@ -1,12 +1,16 @@
 import { spawn } from "child_process";
 import { DeploymentConfig, DeployOptions } from "./type";
-import { extractGasPriceFromOutput } from "./contract";
+import {
+  extractGasPriceFromOutput,
+  isContractHasConstructor,
+} from "./contract";
+import { getRpcUrlFromChain } from "./network";
 
 export async function buildDeployCommand(
   config: DeploymentConfig,
   deployOptions: DeployOptions,
 ) {
-  let baseCommand = `cargo stylus deploy --endpoint='${config.chain?.rpcUrl}' --private-key='${config.privateKey}'`;
+  let baseCommand = `cargo stylus deploy --endpoint='${getRpcUrlFromChain(config.chain)}' --private-key='${config.privateKey}'`;
 
   if (deployOptions.estimateGas) {
     return `${baseCommand} --estimate-gas`;
@@ -19,8 +23,15 @@ export async function buildDeployCommand(
   if (!deployOptions.verify) {
     baseCommand += ` --no-verify`;
   } else {
-    console.log("Skipping constructor args as verify is true");
-    return baseCommand;
+    if (
+      deployOptions.constructorArgs &&
+      deployOptions.constructorArgs.length > 0 &&
+      isContractHasConstructor(config.contractFolder)
+    ) {
+      throw new Error(
+        "Verification is not currently supported with constructors. Please implement and use initialize() function to initialize your contracts: Refer to readme.md for tutorial",
+      );
+    }
   }
 
   if (
@@ -38,7 +49,7 @@ export async function estimateGasPrice(
   config: DeploymentConfig,
   deployOptions: DeployOptions,
 ): Promise<string> {
-  let deployCommand = `cargo stylus deploy --endpoint='${config.chain?.rpcUrl}' --private-key='${config.privateKey}' --no-verify --estimate-gas `;
+  let deployCommand = `cargo stylus deploy --endpoint='${getRpcUrlFromChain(config.chain)}' --private-key='${config.privateKey}' --no-verify --estimate-gas `;
   if (deployOptions.constructorArgs) {
     deployCommand += ` --constructor-args='${deployOptions.constructorArgs.join(" ")}'`;
   }
@@ -75,7 +86,6 @@ export function executeCommand(
 
     let output = "";
     let errorOutput = "";
-    const outputLines: string[] = [];
     let errorLines: string[] = [];
 
     // Handle stdout
@@ -83,8 +93,6 @@ export function executeCommand(
       childProcess.stdout.on("data", (data: Buffer) => {
         const chunk = data.toString();
         output += chunk;
-        const newLines = chunk.split("\n");
-        outputLines.push(...newLines);
       });
     }
 
@@ -95,53 +103,37 @@ export function executeCommand(
         errorOutput += chunk;
         const newLines = chunk.split("\n");
         errorLines.push(...newLines);
-        // Keep only the last 5 lines
-        if (errorLines.length > 5) {
-          errorLines = errorLines.slice(-5);
+        // Keep only the last 20 lines, just for safety
+        if (errorLines.length > 20) {
+          errorLines = errorLines.slice(-20);
         }
       });
     }
 
     // Handle process completion
     childProcess.on("close", (code: number | null) => {
-      if (code === 0) {
+      // this can extract and detect errors from docker logs because it not throw error code
+      const errors = extractErrorLines(errorLines);
+
+      if (code === 0 && !errors) {
         console.log(`\n✅ ${description} completed successfully!`);
         resolve(output);
       } else {
         console.error(`\n❌ ${description} failed with exit code ${code}`);
         // Print error output starting from "project metadata hash computed on deployment" or error patterns, or all logs if not found
-        if (errorLines.length > 0) {
-          const metadataIndex = errorLines.findIndex((line) =>
-            line.includes("project metadata hash computed on deployment"),
-          );
-          const errorIndex = errorLines.findIndex((line) =>
-            line.includes("error["),
-          );
-
-          let startIndex = -1;
-          if (metadataIndex >= 0) {
-            startIndex = metadataIndex;
-          } else if (errorIndex >= 0) {
-            startIndex = errorIndex;
-          }
-
-          if (startIndex >= 0) {
-            const linesToPrint = errorLines.slice(startIndex);
-            linesToPrint.forEach((line) => {
-              if (line.trim()) console.error(line);
-            });
-          } else {
-            errorLines.forEach((line) => {
-              if (line.trim()) console.error(line);
-            });
+        if (errors) {
+          console.error(errors);
+          if (
+            !command.includes("--no-verify") &&
+            errors.includes("mismatch number of constructor arguments")
+          ) {
+            errorOutput += `\nCan not verify contract with constructor arguments.\n`;
           }
         }
-        if (errorOutput) {
-          console.error(errorOutput);
-        }
+
         reject(
           new Error(
-            `Command failed with exit code ${code}. Error output: ${errorOutput}`,
+            `Command failed with exit code ${code}. Error output: \n${errorOutput}`,
           ),
         );
       }
@@ -154,3 +146,35 @@ export function executeCommand(
     });
   });
 }
+
+function extractErrorLines(errorLines: string[]): string | null {
+  let output: string = "";
+  if (errorLines.length > 0) {
+    const metadataIndex = errorLines.findIndex((line) =>
+      line.includes("project metadata hash computed on deployment"),
+    );
+    const errorIndex = errorLines.findIndex(
+      (line) =>
+        line.toLowerCase().includes("error[") ||
+        line.toLowerCase().includes("error:"),
+    );
+
+    let startIndex = -1;
+    if (metadataIndex >= 0) {
+      startIndex = metadataIndex;
+    } else if (errorIndex >= 0) {
+      startIndex = errorIndex;
+    }
+
+    if (startIndex === -1) {
+      return null;
+    }
+
+    const linesToPrint = errorLines.slice(startIndex);
+    linesToPrint.forEach((line) => {
+      if (line.trim()) output += line + "\n";
+    });
+    return output;
+  }
+  return null;
+}

package/templates/base/packages/stylus/scripts/utils/contract.ts

@@ -41,6 +41,15 @@ export function getContractNameFromCargoToml(contractFolder: string): string {
   return parsed.package.name;
 }
 
+export function isContractHasConstructor(contractFolder: string): boolean {
+  const contractPath = path.resolve(contractFolder, "src/lib.rs");
+  if (!fs.existsSync(contractPath)) {
+    throw new Error(`lib.rs not found in contract folder: ${contractPath}`);
+  }
+  const contractContent = fs.readFileSync(contractPath, "utf8");
+  return contractContent.includes("#[constructor]");
+}
+
 export function getExportConfig(
   contractFolder?: string,
   contractName?: string,
@@ -225,3 +234,61 @@ export function handleSolcError(
     console.error("\n💡 Please check the error details above and try again.");
   }
 }
+
+/**
+ * Dynamically load deployed contracts from the TypeScript file
+ * This is useful when the file has been updated during runtime
+ * @returns The deployed contracts object
+ */
+export function loadDeployedContracts(): any {
+  const deployedContractsPath = "../nextjs/contracts/deployedContracts.ts";
+
+  if (!fs.existsSync(deployedContractsPath)) {
+    throw new Error("deployedContracts.ts file not found");
+  }
+
+  const fileContent = fs.readFileSync(deployedContractsPath, "utf8");
+  const match = fileContent.match(
+    /const deployedContracts = ([\s\S]*?) as const;/,
+  );
+
+  if (!match) {
+    throw new Error("Could not parse deployedContracts.ts file");
+  }
+
+  // eslint-disable-next-line no-eval
+  return eval("(" + match[1] + ")");
+}
+
+/**
+ * Get contract data from deployed contracts
+ * @param chainId - The chain ID
+ * @param contractName - The contract name
+ * @returns The contract data with address, txHash, and abi
+ */
+export function getContractData(chainId: string, contractName: string): any {
+  const deployedContracts = loadDeployedContracts();
+
+  if (
+    !deployedContracts ||
+    !deployedContracts[chainId] ||
+    !deployedContracts[chainId][contractName]
+  ) {
+    throw new Error(
+      `Contract ${contractName} not found in deployedContracts for chain ${chainId}`,
+    );
+  }
+
+  const contractData = deployedContracts[chainId][contractName];
+  if (!contractData.abi) {
+    throw new Error(
+      `ABI not found for contract ${contractName} on chain ${chainId}`,
+    );
+  }
+
+  return contractData;
+}
+
+export function contractHasInitializeFunction(contractData: any): boolean {
+  return contractData.abi.some((abi: any) => abi.name === "initialize");
+}

package/templates/base/packages/stylus/scripts/utils/network.ts

@@ -10,7 +10,6 @@ import {
 import * as path from "path";
 import * as fs from "fs";
 import { config as dotenvConfig } from "dotenv";
-import { SupportedNetworkMinimal } from "./type";
 
 const envPath = path.resolve(__dirname, "../../.env");
 if (fs.existsSync(envPath)) {
@@ -47,7 +46,7 @@ export const ORBIT_CHAINS: Chain[] = [
   superpositionTestnet as Chain,
 ];
 
-export function getChain(networkName: string): SupportedNetworkMinimal | null {
+export function getChain(networkName: string): Chain | null {
   try {
     const actualNetworkName = ALIASES[networkName.toLowerCase()] || networkName;
 
@@ -55,15 +54,7 @@ export function getChain(networkName: string): SupportedNetworkMinimal | null {
       ([key]) => key.toLowerCase() === actualNetworkName.toLowerCase(),
     );
 
-    if (chainEntry) {
-      return {
-        name: chainEntry[0],
-        alias: getAliasFromNetworkName(chainEntry[0]),
-        id: chainEntry[1].id.toString(),
-        rpcUrl: getRpcUrlFromChain(chainEntry[1]),
-        blockExplorerUrl: chainEntry[1].blockExplorers?.default?.url,
-      };
-    }
+    if (chainEntry) return chainEntry[1];
 
     const supportedNetworks = Object.keys(SUPPORTED_NETWORKS);
     console.warn(
@@ -132,6 +123,7 @@ export function getPrivateKey(networkName: string): string {
 
 export const getAccountAddress = (networkName: string): Address | undefined => {
   const actualNetworkName = ALIASES[networkName.toLowerCase()] || networkName;
+
   switch (actualNetworkName.toLowerCase()) {
     case "arbitrum":
       return process.env["ACCOUNT_ADDRESS_MAINNET"] as Address;
@@ -155,7 +147,7 @@ export const getAccountAddress = (networkName: string): Address | undefined => {
   }
 };
 
-function getRpcUrlFromChain(chain: Chain): string {
+export function getRpcUrlFromChain(chain: Chain): string {
   //Prefer user rpc url from env
   switch (chain.id) {
     case arbitrum.id:
@@ -214,9 +206,8 @@ function getRpcUrlFromChain(chain: Chain): string {
   throw new Error(`No RPC URL found for chain ${chain.name}`);
 }
 
-function getAliasFromNetworkName(networkName: string): string {
+export function getBlockExplorerUrlFromChain(chain: Chain): string | undefined {
   return (
-    Object.entries(ALIASES).find(([, alias]) => alias === networkName)?.[0] ||
-    networkName
+    chain.blockExplorers?.default?.url || chain.blockExplorers?.etherscan?.url
   );
 }

package/templates/base/packages/stylus/scripts/utils/type.ts

@@ -1,4 +1,4 @@
-import { Address } from "viem";
+import { Address, Chain } from "viem";
 
 interface BaseCommandOptions {
   _: (string | number)[];
@@ -14,11 +14,11 @@ export interface DeployOptions {
   contract?: string;
   name?: string;
   constructorArgs?: NonNullable<unknown>[];
+  isOrbit?: boolean;
   network?: string;
   estimateGas?: boolean;
   maxFee?: string;
   verify?: boolean;
-  isOrbit?: boolean;
 }
 
 export interface DeploymentData {
@@ -32,7 +32,7 @@ export interface DeploymentConfig {
   contractFolder: string;
   contractName: string;
   deploymentDir: string;
-  chain?: SupportedNetworkMinimal;
+  chain: Chain;
 }
 
 export interface ExportConfig {
@@ -43,11 +43,3 @@ export interface ExportConfig {
   txHash: string;
   chainId: string;
 }
-
-export interface SupportedNetworkMinimal {
-  name: string;
-  alias: string;
-  id: string;
-  rpcUrl: string;
-  blockExplorerUrl?: string | undefined;
-}

package/templates/base/readme.md

@@ -233,9 +233,10 @@ Check full documentation for more [details](https://docs.arbitrum.io/stylus/how-
 
 ### Stylus Local Verification (Under Development)
 
-Make sure your constructor does not contain any args
+Make sure your contract does not include constructor or constructor does not contain any args
 
 ```rs
+[#constructor]
 pub fn constructor(&mut self)
 ```
 
@@ -277,6 +278,23 @@ Check official document for detail instructions: <https://docs.arbitrum.io/stylu
 
 > **Note**: Arbiscan verification for Stylus contracts is still evolving. If you encounter issues, consider using the local verification method or check Arbiscan's latest documentation for Stylus-specific instructions.
 
+**Tip**: If you still want to initialize your contract, then add your own `initialize()` function and initialize it yourself
+Sample :
+
+```
+pub fn initialize(&mut self, initial_number: U256) {
+   if !self.is_initialized.get() {
+      self.number.set(initial_number);
+      self.is_initialized.set(true);
+   } else {
+      panic!("Counter already initialized");
+   }
+}
+```
+
+Then use `cast --rpc-url <your-rpc-url> --private-key <your-private-key> [deployed-contract-address] "initialize(uint256)" <initial_number>`
+Or check [`deploy_contract.ts` lines 95-118](packages/stylus/scripts/deploy_contract.ts#L95-L118) and add it to your `deploy.ts` script.
+
 </details>
 
 ## 🛠️ Troubleshooting Common Issues