create-stylus 0.0.5

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

@@ -0,0 +1,260 @@
+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, DeploymentData } from "./type";
+import { getAccountAddress, 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 {
+    deployerAddress: getAccountAddress(deployOptions.network),
+    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 <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 saveDeployment(
+  config: DeploymentConfig,
+  deploymentInfo: DeploymentData,
+) {
+  try {
+    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 {
+        deployments = JSON.parse(content);
+      } catch (e) {
+        console.warn(
+          `⚠️  Could not parse existing ${chainId}_latest.json, will overwrite. Error: ${e}`,
+        );
+      }
+    }
+
+    // Save with the new format
+    deployments[config.contractName] = {
+      address: deploymentInfo.address,
+      txHash: deploymentInfo.txHash,
+      contract: config.contractFolder,
+    };
+
+    fs.writeFileSync(networkPath, JSON.stringify(deployments, null, 2));
+    console.log(`💾 Saved deployed contract to ${networkPath}`);
+  } catch (e) {
+    console.error(`❌ Failed to save deployed contract: ${e}`);
+  }
+}
+
+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 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,
+  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 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 deployment file at ${filePath}: ${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";

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

@@ -0,0 +1,132 @@
+import { arbitrum, arbitrumSepolia } from "viem/chains";
+import { Address, Chain } from "viem";
+import { arbitrumNitro } from "../../../nextjs/utils/scaffold-stylus/chain";
+import * as path from "path";
+import * as fs from "fs";
+import { config as dotenvConfig } from "dotenv";
+import { SupportedNetworkMinimal } from "./type";
+
+const envPath = path.resolve(__dirname, "../../.env");
+if (fs.existsSync(envPath)) {
+  dotenvConfig({ path: envPath });
+}
+
+export const SUPPORTED_NETWORKS: Record<string, Chain> = {
+  arbitrum,
+  arbitrumSepolia,
+  arbitrumNitro: arbitrumNitro as Chain,
+};
+
+export const ALIASES: Record<string, string> = {
+  mainnet: "arbitrum",
+  sepolia: "arbitrumSepolia",
+  devnet: "arbitrumNitro",
+};
+
+export function getChain(networkName: string): SupportedNetworkMinimal | null {
+  try {
+    const actualNetworkName = ALIASES[networkName.toLowerCase()] || networkName;
+
+    const chainEntry = Object.entries(SUPPORTED_NETWORKS).find(
+      ([key]) => key.toLowerCase() === actualNetworkName.toLowerCase(),
+    );
+
+    if (chainEntry) {
+      return {
+        name: chainEntry[0],
+        alias: getAliasFromNetworkName(chainEntry[0]),
+        id: chainEntry[1].id.toString(),
+        rpcUrl: getRpcUrlFromChain(chainEntry[1]),
+      };
+    }
+
+    const supportedNetworks = Object.keys(SUPPORTED_NETWORKS);
+    console.warn(
+      `⚠️  Network '${networkName}' is not supported. Supported networks: ${supportedNetworks.join(", ")}`,
+    );
+    return null;
+  } catch (error) {
+    console.error(`Error getting chain for network ${networkName}:`, error);
+    return null;
+  }
+}
+
+export function getPrivateKey(networkName: string): string {
+  const actualNetworkName = ALIASES[networkName.toLowerCase()] || networkName;
+
+  switch (actualNetworkName.toLowerCase()) {
+    case "arbitrum":
+      if (process.env["PRIVATE_KEY_MAINNET"]) {
+        return process.env["PRIVATE_KEY_MAINNET"];
+      } else {
+        throw new Error("PRIVATE_KEY_MAINNET is not set");
+      }
+    case "arbitrumsepolia":
+      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"] ||
+        "0xb6b15c8cb491557369f3c7d2c287b053eb229daa9c22138887752191c9520659"
+      );
+  }
+}
+
+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) {
+    case arbitrum.id:
+      if (process.env["RPC_URL_MAINNET"]) {
+        return process.env["RPC_URL_MAINNET"];
+      }
+      break;
+    case arbitrumSepolia.id:
+      if (process.env["RPC_URL_SEPOLIA"]) {
+        return process.env["RPC_URL_SEPOLIA"];
+      }
+      break;
+    default:
+      if (process.env["RPC_URL"]) {
+        return process.env["RPC_URL"];
+      }
+  }
+
+  if (chain.rpcUrls?.default?.http && chain.rpcUrls.default.http.length > 0) {
+    return chain.rpcUrls.default.http[0]!;
+  }
+
+  if (
+    "public" in chain.rpcUrls &&
+    chain.rpcUrls.public?.http &&
+    chain.rpcUrls.public.http.length > 0
+  ) {
+    return chain.rpcUrls.public.http[0]!;
+  }
+
+  throw new Error(`No RPC URL found for chain ${chain.name}`);
+}
+
+function getAliasFromNetworkName(networkName: string): string {
+  return (
+    Object.entries(ALIASES).find(([, alias]) => alias === networkName)?.[0] ||
+    networkName
+  );
+}

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

@@ -0,0 +1,51 @@
+import { Address } from "viem";
+
+interface BaseCommandOptions {
+  _: (string | number)[];
+  $0: string;
+  [x: string]: unknown;
+}
+
+export interface DeployCommandOptions
+  extends BaseCommandOptions,
+    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;
+  chain?: SupportedNetworkMinimal;
+}
+
+export interface ExportConfig {
+  contractFolder: string;
+  contractName: string;
+  deploymentDir: string;
+  contractAddress: Address;
+  txHash: string;
+  chainId: string;
+}
+
+export interface SupportedNetworkMinimal {
+  name: string;
+  alias: string;
+  id: string;
+  rpcUrl: string;
+}

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

@@ -0,0 +1,3 @@
+// This file is now a re-export for backward compatibility
+// All utilities have been moved to the utils/ folder for better organization
+export * from "./utils";

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

@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "types": ["node"],
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "removeComments": false,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["scripts/*"]
+    }
+  },
+  "include": [
+    "scripts/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.spec.ts"
+  ]
+} 

package/templates/base/packages/stylus/your-contract/.cargo/config.toml

@@ -0,0 +1,18 @@
+[target.wasm32-unknown-unknown]
+rustflags = [
+  "-C", "link-arg=-zstack-size=32768",
+  "-C", "target-feature=-reference-types",
+  "-C", "target-feature=+bulk-memory",
+]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+"-C", "link-arg=-undefined",
+"-C", "link-arg=dynamic_lookup",
+]
+
+[target.x86_64-apple-darwin]
+rustflags = [
+"-C", "link-arg=-undefined",
+"-C", "link-arg=dynamic_lookup",
+]