create-stylus 1.1.0 → 1.1.1

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

@@ -2,8 +2,8 @@ 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 { DeploymentConfig, DeployOptions, DeploymentData } from "./type";
+import { getAccountAddress, getChain, getPrivateKey } from "./network";
 import { getContractNameFromCargoToml } from "./contract";
 
 // Load environment variables from .env file
@@ -42,6 +42,7 @@ export function getDeploymentConfig(
   }
 
   return {
+    deployerAddress: getAccountAddress(deployOptions.network),
     privateKey: getPrivateKey(deployOptions.network),
     contractFolder: deployOptions.contract!,
     contractName,
@@ -58,79 +59,202 @@ export function ensureDeploymentDirectory(deploymentDir: string): void {
 }
 
 /**
- * Save the deployed contract address to addresses.json in the deployment directory.
+ * Save the deployed contract address to <chain.id>_latest.json in the deployment directory.
+ * If a latest file already exists, it gets renamed to include a timestamp.
  * Updates or creates the file, using contractName as the key.
  */
-export function saveDeployedAddress(config: DeploymentConfig) {
+export function saveDeployment(
+  config: DeploymentConfig,
+  deploymentInfo: DeploymentData,
+) {
   try {
-    const addressesPath = path.resolve(config.deploymentDir, "addresses.json");
-    let addresses: Record<string, any> = {};
-    if (fs.existsSync(addressesPath)) {
-      const content = fs.readFileSync(addressesPath, "utf8");
+    const chainId = config.chain?.id || arbitrumNitro.id;
+    const networkPath = path.resolve(
+      config.deploymentDir,
+      `${chainId}_latest.json`,
+    );
+
+    // Check if the latest file exists and contains the same contract name
+    let shouldCreateNewFile = false;
+    if (fs.existsSync(networkPath)) {
+      try {
+        const existingDeployments = JSON.parse(
+          fs.readFileSync(networkPath, "utf8"),
+        );
+        if (existingDeployments[config.contractName]) {
+          // Contract with same name already exists, create new file
+          shouldCreateNewFile = true;
+        }
+      } catch (e) {
+        console.warn(
+          `⚠️  Could not parse existing ${chainId}_latest.json, will overwrite. Error: ${e}`,
+        );
+      }
+    }
+
+    // If we need to create a new file (contract name already exists), backup the current latest file
+    if (shouldCreateNewFile) {
+      const currentTimestamp = new Date().getTime();
+      const backupPath = networkPath.replace(
+        "_latest.json",
+        `_${currentTimestamp}.json`,
+      );
+      fs.renameSync(networkPath, backupPath);
+      console.log(`📦 Backed up previous deployment to ${backupPath}`);
+    }
+
+    // Read existing deployments or start fresh
+    let deployments: Record<string, any> = {};
+    if (fs.existsSync(networkPath)) {
+      const content = fs.readFileSync(networkPath, "utf8");
       try {
-        addresses = JSON.parse(content);
+        deployments = JSON.parse(content);
       } catch (e) {
         console.warn(
-          `⚠️  Could not parse existing addresses.json, will overwrite. Error: ${e}`,
+          `⚠️  Could not parse existing ${chainId}_latest.json, will overwrite. Error: ${e}`,
         );
       }
     }
 
-    // Save both address and chain ID
-    addresses[config.contractName] = {
-      address: config.contractAddress || "",
-      chainId: (config.chain?.id || arbitrumNitro.id).toString(),
+    // Save with the new format
+    deployments[config.contractName] = {
+      address: deploymentInfo.address,
+      txHash: deploymentInfo.txHash,
+      contract: config.contractFolder,
     };
 
-    fs.writeFileSync(addressesPath, JSON.stringify(addresses, null, 2));
-    console.log(`💾 Saved deployed address and chain ID to ${addressesPath}`);
+    fs.writeFileSync(networkPath, JSON.stringify(deployments, null, 2));
+    console.log(`💾 Saved deployed contract to ${networkPath}`);
   } catch (e) {
-    console.error(`❌ Failed to save deployed address: ${e}`);
+    console.error(`❌ Failed to save deployed contract: ${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}`);
-    });
+export function printDeployedAddresses(
+  deploymentDir: string,
+  chainId?: string,
+): void {
+  // If chainId is provided, only look for that specific chain's deployment file
+  if (chainId) {
+    const networkPath = path.resolve(deploymentDir, `${chainId}_latest.json`);
+    if (!fs.existsSync(networkPath)) {
+      console.log(
+        `📦 No deployment file found for chain ${chainId} in ${deploymentDir}`,
+      );
+      return;
+    }
+
+    try {
+      const deployments = JSON.parse(fs.readFileSync(networkPath, "utf8"));
+      console.log(
+        `📦 Deployed contracts for chain ${chainId} (${networkPath}):`,
+      );
+
+      // Format the output to show contract name, address, and contract folder clearly
+      Object.entries(deployments).forEach(([contractName, contractData]) => {
+        const data = contractData as {
+          address: string;
+          txHash: string;
+          contract: string;
+        };
+        console.log(`  ${contractName}:`);
+        console.log(`    Address: ${data.address}`);
+        console.log(`    Tx Hash: ${data.txHash}`);
+        console.log(`    Contract: ${data.contract}`);
+      });
+    } catch (e) {
+      console.warn(`⚠️  Could not parse deployment file ${networkPath}: ${e}`);
+    }
+    return;
   }
+
+  // If no chainId provided, look for all chain-specific deployment files
+  const files = fs.readdirSync(deploymentDir);
+  const deploymentFiles = files.filter((file) => file.endsWith("_latest.json"));
+
+  if (deploymentFiles.length === 0) {
+    console.log(`📦 No deployment files found in ${deploymentDir}`);
+    return;
+  }
+
+  deploymentFiles.forEach((file) => {
+    const filePath = path.resolve(deploymentDir, file);
+    const currentChainId = file.replace("_latest.json", "");
+
+    try {
+      const deployments = JSON.parse(fs.readFileSync(filePath, "utf8"));
+      console.log(
+        `📦 Deployed contracts for chain ${currentChainId} (${filePath}):`,
+      );
+
+      // Format the output to show contract name, address, and contract folder clearly
+      Object.entries(deployments).forEach(([contractName, contractData]) => {
+        const data = contractData as {
+          address: string;
+          txHash: string;
+          contract: string;
+        };
+        console.log(`  ${contractName}:`);
+        console.log(`    Address: ${data.address}`);
+        console.log(`    Contract: ${data.contract}`);
+      });
+    } catch (e) {
+      console.warn(`⚠️  Could not parse deployment file ${filePath}: ${e}`);
+    }
+  });
 }
 
 /**
- * Reads the deployed contract data from addresses.json in the deployment directory.
+ * Reads the deployed contract data from chain-specific deployment files 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)) {
+  chainId?: string,
+): { address: string; txHash: string; chainId: string } | undefined {
+  // If chainId is provided, look for that specific chain's deployment file
+  if (chainId) {
+    const networkPath = path.resolve(deploymentDir, `${chainId}_latest.json`);
+    if (fs.existsSync(networkPath)) {
+      try {
+        const deployments = JSON.parse(fs.readFileSync(networkPath, "utf8"));
+        if (deployments[contractName]?.address) {
+          return {
+            address: deployments[contractName].address,
+            txHash: deployments[contractName].txHash,
+            chainId: chainId,
+          };
+        }
+      } catch (e) {
+        console.warn(
+          `⚠️  Could not parse deployment file at ${networkPath}: ${e}`,
+        );
+      }
+    }
+    return undefined;
+  }
+
+  // If no chainId provided, search all deployment files
+  const files = fs.readdirSync(deploymentDir);
+  const deploymentFiles = files.filter((file) => file.endsWith("_latest.json"));
+
+  for (const file of deploymentFiles) {
+    const filePath = path.resolve(deploymentDir, file);
+    const currentChainId = file.replace("_latest.json", "");
     try {
-      const addresses = JSON.parse(fs.readFileSync(addressesPath, "utf8"));
-      if (addresses[contractName]?.address) {
-        return addresses[contractName] as {
-          address: string;
-          chainId: string;
+      const deployments = JSON.parse(fs.readFileSync(filePath, "utf8"));
+      if (deployments[contractName]?.address) {
+        return {
+          address: deployments[contractName].address,
+          txHash: deployments[contractName].txHash,
+          chainId: currentChainId,
         };
       }
     } catch (e) {
-      console.warn(
-        `⚠️  Could not parse addresses.json at ${addressesPath}: ${e}`,
-      );
+      console.warn(`⚠️  Could not parse deployment file at ${filePath}: ${e}`);
     }
   }
+
   return undefined;
 }

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

@@ -1,5 +1,5 @@
 import { arbitrum, arbitrumSepolia } from "viem/chains";
-import { Chain } from "viem";
+import { Address, Chain } from "viem";
 import { arbitrumNitro } from "../../../nextjs/utils/scaffold-stylus/chain";
 import * as path from "path";
 import * as fs from "fs";
@@ -25,10 +25,8 @@ export const ALIASES: Record<string, string> = {
 
 export function getChain(networkName: string): SupportedNetworkMinimal | null {
   try {
-    // Normalize network name to lowercase for case-insensitive lookup
     const actualNetworkName = ALIASES[networkName.toLowerCase()] || networkName;
 
-    // Find the chain in SUPPORTED_NETWORKS (case-insensitive)
     const chainEntry = Object.entries(SUPPORTED_NETWORKS).find(
       ([key]) => key.toLowerCase() === actualNetworkName.toLowerCase(),
     );
@@ -42,7 +40,6 @@ export function getChain(networkName: string): SupportedNetworkMinimal | null {
       };
     }
 
-    // If not found, show warning with all supported networks
     const supportedNetworks = Object.keys(SUPPORTED_NETWORKS);
     console.warn(
       `⚠️  Network '${networkName}' is not supported. Supported networks: ${supportedNetworks.join(", ")}`,
@@ -59,9 +56,17 @@ export function getPrivateKey(networkName: string): string {
 
   switch (actualNetworkName.toLowerCase()) {
     case "arbitrum":
-      return process.env["PRIVATE_KEY_MAINNET"] || "";
+      if (process.env["PRIVATE_KEY_MAINNET"]) {
+        return process.env["PRIVATE_KEY_MAINNET"];
+      } else {
+        throw new Error("PRIVATE_KEY_MAINNET is not set");
+      }
     case "arbitrumsepolia":
-      return process.env["PRIVATE_KEY_SEPOLIA"] || "";
+      if (process.env["PRIVATE_KEY_SEPOLIA"]) {
+        return process.env["PRIVATE_KEY_SEPOLIA"];
+      } else {
+        throw new Error("PRIVATE_KEY_SEPOLIA is not set");
+      }
     default:
       return (
         process.env["PRIVATE_KEY"] ||
@@ -70,6 +75,21 @@ 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;
+    case "arbitrumsepolia":
+      return process.env["ACCOUNT_ADDRESS_SEPOLIA"] as Address;
+    default:
+      return (
+        (process.env["ACCOUNT_ADDRESS"] as Address) ||
+        "0x3f1Eae7D46d88F08fc2F8ed27FCb2AB183EB2d0E"
+      );
+  }
+};
+
 function getRpcUrlFromChain(chain: Chain): string {
   //Prefer user rpc url from env
   switch (chain.id) {
@@ -109,4 +129,4 @@ function getAliasFromNetworkName(networkName: string): string {
     Object.entries(ALIASES).find(([, alias]) => alias === networkName)?.[0] ||
     networkName
   );
-}
+}

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

@@ -1,3 +1,5 @@
+import { Address } from "viem";
+
 interface BaseCommandOptions {
   _: (string | number)[];
   $0: string;
@@ -6,29 +8,29 @@ interface BaseCommandOptions {
 
 export interface DeployCommandOptions
   extends BaseCommandOptions,
-    DeployOptions {
-  all?: boolean;
-}
-
-export interface AdditionalOptions {
-  isSingleCommand?: boolean;
-  shouldClearDeploymentDir?: boolean;
-}
+    DeployOptions {}
 
 export interface DeployOptions {
   contract?: string;
   name?: string;
+  constructorArgs?: string[];
   network?: string;
   estimateGas?: boolean;
   maxFee?: string;
+  verify?: boolean;
+}
+
+export interface DeploymentData {
+  address: Address;
+  txHash: string;
 }
 
 export interface DeploymentConfig {
+  deployerAddress: Address | undefined;
   privateKey: string;
   contractFolder: string;
   contractName: string;
   deploymentDir: string;
-  contractAddress?: string;
   chain?: SupportedNetworkMinimal;
 }
 
@@ -36,7 +38,8 @@ export interface ExportConfig {
   contractFolder: string;
   contractName: string;
   deploymentDir: string;
-  contractAddress: string | undefined;
+  contractAddress: Address;
+  txHash: string;
   chainId: string;
 }
 

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

@@ -382,9 +382,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-macro"
-version = "0.8.25"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e10ae8e9a91d328ae954c22542415303919aabe976fe7a92eb06db1b68fd59f2"
+checksum = "13f28f2131dc3a7b8e2cda882758ad4d5231ca26281b9861d4b18c700713e2da"
 dependencies = [
  "alloy-sol-macro-expander",
  "alloy-sol-macro-input",
@@ -396,9 +396,9 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-macro-expander"
-version = "0.8.25"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83ad5da86c127751bc607c174d6c9fe9b85ef0889a9ca0c641735d77d4f98f26"
+checksum = "1ee2da033256a3b27131c030933eab0460a709fbcc4d4bd57bf9a5650b2441c5"
 dependencies = [
  "alloy-sol-macro-input",
  "const-hex",
@@ -414,14 +414,13 @@ dependencies = [
 
 [[package]]
 name = "alloy-sol-macro-input"
-version = "0.8.25"
+version = "0.8.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba3d30f0d3f9ba3b7686f3ff1de9ee312647aac705604417a2f40c604f409a9e"
+checksum = "4e9d9918b0abb632818bf27e2dfb86b209be8433baacf22100b190bbc0904bd4"
 dependencies = [
  "const-hex",
  "dunce",
  "heck",
- "macro-string",
  "proc-macro2",
  "quote",
  "syn 2.0.101",
@@ -2824,17 +2823,6 @@ dependencies = [
  "hashbrown 0.15.3",
 ]
 
-[[package]]
-name = "macro-string"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b27834086c65ec3f9387b096d66e99f221cf081c2b738042aa252bcd41204e3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.101",
-]
-
 [[package]]
 name = "md-5"
 version = "0.10.6"
@@ -3076,6 +3064,34 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "openzeppelin-stylus"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5bdc0165c9dd0628a88cbeb8c059b59fdb301156364c6759d838cbd4a581a2"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-macro",
+ "alloy-sol-macro-expander",
+ "alloy-sol-macro-input",
+ "alloy-sol-types",
+ "keccak-const",
+ "openzeppelin-stylus-proc",
+ "stylus-sdk",
+]
+
+[[package]]
+name = "openzeppelin-stylus-proc"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f592a114a2f3bbfb29303435064b4444ea3d9c4283b667f551a8543e8da8896f"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.101",
+]
+
 [[package]]
 name = "option-ext"
 version = "0.2.0"
@@ -5596,6 +5612,7 @@ dependencies = [
  "ethers",
  "eyre",
  "hex",
+ "openzeppelin-stylus",
  "stylus-sdk",
  "tokio",
 ]

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

@@ -13,6 +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"
 
 [dev-dependencies]
 alloy-primitives = { version = "=0.8.20", features = ["sha3-keccak"] }
@@ -24,7 +25,8 @@ dotenv = "0.15.0"
 
 [features]
 default = ["mini-alloc"]
-export-abi = ["stylus-sdk/export-abi"]
+# stylus-sdk/export-abi will be enabled automatically.
+export-abi = ["openzeppelin-stylus/export-abi"]
 debug = ["stylus-sdk/debug"]
 mini-alloc = ["stylus-sdk/mini-alloc"]
 

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

@@ -25,13 +25,25 @@ use stylus_sdk::{
     stylus_core::log,
 };
 
-/// Helper macro for require-like assertions
-macro_rules! require {
-    ($condition:expr, $message:expr) => {
-        if !$condition {
-            panic!($message);
+/// Import OpenZeppelin Ownable functionality
+use openzeppelin_stylus::access::ownable::{self, Ownable, IOwnable};
+
+/// Error types for the contract
+#[derive(SolidityError, Debug)]
+pub enum Error {
+    UnauthorizedAccount(ownable::OwnableUnauthorizedAccount),
+    InvalidOwner(ownable::OwnableInvalidOwner),
+}
+
+impl From<ownable::Error> for Error {
+    fn from(value: ownable::Error) -> Self {
+        match value {
+            ownable::Error::UnauthorizedAccount(e) => {
+                Error::UnauthorizedAccount(e)
+            }
+            ownable::Error::InvalidOwner(e) => Error::InvalidOwner(e),
         }
-    };
+    }
 }
 
 // Define the GreetingChange event
@@ -44,7 +56,7 @@ sol! {
 sol_storage! {
     #[entrypoint]
     pub struct YourContract {
-        address owner;
+        Ownable ownable;
         string greeting;
         bool premium;
         uint256 total_counter;
@@ -54,18 +66,16 @@ sol_storage! {
 
 /// Declare that `YourContract` is a contract with the following external methods.
 #[public]
+#[implements(IOwnable<Error = Error>)]
 impl YourContract {
-    /// Constructor equivalent - initializes the contract
-    pub fn init(&mut self, owner: Address) {
-        self.owner.set(owner);
+    #[constructor]
+    pub fn constructor(&mut self, initial_owner: Address) -> Result<(), Error> {
+        // Initialize Ownable with the initial owner using OpenZeppelin pattern
+        self.ownable.constructor(initial_owner)?;
         self.greeting.set_str("Building Unstoppable Apps!!!");
         self.premium.set(false);
         self.total_counter.set(U256::ZERO);
-    }
-
-    /// Gets the owner address
-    pub fn owner(&self) -> Address {
-        self.owner.get()
+        Ok(())
     }
 
     /// Gets the current greeting
@@ -119,15 +129,14 @@ impl YourContract {
 
     /// Function that allows the owner to withdraw all the Ether in the contract
     /// The function can only be called by the owner of the contract
-    pub fn withdraw(&mut self) -> Result<(), Vec<u8>> {
-        // Check if caller is owner
-        let sender: Address = self.vm().msg_sender() ;
-        let owner: Address = self.owner.get();
-        require!(sender == owner, "Not the Owner");
+    pub fn withdraw(&mut self) -> Result<(), Error> {
+        // Check if caller is owner using OpenZeppelin's only_owner
+        self.ownable.only_owner()?;
 
         // Get contract balance and transfer to owner using transfer_eth
-        let balance = self.vm().balance(sender);
+        let balance = self.vm().balance(self.vm().contract_address());
         if balance > U256::ZERO {
+            let owner = self.ownable.owner();
             let _ = self.vm().transfer_eth(owner, balance);
         }
         
@@ -142,6 +151,27 @@ impl YourContract {
     }
 }
 
+/// Implementation of the IOwnable interface
+#[public]
+impl IOwnable for YourContract {
+    type Error = Error;
+
+    fn owner(&self) -> Address {
+        self.ownable.owner()
+    }
+
+    fn transfer_ownership(
+        &mut self,
+        new_owner: Address,
+    ) -> Result<(), Self::Error> {
+        Ok(self.ownable.transfer_ownership(new_owner)?)
+    }
+
+    fn renounce_ownership(&mut self) -> Result<(), Self::Error> {
+        Ok(self.ownable.renounce_ownership()?)
+    }
+}
+
 // #[cfg(test)]
 // mod test {
 //     use super::*;