// 标准 OpenSea/市场兼容的元数据

{

  "name": "Bored Ape #1",

  "description": "随机生成的猿猴收藏品",

  "image": "ipfs://Qm.../1.png",

  "attributes": [

    {"trait_type": "Background", "value": "Deep Blue"},

    {"trait_type": "Fur", "value": "Golden"},

    {"trait_type": "Eyes", "value": "Laser", "rarity": 0.5}

  ],

  "external_url": "https://example.com/ape/1"

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;



import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";

import "@openzeppelin/contracts/access/Ownable.sol";



contract MyNFT is ERC721, ERC721Enumerable, Ownable {

    using Strings for uint256;

    

    // === 状态变量 ===

    string private _baseTokenURI;     // 元数据基础 URL: https://ipfs.io/ipfs/Qm.../

    uint256 public maxSupply = 10000;  // 最大供应量

    uint256 public totalMinted = 0;    // 已铸造量

    uint256 public mintPrice = 0.01 ether;  // 铸造价格

    bool public mintActive = false;    // 铸造开关

    

    // === 事件 ===

    event Minted(address indexed to, uint256 indexed tokenId, uint256 price);

    event BaseURIChanged(string newURI);

    

    constructor(

        string memory name,

        string memory symbol,

        string memory baseURI

    ) ERC721(name, symbol) Ownable(msg.sender) {

        _baseTokenURI = baseURI;

    }

    

    // === 铸造功能 ===

    function mint(uint256 quantity) external payable {

        require(mintActive, "Minting is not active");

        require(quantity > 0 && quantity <= 10, "Max 10 per tx");

        require(totalMinted + quantity <= maxSupply, "Exceeds max supply");

        require(msg.value >= mintPrice * quantity, "Insufficient payment");

        

        for (uint256 i = 0; i < quantity; i++) {

            uint256 tokenId = totalMinted;

            _safeMint(msg.sender, tokenId);

            totalMinted++;

        }

        

        emit Minted(msg.sender, tokenId, msg.value);

        

        // 退款多余 ETH

        if (msg.value > mintPrice * quantity) {

            payable(msg.sender).transfer(msg.value - mintPrice * quantity);

        }

    }

    

    // === 查询 ===

    function tokenURI(uint256 tokenId) public view override returns (string memory) {

        _requireOwned(tokenId);

        return string(abi.encodePacked(_baseTokenURI, tokenId.toString(), ".json"));

    }

    

    function walletOfOwner(address owner) public view returns (uint256[] memory) {

        uint256 balance = balanceOf(owner);

        uint256[] memory tokenIds = new uint256[](balance);

        for (uint256 i = 0; i < balance; i++) {

            tokenIds[i] = tokenOfOwnerByIndex(owner, i);

        }

        return tokenIds;

    }

    

    // === 仅所有者 ===

    function setBaseURI(string memory newURI) external onlyOwner {

        _baseTokenURI = newURI;

        emit BaseURIChanged(newURI);

    }

    

    function toggleMint() external onlyOwner {

        mintActive = !mintActive;

    }

    

    function withdraw() external onlyOwner {

        (bool success, ) = payable(owner()).call{value: address(this).balance}("");

        require(success, "Withdraw failed");

    }

    

    // === 必需覆盖 ===

    function supportsInterface(bytes4 interfaceId)

        public view override(ERC721, ERC721Enumerable)

        returns (bool)

    {

        return super.supportsInterface(interfaceId);

    }

}

// 未优化: 每次循环都检查 supply

for (uint i = 0; i < quantity; i++) {

    require(totalMinted < maxSupply, "..."); // 多余

    // ...

}



// 已优化: 外部统一检查后批量铸造

require(totalMinted + quantity <= maxSupply, "..."); // 一次检查

for (uint i = 0; i < quantity; i++) {

    // ...

}

// components/Minter.tsx

import { useState, useEffect } from 'react';

import { ethers } from 'ethers';

import MyNFT from '../abi/MyNFT.json';



const CONTRACT_ADDRESS = "0x...";

const MINT_PRICE = ethers.parseEther("0.01");



export const Minter = () => {

  const [quantity, setQuantity] = useState(1);

  const [supply, setSupply] = useState({ total: 0, max: 10000 });

  const [price, setPrice] = useState(MINT_PRICE);

  const [loading, setLoading] = useState(false);

  const [txHash, setTxHash] = useState('');



  const provider = new ethers.BrowserProvider(window.ethereum);



  useEffect(() => {

    const loadSupply = async () => {

      const contract = new ethers.Contract(CONTRACT_ADDRESS, MyNFT, await provider.getSigner());

      const [minted, max, mintPrice] = await Promise.all([

        contract.totalMinted(),

        contract.maxSupply(),

        contract.mintPrice(),

      ]);

      setSupply({ total: Number(minted), max: Number(max) });

      setPrice(mintPrice);

    };

    loadSupply();

  }, []);



  const mint = async () => {

    setLoading(true);

    try {

      const signer = await provider.getSigner();

      const contract = new ethers.Contract(CONTRACT_ADDRESS, MyNFT, signer);

      

      const tx = await contract.mint(quantity, {

        value: price * BigInt(quantity),

      });

      

      setTxHash(tx.hash);

      await tx.wait();

      

      // 刷新供应量

      const newTotal = await contract.totalMinted();

      setSupply(s => ({ ...s, total: Number(newTotal) }));

    } finally {

      setLoading(false);

    }

  };



  const remaining = supply.max - supply.total;



  return (

    <div className="minter">

      <h2>Mint Your NFT</h2>

      <div className="supply">{supply.total} / {supply.max} 已铸造</div>

      

      <div className="quantity-selector">

        <button onClick={() => setQuantity(Math.max(1, q-1))}>-</button>

        <span>{quantity}</span>

        <button onClick={() => setQuantity(Math.min(10, q+1))}>+</button>

      </div>



      <div className="price">总计: {ethers.formatEther(price * BigInt(quantity))} ETH</div>



      <button 

        onClick={mint} 

        disabled={loading || remaining <= 0}

        className="mint-btn"

      >

        {loading ? '铸造中...' : remaining <= 0 ? '已售完' : '立即铸造'}

      </button>



      {txHash && (

        <a href={`https://etherscan.io/tx/${txHash}`} target="_blank">

          查看交易 →

        </a>

      )}

    </div>

  );

};

// 反射代币核心：从零实现（纯 TS + BigInt，无外部库）

// 模型：每笔转账收取 3% 税费，税费按"除发送方外"各持有者转账前余额占比再分配

//  => 发送方付全额，接收方得净额，税费让全体持有者被动增值（反射语义）

class ReflectToken {

  totalReal: bigint;              // 真实总供应量

  balances: Map<string, bigint>;  // 地址 -> 真实余额

  static readonly TAX_BPS = 300n; // 3% 交易税（1/10000 为单位）



  constructor(initialSupply: bigint, holders: Array<[string, bigint]>) {

    this.totalReal = initialSupply;

    this.balances = new Map(holders);

  }



  realBalance(addr: string): bigint {

    return this.balances.get(addr) ?? 0n;

  }



  transfer(from: string, to: string, amount: bigint): void {

    const fromBal = this.balances.get(from) ?? 0n;

    if (fromBal < amount) throw new Error("余额不足");

    const fee = (amount * ReflectToken.TAX_BPS) / 10000n; // 税费

    const net = amount - fee;                             // 净到账



    // 1) 反射分配：基于"除发送方外"其余持有者的转账前余额占比

    //    （顺序在 B 到账之前，保证分母不因本次净到账而改变）

    const othersBefore: Array<[string, bigint]> = [];

    let sumOtherBefore = 0n;

    for (const [addr, bal] of this.balances) {

      if (addr === from) continue;

      othersBefore.push([addr, bal]);

      sumOtherBefore += bal;

    }

    if (sumOtherBefore > 0n) {

      for (const [addr, bal] of othersBefore) {

        const share = (fee * bal) / sumOtherBefore; // 税费按占比反射

        this.balances.set(addr, (this.balances.get(addr) ?? 0n) + share);

      }

    }



    // 2) 发送方扣全额，接收方得净额

    this.balances.set(from, fromBal - amount);

    this.balances.set(to, (this.balances.get(to) ?? 0n) + net);



    // 3) 税费进入持有者账户 => 总真实供应增长（等价于全体持有人被动增持）

    this.totalReal += fee;

  }

}



// 验证：创始 1000 token，A=500、B=500；A 给 B 转 100（税 3%）

const WEI = 10n ** 18n; // 1e18 定点

const t = new ReflectToken(1000n * WEI, [

  ["0xA", 500n * WEI],

  ["0xB", 500n * WEI],

]);

const b0 = t.realBalance("0xB");

t.transfer("0xA", "0xB", 100n * WEI);

const b1 = t.realBalance("0xB");

const got = Number(b1 - b0) / Number(WEI);

// 理论：净到账 97 + 反射份额 = fee(3) × B占比(500/500=1.0) = 3 => 增量 = 100

console.log("B 到账增量 ≈", got.toFixed(2), "token（预期 100.00）");

function _burn(address from, uint256 amount) internal {

    _balances[from] -= amount;

    _totalSupply -= amount;

    emit Transfer(from, address(0), amount);

}

// 税率数学：输入金额 -> 各项去向（纯 BigInt，无外部库）

function splitFee(amount: bigint, basisPoints: readonly number[]): bigint[] {

  // basisPoints: [burn, reflect, liquidity, treasury]，单位万分比(1/10000)

  const TOTAL = 10000n;

  const totalBps = basisPoints.reduce((a, b) => a + b, 0);

  if (totalBps > 10000) throw new Error("总税率超过100%");



  const parts = basisPoints.map(bp => (amount * BigInt(bp)) / TOTAL);

  // 用整数除法后余数归给接收方，保证到账+税费 == 原金额

  const net = amount - parts.reduce((a, b) => a + b, 0n);

  return [...parts, net]; // [burn, reflect, liq, treasury, netToReceiver]

}



// 验证：100e18 代币，税 8% (burn1% reflect3% liq3% treasury1%)

const amount = 100n * 10n ** 18n;

const [b, r, l, t, net] = splitFee(amount, [100, 300, 300, 100]);

console.log("burn", (b / 10n ** 16n) / 100, "reflect", (r / 10n ** 16n) / 100);

console.log("liq ", (l / 10n ** 16n) / 100, "treasury", (t / 10n ** 16n) / 100);

console.log("net ", (net / 10n ** 16n) / 100);   // 应约 92

// 输出：burn 1  reflect 3  liq 3  treasury 1  net 92

// 质押激励引擎：从零实现（纯 TS + BigInt，无外部库）

// 计算：每 epoch 按质押份额分配奖励；提前解锁需罚没部分本金

class StakingEngine {

  epochDurationSeconds: bigint; // 每个 epoch 时长

  totalStaked: bigint;          // 当前总质押额

  rewardPerEpoch: bigint;       // 每 epoch 奖励总量（协议补贴）

  positions: Map<string, { amount: bigint; lockUntil: bigint; entered: bigint }>;



  constructor(epochDur: bigint, reward: bigint) {

    this.epochDurationSeconds = epochDur;

    this.totalStaked = 0n;

    this.rewardPerEpoch = reward;

    this.positions = new Map();

  }



  stake(user: string, amount: bigint, now: bigint, lockEpochs: bigint): void {

    const until = now + lockEpochs * this.epochDurationSeconds;

    const pos = this.positions.get(user);

    if (pos) {

      pos.amount += amount;

      pos.lockUntil = pos.lockUntil > until ? pos.lockUntil : until;

    } else {

      this.positions.set(user, { amount, lockUntil: until, entered: now });

    }

    this.totalStaked += amount;

  }



  // 每 epoch 由协议触发：奖励按各质押者份额分配

  distributeRewards(now: bigint): void {

    if (this.totalStaked === 0n) return;

    for (const [user, pos] of this.positions) {

      const share = (pos.amount * this.rewardPerEpoch) / this.totalStaked;

      pos.amount += share;            // 复利：奖励自动再质押

      this.totalStaked += share;

    }

  }



  // 提前解冻：罚没 penaltyBps（万分比）

  unstake(user: string, now: bigint, penaltyBps: bigint): bigint {

    const pos = this.positions.get(user);

    if (!pos) throw new Error("无质押");

    let payout = pos.amount;

    if (now < pos.lockUntil) {

      const penalty = (payout * penaltyBps) / 10000n; // 提前赎回罚金（部分销毁）

      payout -= penalty;

    }

    this.totalStaked -= pos.amount;

    this.positions.delete(user);

    return payout; // 返回实际可提取金额

  }

}



// 验证：2 个质押者 share epochs 奖励（整数单位，简化演示）

// 注意：distributeRewards 按 Map 插入序遍历，A 先分后 totalStaked 增大，

//       故 B 的份额分母变大（2000→2050），B 实得 1048（顺序复利特性）

const s = new StakingEngine(1n, 100n);

s.stake("0xA", 1000n, 0n, 10n);   // A 质押 1000，锁 10 epoch

s.stake("0xB", 1000n, 0n, 1n);    // B 质押 1000，锁 1 epoch

s.distributeRewards(1n);          // A 先分 50，B 后分 48（分母变大）

const bEarly = s.unstake("0xB", 2n, 500n); // now=2 已过 B 锁定期(1)，不罚没

console.log("B 实得 =", bEarly.toString(), "（A 先分→B 份额减少，1048 符合顺序复利）");

console.log("锁定期内解冻示例(罚5%)：", (1050n * 9500n / 10000n).toString()); // 997

// 链下订单撮合：签名校验 + 版税拆分的数学（纯 TS + BigInt，无外部库）

type Address = string;



interface Listing {

  seller: Address;      // 卖家

  nft: Address;         // NFT 合约地址

  tokenId: bigint;      // 具体 NFT 编号

  price: bigint;        // 成交价（wei）

  royaltyBps: bigint;   // 版税（1/10000）

  deadline: bigint;     // 截止时间戳

  nonce: bigint;        // 防重放序号

}



class Marketplace {

  usedNonces: Set<string>; // 已消费的 (seller:nft:tokenId:nonce)

  creatorRoyalty: Map<string, bigint>; // nft合约 => 版税bps（项目方预设）



  constructor() {

    this.usedNonces = new Set();

    this.creatorRoyalty = new Map();

  }



  // 成交结算：返回 [买方支付, 卖家所得, 创作者版税]

  fillOrder(

    order: Listing,

    fundsDeposited: bigint,

    _signatureValid: boolean

  ): [bigint, bigint, bigint] {

    if (!_signatureValid) throw new Error("签名无效");

    if (fundsDeposited < order.price) throw new Error("支付不足");

    const nonceKey = `${order.seller}:${order.nft}:${order.tokenId}:${order.nonce}`;

    if (this.usedNonces.has(nonceKey)) throw new Error("订单已执行/取消");

    this.usedNonces.add(nonceKey);



    const royalty = (order.price * order.royaltyBps) / 10000n; // 版税

    const sellerNet = order.price - royalty;                    // 卖家净得

    return [order.price, sellerNet, royalty]; // [买方支付, 卖家, 创作者]

  }

}



// 验证：售价 1 ETH，版税 5% => 版税 0.05 ETH，卖家净得 0.95 ETH

const WEI = 10n ** 18n;

const mk = new Marketplace();

const order: Listing = {

  seller: "0xSeller",

  nft: "0xNft",

  tokenId: 1n,

  price: 1n * WEI,

  royaltyBps: 500n, // 5%

  deadline: 2000n,

  nonce: 0n,

};

const [pay, seller, creator] = mk.fillOrder(order, 1n * WEI, true);

console.log(

  "版税 =", Number(creator) / Number(WEI), "ETH,",

  "卖家净得 =", Number(seller) / Number(WEI), "ETH"

);

// 输出：版税 = 0.05 ETH  卖家净得 = 0.95 ETH

interface IERC2981 {

    /// @notice 返回给定 tokenId/售价下的版税接收者与金额

    function royaltyInfo(uint256 tokenId, uint256 salePrice)

        external view returns (address receiver, uint256 royaltyAmount);

}