create-stylus 0.0.6 → 0.1.1

package/templates/base/packages/stylus/counter/Cargo.toml

@@ -0,0 +1,46 @@
+[package]
+name = "stylus-hello-world"
+version = "0.1.11"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+homepage = "https://github.com/OffchainLabs/stylus-hello-world"
+repository = "https://github.com/OffchainLabs/stylus-hello-world"
+keywords = ["arbitrum", "ethereum", "stylus", "alloy"]
+description = "Stylus hello world example"
+
+[dependencies]
+alloy-primitives = "=0.8.20"
+alloy-sol-types = "=0.8.20"
+stylus-sdk = "0.9.0"
+hex = { version = "0.4", default-features = false }
+
+[dev-dependencies]
+alloy-primitives = { version = "=0.8.20", features = ["sha3-keccak"] }
+tokio = { version = "1.12.0", features = ["full"] }
+ethers = "2.0"
+eyre = "0.6.8"
+stylus-sdk = { version = "0.9.0", features = ["stylus-test"] }
+dotenv = "0.15.0"
+
+[features]
+default = ["mini-alloc"]
+export-abi = ["stylus-sdk/export-abi"]
+debug = ["stylus-sdk/debug"]
+mini-alloc = ["stylus-sdk/mini-alloc"]
+
+[[bin]]
+name = "stylus-hello-world"
+path = "src/main.rs"
+
+[lib]
+crate-type = ["lib", "cdylib"]
+
+[profile.release]
+codegen-units = 1
+strip = true
+lto = true
+panic = "abort"
+
+# If you need to reduce the binary size, it is advisable to try other
+# optimization levels, such as "s" and "z"
+opt-level = 3

package/templates/base/packages/stylus/counter/rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "1.87.0"

package/templates/base/packages/stylus/counter/src/lib.rs

@@ -0,0 +1,121 @@
+//!
+//! Stylus Hello World
+//!
+//! The following contract implements the Counter example from Foundry.
+//!
+//! ```solidity
+//! contract Counter {
+//!     uint256 public number;
+//!     function setNumber(uint256 newNumber) public {
+//!         number = newNumber;
+//!     }
+//!     function increment() public {
+//!         number++;
+//!     }
+//! }
+//! ```
+//!
+//! The program is ABI-equivalent with Solidity, which means you can call it from both Solidity and Rust.
+//! To do this, run `cargo stylus export-abi`.
+//!
+//! Note: this code is a template-only and has not been audited.
+//!
+// Allow `cargo stylus export-abi` to generate a main function.
+#![cfg_attr(not(any(test, feature = "export-abi")), no_main)]
+#![cfg_attr(not(any(test, feature = "export-abi")), no_std)]
+
+#[macro_use]
+extern crate alloc;
+
+use alloc::vec::Vec;
+
+/// Import items from the SDK. The prelude contains common traits and macros.
+use stylus_sdk::{alloy_primitives::U256, prelude::*};
+
+// Define some persistent storage using the Solidity ABI.
+// `Counter` will be the entrypoint.
+sol_storage! {
+    #[entrypoint]
+    pub struct Counter {
+        uint256 number;
+        bool is_initialized;
+    }
+}
+
+/// Declare that `Counter` is a contract with the following external methods.
+#[public]
+impl Counter {
+    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");
+        }
+    }
+
+    /// Gets the number from storage.
+    pub fn number(&self) -> U256 {
+        self.number.get()
+    }
+
+    /// Sets a number in storage to a user-specified value.
+    pub fn set_number(&mut self, new_number: U256) {
+        self.number.set(new_number);
+    }
+
+    /// Sets a number in storage to a user-specified value.
+    pub fn mul_number(&mut self, new_number: U256) {
+        self.number.set(new_number * self.number.get());
+    }
+
+    /// Sets a number in storage to a user-specified value.
+    pub fn add_number(&mut self, new_number: U256) {
+        self.number.set(new_number + self.number.get());
+    }
+
+    /// Increments `number` and updates its value in storage.
+    pub fn increment(&mut self) {
+        let number = self.number.get();
+        self.set_number(number + U256::from(1));
+    }
+
+    /// Adds the wei value from msg_value to the number in storage.
+    #[payable]
+    pub fn add_from_msg_value(&mut self) {
+        let number = self.number.get();
+        self.set_number(number + self.vm().msg_value());
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_counter() {
+        use stylus_sdk::testing::*;
+        let vm = TestVM::default();
+        let mut contract = Counter::from(&vm);
+
+        assert_eq!(U256::ZERO, contract.number());
+
+        contract.increment();
+        assert_eq!(U256::from(1), contract.number());
+
+        contract.add_number(U256::from(3));
+        assert_eq!(U256::from(4), contract.number());
+
+        contract.mul_number(U256::from(2));
+        assert_eq!(U256::from(8), contract.number());
+
+        contract.set_number(U256::from(100));
+        assert_eq!(U256::from(100), contract.number());
+
+        // Override the msg value for future contract method invocations.
+        vm.set_value(U256::from(2));
+
+        contract.add_from_msg_value();
+        assert_eq!(U256::from(102), contract.number());
+    }
+}

package/templates/base/packages/stylus/counter/src/main.rs

@@ -0,0 +1,10 @@
+#![cfg_attr(not(any(test, feature = "export-abi")), no_main)]
+
+#[cfg(not(any(test, feature = "export-abi")))]
+#[no_mangle]
+pub extern "C" fn main() {}
+
+#[cfg(feature = "export-abi")]
+fn main() {
+    stylus_hello_world::print_from_args();
+}

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/deploy.ts

@@ -32,7 +32,15 @@ export default async function deployScript(deployOptions: DeployOptions) {
     ...deployOptions,
   });
 
-  /// Deploy your contract with a custom name
+  // EXAMPLE: Deploy to Orbit Chains, uncomment to try
+  // await deployStylusContract({
+  //   contract: "counter",
+  //   constructorArgs: [100],
+  //   isOrbit: true,
+  //   ...deployOptions,
+  // });
+
+  // EXAMPLE: Deploy your contract with a custom name, uncomment to try
   // await deployStylusContract({
   //   contract: "your-contract",
   //   constructorArgs: [config.deployerAddress],

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

@@ -4,11 +4,17 @@ import {
   executeCommand,
   extractDeploymentInfo,
   saveDeployment,
+  ORBIT_CHAINS,
   // 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 { 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
@@ -61,6 +67,48 @@ export default async function deployStylusContract(
       config.chain?.id,
     );
 
+    // Call the initialize function if orbit deployment
+    if (
+      !!deployOptions.isOrbit &&
+      config.chain?.id !== arbitrumNitro?.id.toString()
+    ) {
+      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,
+        transport: http(),
+      });
+
+      // need wallet client to sign the transaction
+      const walletClient = createWalletClient({
+        chain: orbitChain as unknown as Chain,
+        transport: http(),
+      });
+
+      const account = privateKeyToAccount(config.privateKey as `0x${string}`);
+
+      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,
+        functionName: "initialize",
+        args: deployOptions.constructorArgs,
+      });
+
+      const initTxHash = await walletClient.writeContract(request);
+
+      console.log("Initialize transaction hash: ", initTxHash);
+    }
+
     // Step 3: Verify the contract
     if (deployOptions.verify) {
       try {

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/scripts/utils/command.ts

@@ -22,7 +22,8 @@ export async function buildDeployCommand(
 
   if (
     deployOptions.constructorArgs &&
-    deployOptions.constructorArgs.length > 0
+    deployOptions.constructorArgs.length > 0 &&
+    !deployOptions.isOrbit
   ) {
     baseCommand += ` --constructor-args ${deployOptions.constructorArgs.map((arg) => `"${arg}"`).join(" ")} `;
   }

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

@@ -154,9 +154,7 @@ export async function generateTsAbi(
   };
 
   let deployedContractsObj: any = {};
-  const fileHeader =
-    generatedContractComment +
-    'import { GenericContractsDeclaration } from "~~/utils/scaffold-eth/contract";\n\n';
+  const fileHeader = generatedContractComment + "\n\n";
 
   if (fs.existsSync(TARGET_FILE)) {
     const fileContent = fs.readFileSync(TARGET_FILE, "utf8");
@@ -177,7 +175,7 @@ export async function generateTsAbi(
 
   const contractsString = JSON.stringify(deployedContractsObj, null, 2);
 
-  const output = `${fileHeader}const deployedContracts = ${contractsString} as const;\n\nexport default deployedContracts satisfies GenericContractsDeclaration;\n`;
+  const output = `${fileHeader}const deployedContracts = ${contractsString} as const;\n\nexport default deployedContracts;\n`;
 
   if (!fs.existsSync(TARGET_DIR)) {
     fs.mkdirSync(TARGET_DIR);