create-stylus 0.0.6-hotfix.1 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-stylus",
-  "version": "0.0.6-hotfix.1",
+  "version": "0.1.0",
   "author": "Q3 Labs",
   "license": "MIT",
   "repository": {

package/templates/base/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ss",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "private": true,
   "workspaces": {
     "packages": [
@@ -24,7 +24,7 @@
     "stylus:format": "yarn workspace @ss/stylus format",
     "stylus:test": "yarn workspace @ss/stylus test",
     "test": "yarn stylus:test",
-    "test:networks": "yarn workspace @ss/stylus test:networks",
+    "info:networks": "yarn workspace @ss/stylus info:networks",
     "format": "yarn next:format",
     "start": "yarn workspace @ss/nextjs dev",
     "next:lint": "yarn workspace @ss/nextjs lint",

package/templates/base/packages/stylus/package.json

@@ -9,10 +9,10 @@
     "dev": "tsc --watch",
     "start": "node dist/index.js",
     "deploy": "ts-node scripts/deploy_wrapper.ts",
-    "test:networks": "ts-node scripts/test_network.ts",
+    "info:networks": "ts-node scripts/test_network.ts",
     "export-abi": "ts-node scripts/export_abi.ts",
     "clean-contracts": "git clean -xdf -e .env -e your-contract/ -e node_modules/",
-    "test": "cargo test",
+    "test": "ts-node scripts/test.ts",
     "lint": "eslint scripts --ext .ts",
     "lint:fix": "eslint scripts --ext .ts --fix",
     "new-module": "bash scripts/new_module.sh"

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

@@ -0,0 +1,236 @@
+#!/usr/bin/env ts-node
+/**
+ * Stylus Cargo Test Runner
+ *
+ * This script automatically finds and runs tests for all Cargo projects
+ * in the stylus directory that have a Cargo.toml file.
+ *
+ * Features:
+ * - Automatically discovers Cargo projects by looking for Cargo.toml files
+ * - Excludes scripts, deployments, and node_modules directories
+ * - Runs `cargo test` for each project
+ * - Shows real-time output during test execution
+ * - Provides a comprehensive summary of test results
+ * - Exits with appropriate error codes for CI/CD integration
+ *
+ * Usage:
+ *   npm run test
+ *   or
+ *   ts-node scripts/test.ts
+ */
+import { spawn } from "child_process";
+import { promises as fs } from "fs";
+import * as path from "path";
+
+interface TestResult {
+  project: string;
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+/**
+ * Execute a command and return a promise with the result
+ */
+function executeCommand(
+  command: string,
+  cwd: string,
+): Promise<{ success: boolean; output: string; error?: string }> {
+  return new Promise((resolve) => {
+    console.log(`\n🔄 Running tests in ${path.basename(cwd)}...`);
+    console.log(`Executing: ${command}`);
+
+    const childProcess = spawn(command, [], {
+      cwd,
+      shell: true,
+      stdio: ["inherit", "pipe", "pipe"],
+    });
+
+    let output = "";
+    let errorOutput = "";
+
+    // Handle stdout
+    if (childProcess.stdout) {
+      childProcess.stdout.on("data", (data: Buffer) => {
+        const chunk = data.toString();
+        output += chunk;
+        process.stdout.write(chunk); // Show real-time output
+      });
+    }
+
+    // Handle stderr
+    if (childProcess.stderr) {
+      childProcess.stderr.on("data", (data: Buffer) => {
+        const chunk = data.toString();
+        errorOutput += chunk;
+        process.stderr.write(chunk); // Show real-time errors
+      });
+    }
+
+    // Handle process completion
+    childProcess.on("close", (code: number | null) => {
+      const success = code === 0;
+      if (success) {
+        console.log(
+          `✅ Tests completed successfully in ${path.basename(cwd)}!`,
+        );
+      } else {
+        console.log(
+          `❌ Tests failed in ${path.basename(cwd)} with exit code ${code}`,
+        );
+      }
+
+      resolve({
+        success,
+        output,
+        ...(errorOutput && { error: errorOutput }),
+      });
+    });
+
+    // Handle process errors
+    childProcess.on("error", (error: Error) => {
+      console.error(
+        `❌ Error running tests in ${path.basename(cwd)}:`,
+        error.message,
+      );
+      resolve({
+        success: false,
+        output: "",
+        error: error.message,
+      });
+    });
+  });
+}
+
+/**
+ * Check if a directory contains a Cargo.toml file
+ */
+async function hasCargoToml(dirPath: string): Promise<boolean> {
+  try {
+    await fs.access(path.join(dirPath, "Cargo.toml"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Find all Cargo projects in the stylus directory
+ */
+async function findCargoProjects(): Promise<string[]> {
+  const stylusDir = path.resolve(__dirname, "..");
+  const cargoProjects: string[] = [];
+
+  try {
+    const entries = await fs.readdir(stylusDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const dirName = entry.name;
+
+        // Skip excluded directories
+        if (
+          dirName === "scripts" ||
+          dirName === "deployments" ||
+          dirName === "node_modules"
+        ) {
+          continue;
+        }
+
+        const dirPath = path.join(stylusDir, dirName);
+
+        if (await hasCargoToml(dirPath)) {
+          cargoProjects.push(dirPath);
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error scanning for Cargo projects:", error);
+  }
+
+  return cargoProjects;
+}
+
+/**
+ * Run tests for all Cargo projects
+ */
+async function runAllTests(): Promise<void> {
+  console.log("🚀 Starting Stylus Cargo Tests...\n");
+
+  const cargoProjects = await findCargoProjects();
+
+  if (cargoProjects.length === 0) {
+    console.log("❗ No Cargo projects found with Cargo.toml files.");
+    process.exit(1);
+  }
+
+  console.log(`Found ${cargoProjects.length} Stylus Contract(s):`);
+  cargoProjects.forEach((project) => {
+    console.log(`  - ${path.basename(project)}`);
+  });
+  console.log("");
+
+  const results: TestResult[] = [];
+
+  // Run tests for each project
+  for (const projectPath of cargoProjects) {
+    const projectName = path.basename(projectPath);
+
+    const result = await executeCommand("cargo test", projectPath);
+
+    results.push({
+      project: projectName,
+      success: result.success,
+      output: result.output,
+      ...(result.error && { error: result.error }),
+    });
+  }
+
+  // Print summary
+  console.log("\n" + "=".repeat(60));
+  console.log("📊 TEST SUMMARY");
+  console.log("=".repeat(60));
+
+  const successful = results.filter((r) => r.success);
+  const failed = results.filter((r) => !r.success);
+
+  console.log(`✅ Successful: ${successful.length}`);
+  console.log(`❌ Failed: ${failed.length}`);
+  console.log(`📦 Total projects: ${results.length}`);
+
+  if (successful.length > 0) {
+    console.log("\n✅ Successful projects:");
+    successful.forEach((result) => {
+      console.log(`  - ${result.project}`);
+    });
+  }
+
+  if (failed.length > 0) {
+    console.log("\n❌ Failed projects:");
+    failed.forEach((result) => {
+      console.log(`  - ${result.project}`);
+      if (result.error) {
+        console.log(`    Error: ${result.error.split("\n")[0]}`);
+      }
+    });
+  }
+
+  // Exit with error code if any tests failed
+  if (failed.length > 0) {
+    console.log("\n💥 Some tests failed!");
+    process.exit(1);
+  } else {
+    console.log("\n🎉 All tests passed!");
+    process.exit(0);
+  }
+}
+
+// Main execution
+if (require.main === module) {
+  runAllTests().catch((error) => {
+    console.error("❌ Unexpected error:", error);
+    process.exit(1);
+  });
+}
+
+export { runAllTests, findCargoProjects };

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

@@ -3,13 +3,10 @@ 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 testNetworks = [...Object.keys(SUPPORTED_NETWORKS)];
+
+  testNetworks.forEach((network) => {
     const chain = getChain(network);
     if (chain) {
       console.log(`✅ ${network}: ${chain.rpcUrl}`);
@@ -17,15 +14,21 @@ function testNetworkFunctionality() {
       console.log(`❌ ${network}: Not found in viem chains`);
     }
   });
-  
+
   console.log("\n📝 Usage examples:");
-  Object.keys(SUPPORTED_NETWORKS).forEach(network => {
+  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)`);
+    console.log(
+      `  yarn deploy --network ${chain?.name}\t# Deploy to ${chain?.name}`,
+    );
+
+    // TODO: determine which one to use later, for now we use all original names
+    // console.log(
+    //   `  yarn deploy --network ${chain?.alias}\t\t# Deploy to ${chain?.name} (alias)`,
+    // );
   });
 }
 
 if (require.main === module) {
   testNetworkFunctionality();
-} 
+}

package/templates/base/packages/stylus/your-contract/Cargo.toml

@@ -13,7 +13,7 @@ alloy-primitives = "=0.8.20"
 alloy-sol-types = "=0.8.20"
 stylus-sdk = "0.9.0"
 hex = { version = "0.4", default-features = false }
-openzeppelin-stylus = "0.2.0"
+openzeppelin-stylus = "=0.2.0"
 
 [dev-dependencies]
 alloy-primitives = { version = "=0.8.20", features = ["sha3-keccak"] }

package/templates/base/packages/stylus/your-contract/rust-toolchain.toml

@@ -1,2 +1,8 @@
+# NOTE: this toolchain is nightly because of openzeppelin requirements
+
 [toolchain]
-channel = "1.87.0"
+# We should use stable here once nitro-testnode is updated and the contracts fit
+# the size limit (issue <https://github.com/OpenZeppelin/rust-contracts-stylus/issues/129>).
+channel = "1.89.0"
+components = ["rust-src", "rustfmt", "clippy"]
+targets = ["wasm32-unknown-unknown"]

package/templates/base/packages/stylus/your-contract/src/lib.rs

@@ -170,70 +170,46 @@ impl IOwnable for YourContract {
     }
 }
 
-// #[cfg(test)]
-// mod test {
-//     use super::*;
-//     use stylus_sdk::testing::*;
-
-//     #[test]
-//     fn test_your_contract() {
-//         let vm = TestVM::default();
-//         let mut contract = YourContract::from(&vm);
-
-//         // Test initialization
-//         let owner_addr = Address::from([1u8; 20]);
-//         contract.init(owner_addr);
-
-//         assert_eq!(contract.owner(), owner_addr);
-//         assert_eq!(contract.greeting(), "Building Unstoppable Apps!!!");
-//         assert_eq!(contract.premium(), false);
-//         assert_eq!(contract.total_counter(), U256::ZERO);
-
-//         // Test setting greeting without payment
-//         contract.set_greeting("Hello World".to_string());
-//         assert_eq!(contract.greeting(), "Hello World");
-//         assert_eq!(contract.premium(), false);
-//         assert_eq!(contract.total_counter(), U256::from(1));
-
-//         // Test user greeting counter
-//         let sender = vm.addr();
-//         assert_eq!(contract.user_greeting_counter(sender), U256::from(1));
-
-//         // Test setting greeting with payment
-//         vm.set_value(U256::from(100));
-//         contract.set_greeting("Premium Hello".to_string());
-//         assert_eq!(contract.greeting(), "Premium Hello");
-//         assert_eq!(contract.premium(), true);
-//         assert_eq!(contract.total_counter(), U256::from(2));
-//         assert_eq!(contract.user_greeting_counter(sender), U256::from(2));
-//     }
-
-//     #[test]
-//     fn test_withdraw() {
-//         let vm = TestVM::default();
-//         let mut contract = YourContract::from(&vm);
-
-//         // Initialize with owner
-//         let owner_addr = vm.addr(); // Use VM address as owner for testing
-//         contract.init(owner_addr);
-
-//         // Test withdraw (in real scenario, contract would have received ETH)
-//         let result = contract.withdraw();
-//         assert!(result.is_ok()); // Should not panic since caller is owner
-//     }
-
-//     #[test]
-//     fn test_withdraw_not_owner() {
-//         let vm = TestVM::default();
-//         let mut contract = YourContract::from(&vm);
-
-//         // Initialize with different owner
-//         let owner_addr = Address::from([1u8; 20]);
-//         contract.init(owner_addr);
-
-//         // This test should panic with "Not the Owner" when withdraw is called by non-owner
-//         // In a real test environment, you'd want to test this more carefully
-//         // but for now we'll just verify the function exists
-//         assert_eq!(contract.owner(), owner_addr);
-//     }
-// }
+#[cfg(test)]
+mod test {
+    use super::*;
+    use stylus_sdk::testing::*;
+
+    #[no_mangle]
+    pub unsafe extern "C" fn emit_log(_pointer: *const u8, _len: usize, _: usize) {}
+    #[no_mangle]
+    pub unsafe extern "C" fn msg_sender(_sender: *mut u8) {}
+
+    #[test]
+    fn test_your_contract() {
+        let vm = TestVM::default();
+        let mut contract = YourContract::from(&vm);
+
+        // Test initialization
+        let owner_addr = Address::from([1u8; 20]);
+        let _ = contract.constructor(owner_addr);
+
+        assert_eq!(contract.owner(), owner_addr);
+        assert_eq!(contract.greeting(), "Building Unstoppable Apps!!!");
+        assert_eq!(contract.premium(), false);
+        assert_eq!(contract.total_counter(), U256::ZERO);
+
+        // Test setting greeting without payment
+        contract.set_greeting("Hello World".to_string());
+        assert_eq!(contract.greeting(), "Hello World");
+        assert_eq!(contract.premium(), false);
+        assert_eq!(contract.total_counter(), U256::from(1));
+
+        // Test user greeting counter
+        let sender = vm.msg_sender();
+        assert_eq!(contract.user_greeting_counter(sender), U256::from(1));
+
+        // Test setting greeting with payment
+        vm.set_value(U256::from(100));
+        contract.set_greeting("Premium Hello".to_string());
+        assert_eq!(contract.greeting(), "Premium Hello");
+        assert_eq!(contract.premium(), true);
+        assert_eq!(contract.total_counter(), U256::from(2));
+        assert_eq!(contract.user_greeting_counter(sender), U256::from(2));
+    }
+}

package/templates/base/readme.md

@@ -189,7 +189,7 @@ To deploy your contracts to other networks (other than the default local Nitro d
 This template supports Arbitrum networks only. You can test which networks are available and their RPC URLs:
 
 ```bash
-yarn test:networks
+yarn info:networks
 ```
 
 This will show you all supported networks and their corresponding RPC endpoints.