create-stylus 0.0.5

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

@@ -0,0 +1,87 @@
+import * as path from "path";
+import * as fs from "fs";
+import {
+  getExportConfig,
+  ensureDeploymentDirectory,
+  executeCommand,
+  generateTsAbi,
+  handleSolcError,
+} from "./utils/";
+
+export async function exportStylusAbi(
+  contractFolder: string,
+  contractName: string,
+  isScript: boolean = true,
+  chainId?: string,
+) {
+  console.log("📄 Starting Stylus ABI export...");
+
+  const config = getExportConfig(contractFolder, contractName, chainId);
+
+  if (!config.contractAddress) {
+    console.error(
+      `❌ Contract address not found. Please deploy the contract first or ensure it is saved in a chain-specific deployment file in ${config.deploymentDir}`,
+    );
+    process.exit(1);
+  }
+
+  if (isScript) {
+    console.log(`📄 Contract name: ${config.contractName}`);
+    console.log(`📁 Deployment directory: ${config.deploymentDir}`);
+    console.log(`📍 Contract address: ${config.contractAddress}`);
+    console.log(`🔗 Chain ID: ${config.chainId}`);
+  }
+
+  try {
+    ensureDeploymentDirectory(config.deploymentDir);
+
+    // Export ABI
+    const exportCommand = `cargo stylus export-abi --output='../${config.deploymentDir}/${config.contractFolder}' --json`;
+    await executeCommand(exportCommand, contractFolder, "Exporting ABI");
+
+    console.log(
+      `📄 ABI file location: ${config.deploymentDir}/${config.contractFolder}`,
+    );
+
+    const abiFilePath = path.resolve(
+      config.deploymentDir,
+      `${config.contractFolder}`,
+    );
+    if (fs.existsSync(abiFilePath)) {
+      console.log(`✅ ABI file verified at: ${abiFilePath}`);
+    } else {
+      console.warn(
+        `⚠️  ABI file not found at expected location: ${abiFilePath}`,
+      );
+    }
+
+    // do not Generate TypeScript ABI when called from yarn script
+    if (!isScript) {
+      await generateTsAbi(
+        abiFilePath,
+        config.contractName,
+        config.contractAddress,
+        config.txHash,
+        config.chainId,
+      );
+    }
+  } catch (error) {
+    handleSolcError(error as Error);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  // Get contract folder from command line args, default to 'your-contract'
+  const contractFolder = process.argv[2] || "your-contract";
+  if (!fs.existsSync(contractFolder)) {
+    console.error(`❌ Contract folder does not exist: ${contractFolder}`);
+    process.exit(1);
+  }
+  exportStylusAbi(contractFolder, contractFolder).catch(
+    (error) => {
+      console.error("Fatal error:", error);
+      process.exit(1);
+    },
+  );
+}

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,152 @@
+import { spawn } from "child_process";
+import { DeploymentConfig, DeployOptions } from "./type";
+import { extractGasPriceFromOutput } from "./contract";
+
+export async function buildDeployCommand(
+  config: DeploymentConfig,
+  deployOptions: DeployOptions,
+) {
+  let baseCommand = `cargo stylus deploy --endpoint='${config.chain?.rpcUrl}' --private-key='${config.privateKey}'`;
+
+  if (
+    deployOptions.constructorArgs &&
+    deployOptions.constructorArgs.length > 0
+  ) {
+    baseCommand += ` --constructor-args='${deployOptions.constructorArgs.join(" ")}'`;
+  }
+
+  if (deployOptions.estimateGas) {
+    return `${baseCommand} --estimate-gas`;
+  }
+
+  if (!deployOptions.verify) {
+    baseCommand += ` --no-verify`;
+  }
+
+  if (deployOptions.maxFee) {
+    baseCommand += ` --max-fee-per-gas-gwei=${deployOptions.maxFee}`;
+  }
+
+  return baseCommand;
+}
+
+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 `;
+  if (deployOptions.constructorArgs) {
+    deployCommand += ` --constructor-args='${deployOptions.constructorArgs.join(" ")}'`;
+  }
+  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!`);
+        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,228 @@
+import * as path from "path";
+import * as fs from "fs";
+import { ethers } from "ethers";
+import toml from "toml";
+import prettier from "prettier";
+import { DeploymentData, ExportConfig } from "./type";
+import { getContractDataFromDeployments } from "./deployment";
+import { Address } from "viem";
+
+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,
+  chainId?: 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,
+    chainId,
+  );
+  if (!deploymentData) {
+    throw new Error(
+      `❌ Contract address for '${contractName}' not found in any chain-specific deployment files in ${deploymentDir}. Please deploy the contract first.`,
+    );
+  }
+
+  return {
+    contractFolder,
+    contractName,
+    deploymentDir,
+    contractAddress: deploymentData.address as Address,
+    txHash: deploymentData.txHash,
+    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 extractDeploymentInfo(output: string): DeploymentData | null {
+  let result: DeploymentData | null = null;
+  const lines = output.split("\n");
+  for (const line of lines) {
+    if (line.includes("deployed code at address:")) {
+      // Extract the hex address directly
+      const hexMatch = line.match(/(0x[a-fA-F0-9]{40})/);
+      if (hexMatch && hexMatch[1]) {
+        result = { address: hexMatch[1] as Address, txHash: "" };
+      }
+    }
+    if (line.includes("deployment tx hash:")) {
+      const txHashMatch = line.match(/(0x[a-fA-F0-9]{64})/);
+      if (txHashMatch && txHashMatch[1]) {
+        result = {
+          address: result?.address as Address,
+          txHash: txHashMatch[1],
+        };
+      }
+    }
+  }
+  return result;
+}
+
+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, "");
+
+      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,
+  txHash: 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);
+
+  const newContractEntry = {
+    address: contractAddress,
+    txHash: txHash,
+    abi: abiJson,
+  };
+
+  let deployedContractsObj: any = {};
+  const fileHeader =
+    generatedContractComment +
+    'import { GenericContractsDeclaration } from "~~/utils/scaffold-eth/contract";\n\n';
+
+  if (fs.existsSync(TARGET_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] + ")");
+    }
+  }
+
+  if (!deployedContractsObj[chainId]) {
+    deployedContractsObj[chainId] = {};
+  }
+  deployedContractsObj[chainId][contractName] = newContractEntry;
+
+  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.");
+  }
+}