@diamondslab/diamonds 1.0.0

package/examples/Diamond_Config_and_Deployment_examples/diamonds/ProxyDiamond/callbacks/ERC20ProxyFacet.ts

@@ -0,0 +1,31 @@
+import { ExampleDiamond } from "../../../typechain-types";
+import "@nomicfoundation/hardhat-ethers";
+import {
+  CallbackArgs,
+} from "diamonds";
+import hre from "hardhat";
+
+export async function createXMPLToken(CallbackArgs: CallbackArgs) {
+  const { diamond } = CallbackArgs;
+
+  const networkName = diamond.networkName;
+  const chainID = diamond.chainId;
+  const deployInfo = diamond.getDeployedDiamondData();
+
+  console.log(`In ERC20ProxyFacet after Deploy function, chainID: ${chainID}`);
+  console.log(`Network name: ${networkName}`);
+  // Get the GeniusDiamond instance
+  const diamondName = diamond.diamondName;
+  const diamondAddress = deployInfo.DiamondAddress!;
+  const deployer = diamond.signer!;
+  const diamondArtifactName = `hardhat-diamond-abi/HardhatDiamondABI.sol:${diamondName}`;
+  const diamondArtifact = hre.artifacts.readArtifactSync(diamondArtifactName);
+  const diamondContract = new hre.ethers.Contract(diamondAddress, diamondArtifact.abi, diamond.provider) as ProxyDiamond;
+  const deployerDiamondContract = diamondContract.connect(deployer);
+  await deployerDiamondContract.initializeERC20Proxy(
+    diamondAddress,
+    chainID,
+    "ExampleToken",
+    "XMPL"
+  );
+};

package/examples/Diamond_Config_and_Deployment_examples/diamonds/ProxyDiamond/proxydiamond.config.json

@@ -0,0 +1,27 @@
+{
+  "protocolVersion": 0.0,
+  "facets": {
+    "DiamondCutFacet": {
+      "priority": 10,
+      "versions": {
+        "0.0": {}
+      }
+    },
+    "DiamondLoupeFacet": {
+      "priority": 20,
+      "versions": {
+        "0.0": {}
+      }
+    },
+    "ERC20ProxyFacet": {
+      "priority": 40,
+      "versions": {
+        "0.0": {
+          "callbacks": [
+            "createXMPLToken"
+          ]
+        }
+      }
+    }
+  }
+}

package/examples/Local_Hardhat_Deployer_Script_example/LocalDiamondDeployer.ts

@@ -0,0 +1,180 @@
+import {
+  Diamond,
+  DiamondDeployer,
+  DeploymentManager,
+  LocalDeploymentStrategy,
+  FileDeploymentRepository,
+  DeploymentRepository,
+  impersonateSigner,
+  setEtherBalance,
+  DiamondConfig,
+  DiamondPathsConfig,
+  cutKey,
+  impersonateAndFundSigner
+} from 'diamonds';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { Signer, ethers } from 'ethers';
+import hre from 'hardhat';
+import "@nomicfoundation/hardhat-ethers";
+import { SignerWithAddress } from '@nomicfoundation/hardhat-ethers/signers';
+import { join } from 'path';
+import 'hardhat-diamonds';
+import { HardhatEthersProvider } from '@nomicfoundation/hardhat-ethers/internal/hardhat-ethers-provider';
+
+export interface LocalDiamondDeployerConfig extends DiamondConfig {
+  provider?: JsonRpcProvider | HardhatEthersProvider;
+  signer?: SignerWithAddress;
+  localDiamondDeployerKey?: string;
+}
+
+export class LocalDiamondDeployer {
+  private static instances: Map<string, LocalDiamondDeployer> = new Map();
+  private deployInProgress: boolean = false;
+  private deployComplete: boolean = false;
+  private diamond: Diamond | undefined;
+  private verbose: boolean = true;
+  private config: LocalDiamondDeployerConfig;
+  private provider: JsonRpcProvider | HardhatEthersProvider;
+  private signer: SignerWithAddress;
+  private diamondName: string;
+  private networkName: string = 'hardhat';
+  private chainId: bigint | number = 31337;
+  private repository: DeploymentRepository;
+
+  constructor(config: LocalDiamondDeployerConfig, repository: DeploymentRepository) {
+    this.config = config as DiamondConfig;
+    this.diamondName = config.diamondName;
+    this.provider = config.provider || hre.ethers.provider;
+    if (!config.networkName) {
+      // TODO account for "unknown" as hardhat 
+      config.networkName = (this.provider as JsonRpcProvider)._network.name;
+    } else {
+      this.networkName = config.networkName;
+    }
+    if (!config.chainId) {
+      config.chainId = (this.provider as JsonRpcProvider)._network.chainId;
+    } else {
+      this.chainId = config.chainId;
+    }
+    this.signer = config.signer!;
+    // this.config.signer = this.signer;
+    this.repository = repository!;
+
+    // TODO make provider signer and repository optional (this may be handled in diamond constructor already)
+    this.diamond = new Diamond(this.config, repository);
+    this.diamond.setProvider(this.provider);
+    this.diamond.setSigner(this.signer);
+  }
+
+  public static async getInstance(config: LocalDiamondDeployerConfig): Promise<LocalDiamondDeployer> {
+    if (!config.provider) {
+      config.provider = hre.ethers.provider;
+    } else {
+      hre.ethers.provider = config.provider as any;
+    }
+    if (!config.networkName) {
+      const networkName = (await config.provider?.getNetwork()).name || 'hardhat';
+      config.networkName = networkName === 'unknown' ? 'hardhat' : networkName;
+    }
+    if (!config.chainId) {
+      config.chainId = (await config.provider.getNetwork()).chainId || 31337;
+    }
+
+    const key = config.localDiamondDeployerKey || await (cutKey(
+      config.diamondName,
+      config.networkName,
+      (config.chainId ?? 31337).toString()
+    ));
+
+    if (!this.instances.has(key)) {
+      const hardhatDiamonds: DiamondPathsConfig = hre.diamonds?.getDiamondConfig(config.diamondName);
+      const deployedDiamondDataFileName = `${config.diamondName.toLowerCase()}-${config.networkName.toLowerCase()}-${config.chainId.toString()}.json`;
+      const defaultDeployedDiamondDataFilePath = join(
+        'diamonds',
+        config.diamondName,
+        'deployments',
+        deployedDiamondDataFileName
+      );
+      const defaultConfigFilePath = join(
+        'diamonds',
+        config.diamondName,
+        `${config.diamondName.toLowerCase()}.config.json`
+      );
+
+      config.deploymentsPath = config.deploymentsPath || hardhatDiamonds?.deploymentsPath
+        || 'diamonds';
+      config.contractsPath = hardhatDiamonds?.contractsPath || 'contracts';
+      config.callbacksPath = hardhatDiamonds?.callbacksPath
+        || join('diamonds', config.diamondName, 'callbacks');
+      config.deployedDiamondDataFilePath = config.deployedDiamondDataFilePath
+        || hardhatDiamonds?.deployedDiamondDataFilePath
+        || defaultDeployedDiamondDataFilePath;
+      config.configFilePath = config.configFilePath
+        || hardhatDiamonds?.configFilePath
+        || defaultConfigFilePath;
+
+      const repository = new FileDeploymentRepository(config);
+      repository.setWriteDeployedDiamondData(config.writeDeployedDiamondData || hardhatDiamonds?.writeDeployedDiamondData || false);
+      const deployedDiamondData = repository.loadDeployedDiamondData();
+
+      const [signer0] = await hre.ethers.getSigners();
+      // ethers.provider = config.provider;
+      if (!deployedDiamondData.DeployerAddress) {
+        config.signer = signer0;
+      } else {
+        config.signer = await hre.ethers.getSigner(deployedDiamondData.DeployerAddress);
+        await impersonateAndFundSigner(deployedDiamondData.DeployerAddress, config.provider as any);
+      }
+
+      const instance = new LocalDiamondDeployer(config, repository);
+      this.instances.set(key, instance);
+    }
+    return this.instances.get(key)!;
+  }
+
+  public async deployDiamond(): Promise<Diamond> {
+    const chainId = (await this.provider.getNetwork()).chainId || 31337;
+    const key = cutKey(this.diamondName, this.networkName, chainId.toString());
+    if (this.deployComplete) {
+      console.log(`Deployment already completed for ${this.diamondName} on ${this.networkName}-${chainId.toString()}`);
+      return Promise.resolve(this.diamond!);
+    }
+    else if (this.deployInProgress) {
+      console.log(`Deployment already in progress for ${this.networkName}`);
+      // Wait for the deployment to complete
+      while (this.deployInProgress) {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+      }
+      return Promise.resolve(this.diamond!);
+    }
+
+    this.deployInProgress = true;
+
+    // Make Deployment Strategy configurable.
+    const strategy = new LocalDeploymentStrategy(this.verbose);
+    const deployer = new DiamondDeployer(this.diamond!, strategy);
+
+    await deployer.deployDiamond();
+
+    this.deployComplete = true;
+    this.deployInProgress = false;
+
+    return deployer.getDiamond();
+  }
+
+  public async getDiamondDeployed(): Promise<Diamond> {
+    if (this.deployComplete && this.diamond) {
+      return this.diamond;
+    }
+    const diamond = await this.deployDiamond();
+    return diamond;
+  }
+
+  public async getDiamond(): Promise<Diamond> {
+    return this.diamond!;
+  }
+
+  public async setVerbose(useVerboseLogging: boolean): Promise<void> {
+    this.verbose = useVerboseLogging;
+  }
+}

package/examples/OZ_Defender_Deployer_Script_example/OZDiamondDeployer.ts

@@ -0,0 +1,107 @@
+import {
+  Diamond,
+  DiamondDeployer,
+  FileDeploymentRepository,
+  DeploymentRepository,
+  DiamondConfig,
+  cutKey
+} from 'diamonds';
+
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { ethers } from 'hardhat';
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
+import { OZDefenderDeploymentStrategy } from 'diamonds'; // Adjust based on your export path
+import { join } from 'path';
+
+export interface OZDiamondDeployerConfig extends DiamondConfig {
+  provider?: JsonRpcProvider;
+  signer?: SignerWithAddress;
+  ozDiamondDeployerKey?: string;
+}
+
+export class OZDiamondDeployer {
+  private static instances: Map<string, OZDiamondDeployer> = new Map();
+  private deployInProgress = false;
+  private deployComplete = false;
+  private config: OZDiamondDeployerConfig;
+  private diamond: Diamond;
+  private provider: JsonRpcProvider;
+  private signer: SignerWithAddress;
+  private repository: DeploymentRepository;
+
+  constructor(config: OZDiamondDeployerConfig, repository: DeploymentRepository) {
+    this.config = config;
+    this.provider = config.provider || ethers.provider;
+    this.signer = config.signer!;
+    this.repository = repository;
+
+    this.diamond = new Diamond(config, repository);
+    this.diamond.setProvider(this.provider);
+    this.diamond.setSigner(this.signer);
+  }
+
+  public static async getInstance(config: OZDiamondDeployerConfig): Promise<OZDiamondDeployer> {
+    config.provider = config.provider || ethers.provider;
+
+    const net = await config.provider.getNetwork();
+    config.networkName = config.networkName || (net.name === 'unknown' ? 'hardhat' : net.name);
+    config.chainId = config.chainId || net.chainId;
+
+    const key = config.ozDiamondDeployerKey || await cutKey(config.diamondName, config.networkName, config.chainId.toString());
+
+    if (!this.instances.has(key)) {
+      const defaultPaths = {
+        deploymentsPath: 'diamonds',
+        contractsPath: 'contracts',
+        callbacksPath: join('diamonds', config.diamondName, 'callbacks'),
+        deployedDiamondDataFilePath: join('diamonds', config.diamondName, 'deployments', `${config.diamondName.toLowerCase()}-${config.networkName.toLowerCase()}-${config.chainId}.json`),
+        configFilePath: join('diamonds', config.diamondName, `${config.diamondName.toLowerCase()}.config.json`)
+      };
+
+      config.deploymentsPath ||= defaultPaths.deploymentsPath;
+      config.contractsPath ||= defaultPaths.contractsPath;
+      config.callbacksPath ||= defaultPaths.callbacksPath;
+      config.deployedDiamondDataFilePath ||= defaultPaths.deployedDiamondDataFilePath;
+      config.configFilePath ||= defaultPaths.configFilePath;
+
+      const repository = new FileDeploymentRepository(config);
+      const [signer0] = await ethers.getSigners();
+      config.signer = signer0;
+
+      const instance = new OZDiamondDeployer(config, repository);
+      this.instances.set(key, instance);
+    }
+
+    return this.instances.get(key)!;
+  }
+
+  public async deployDiamond(): Promise<Diamond> {
+    if (this.deployComplete) return this.diamond;
+    if (this.deployInProgress) {
+      console.log(`Deployment already in progress. Waiting...`);
+      while (this.deployInProgress) await new Promise(res => setTimeout(res, 1000));
+      return this.diamond;
+    }
+
+    this.deployInProgress = true;
+    const strategy = new OZDefenderDeploymentStrategy(
+      process.env.DEFENDER_API_KEY!,
+      process.env.DEFENDER_API_SECRET!,
+      process.env.DEFENDER_RELAYER_ADDRESS!, // required
+      true, // auto-approve
+      process.env.DEFENDER_SAFE_ADDRESS!,
+      'Safe' // TODO this should be configurable.
+    );
+
+    const deployer = new DiamondDeployer(this.diamond, strategy);
+    await deployer.deployDiamond();
+
+    this.deployComplete = true;
+    this.deployInProgress = false;
+    return deployer.getDiamond();
+  }
+
+  public async getDiamond(): Promise<Diamond> {
+    return this.diamond;
+  }
+}

package/examples/OZ_Defender_Deployer_Script_example/run-oz-deploy.ts

@@ -0,0 +1,17 @@
+import { OZDiamondDeployer } from './OZDiamondDeployer';
+import { config } from 'dotenv';
+config();
+
+async function main() {
+  const deployer = await OZDiamondDeployer.getInstance({
+    diamondName: 'GeniusDiamond'
+  });
+
+  const diamond = await deployer.deployDiamond();
+  console.log(`🚀 Deployed Diamond at: ${diamond.getDeployedDiamondData().DiamondAddress}`);
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/examples/Test_examples/ProxyDiamondDeployment.test.ts

@@ -0,0 +1,202 @@
+import { debug } from 'debug';
+import { pathExistsSync } from "fs-extra";
+import { expect, assert } from 'chai';
+import { ethers } from 'hardhat';
+import hre from 'hardhat';
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
+import { JsonRpcProvider } from '@ethersproject/providers';
+import { multichain } from 'hardhat-multichain';
+import { getInterfaceID } from '../../scripts/utils/helpers';
+import { LocalDiamondDeployer, LocalDiamondDeployerConfig } from '../../scripts/setup/LocalDiamondDeployer';
+import { Diamond, deleteDeployInfo } from 'diamonds';
+import {
+  ProxyDiamond,
+  IERC20Upgradeable__factory,
+  IDiamondCut__factory,
+  IDiamondLoupe__factory
+} from '../../typechain-types/';
+
+describe('🧪 Multichain Fork and Diamond Deployment Tests', async function () {
+  const diamondName = 'ProxyDiamond';
+  const log: debug.Debugger = debug('GNUSDeploy:log:${diamondName}');
+  this.timeout(0); // Extended indefinitely for diamond deployment time
+
+  let networkProviders = multichain.getProviders() || new Map<string, JsonRpcProvider>();
+
+  if (process.argv.includes('test-multichain')) {
+    const networkNames = process.argv[process.argv.indexOf('--chains') + 1].split(',');
+    if (networkNames.includes('hardhat')) {
+      networkProviders.set('hardhat', ethers.provider);
+    }
+  } else if (process.argv.includes('test') || process.argv.includes('coverage')) {
+    networkProviders.set('hardhat', ethers.provider);
+  }
+
+  for (const [networkName, provider] of networkProviders.entries()) {
+    describe(`🔗 Chain: ${networkName} 🔷 Diamond: ${diamondName}`, function () {
+      let diamond: Diamond;
+      let signers: SignerWithAddress[];
+      let signer0: string;
+      let signer1: string;
+      let signer2: string;
+      let owner: string;
+      let ownerSigner: SignerWithAddress;
+      let proxyDiamond: ProxyDiamond;
+      let signer0Diamond: ProxyDiamond;
+      let signer1Diamond: ProxyDiamond;
+      let signer2Diamond: ProxyDiamond;
+      let ownerDiamond: ProxyDiamond;
+
+      let ethersMultichain: typeof ethers;
+      let snapshotId: string;
+
+      before(async function () {
+        const config = {
+          diamondName: diamondName,
+          networkName: networkName,
+          provider: provider,
+          // chainId: (await provider.getNetwork()).chainId,
+          // writeDeployedDiamondData: false,
+          // configFilePath: `diamonds/GeniusDiamond/proxydiamond.config.json`,
+        } as LocalDiamondDeployerConfig;
+        const diamondDeployer = await LocalDiamondDeployer.getInstance(config);
+        diamond = await diamondDeployer.getDiamondDeployed();
+        const deployInfo = diamond.getDeployedDiamondData();
+
+        const hardhatDiamondAbiPath = 'hardhat-diamond-abi/HardhatDiamondABI.sol:';
+        const diamondArtifactName = `${hardhatDiamondAbiPath}${diamond.diamondName}`;
+        proxyDiamond = await ethers.getContractAt(diamondArtifactName, deployInfo.DiamondAddress!) as ProxyDiamond;
+
+        ethersMultichain = ethers;
+        ethersMultichain.provider = provider;
+
+        // Retrieve the signers for the chain
+        signers = await ethersMultichain.getSigners();
+        signer0 = signers[0].address;
+        signer1 = signers[1].address;
+        signer2 = signers[2].address;
+        signer0Diamond = proxyDiamond.connect(signers[0]);
+        signer1Diamond = proxyDiamond.connect(signers[1]);
+        signer2Diamond = proxyDiamond.connect(signers[2]);
+
+        // get the signer for the owner
+        owner = deployInfo.DeployerAddress;  //  this will be = signer0 for hardhat;
+        ownerSigner = await ethersMultichain.getSigner(owner);
+        ownerDiamond = proxyDiamond.connect(ownerSigner);
+      });
+
+      beforeEach(async function () {
+        snapshotId = await provider.send('evm_snapshot', []);
+      });
+
+      afterEach(async () => {
+        await provider.send('evm_revert', [snapshotId]);
+      });
+
+      it(`should ensure that ${networkName} chain object can be retrieved and reused`, async function () {
+
+        expect(provider).to.not.be.undefined;
+        // expect(diamond).to.not.be.null;
+
+        const { chainId } = await provider.getNetwork();
+        expect(chainId).to.be.a('number');
+      });
+
+      it(`should verify that ${networkName} diamond is deployed and we can get hardhat signers on ${networkName}`, async function () {
+
+        expect(signers).to.be.an('array');
+        expect(signers).to.have.lengthOf(20);
+        expect(signers[0]).to.be.instanceOf(SignerWithAddress);
+
+        expect(owner).to.not.be.undefined;
+        expect(owner).to.be.a('string');
+        // expect(owner).to.be.properAddress;
+        expect(ownerSigner).to.be.instanceOf(SignerWithAddress);
+      });
+
+      it(`should verify that ${networkName} providers are defined and have valid block numbers`, async function () {
+        log(`Checking chain provider for: ${networkName}`);
+        expect(provider).to.not.be.undefined;
+
+        const blockNumber = await ethersMultichain.provider.getBlockNumber();
+        log(`Block number for ${networkName}: ${blockNumber}`);
+
+        expect(blockNumber).to.be.a('number');
+        // Fails for hardhat because it defaults to 0.
+        if (networkName !== 'hardhat') {
+          expect(blockNumber).to.be.greaterThan(0);
+        }
+
+        // This isn't a perfect check, because it is trying to place the current block in 
+        // a range relative to the configured block number used for caching.
+        // The default of zero is to account for hardhat chain.  It also possible that no 
+        // block number is configured in the hardhat.config.js file which will always fetch
+        // the latest block number. This will also cause it to fail.
+        const configBlockNumber = hre.config.chainManager?.chains?.[networkName]?.blockNumber ?? 0;
+        expect(blockNumber).to.be.gte(configBlockNumber);
+
+        expect(blockNumber).to.be.lte(configBlockNumber + 500);
+      });
+
+      // it(`should verify ERC173 contract ownership on ${networkName}`, async function () {
+      //   // check if the owner is the deployer and transfer ownership to the deployer
+      //   const currentContractOwner = await ownerDiamond.owner();
+      //   expect(currentContractOwner.toLowerCase()).to.be.eq(await owner.toLowerCase());
+      // });
+
+      it(`should validate ERC165 interface compatibility on ${networkName}`, async function () {
+        // Test ERC165 interface compatibility
+        const supportsERC165 = await proxyDiamond.supportsInterface('0x01ffc9a7');
+        expect(supportsERC165).to.be.true;
+
+        log(`Diamond deployed and validated on ${networkName}`);
+      });
+
+      it(`should validate IDiamondCut interface compatibility on ${networkName}`, async function () {
+        // Test ERC165 interface compatibility
+        const iDiamonCutInterface = IDiamondCut__factory.createInterface();
+        // Generate the IDiamondCut interface ID by XORing with the base interface ID.
+        const iDiamondCutInterfaceID = getInterfaceID(iDiamonCutInterface);
+        // const supportsIDiamondCut = await proxyDiamond.supportsInterface('0x1f931c1c');
+        const supportsERC165 = await proxyDiamond.supportsInterface(iDiamondCutInterfaceID._hex);
+        expect(supportsERC165).to.be.true;
+
+        log(`DiamondCut Facet interface support validated on ${networkName}`);
+      });
+
+      it(`should validate IDiamondLoupe interface compatibility on ${networkName}`, async function () {
+        // Test ERC165 interface compatibility
+        const iDiamondLoupeInterface = IDiamondLoupe__factory.createInterface();
+        // Generate the IDiamondLoupe interface ID by XORing with the base interface ID.
+        const iDiamondLoupeInterfaceID = getInterfaceID(iDiamondLoupeInterface);
+        // const supportsIDiamondLoupe = await proxyDiamond.supportsInterface('0x48e3885f');
+        const supportsERC165 = await proxyDiamond.supportsInterface(iDiamondLoupeInterfaceID._hex);
+        expect(supportsERC165).to.be.true;
+        log(`DiamondLoupe Facet interface support validated on ${networkName}`);
+      });
+
+      it(`should verify ERC165 supported interface for ERC20 on ${networkName}`, async function () {
+        log(`Validating ERC20 interface on chain: ${networkName}`);
+        const IERC20UpgradeableInterface = IERC20Upgradeable__factory.createInterface();
+        // Generate the ERC20 interface ID by XORing with the base interface ID.
+        const IERC20InterfaceID = getInterfaceID(IERC20UpgradeableInterface);
+        // Assert that the `diamond` contract supports the ERC20 interface.
+        // assert(
+        //   await proxyDiamond?.supportsInterface(IERC20InterfaceID._hex),
+        //   "Doesn't support IERC20Upgradeable",
+        // );
+
+        // Test ERC165 interface compatibility for ERC20 '0x37c8e2a0'
+        // const supportsERC20 = await proxyDiamond?.supportsInterface(IERC20InterfaceID._hex);
+
+        // Test ERC165 interface compatibility for ERC20Upgradeable '0x36372b07'
+        const supportsERC20 = await proxyDiamond?.supportsInterface('0x36372b07');
+
+        expect(supportsERC20).to.be.true;
+
+        log(`ERC20 interface validated on ${networkName}`);
+      });
+    });
+  }
+});
+

package/examples/defender-deployment/.env.example

@@ -0,0 +1,35 @@
+# OpenZeppelin Defender Configuration
+# Get these from your Defender dashboard: https://defender.openzeppelin.com/
+DEFENDER_API_KEY=your_defender_api_key_here
+DEFENDER_API_SECRET=your_defender_api_secret_here
+
+# Defender Relayer Configuration
+# The address of your Defender Relayer (optional for deployment, required for automation)
+DEFENDER_RELAYER_ADDRESS=0x1234567890123456789012345678901234567890
+
+# Multi-signature Safe Configuration
+# Address of your Gnosis Safe or similar multi-sig wallet
+DEFENDER_SAFE_ADDRESS=0x0987654321098765432109876543210987654321
+
+# Deployment Configuration
+# Enable automatic approval of Defender proposals (use with caution)
+AUTO_APPROVE=false
+
+# Network Configuration for Testing
+# Sepolia Testnet (recommended for testing)
+SEPOLIA_RPC_URL=https://sepolia.infura.io/v3/YOUR_INFURA_KEY
+
+# Mumbai Testnet (Polygon)
+MUMBAI_RPC_URL=https://polygon-mumbai.infura.io/v3/YOUR_INFURA_KEY
+
+# Private Key for Deployment (NEVER commit this to version control)
+# Use a dedicated deployment account with limited funds
+DEPLOYER_PRIVATE_KEY=your_private_key_here_for_testing_only
+
+# Contract Verification (optional)
+ETHERSCAN_API_KEY=your_etherscan_api_key
+POLYGONSCAN_API_KEY=your_polygonscan_api_key
+
+# Debug and Logging
+DEBUG=false
+VERBOSE_DEPLOYMENT=true