修飾器、require、事件與自訂錯誤：把關與紀錄

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

contract Vault {
    address public owner;

    constructor() {
        owner = msg.sender;          // whoever deploys becomes the owner
    }

    // The bouncer: run this check, then (at _;) the function body
    modifier onlyOwner() {
        require(msg.sender == owner, "Not the owner");
        _;
    }

    uint256 public threshold;

    // Reuse the same guard on any privileged function
    function setThreshold(uint256 v) external onlyOwner {
        threshold = v;
    }
}

// require: validate inputs / external conditions (the common case)
require(amount > 0, "amount must be positive");
require(msg.sender == owner, "Not the owner");

// revert: identical effect, handy with branching or complex conditions
if (recipient == address(0)) {
    revert("zero address");
}

// assert: check an invariant that should NEVER be false.
// A failing assert means a BUG in your code, not bad user input.
assert(totalSupply == sumOfAllBalances);

// Declared once, can carry typed data about what went wrong
error NotOwner(address caller);
error InsufficientBalance(uint256 requested, uint256 available);

function withdraw(uint256 amount) external {
    if (msg.sender != owner) {
        revert NotOwner(msg.sender);
    }
    uint256 bal = address(this).balance;
    if (amount > bal) {
        revert InsufficientBalance(amount, bal);   // tells the caller the numbers
    }
    // ... proceed
}

// Up to 3 parameters may be 'indexed' (searchable); the rest go in 'data'
event Transfer(address indexed from, address indexed to, uint256 value);

function _transfer(address from, address to, uint256 value) internal {
    balanceOf[from] -= value;
    balanceOf[to]   += value;
    emit Transfer(from, to, value);   // writes a log entry, not storage
}

{
  "jsonrpc": "2.0",
  "method": "eth_getLogs",
  "params": [{
    "address": "0xTokenContractAddress",
    "topics": [
      "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      null,
      "0x000000000000000000000000YourAddressPaddedTo32Bytes"
    ],
    "fromBlock": "0x0",
    "toBlock": "latest"
  }],
  "id": 1
}

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

contract Treasury {
    address public owner;
    uint256 public feeBps;   // fee in basis points: 100 = 1%

    // ---- Events: the public logbook ----
    event OwnershipTransferred(address indexed from, address indexed to);
    event FeeUpdated(uint256 oldFeeBps, uint256 newFeeBps);

    // ---- Custom errors: cheap, typed revert reasons ----
    error NotOwner(address caller);
    error ZeroAddress();
    error FeeTooHigh(uint256 requested, uint256 maxBps);

    constructor() {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);  // mint of ownership
    }

    modifier onlyOwner() {
        if (msg.sender != owner) revert NotOwner(msg.sender);
        _;
    }

    function setFee(uint256 newFeeBps) external onlyOwner {
        if (newFeeBps > 1000) revert FeeTooHigh(newFeeBps, 1000);  // cap at 10%
        emit FeeUpdated(feeBps, newFeeBps);   // emit BEFORE overwriting state
        feeBps = newFeeBps;
    }

    function transferOwnership(address newOwner) external onlyOwner {
        if (newOwner == address(0)) revert ZeroAddress();
        emit OwnershipTransferred(owner, newOwner);  // owner is still the old one
        owner = newOwner;
    }
}