1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

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

contract Token {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    
    event Transfer(address indexed from, address indexed to, uint256 value);
    
    constructor(string memory _name, string memory _symbol) {
        name = _name;
        symbol = _symbol;
        decimals = 18;
        totalSupply = 1000000 * 10**decimals;
        balanceOf[msg.sender] = totalSupply;
    }
    
    function transfer(address to, uint256 value) public returns (bool) {
        require(balanceOf[msg.sender] >= value, "Insufficient balance");
        balanceOf[msg.sender] -= value;
        balanceOf[to] += value;
        emit Transfer(msg.sender, to, value);
        return true;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

contract LiquidityPool {
    IERC20 public token;
    mapping(address => uint256) public stakes;
    uint256 public totalStaked;
    
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    
    constructor(address _token) {
        token = IERC20(_token);
    }
    
    function stake(uint256 amount) external {
        require(amount > 0, "Amount must be positive");
        require(token.transferFrom(msg.sender, address(this), amount), "Transfer failed");
        
        stakes[msg.sender] += amount;
        totalStaked += amount;
        emit Staked(msg.sender, amount);
    }
    
    function withdraw(uint256 amount) external {
        require(amount > 0, "Amount must be positive");
        require(stakes[msg.sender] >= amount, "Insufficient stake");
        
        stakes[msg.sender] -= amount;
        totalStaked -= amount;
        require(token.transfer(msg.sender, amount), "Transfer failed");
        emit Withdrawn(msg.sender, amount);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import Web3 from 'web3';
import { Contract } from 'web3-eth-contract';

class Web3Service {
    constructor() {
        this.web3 = null;
        this.contract = null;
    }
    
    async connect() {
        if (window.ethereum) {
            try {
                await window.ethereum.request({ method: 'eth_requestAccounts' });
                this.web3 = new Web3(window.ethereum);
                return true;
            } catch (error) {
                console.error('User denied account access');
                return false;
            }
        }
        return false;
    }
    
    async loadContract(abi, address) {
        this.contract = new this.web3.eth.Contract(abi, address);
    }
    
    async getBalance(address) {
        return await this.contract.methods.balanceOf(address).call();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

async function sendTransaction(contract, method, params, from) {
    try {
        const gas = await method.estimateGas({ from });
        const gasPrice = await web3.eth.getGasPrice();
        
        const tx = await method.send({
            from,
            gas,
            gasPrice
        });
        
        return tx;
    } catch (error) {
        console.error('Transaction failed:', error);
        throw error;
    }
}

// 使用示例
const transfer = async (to, amount) => {
    const accounts = await web3.eth.getAccounts();
    const method = contract.methods.transfer(to, amount);
    return await sendTransaction(contract, method, [], accounts[0]);
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

const Token = artifacts.require("Token");
const { expectRevert } = require('@openzeppelin/test-helpers');

contract("Token", accounts => {
    let token;
    const [owner, user1, user2] = accounts;
    
    beforeEach(async () => {
        token = await Token.new("Test Token", "TEST");
    });
    
    it("should transfer tokens correctly", async () => {
        const amount = web3.utils.toWei("100", "ether");
        await token.transfer(user1, amount, { from: owner });
        
        const balance = await token.balanceOf(user1);
        assert.equal(balance.toString(), amount);
    });
    
    it("should fail when transferring with insufficient balance", async () => {
        const amount = web3.utils.toWei("1000001", "ether");
        await expectRevert(
            token.transfer(user2, amount, { from: user1 }),
            "Insufficient balance"
        );
    });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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

describe("LiquidityPool", function() {
    let token;
    let pool;
    let owner;
    let user1;
    
    beforeEach(async function() {
        [owner, user1] = await ethers.getSigners();
        
        const Token = await ethers.getContractFactory("Token");
        token = await Token.deploy("Test Token", "TEST");
        await token.deployed();
        
        const LiquidityPool = await ethers.getContractFactory("LiquidityPool");
        pool = await LiquidityPool.deploy(token.address);
        await pool.deployed();
    });
    
    it("Should stake tokens correctly", async function() {
        const amount = ethers.utils.parseEther("100");
        await token.approve(pool.address, amount);
        await pool.stake(amount);
        
        expect(await pool.stakes(owner.address)).to.equal(amount);
        expect(await pool.totalStaked()).to.equal(amount);
    });
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

contract Vault {
    mapping(address => uint256) private balances;
    bool private locked;
    
    modifier nonReentrant() {
        require(!locked, "Reentrant call");
        locked = true;
        _;
        locked = false;
    }
    
    function withdraw() external nonReentrant {
        uint256 balance = balances[msg.sender];
        require(balance > 0, "No balance");
        
        balances[msg.sender] = 0;
        (bool success, ) = msg.sender.call{value: balance}("");
        require(success, "Transfer failed");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

abstract contract Ownable {
    address private _owner;
    
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
    constructor() {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }
    
    modifier onlyOwner() {
        require(_owner == msg.sender, "Ownable: caller is not the owner");
        _;
    }
    
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}