create-stylus 1.1.0

package/templates/base/packages/stylus/scripts/new_module.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+# Check if module name is provided
+if [ -z "$1" ]; then
+    echo "Error: Module name is required"
+    echo "Usage: $0 <module_name>"
+    exit 1
+fi
+
+MODULE_NAME="$1"
+
+CARGO_CMD="cargo stylus new \"$MODULE_NAME\""
+
+echo "Creating new module: $MODULE_NAME"
+
+if output=$(eval $CARGO_CMD 2>&1); then
+    cd "$MODULE_NAME"
+    # Remove unnecessary files
+    rm -rf .git .github ci .gitignore examples licenses .env.example header.png README.md
+    # Update Cargo.toml name field to $MODULE_NAME
+    if [ -f Cargo.toml ]; then
+        sed -i "s/^name = \".*\"/name = \"$MODULE_NAME\"/" Cargo.toml
+    fi
+    # Update main.rs module name in print_from_args call
+    if [ -f src/main.rs ]; then
+        MODULE_NAME_UNDERSCORE=$(echo "$MODULE_NAME" | tr '-' '_')
+        sed -i "s/^[[:space:]]*stylus_hello_world::print_from_args();/\t$MODULE_NAME_UNDERSCORE::print_from_args();/" src/main.rs
+    fi
+    cargo generate-lockfile
+    echo "New module created successfully"
+else
+    echo "Error: Failed to create new module with '$CARGO_CMD'"
+    echo "$output"
+    exit 1
+fi

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

@@ -0,0 +1,31 @@
+import { getChain } from "./utils/";
+import { SUPPORTED_NETWORKS } from "./utils/";
+
+function testNetworkFunctionality() {
+  console.log("🧪 Testing network functionality...\n");
+  
+  const testNetworks = [
+    ...Object.keys(SUPPORTED_NETWORKS),
+    "invalid-network",
+  ];
+  
+  testNetworks.forEach(network => {
+    const chain = getChain(network);
+    if (chain) {
+      console.log(`✅ ${network}: ${chain.rpcUrl}`);
+    } else {
+      console.log(`❌ ${network}: Not found in viem chains`);
+    }
+  });
+  
+  console.log("\n📝 Usage examples:");
+  Object.keys(SUPPORTED_NETWORKS).forEach(network => {
+    const chain = getChain(network);
+    console.log(`  yarn deploy --network ${chain?.name}\t# Deploy to ${chain?.name}`);
+    console.log(`  yarn deploy --network ${chain?.alias}\t\t# Deploy to ${chain?.name} (alias)`);
+  });
+}
+
+if (require.main === module) {
+  testNetworkFunctionality();
+} 

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

@@ -0,0 +1,165 @@
+import { spawn } from "child_process";
+import { DeploymentConfig, DeployOptions } from "./type";
+import { extractGasPriceFromOutput } from "./contract";
+
+export async function buildDeployCommand(
+  config: DeploymentConfig,
+  deployOptions: DeployOptions,
+) {
+  const baseCommand = `cargo stylus deploy --endpoint='${config.chain?.rpcUrl}' --private-key='${config.privateKey}' --no-verify`;
+
+  if (deployOptions.estimateGas) {
+    return `${baseCommand} --estimate-gas`;
+  }
+
+  if (deployOptions.maxFee) {
+    return `${baseCommand} --max-fee-per-gas-gwei=${deployOptions.maxFee}`;
+  }
+
+  // const gasPrice = await estimateGasPrice(config);
+  return baseCommand;
+}
+
+export async function estimateGasPrice(
+  config: DeploymentConfig,
+): Promise<string> {
+  const deployCommand = `cargo stylus deploy --endpoint='${config.chain?.rpcUrl}' --private-key='${config.privateKey}' --no-verify --estimate-gas`;
+  const deployOutput = await executeCommand(
+    deployCommand,
+    config.contractName,
+    "Estimating gas price with cargo stylus",
+  );
+  const gasPrice = extractGasPriceFromOutput(deployOutput);
+  if (gasPrice) {
+    return gasPrice;
+  }
+  return "0";
+}
+
+export function executeCommand(
+  command: string,
+  cwd: string,
+  description: string,
+): Promise<string> {
+  console.log(`\n🔄 ${description}...`);
+  // Sanitize command to hide private key (create a copy to avoid modifying original)
+  const sanitizedCommand = command.slice();
+  console.log(
+    `Executing: ${sanitizedCommand.replace(/--private-key=[^\s]+/g, "--private-key=***")}`,
+  );
+
+  return new Promise((resolve, reject) => {
+    const childProcess = spawn(command, [], {
+      cwd,
+      shell: true,
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+
+    let output = "";
+    let errorOutput = "";
+    const outputLines: string[] = [];
+    let errorLines: string[] = [];
+
+    // Handle stdout
+    if (childProcess.stdout) {
+      childProcess.stdout.on("data", (data: Buffer) => {
+        const chunk = data.toString();
+        output += chunk;
+        const newLines = chunk.split("\n");
+        outputLines.push(...newLines);
+      });
+    }
+
+    // Handle stderr
+    if (childProcess.stderr) {
+      childProcess.stderr.on("data", (data: Buffer) => {
+        const chunk = data.toString();
+        errorOutput += chunk;
+        const newLines = chunk.split("\n");
+        errorLines.push(...newLines);
+        // Keep only the last 5 lines
+        if (errorLines.length > 5) {
+          errorLines = errorLines.slice(-5);
+        }
+      });
+    }
+
+    // Handle process completion
+    childProcess.on("close", (code: number | null) => {
+      if (code === 0) {
+        console.log(`\n✅ ${description} completed successfully!`);
+        // Print output starting from "project metadata hash computed on deployment" or error patterns, or all logs if not found
+        // if (outputLines.length > 0) {
+        //   const metadataIndex = outputLines.findIndex((line) =>
+        //     line.includes("project metadata hash computed on deployment"),
+        //   );
+        //   const errorIndex = outputLines.findIndex((line) =>
+        //     line.includes("error["),
+        //   );
+
+        //   let startIndex = -1;
+        //   if (metadataIndex >= 0) {
+        //     startIndex = metadataIndex;
+        //   } else if (errorIndex >= 0) {
+        //     startIndex = errorIndex;
+        //   }
+
+        //   if (startIndex >= 0) {
+        //     const linesToPrint = outputLines.slice(startIndex);
+        //     linesToPrint.forEach((line) => {
+        //       if (line.trim()) console.log(line);
+        //     });
+        //   } else {
+        //     outputLines.forEach((line) => {
+        //       if (line.trim()) console.log(line);
+        //     });
+        //   }
+        // }
+        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 (errorOutput) {
+          console.error(errorOutput);
+        }
+        reject(
+          new Error(
+            `Command failed with exit code ${code}. Error output: ${errorOutput}`,
+          ),
+        );
+      }
+    });
+
+    // Handle process errors
+    childProcess.on("error", (error: Error) => {
+      console.error(`\n❌ ${description} failed:`, error);
+      reject(error);
+    });
+  });
+}

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

@@ -0,0 +1,219 @@
+import * as path from "path";
+import * as fs from "fs";
+import { ethers } from "ethers";
+import toml from "toml";
+import prettier from "prettier";
+import { ExportConfig } from "./type";
+import { getContractDataFromDeployments } from "./deployment";
+
+export const generatedContractComment = `
+/**
+ * This file is autogenerated by scaffold-stylus.
+ * You should not edit it manually or your changes might be overwritten.
+ */
+`;
+
+/**
+ * Reads the contract name from Cargo.toml in the given contract folder.
+ * Throws if the file or name field is missing.
+ */
+export function getContractNameFromCargoToml(contractFolder: string): string {
+  const cargoTomlPath = path.join(contractFolder, "Cargo.toml");
+  if (!fs.existsSync(cargoTomlPath)) {
+    throw new Error(
+      `Cargo.toml not found in contract folder: ${cargoTomlPath}`,
+    );
+  }
+  const tomlContent = fs.readFileSync(cargoTomlPath, "utf8");
+  let parsed: any;
+  try {
+    parsed = toml.parse(tomlContent);
+  } catch (e) {
+    throw new Error(`Failed to parse Cargo.toml: ${e}`);
+  }
+  if (!parsed.package || !parsed.package.name) {
+    throw new Error(
+      `Missing [package] or name field in Cargo.toml at ${cargoTomlPath}`,
+    );
+  }
+  return parsed.package.name;
+}
+
+export function getExportConfig(
+  contractFolder?: string,
+  contractName?: string,
+): ExportConfig {
+  if (!contractFolder) {
+    throw new Error("Contract folder is required");
+  }
+
+  contractName = contractName || getContractNameFromCargoToml(contractFolder);
+  const deploymentDir = process.env["DEPLOYMENT_DIR"] || "deployments";
+
+  const deploymentData = getContractDataFromDeployments(
+    deploymentDir,
+    contractName,
+  );
+  if (!deploymentData) {
+    throw new Error(
+      `❌ Contract address for '${contractName}' not found in ${deploymentDir}/addresses.json. Please deploy the contract first.`,
+    );
+  }
+
+  return {
+    contractFolder,
+    contractName,
+    deploymentDir,
+    contractAddress: deploymentData.address,
+    chainId: deploymentData.chainId,
+  };
+}
+
+export function isContractFolder(contractFolder: string): boolean {
+  const cargoTomlPath = path.join(contractFolder, "Cargo.toml");
+  const libRsPath = path.join(contractFolder, "src", "lib.rs");
+  const mainRsPath = path.join(contractFolder, "src", "main.rs");
+  return (
+    fs.existsSync(cargoTomlPath) &&
+    fs.existsSync(libRsPath) &&
+    fs.existsSync(mainRsPath)
+  );
+}
+
+export function generateContractAddress(): string {
+  // Generate a random private key and derive the address
+  const wallet = ethers.Wallet.createRandom();
+  return wallet.address;
+}
+
+export function extractDeployedAddress(output: string): string | null {
+  // Look for the line containing "deployed code at address:"
+  const lines = output.split("\n");
+  for (const line of lines) {
+    if (line.includes("deployed code at address:")) {
+      // Simple approach: just extract the hex address directly
+      const hexMatch = line.match(/(0x[a-fA-F0-9]{40})/);
+      if (hexMatch && hexMatch[1]) {
+        return hexMatch[1];
+      }
+    }
+  }
+  return null;
+}
+
+export function extractGasPriceFromOutput(output: string): string | null {
+  const lines = output.split("\n");
+  for (const line of lines) {
+    if (line.includes("gas price:")) {
+      // Remove ANSI color codes first
+      // eslint-disable-next-line no-control-regex
+      const cleanLine = line.replace(/\x1b\[[0-9;]*m/g, "");
+
+      // Extract the value inside quotes after 'gas price:'
+      const match = cleanLine.match(/gas price:\s*"([^"]+)"/);
+      if (match && match[1]) {
+        return match[1];
+      }
+    }
+  }
+  return null;
+}
+
+export async function generateTsAbi(
+  abiFilePath: string,
+  contractName: string,
+  contractAddress: string,
+  chainId: string,
+) {
+  const TARGET_DIR = "../nextjs/contracts/";
+  const TARGET_FILE = `${TARGET_DIR}deployedContracts.ts`;
+  const abiTxt = fs.readFileSync(abiFilePath, "utf8");
+
+  // Extract from 4th row to the end
+  const lines = abiTxt.split("\n");
+  const extractedAbi = lines.slice(3).join("\n");
+  const abiJson = JSON.parse(extractedAbi);
+
+  // Helper to generate the contract entry
+  const newContractEntry = {
+    address: contractAddress,
+    abi: abiJson,
+  };
+
+  let deployedContractsObj: any = {};
+  const fileHeader =
+    generatedContractComment +
+    'import { GenericContractsDeclaration } from "~~/utils/scaffold-eth/contract";\n\n';
+
+  if (fs.existsSync(TARGET_FILE)) {
+    // Read and parse the existing file
+    const fileContent = fs.readFileSync(TARGET_FILE, "utf8");
+    // Extract the deployedContracts object using regex
+    const match = fileContent.match(
+      /const deployedContracts = ([\s\S]*?) as const;/,
+    );
+    if (match) {
+      // eslint-disable-next-line no-eval
+      deployedContractsObj = eval("(" + match[1] + ")");
+    }
+  }
+
+  // Ensure the chainId exists
+  if (!deployedContractsObj[chainId]) {
+    deployedContractsObj[chainId] = {};
+  }
+  // Update or insert the contract entry
+  deployedContractsObj[chainId][contractName] = newContractEntry;
+
+  // Stringify the object for TypeScript output
+  const contractsString = JSON.stringify(deployedContractsObj, null, 2);
+
+  const output = `${fileHeader}const deployedContracts = ${contractsString} as const;\n\nexport default deployedContracts satisfies GenericContractsDeclaration;\n`;
+
+  if (!fs.existsSync(TARGET_DIR)) {
+    fs.mkdirSync(TARGET_DIR);
+  }
+
+  fs.writeFileSync(
+    TARGET_FILE,
+    await prettier.format(output, { parser: "typescript" }),
+  );
+
+  console.log(
+    `📝 Updated TypeScript contract definition file on ${TARGET_FILE}`,
+  );
+}
+
+export function handleSolcError(
+  error: Error,
+  context: string = "ABI export",
+): void {
+  console.error(`\n❌ ${context} failed!`);
+  console.error("\n🔍 Error details:", error.message);
+
+  // Check if the error is related to solc not being found
+  if (
+    error.message.includes("solc") ||
+    error.message.includes("solidity") ||
+    error.message.includes("command not found")
+  ) {
+    console.error(
+      "\n💡 It appears that the Solidity compiler (solc) is not installed on your system.",
+    );
+    console.error("\n📚 To install Solidity, please visit:");
+    console.error(
+      "   https://docs.soliditylang.org/en/latest/installing-solidity.html",
+    );
+    console.error(
+      "\n🚀 After installing solc, you can run this command again:",
+    );
+    console.error("   yarn export-abi");
+    console.error("\n📋 Quick installation options:");
+    console.error("   • npm: npm install --global solc");
+    console.error("   • Docker: docker run ethereum/solc:stable --help");
+    console.error("   • Homebrew (macOS): brew install solidity");
+    console.error("   • Linux: sudo apt-get install solc");
+  } else {
+    console.error("\n💡 Please check the error details above and try again.");
+  }
+}

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

@@ -0,0 +1,136 @@
+import { config as dotenvConfig } from "dotenv";
+import * as path from "path";
+import * as fs from "fs";
+import { arbitrumNitro } from "../../../nextjs/utils/scaffold-stylus/chain";
+import { DeploymentConfig, DeployOptions } from "./type";
+import { getChain, getPrivateKey } from "./network";
+import { getContractNameFromCargoToml } from "./contract";
+
+// Load environment variables from .env file
+const envPath = path.resolve(__dirname, "../../.env");
+if (fs.existsSync(envPath)) {
+  dotenvConfig({ path: envPath });
+}
+
+export function clearDeploymentDir(): void {
+  const deploymentDir = process.env["DEPLOYMENT_DIR"] || "deployments";
+  if (fs.existsSync(deploymentDir)) {
+    fs.rmSync(deploymentDir, { recursive: true });
+  }
+}
+
+export function getDeploymentConfig(
+  deployOptions: DeployOptions,
+): DeploymentConfig {
+  // If network is specified, try to get RPC URL from viem chains
+  if (!deployOptions.network) deployOptions.network = "devnet";
+
+  const chain = getChain(deployOptions.network);
+  if (!chain) throw new Error(`Network ${deployOptions.network} not found`);
+
+  let contractName: string;
+  if (deployOptions.contract) {
+    try {
+      contractName =
+        deployOptions.name ||
+        getContractNameFromCargoToml(deployOptions.contract);
+    } catch (e) {
+      throw new Error(`❌ Could not read contract name from Cargo.toml: ${e}`);
+    }
+  } else {
+    contractName = "your-contract";
+  }
+
+  return {
+    privateKey: getPrivateKey(deployOptions.network),
+    contractFolder: deployOptions.contract!,
+    contractName,
+    deploymentDir: process.env["DEPLOYMENT_DIR"] || "deployments",
+    chain,
+  };
+}
+
+export function ensureDeploymentDirectory(deploymentDir: string): void {
+  if (!fs.existsSync(deploymentDir)) {
+    console.log(`📁 Creating deployment directory: ${deploymentDir}`);
+    fs.mkdirSync(deploymentDir, { recursive: true });
+  }
+}
+
+/**
+ * Save the deployed contract address to addresses.json in the deployment directory.
+ * Updates or creates the file, using contractName as the key.
+ */
+export function saveDeployedAddress(config: DeploymentConfig) {
+  try {
+    const addressesPath = path.resolve(config.deploymentDir, "addresses.json");
+    let addresses: Record<string, any> = {};
+    if (fs.existsSync(addressesPath)) {
+      const content = fs.readFileSync(addressesPath, "utf8");
+      try {
+        addresses = JSON.parse(content);
+      } catch (e) {
+        console.warn(
+          `⚠️  Could not parse existing addresses.json, will overwrite. Error: ${e}`,
+        );
+      }
+    }
+
+    // Save both address and chain ID
+    addresses[config.contractName] = {
+      address: config.contractAddress || "",
+      chainId: (config.chain?.id || arbitrumNitro.id).toString(),
+    };
+
+    fs.writeFileSync(addressesPath, JSON.stringify(addresses, null, 2));
+    console.log(`💾 Saved deployed address and chain ID to ${addressesPath}`);
+  } catch (e) {
+    console.error(`❌ Failed to save deployed address: ${e}`);
+  }
+}
+
+export function printDeployedAddresses(deploymentDir: string): void {
+  const addressesPath = path.resolve(deploymentDir, "addresses.json");
+  if (fs.existsSync(addressesPath)) {
+    const addresses = JSON.parse(fs.readFileSync(addressesPath, "utf8"));
+    console.log(`📦 Deployed contract addresses (${addressesPath}):`);
+
+    // Format the output to show contract name, address, and chain ID clearly
+    Object.entries(addresses).forEach(([contractName, contractData]) => {
+      const data = contractData as {
+        address: string;
+        chainId: string;
+      };
+      console.log(`  ${contractName}:`);
+      console.log(`    Address: ${data.address}`);
+      console.log(`    Chain ID: ${data.chainId}`);
+    });
+  }
+}
+
+/**
+ * Reads the deployed contract data from addresses.json in the deployment directory.
+ * Returns an object with address and chainId for the given contractName, or undefined if not found.
+ */
+export function getContractDataFromDeployments(
+  deploymentDir: string,
+  contractName: string,
+): { address: string; chainId: string } | undefined {
+  const addressesPath = path.resolve(deploymentDir, "addresses.json");
+  if (fs.existsSync(addressesPath)) {
+    try {
+      const addresses = JSON.parse(fs.readFileSync(addressesPath, "utf8"));
+      if (addresses[contractName]?.address) {
+        return addresses[contractName] as {
+          address: string;
+          chainId: string;
+        };
+      }
+    } catch (e) {
+      console.warn(
+        `⚠️  Could not parse addresses.json at ${addressesPath}: ${e}`,
+      );
+    }
+  }
+  return undefined;
+}

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

@@ -0,0 +1,6 @@
+// Re-export all utilities from their respective modules for backward compatibility
+export * from "./deployment";
+export * from "./network";
+export * from "./contract";
+export * from "./command";
+export * from "./type";