How to Fork the Hedera Network with Foundry - Basic ERC-20 Contract

@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
hedera-forking/=lib/hedera-forking/contracts/
forge-std/=lib/forge-std/src/

HEDERA_RPC_URL=https://testnet.hashio.io/api
HEDERA_PRIVATE_KEY=0x-your-private-key

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
ffi = true
solc = "0.8.33"

# Add this section for Hedera testnet
[rpc_endpoints]
testnet = "${HEDERA_RPC_URL}"

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

contract ERC20Token is ERC20, Ownable {
    constructor(address initialOwner, address recipient)
        ERC20("MyToken", "MTK")
        Ownable(initialOwner)
    {
        _mint(recipient, 10000 * 10 ** decimals());
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {Script, console} from "forge-std/Script.sol";
import {ERC20Token} from "../src/ERC20Token.sol";

contract DeployScript is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("HEDERA_PRIVATE_KEY");
        address deployer = vm.addr(deployerPrivateKey);

        console.log("Deploying contracts with the account:", deployer);
        console.log("Account balance:", deployer.balance / 1e18, "HBAR");

        vm.startBroadcast(deployerPrivateKey);

        // Deploy ERC20Token with deployer as both owner and initial recipient
        ERC20Token token = new ERC20Token(deployer, deployer);

        vm.stopBroadcast();

        console.log("ERC20Token deployed to:", address(token));
        console.log(
            "View on HashScan: https://hashscan.io/testnet/contract/%s",
            address(token)
        );

        // Get deployment block number for fork testing reference
        uint256 blockNumber = block.number;
        console.log("Deployed at block number:", blockNumber);
        console.log("");
        console.log("=== IMPORTANT ===");
        console.log("Save this contract address for your fork tests!");
        console.log(
            "Update DEPLOYED_CONTRACT in your test file with this address"
        );
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.33;

import {Test, console} from "forge-std/Test.sol";
import {ERC20Token} from "../src/ERC20Token.sol";

contract ERC20TokenForkTest is Test {
    // Your deployed testnet contract:
    address constant DEPLOYED_CONTRACT =
        "YOUR_CONTRACT_ADDRESS"; // <-- Update this!

    ERC20Token public token;
    address public owner;
    address public alice;
    address public bob;

    function setUp() public {
        // Bind to the deployed contract on the forked network
        token = ERC20Token(DEPLOYED_CONTRACT);

        // Get the real owner from the deployed contract
        owner = token.owner();

        // Create test accounts
        alice = makeAddr("alice");
        bob = makeAddr("bob");

        // Fund test accounts
        vm.deal(owner, 100 ether);
        vm.deal(alice, 100 ether);
        vm.deal(bob, 100 ether);
    }

    /* =========================
            Basic Info
       ========================= */

    function test_ReadNameAndSymbol() public view {
        assertEq(token.name(), "MyToken");
        assertEq(token.symbol(), "MTK");
    }

    function test_ReadDecimals() public view {
        assertEq(token.decimals(), 18);
    }

    function test_ReadTotalSupply() public view {
        uint256 totalSupply = token.totalSupply();
        console.log("Total supply on testnet:", totalSupply);
        assertGt(totalSupply, 0);
    }

    function test_ReadOwnerBalance() public view {
        uint256 balance = token.balanceOf(owner);
        console.log("Owner balance:", balance);
        assertGt(balance, 0);
    }

    /* =========================
            Ownership
       ========================= */

    function test_RejectMintingFromNonOwner() public {
        // Alice (not the owner) tries to mint → should revert
        vm.prank(alice);
        vm.expectRevert();
        token.mint(alice, 100 ether);
    }

    function test_AllowOwnerToMint() public {
        uint256 balanceBefore = token.balanceOf(alice);

        // Impersonate the real owner to mint
        vm.prank(owner);
        token.mint(alice, 500 ether);

        uint256 balanceAfter = token.balanceOf(alice);
        assertEq(balanceAfter, balanceBefore + 500 ether);
    }

    /* =========================
            Transfers
       ========================= */

    function test_TransferFromOwnerToAlice() public {
        uint256 amount = 100 ether;
        uint256 balanceBefore = token.balanceOf(alice);

        // Transfer from owner
        vm.prank(owner);
        token.transfer(alice, amount);

        uint256 balanceAfter = token.balanceOf(alice);
        assertEq(balanceAfter, balanceBefore + amount);
    }

    function test_HandleMultipleTransfers() public {
        // Mint tokens to alice first
        vm.prank(owner);
        token.mint(alice, 1000 ether);

        uint256 aliceInitial = token.balanceOf(alice);
        uint256 bobInitial = token.balanceOf(bob);

        // Alice transfers to bob
        vm.prank(alice);
        token.transfer(bob, 300 ether);

        assertEq(token.balanceOf(alice), aliceInitial - 300 ether);
        assertEq(token.balanceOf(bob), bobInitial + 300 ether);
    }

    function test_FailTransferWithInsufficientBalance() public {
        // Bob has no tokens initially, should fail
        vm.prank(bob);
        vm.expectRevert();
        token.transfer(alice, 100 ether);
    }

    /* =========================
          Allowances
       ========================= */

    function test_ApproveAndCheckAllowance() public {
        // Mint tokens to alice
        vm.prank(owner);
        token.mint(alice, 1000 ether);

        // Alice approves bob
        vm.prank(alice);
        token.approve(bob, 500 ether);

        assertEq(token.allowance(alice, bob), 500 ether);
    }

    function test_TransferFromAfterApproval() public {
        // Mint tokens to alice
        vm.prank(owner);
        token.mint(alice, 1000 ether);

        // Alice approves bob
        vm.prank(alice);
        token.approve(bob, 500 ether);

        uint256 aliceBefore = token.balanceOf(alice);

        // Bob transfers from alice to himself
        vm.prank(bob);
        token.transferFrom(alice, bob, 200 ether);

        assertEq(token.balanceOf(bob), 200 ether);
        assertEq(token.balanceOf(alice), aliceBefore - 200 ether);
        assertEq(token.allowance(alice, bob), 300 ether);
    }

    function test_FailTransferFromWithoutApproval() public {
        // Mint tokens to alice but no approval for bob
        vm.prank(owner);
        token.mint(alice, 1000 ether);

        vm.prank(bob);
        vm.expectRevert();
        token.transferFrom(alice, bob, 100 ether);
    }

    /* =========================
         Supply Changes
       ========================= */

    function test_TrackSupplyChangesAfterMinting() public {
        uint256 supplyBefore = token.totalSupply();

        vm.prank(owner);
        token.mint(alice, 5000 ether);

        uint256 supplyAfter = token.totalSupply();
        assertEq(supplyAfter, supplyBefore + 5000 ether);
    }

    /* =========================
        Fork Verification
       ========================= */

    function test_ConnectedToForkedNetwork() public view {
        uint256 blockNumber = block.number;
        console.log("Current fork block number:", blockNumber);
        assertGt(blockNumber, 0);
    }

    function test_InteractingWithRealDeployedContract() public view {
        // Verify we're reading from the actual deployed contract
        uint256 codeSize;
        address contractAddr = DEPLOYED_CONTRACT;
        assembly {
            codeSize := extcodesize(contractAddr)
        }
        assertGt(codeSize, 0);
        console.log("Contract code size:", codeSize);
    }
}