@pasosdejesus/m 0.15.0

package/dist/templates/apps/hardhat/README.md

@@ -0,0 +1,129 @@
+# Learn.tg - Smart Contracts
+
+This directory contains the Solidity smart contracts for the 
+platform, managed with Hardhat. These contracts handle ...
+
+## Overview
+
+- **`MockUSDT.sol`**: A mock USDT contract for testing purposes in a
+  local or testnet environment.
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/) (>= 18)
+- [Yarn](https://yarnpkg.com/)
+- A Celo-compatible wallet with test funds. You can get Sepolia Celo
+  tokens from the [Celo Faucet](https://faucet.celo.org/celo-sepolia).
+  To get test cCop use https://app.mento.org/
+
+## 1. Environment Configuration
+
+First, create your environment file by copying the template:
+
+```sh
+cp .env.example .env
+```
+
+Next, edit the `.env` file with the following information:
+
+- `NETWORK`: The network to deploy to. Use `celoSepolia` for the testnet
+  or `celo` for mainnet.
+- `PRIVATE_KEY`: The private key of the wallet you will use for deployment.
+- `BLOCKSCOUT_API_KEY`: Your API key from Blockscout for contract
+  verification. You can generate one in your account settings on the
+  [Celo Blockscout explorer](https://explorer.celo.org/).
+- `DEPLOYED_AT`: This will hold the contract address after deployment.
+  Leave it blank for now.
+
+**⚠️ Security Warning:** Never use a wallet containing real funds for
+  development. Always generate and use a separate, dedicated wallet
+  for testing.
+
+## 2. Platform-Specific Setup (adJ / OpenBSD)
+
+Due to compatibility issues, Hardhat v3 does not work on adJ/OpenBSD 
+as of 2025. This project is configured to use Hardhat v2. If you are on 
+this platform, you must first run the following script to prepare the 
+environment:
+
+```sh
+bin/prepadJ.sh
+```
+
+## 3. Development Workflow
+
+Follow these steps to compile, deploy, and verify your contracts.
+
+### Step 3.1: Install Dependencies
+
+```sh
+yarn install
+```
+
+### Step 3.2: Compile Contracts
+
+This command compiles the Solidity contracts and automatically syncs the 
+ABIs with the Next.js frontend.
+
+```sh
+yarn build
+```
+
+### Step 3.3: Deploy the Contract
+
+Make sure your deployment wallet is funded. Then, run the deployment 
+script:
+
+```sh
+bin/deploy*
+```
+
+The script will output the contract address to the console. **Copy 
+this address.**
+
+### Step 3.4: Update Environment File
+
+Paste the copied contract address into the `DEPLOYED_AT` variable in 
+your `.env` file.
+
+### Step 3.5: Verify Contract on Blockscout
+
+This step publishes and verifies the contract's source code on the 
+blockchain explorer, which is a crucial trust and security signal.
+
+```sh
+bin/contractVerification
+```
+
+## 4. Testing
+
+The project uses Hardhat's built-in testing framework with Chai matchers. 
+The tests are located in the `test/` directory.
+
+To run the entire test suite, execute the following command:
+
+```sh
+yarn test
+```
+
+This will compile your contracts, run the tests in an in-memory Hardhat 
+Network, and report the results in the console.
+
+## ABI Synchronization
+
+The contract ABIs (Application Binary Interfaces) are essential for the 
+frontend to interact with the smart contracts. This project is configured 
+to sync them automatically.
+
+- **Automatic Sync:** ABIs are synced to `../nextjs/abis/` every time you 
+  run `yarn build` (or `yarn compile`).
+- **Manual Sync:** To sync the ABIs without recompiling, run 
+  `yarn sync:abis`.
+
+
+## 5. Practices
+
+* Prefer a multisig
+* For a project with only one owner prefer a contract with transferOwner 
+  https://metaschool.so/articles/account-ownership-in-solidity
+  and setBackendAddress 

package/dist/templates/apps/hardhat/bin/MusdtVerification

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+. .env
+npx hardhat verify --network celoSepolia $MOCK_USDT_ADDRESS

package/dist/templates/apps/hardhat/bin/approveDepositOwner

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+# Load environment variables from the root .env file
+. ../.env
+
+# Run the script to approve the deposit owner
+npx hardhat run scripts/approveDepositOwner.ts --network $NEXT_PUBLIC_NETWORK

package/dist/templates/apps/hardhat/bin/contractVerification

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+# Load environment variables from the root .env file
+. ../.env
+
+# Run the verification script, which will read the necessary variables
+# from the environment.
+# The network is specified via the NETWORK variable in the .env file.
+npx hardhat run scripts/verifyDeployment.ts --network $NEXT_PUBLIC_NETWORK

package/dist/templates/apps/hardhat/bin/deployMockUSDT

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+# Load environment variables from the root .env file
+. ../.env
+
+# Run the deployment script for MockUSDT
+npx hardhat run scripts/deployMockUSDT.ts --network $NEXT_PUBLIC_NETWORK

package/dist/templates/apps/hardhat/bin/prepadJ.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+yarn install
+mkdir -p tmpart
+sed -e "s/freebsd/openbsd/g" node_modules/@nomicfoundation/solidity-analyzer/index.js > tmpart/index-sa.js
+cp tmpart/index-sa.js node_modules/@nomicfoundation/solidity-analyzer/index.js
+cd node_modules/@nomicfoundation/solidity-analyzer/
+doas corepack enable
+yarn 
+yarn build
+cd ../../..
+yarn
+cp tmpart/index-sa.js node_modules/@nomicfoundation/solidity-analyzer/index.js
+yarn build

package/dist/templates/apps/hardhat/bin/verifyMockUSDT

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+# Load environment variables from the root .env file
+. ../.env
+
+# Run the verification script for MockUSDT
+npx hardhat run scripts/verifyMockUSDT.ts --network $NEXT_PUBLIC_NETWORK

package/dist/templates/apps/hardhat/contracts/MockUSDT.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+contract MockUSDT {
+    string public constant name = "Mock USDT";
+    string public constant symbol = "MUSDT";
+    uint8 public constant decimals = 6;
+    uint256 public totalSupply;
+    
+    mapping(address => uint256) public balanceOf;
+    mapping(address => mapping(address => uint256)) public allowance;
+    
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    
+    function mint(address to, uint256 amount) external {
+        totalSupply += amount;
+        balanceOf[to] += amount;
+        emit Transfer(address(0), to, amount);
+    }
+    
+    function transfer(address to, uint256 amount) external returns (bool) {
+        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
+        balanceOf[msg.sender] -= amount;
+        balanceOf[to] += amount;
+        emit Transfer(msg.sender, to, amount);
+        return true;
+    }
+    
+    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
+        require(balanceOf[from] >= amount, "Insufficient balance");
+        require(allowance[from][msg.sender] >= amount, "Insufficient allowance");
+        
+        balanceOf[from] -= amount;
+        balanceOf[to] += amount;
+        allowance[from][msg.sender] -= amount;
+        
+        emit Transfer(from, to, amount);
+        return true;
+    }
+    
+    function approve(address spender, uint256 amount) external returns (bool) {
+        allowance[msg.sender][spender] = amount;
+        emit Approval(msg.sender, spender, amount);
+        return true;
+    }
+}

package/dist/templates/apps/hardhat/hardhat.config.ts

@@ -0,0 +1,102 @@
+import '@nomicfoundation/hardhat-toolbox';
+import '@nomicfoundation/hardhat-verify';
+import { config as dotEnvConfig } from 'dotenv';
+import { HardhatUserConfig } from 'hardhat/config';
+import { task } from "hardhat/config";
+import { task } from "hardhat/config";
+
+
+dotEnvConfig({ path: '../.env' });
+
+
+task("check-transfer", "Check token transfer from tx hash")
+.addParam("tx", "Transaction hash")
+.addParam("token", "Token contract address")
+.setAction(async (taskArgs, hre) => {
+  const { ethers } = hre;
+  const { tx, token } = taskArgs;
+
+  const receipt = await ethers.provider.getTransactionReceipt(tx);
+  if (!receipt) {
+    console.log("Transaction not found");
+    return;
+  }
+
+  const TokenABI = [
+    "event Transfer(address indexed from, address indexed to, uint256 value)",
+    "function decimals() view returns (uint8)"
+  ];
+
+  const tokenContract = new ethers.Contract(token, TokenABI, ethers.provider);
+  const decimals = await tokenContract.decimals();
+
+  const transferEventTopic = ethers.id("Transfer(address,address,uint256)");
+  const transferLogs = receipt.logs.filter(log => log.topics[0] === transferEventTopic);
+
+  if (transferLogs.length === 0) {
+    console.log("No Transfer event found");
+    return;
+  }
+
+  for (const log of transferLogs) {
+    const parsedLog = tokenContract.interface.parseLog(log);
+    console.log("Amount:", ethers.formatUnits(parsedLog.args.value, decimals));
+  }
+});
+
+const config: HardhatUserConfig = {
+  networks: {
+    celo: {
+      accounts: [process.env.PRIVATE_KEY ?? '0x0'],
+      url: 'https://forno.celo.org',
+    },
+    celoSepolia: {
+      accounts: [process.env.PRIVATE_KEY ?? '0x0'],
+      url: 'https://forno.celo-sepolia.celo-testnet.org/',
+    },
+
+    'base-sepolia': {
+      accounts: [process.env.PRIVATE_KEY ?? '0x0'],
+      url: 'https://sepolia.base.org',
+    },
+  },
+  etherscan: {
+    apiKey: {
+      celoSepolia: process.env.BLOCKSCOUT_API_KEY ?? '',
+      celo: process.env.BLOCKSCOUT_API_KEY ?? '',
+      'base-sepolia': process.env.BASESCAN_API_KEY ?? '',
+    },
+    customChains: [
+      {
+        network: 'celoSepolia',
+        chainId: 11_142_220,
+        urls: {
+          apiURL: 'https://celo-sepolia.blockscout.com/api',
+          browserURL: 'https://celo-sepolia.blockscout.com/',
+        },
+      },
+      {
+        chainId: 42_220,
+        network: 'celo',
+        urls: {
+          apiURL: 'https://celo.blockscout.com/api',
+          browserURL: 'https://celo.blockscout.com/',
+        },
+      },
+      {
+        chainId: 84532,
+        network: 'base-sepolia',
+        urls: {
+          apiURL: 'https://api-sepolia.basescan.org/api',
+          browserURL: 'https://sepolia.basescan.org/',
+        },
+      },
+    ],
+  },
+  sourcify: {
+    enabled: false,
+  },
+  solidity: '0.8.24',
+};
+
+export default config;

package/dist/templates/apps/hardhat/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@stable-sl/hardhat",
+  "license": "MIT",
+  "version": "1.0.0",
+  "devDependencies": {
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.11",
+    "@nomicfoundation/hardhat-toolbox": "^5.0.0",
+    "@nomicfoundation/hardhat-verify": "^2.0.11",
+    "@nomiclabs/hardhat-ethers": "^2.2.3",
+    "@typechain/ethers-v6": "^0.5.0",
+    "@typechain/hardhat": "^9.1.0",
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.7",
+    "chai": "^4.2.0",
+    "ethers": "^6.15.0",
+    "hardhat": ">=2.27.0 <3.0.0",
+    "hardhat-gas-reporter": "^2.3.0",
+    "minimatch": "^10.1.1",
+    "solidity-coverage": "^0.8.1",
+    "ts-node": "^10.9.2",
+    "typechain": "^8.3.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "@nomicfoundation/hardhat-ignition": "0.15.0",
+    "@openzeppelin/contracts": "^5.4.0",
+    "dotenv": "^17.2.3",
+    "viem": "^2.40.0"
+  },
+  "scripts": {
+    "postinstall": "chmod +x sync-abis.mjs",
+    "compile": "hardhat clean && hardhat compile && node sync-abis.mjs",
+    "tsc": "node_modules/.bin/tsc -p . && mkdir -p dist/typechain-types/ && cp typechain-types/*.d.ts dist/typechain-types/",
+    "build": "pnpm compile && pnpm tsc",
+    "clean": "hardhat clean",
+    "run:node": "hardhat node",
+    "test": "hardhat test",
+    "deploy": "bin/deployLearnTGVaults",
+    "verify": "bin/verifyLearnTGVaults",
+    "contract-verification": "bin/contractVerification",
+    "deploy-mock-usdt": "bin/deployMockUsdt",
+    "verify-mock-usdt": "bin/verifyMockUSDT",
+    "deploy-celoubi": "bin/deployCeloUbi",
+    "verify-celoubi": "bin/verifyCeloUbi",
+    "contract-verification-celoubi": "bin/contractVerificationCeloUbi",
+    "prettier": "prettier --write 'contracts/**/*.sol' '**/*.ts'",
+    "sync:abis": "node sync-abis.mjs"
+  },
+  "author": "pasosdeJesus",
+  "packageManager": "pnpm@10.34.5"
+}

package/dist/templates/apps/hardhat/scripts/approveDepositOwner.ts

@@ -0,0 +1,22 @@
+import { ethers } from "hardhat";
+
+async function main() {
+  // Get signers
+  const [deployer] = await ethers.getSigners();
+
+  // Attach to existing ERC-20 token contract
+  const tokenAddress = process.env.USDT_ADDRES;
+  const TokenABI = ["function approve(address spender, uint256 amount) returns (bool)"];
+  const token = new ethers.Contract(tokenAddress, TokenABI, deployer);
+
+  const spenderAddress = process.env.DEPLOYED_ADDRESS; 
+
+  // Approve 1 token (adjust decimals as needed)
+  const amount = ethers.parseUnits("1000", 18);
+
+  console.log("Approving...");
+  const tx = await token.approve(spenderAddress, amount);
+  await tx.wait();
+
+  console.log("Approved! Transaction hash:", tx.hash);
+}

package/dist/templates/apps/hardhat/scripts/deployMockUSDT.ts

@@ -0,0 +1,49 @@
+import { ethers } from "hardhat";
+
+async function main() {
+  // Get the contract factory for MockUSDT
+  const MockUSDT = await ethers.getContractFactory("MockUSDT");
+  
+  console.log("Deploying MockUSDT token...");
+  
+  // Deploy the contract
+  const mockUSDT = await MockUSDT.deploy();
+  
+  // Wait for the deployment transaction to be mined
+  await mockUSDT.waitForDeployment();
+  
+  const mockUSDTAddress = await mockUSDT.getAddress();
+  console.log("MockUSDT deployed to:", mockUSDTAddress);
+  
+  // Mint 1,000,000 tokens to the deployer (owner)
+  // USDT has 6 decimals, so we need to multiply by 10^6
+  const deployer = (await ethers.getSigners())[0];
+  const deployerAddress = await deployer.getAddress();
+  const amount = ethers.parseUnits("10000000000", 6); // 10,000,000,000 tokens with 6 decimals
+  
+  console.log("Minting 10,000,000,000 tokens to:", deployerAddress);
+  const tx = await mockUSDT.mint(deployerAddress, amount);
+  await tx.wait();
+  
+  console.log("Minted 10,000,000,000 tokens to the owner's account");
+  
+  // Verify the balance
+  const balance = await mockUSDT.balanceOf(deployerAddress);
+  console.log("Owner's balance:", ethers.formatUnits(balance, 6), "MUSDT");
+  
+  // Also check the total supply
+  const totalSupply = await mockUSDT.totalSupply();
+  console.log("Total supply:", ethers.formatUnits(totalSupply, 6), "MUSDT");
+  
+  // Save the deployment address to .env file
+  console.log("Deployment completed successfully!");
+  console.log("Add this line to your .env file:");
+  console.log(`MOCK_USDT_ADDRESS="${mockUSDTAddress}"`);
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/dist/templates/apps/hardhat/scripts/verifyDeployment.ts

@@ -0,0 +1,93 @@
+import { ethers } from "hardhat";
+import dotenv from "dotenv"
+dotenv.config({ path: '../.env' })
+
+async function main() {
+  // Get the deployed contract
+  const learnTGVaults = await ethers.getContractAt(
+    "LearnTGVaults",
+    process.env.NEXT_PUBLIC_DEPLOYED_AT  // The deployed address
+  );
+  console.log("📜 LearnTGVaults Verification");
+  console.log("=============================");
+  console.log("Contract address:", process.env.NEXT_PUBLIC_DEPLOYED_AT);
+
+  // Get the owner of the contract
+  const owner = await learnTGVaults.owner();
+  console.log("\n👤 Contract owner:", owner);
+
+  // Get the USDT token address that the contract was initialized with
+  const usdtToken = await learnTGVaults.usdtToken();
+  console.log("💰 Contract USDT token address:", usdtToken);
+
+  // Get the cCop token address that the contract was initialized with
+  const cCopToken = await learnTGVaults.cCopToken();
+  console.log("🔶 Contract cCop token address:", cCopToken);
+
+  // Get the gooddollar token address that the contract was initialized with
+  const gooddollarToken = await learnTGVaults.gooddollarToken();
+  console.log("💎 Contract gooddollar token address:", gooddollarToken);
+
+  // Get provider
+  const provider = ethers.provider;
+
+  // Get USDT contract instance
+  const usdtContract = await ethers.getContractAt("IERC20", usdtToken);
+  const usdtDecimals = process.env.NEXT_PUBLIC_USDT_DECIMALS ? parseInt(process.env.NEXT_PUBLIC_USDT_DECIMALS) : 6;
+
+  console.log("\n📊 Balance Verification");
+  console.log("=====================");
+
+  // 1. Check contract USDT balance
+  const contractUSDTBalance = await usdtContract.balanceOf(learnTGVaults.target);
+  const formattedContractUSDT = ethers.formatUnits(contractUSDTBalance, usdtDecimals);
+  console.log(`1. LearnTGVaults USDT balance: ${formattedContractUSDT} USDT`);
+
+  // 2. Check contract CELO balance
+  const contractCELOBalance = await provider.getBalance(learnTGVaults.target);
+  const formattedContractCELO = ethers.formatEther(contractCELOBalance);
+  console.log(`2. LearnTGVaults CELO balance: ${formattedContractCELO} CELO`);
+
+  // 3. Check owner USDT balance
+  const ownerUSDTBalance = await usdtContract.balanceOf(owner);
+  const formattedOwnerUSDT = ethers.formatUnits(ownerUSDTBalance, usdtDecimals);
+  console.log(`3. Owner USDT balance: ${formattedOwnerUSDT} USDT`);
+
+  // 4. Check owner CELO balance
+  const ownerCELOBalance = await provider.getBalance(owner);
+  const formattedOwnerCELO = ethers.formatEther(ownerCELOBalance);
+  console.log(`4. Owner CELO balance: ${formattedOwnerCELO} CELO`);
+
+  // 5. Check deployer account (from private key) balances if available
+  if (process.env.PRIVATE_KEY) {
+    const deployerWallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);
+    const deployerAddress = deployerWallet.address;
+    const deployerUSDTBalance = await usdtContract.balanceOf(deployerAddress);
+    const deployerCELOBalance = await provider.getBalance(deployerAddress);
+    console.log(`\n🔑 Deployer account (from PRIVATE_KEY):`);
+    console.log(`   Address: ${deployerAddress}`);
+    console.log(`   USDT: ${ethers.formatUnits(deployerUSDTBalance, usdtDecimals)} USDT`);
+    console.log(`   CELO: ${ethers.formatEther(deployerCELOBalance)} CELO`);
+  }
+
+  // 6. Check old Hardhat account #0 (common test account)
+  const hardhatAccount0 = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+  const hardhatUSDTBalance = await usdtContract.balanceOf(hardhatAccount0);
+  const hardhatCELOBalance = await provider.getBalance(hardhatAccount0);
+  console.log(`\n🧪 Hardhat account #0 (common test):`);
+  console.log(`   Address: ${hardhatAccount0}`);
+  console.log(`   USDT: ${ethers.formatUnits(hardhatUSDTBalance, usdtDecimals)} USDT`);
+  console.log(`   CELO: ${ethers.formatEther(hardhatCELOBalance)} CELO`);
+
+  console.log("\n✅ Contract deployed and verified successfully!");
+  console.log("\n📋 Summary:");
+  console.log("   • LearnTGVaults contract is deployed and accessible");
+  console.log("   • Verify contract has sufficient USDT for rewards");
+  console.log("   • Verify contract has CELO for gas (if needed)");
+  console.log("   • Owner and deployer accounts should have CELO for operations");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/dist/templates/apps/hardhat/scripts/verifyMockUSDT.ts

@@ -0,0 +1,52 @@
+import { ethers } from "hardhat";
+
+async function main() {
+  // Get the MockUSDT address from environment variables
+  const mockUSDTAddress = process.env.MOCK_USDT_ADDRESS;
+  
+  if (!mockUSDTAddress) {
+    throw new Error("MOCK_USDT_ADDRESS not found in environment variables");
+  }
+  
+  // Get the contract factory for MockUSDT
+  const MockUSDT = await ethers.getContractFactory("MockUSDT");
+  
+  // Connect to the deployed contract
+  const mockUSDT = MockUSDT.attach(mockUSDTAddress);
+  
+  console.log("Verifying MockUSDT deployment at:", mockUSDTAddress);
+  
+  // Check token details
+  const name = await mockUSDT.name();
+  const symbol = await mockUSDT.symbol();
+  const decimals = await mockUSDT.decimals();
+  const totalSupply = await mockUSDT.totalSupply();
+  
+  console.log("Token Name:", name);
+  console.log("Token Symbol:", symbol);
+  console.log("Decimals:", decimals);
+  console.log("Total Supply:", ethers.formatUnits(totalSupply, decimals), symbol);
+  
+  // Check owner's balance
+  const deployer = (await ethers.getSigners())[0];
+  const deployerAddress = await deployer.getAddress();
+  const balance = await mockUSDT.balanceOf(deployerAddress);
+  
+  console.log("Owner Address:", deployerAddress);
+  console.log("Owner Balance:", ethers.formatUnits(balance, decimals), symbol);
+  
+  // Verify that the owner has tokens
+  const expectedBalance = ethers.parseUnits("10000000000", decimals);
+  if (balance > 0) {
+    console.log("✓ Verification successful: Owner has tokens");
+  } else {
+    console.log("✗ Verification failed: Owner does not have the expected balance");
+  }
+}
+
+// We recommend this pattern to be able to use async/await everywhere
+// and properly handle errors.
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/dist/templates/apps/hardhat/sync-abis.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node 
+
+import fs from 'fs'
+import path from 'path'
+
+// Configuration - directory files
+const HARDHAT_ARTIFACTS_PATH = './artifacts/contracts'
+const NEXTJS_ABI_PATH = '../nextjs/abis'
+
+// Create the React ABI directory if it doesn't exist
+if (!fs.existsSync(NEXTJS_ABI_PATH)) {
+  fs.mkdirSync(NEXTJS_ABI_PATH, { recursive: true })
+}
+
+// Function to walk through directories recursively
+function walkDir(dir) {
+  let results = []
+  const list = fs.readdirSync(dir)
+  list.forEach(file => {
+    const filePath = path.join(dir, file)
+    const stat = fs.statSync(filePath)
+    if (stat && stat.isDirectory()) {
+      results = results.concat(walkDir(filePath))
+    } else {
+      // Ensure we only grab the main contract JSON, not the debug files
+      if (file.endsWith('.json') && !file.includes('.dbg.')) {
+        results.push(filePath)
+      }
+    }
+  })
+  return results
+}
+
+// Main script
+console.log("🔄 Syncing ABIs to the frontend app...")
+
+try {
+  // Find all artifact JSON files from Hardhat compilation
+  const artifactFiles = walkDir(HARDHAT_ARTIFACTS_PATH)
+
+  artifactFiles.forEach(filepath => {
+    // Read and parse the artifact file
+    const artifact = JSON.parse(fs.readFileSync(filepath, 'utf8'))
+    const filename = path.basename(filepath)
+    const contractName = filename.replace('.json', '')
+
+    // Extract just the ABI and save it to the Next.js directory
+    const abiPath = path.join(NEXTJS_ABI_PATH, `${contractName}.json`)
+    fs.writeFileSync(abiPath, JSON.stringify(artifact.abi, null, 2))
+    console.log(`Copied ABI for ${contractName}`)
+  })
+
+  console.log("✅ ABI sync complete!")
+
+} catch (error) {
+  console.error("❌ Error syncing ABIs:", error)
+  process.exit(1)
+}