测试与部署 #

const { expect } = require("chai");
const { ethers } = require("hardhat");

describe("Token", function () {
  let token;
  let owner;
  let addr1;
  
  beforeEach(async function () {
    [owner, addr1] = await ethers.getSigners();
    
    const Token = await ethers.getContractFactory("Token");
    token = await Token.deploy("MyToken", "MTK", 1000000);
  });
  
  describe("Deployment", function () {
    it("Should set correct name", async function () {
      expect(await token.name()).to.equal("MyToken");
    });
    
    it("Should assign supply to owner", async function () {
      const balance = await token.balanceOf(owner.address);
      expect(balance).to.equal(ethers.utils.parseEther("1000000"));
    });
  });
  
  describe("Transfers", function () {
    it("Should transfer tokens", async function () {
      await token.transfer(addr1.address, 100);
      expect(await token.balanceOf(addr1.address)).to.equal(100);
    });
    
    it("Should fail if insufficient balance", async function () {
      await expect(
        token.connect(addr1).transfer(owner.address, 100)
      ).to.be.reverted;
    });
  });
});

contract TokenTest is Test {
    Token public token;
    address public owner;
    address public user;
    
    function setUp() public {
        owner = address(this);
        user = address(0x1);
        token = new Token("MyToken", "MTK", 1000000);
    }
    
    function test_Name() public {
        assertEq(token.name(), "MyToken");
    }
    
    function test_Transfer() public {
        token.transfer(user, 100);
        assertEq(token.balanceOf(user), 100);
    }
    
    function testFail_InsufficientBalance() public {
        token.transfer(user, 1000000000);  // 应该失败
    }
    
    function testRevert_InsufficientBalance() public {
        vm.expectRevert("ERC20: transfer amount exceeds balance");
        token.transfer(user, 1000000000);
    }
}

contract FuzzTest is Test {
    Token public token;
    
    function setUp() public {
        token = new Token("Test", "TST", 1000000);
    }
    
    function testFuzz_Transfer(uint256 amount) public {
        vm.assume(amount <= token.balanceOf(address(this)));
        
        address user = address(0x1);
        uint256 balanceBefore = token.balanceOf(user);
        
        token.transfer(user, amount);
        
        assertEq(token.balanceOf(user), balanceBefore + amount);
    }
    
    function testFuzz_Approve(address spender, uint256 amount) public {
        token.approve(spender, amount);
        assertEq(token.allowance(address(this), spender), amount);
    }
}

// scripts/deploy.js
const hre = require("hardhat");

async function main() {
  const [deployer] = await ethers.getSigners();
  
  console.log("Deploying contracts with account:", deployer.address);
  console.log("Account balance:", (await deployer.getBalance()).toString());
  
  const Token = await hre.ethers.getContractFactory("Token");
  const token = await Token.deploy("MyToken", "MTK", 1000000);
  await token.deployed();
  
  console.log("Token deployed to:", token.address);
  
  // 验证合约
  if (network.name !== "hardhat") {
    await hre.run("verify:verify", {
      address: token.address,
      constructorArguments: ["MyToken", "MTK", 1000000],
    });
  }
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

// script/Deploy.s.sol
contract DeployScript is Script {
    function run() external {
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        
        vm.startBroadcast(deployerPrivateKey);
        
        Token token = new Token("MyToken", "MTK", 1000000);
        
        vm.stopBroadcast();
    }
}

forge script script/Deploy.s.sol --rpc-url $RPC_URL --broadcast --private-key $PRIVATE_KEY

name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Compile contracts
        run: npx hardhat compile
      
      - name: Run tests
        run: npx hardhat test
      
      - name: Run coverage
        run: npx hardhat coverage