别再只听概念了!手把手手搓图币二象性合约|DN-404 极简实战

前言:从"硬塞缝合怪"到"双子星联动"

上一篇咱们聊透了"图币二象性"的前世今生。怕有刚刷到的兄弟没看上集,咱们花 15 秒极速复习一下核心剧情:

  • 为什么折腾这个? 以前发币(ERC-20)像撒芝麻,流动性好但没个性;发 NFT(ERC-721)像卖古董,稀缺但半天卖不出去。大佬们就想:能不能把"芝麻"和"古董"合二为一?
  • 1.0 时代(ERC-404)的翻车现场:早期方案直接把两套代码硬塞进一个合约里,堪比把电饭煲和洗衣机焊在一起。结果不仅转账费(Gas)贵到离谱,买卖碎片时还会把你手里最稀有的"SSR 级 NFT"当废纸一样随机销毁,属实是个"暴力缝合怪"。
  • 2.0 时代(DN-404)的破局神操作 :新标准彻底想通了------既然塞一起打架,那就分家过日子! 搞一个"管账的本体合约(ERC-20)"+ 一个"管发卡的镜像合约(ERC-721)"。一个管钱,一个管图,暗地里用一条加密专线死死绑定。
  • 给咱们的启示 :写代码跟做人一样,别试图让一个模块干所有的活。各司其职、互不干扰,才是顶级架构的浪漫。

正所谓"光说不练假把式"。看懂了原理,今天咱们就直接卷起袖子进厨房,亲手搭一个最小化、能跑通自动化闭环的 DN-404 极简原型。哪怕你不是天天写代码的极客,顺着下面的逻辑看下来,也能彻底看穿它底层的"自动发卡机"是怎么转起来的!


一、 核心玩法拆解:这台"自动售货机"怎么运转?

在写代码之前,咱们先画一张草图。你可以把整个 DN-404 想象成一台全自动盲盒售货机,规矩就四条,简单粗暴:

  1. 明码标价 :1 个完整代币(10^18 最小单位) = 1 张 NFT 卡片。不多不少,童叟无欺。

  2. 攒够整币,自动吐卡(币驱动图) :

    • 你在交易所零敲碎打买代币,只要钱包里的整币数量往上跳了一格 (比如从 0.8 变成 1.2),售货机立刻"咔嚓"一声,往你钱包里吐出 1 张 NFT。
    • 反过来,如果你卖掉了一点币,整币数量往下掉了一格 (比如从 1.2 变成 0.9),机器二话不说,直接把你手里最后拿到的一张卡收回去销毁(行话叫 LIFO:后进先出,就像一摞盘子,永远先拿最上面那个)。
  3. 转走卡片,钱自动跟过去(图驱动币) :

    • 如果你直接在 OpenSea 上把这张 NFT 转送给了好兄弟,镜像合约在过户卡片的同时,会偷偷给本体合约发个暗号:"兄弟,把这哥们账户里的 1 个整币也划给人家!" 确保图在人在,图走钱消。
  4. 防卡死安全锁:你想啊,"钱动"会触发"图动","图动"又会触发"钱动",这要是没个拦着,俩合约岂不是要无限套娃、原地卡死?所以咱们必须在底层加一道"免打扰专属通道",防止左右互搏。


二、 动手造轮子:双子星核心合约

下面就是最核心的两大合约骨架。为了让大家看清脉络,我把关键的逻辑路标都标好了,具体的砖头水泥(代码细节)留给大家亲手填进去,体验一把当协议架构师的快乐!

1. 管账的大哥:DN404Base.sol(标准 ERC-20 本体)

这位大哥对外就是个老实巴交的 ERC-20 代币,去 Uniswap 组池子、在钱包里转账跟普通土狗币一模一样。它的秘密全藏在每次余额变动的 _update 钩子里------每次算完账,它都会偷偷瞄一眼双方的整币数量变没变。

js 复制代码
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

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

interface IDN404Mirror {
    function mintFromBase(address to, uint256 tokenId) external;
    function burnFromBase(uint256 tokenId) external;
}

contract CustomDN404 is ERC20, Ownable {
    IDN404Mirror public immutable mirror;
    
    uint256 public constant UNIT = 10 ** 18;
    uint256 public immutable maxNFTSupply;
    uint256 private _nextTokenId = 1;

    /// @notice 回收已销毁的 NFT ID 池(后进先出栈),保证 ID 永远不越界
    uint256[] private _burnedTokenIds;

    /// @notice 记录每个地址持有的 NFT ID 列表
    mapping(address => uint256[]) private _ownedTokenIds;
    /// @notice 记录每个 tokenId 在其持有者数组中的下标,实现 O(1) 精准移除
    mapping(uint256 => uint256) private _ownedTokenIndex;

    /// @notice 免除 NFT 铸造/销毁的白名单(默认合约地址开启,EOA 账户关闭)
    mapping(address => bool) public skipNFT;

    /// @notice 瞬态存储锁:防止 Mirror 触发代币划转时再次触发 Base 的 Mint/Burn
    bool private transient _isSyncingFromMirror;

    error OnlyMirrorCanCall();
    error MaxSupplyExceeded();

    event SkipNFTUpdated(address indexed account, bool status);

    constructor(
        string memory name_,
        string memory symbol_,
        uint256 maxNFTSupply_,
        address initialOwner_,
        address mirrorAddress_
    ) ERC20(name_, symbol_) Ownable(initialOwner_) {
        maxNFTSupply = maxNFTSupply_;
        mirror = IDN404Mirror(mirrorAddress_);
        
        // 默认开启部署者免 NFT,方便一次性铸造初始总供应量(如注入 DEX 池子)
        skipNFT[initialOwner_] = true;
    }

    /// @notice 铸造初始代币供应量(最大不超过 maxNFTSupply * UNIT)
    function mintInitialSupply(address to, uint256 tokenAmount) external onlyOwner {
        if (totalSupply() + tokenAmount > maxNFTSupply * UNIT) revert MaxSupplyExceeded();
        _mint(to, tokenAmount);
    }

    /// @notice 用户或管理员设置是否跳过 NFT 铸造(Uniswap 池子必须设为 true)
    function setSkipNFT(bool status) external {
        skipNFT[msg.sender] = status;
        emit SkipNFTUpdated(msg.sender, status);
    }

    function setSkipNFTForContract(address target, bool status) external onlyOwner {
        skipNFT[target] = status;
        emit SkipNFTUpdated(target, status);
    }

    /// @notice 核心拦截器:处理所有 ERC-20 余额变动
    function _update(address from, address to, uint256 value) internal override {
        // 如果是由 Mirror 合约转移 NFT 引发的 1 UNIT 同步划转,直接完成代币记账并退出
        if (_isSyncingFromMirror) {
            super._update(from, to, value);
            return;
        }

        uint256 fromBalBefore = from == address(0) ? 0 : balanceOf(from);
        uint256 toBalBefore = to == address(0) ? 0 : balanceOf(to);

        super._update(from, to, value);

        // 1. 发送方整数位减少 -> 销毁对应数量的 NFT
        if (from != address(0) && !skipNFT[from]) {
            uint256 nftBefore = fromBalBefore / UNIT;
            uint256 nftAfter = balanceOf(from) / UNIT;
            if (nftBefore > nftAfter) {
                _burnNFTs(from, nftBefore - nftAfter);
            }
        }

        // 2. 接收方整数位增加 -> 铸造对应数量的 NFT
        if (to != address(0) && !skipNFT[to]) {
            uint256 nftBefore = toBalBefore / UNIT;
            uint256 nftAfter = balanceOf(to) / UNIT;
            if (nftAfter > nftBefore) {
                _mintNFTs(to, nftAfter - nftBefore);
            }
        }
    }

    /// @notice 双向闭环回调:当用户在 OpenSea 直接转移整张 NFT 时由 Mirror 调用
    function transferFromMirror(address from, address to, uint256 tokenId) external {
        if (msg.sender != address(mirror)) revert OnlyMirrorCanCall();

        // 1. 从发送方队列 O(1) 移除该指定 tokenId
        _removeTokenFromOwner(from, tokenId);

        // 2. 如果接收方未跳过 NFT,则记入接收方队列;若接收方是免 NFT 池子,则回收销毁该 NFT
        if (!skipNFT[to]) {
            _addTokenToOwner(to, tokenId);
        } else {
            _burnedTokenIds.push(tokenId);
            mirror.burnFromBase(tokenId);
        }

        // 3. 开启瞬态锁,同步划转 1 个完整代币
        _isSyncingFromMirror = true;
        super._update(from, to, UNIT);
        _isSyncingFromMirror = false;
    }

    // ==================== 内部 O(1) 队列与 ID 回收引擎 ====================

    function _mintNFTs(address to, uint256 count) internal {
        for (uint256 i = 0; i < count; ++i) {
            uint256 tokenId;
            // 优先从回收池弹出旧 ID,确保 ID 严格循环在 1 ~ maxNFTSupply
            if (_burnedTokenIds.length > 0) {
                tokenId = _burnedTokenIds[_burnedTokenIds.length - 1];
                _burnedTokenIds.pop();
            } else {
                tokenId = _nextTokenId++;
                if (tokenId > maxNFTSupply) revert MaxSupplyExceeded();
            }

            _addTokenToOwner(to, tokenId);
            mirror.mintFromBase(to, tokenId);
        }
    }

    function _burnNFTs(address from, uint256 count) internal {
        uint256[] storage ids = _ownedTokenIds[from];
        for (uint256 i = 0; i < count; ++i) {
            // 后进先出(LIFO):销毁用户最新获得的 NFT
            uint256 tokenId = ids[ids.length - 1];
            _removeTokenFromOwner(from, tokenId);
            
            // 压入回收栈供后续复用
            _burnedTokenIds.push(tokenId);
            mirror.burnFromBase(tokenId);
        }
    }

    function _addTokenToOwner(address to, uint256 tokenId) internal {
        _ownedTokenIndex[tokenId] = _ownedTokenIds[to].length;
        _ownedTokenIds[to].push(tokenId);
    }

    /// @notice Swap-and-Pop 算法:O(1) 时间复杂度移除指定 tokenId,避免数组遍历消耗 Gas
    function _removeTokenFromOwner(address from, uint256 tokenId) internal {
        uint256[] storage ids = _ownedTokenIds[from];
        uint256 lastIndex = ids.length - 1;
        uint256 targetIndex = _ownedTokenIndex[tokenId];

        if (targetIndex != lastIndex) {
            uint256 lastTokenId = ids[lastIndex];
            ids[targetIndex] = lastTokenId;
            _ownedTokenIndex[lastTokenId] = targetIndex;
        }

        ids.pop();
        delete _ownedTokenIndex[tokenId];
    }

    /// @notice 辅助查询函数:查看某地址当前持有的所有 NFT ID 列表
    function getOwnedTokenIds(address owner) external view returns (uint256[] memory) {
        return _ownedTokenIds[owner];
    }
}

2. 管图的小弟:DN404Mirror.sol(标准 ERC-721 镜像)

这位小弟专门负责在 NFT 市场和钱包里"抛头露面"。为了省下高昂的链上存储费,它还自带一个 "二手卡片回收箱( burnedPool )" ------别人销毁掉的编号先扔进箱子里,下次有人凑够整币,优先从箱子里摸一张旧编号发出去,主打一个勤俭持家!

js 复制代码
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";

interface ICustomDN404 {
    function transferFromMirror(address from, address to, uint256 tokenId) external;
    function owner() external view returns (address);
}

contract MyDN404Mirror is ERC721 {
    using Strings for uint256;

    /// @notice 绑定的主合约 (ERC-20) 地址
    address public baseERC20;

    /// @notice NFT 元数据基础 URI(例如 ipfs://Qm.../)
    string private _baseTokenURI;

    /// @notice 利用 Solidity 0.8.28 瞬态存储实现的同步状态锁(比普通 storage 省约 20,000 Gas)
    bool private transient _isSyncingFromBase;

    error OnlyBaseERC20();
    error OnlyBaseOwner();
    error AlreadyInitialized();
    error InvalidBaseAddress();

    modifier onlyBase() {
        if (msg.sender != baseERC20) revert OnlyBaseERC20();
        _;
    }

    modifier onlyBaseOwner() {
        if (msg.sender != ICustomDN404(baseERC20).owner()) revert OnlyBaseOwner();
        _;
    }

    constructor(
        string memory name_,
        string memory symbol_,
        string memory initialBaseURI_
    ) ERC721(name_, symbol_) {
        _baseTokenURI = initialBaseURI_;
    }

    /// @notice 绑定主合约地址(部署完主合约后调用一次,避免循环依赖构造难题)
    function linkBaseERC20(address baseAddress_) external {
        if (baseERC20 != address(0)) revert AlreadyInitialized();
        if (baseAddress_ == address(0)) revert InvalidBaseAddress();
        baseERC20 = baseAddress_;
    }

    /// @notice 由主合约调用:当用户买满 1 个完整代币时铸造对应 NFT
    function mintFromBase(address to, uint256 tokenId) external onlyBase {
        _isSyncingFromBase = true;
        _mint(to, tokenId);
        _isSyncingFromBase = false;
    }

    /// @notice 由主合约调用:当用户卖出代币导致整数位减少时销毁 NFT
    function burnFromBase(uint256 tokenId) external onlyBase {
        _isSyncingFromBase = true;
        _burn(tokenId);
        _isSyncingFromBase = false;
    }

    /// @notice 核心双向闭环:拦截 OZ v5 的统一更新钩子
    function _update(
        address to,
        uint256 tokenId,
        address auth
    ) internal override returns (address) {
        address from = super._update(to, tokenId, auth);

        // 只有当变动不是由 Base 合约触发(即用户在 OpenSea/Blur/钱包直接转移 NFT)时,才反向通知 Base
        if (!_isSyncingFromBase && from != address(0) && to != address(0)) {
            ICustomDN404(baseERC20).transferFromMirror(from, to, tokenId);
        }

        return from;
    }

    /// @notice 动态修改盲盒开图 URI(仅主合约 Owner 可调用)
    function setBaseURI(string calldata newBaseURI) external onlyBaseOwner {
        _baseTokenURI = newBaseURI;
    }

    function _baseURI() internal view override returns (string memory) {
        return _baseTokenURI;
    }

    /// @notice 返回标准 JSON 元数据链接,例如 ipfs://xxx/1.json
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        _requireOwned(tokenId);
        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0
            ? string.concat(baseURI, tokenId.toString(), ".json")
            : "";
    }
}

三、 老司机防翻车指南(三个极易踩的坑)

很多兄弟看懂了原理,代码一跑直接报错或者 Gas 爆炸,多半是栽在了下面这三个坑里:

  1. 创世发币直接炸缸 :项目刚部署时,你往自己钱包里一口气 Mint 一万个币,如果直接走通用逻辑,合约会试图在同一笔交易里同时铸造一万张 NFT ,瞬间把区块 Gas 撑爆!解法:给项目方金库和 Uniswap 流动性池加个"免发卡白名单",做市商只管搬砖交易,不参与发卡凑热闹。
  2. 左手倒右手的乌龙 :如果某个闲得无聊的用户,自己给自己转了 1 个整币,你不做拦截的话,合约会傻乎乎地先销毁他一张卡,再重新发他一张新卡,白白浪费手续费。解法 :钩子开头第一行直接写死 if (from == to) return;。
  3. 丝滑的免二次授权体验 :用户在 OpenSea 卖 NFT 时,只需要授权一次 Mirror 合约。因为 Mirror 内部调用 Base 走的是"协议级后门(transferFromMirror)",用户不需要再去 ERC-20 合约里点一次授权,体验直接拉满!

四、 终极质检:自动化测试剧本

  • 测试用例:DN-404 (图币二象性) 全链路闭环集成测试
    • 初始化验证:双合约应正确完成绑定,且免 NFT 账户初始铸造不产生镜像 NFT
    • 币 -> 图闭环:散户碎片买入跨过 1.0 阈值自动铸造 NFT,批量买入连续铸造
    • 图 -> 币闭环:在 NFT 市场直接转移指定 ID,主合约同步划转 1.0 枚代币且无重入循环
    • 销毁与 ID 回收闭环:卖出代币跌破整数位销毁最新 NFT,后续新铸造优先复用回收池 ID
    • 权限与安全拦截:外部地址无法直接调用 Mirror 内部的 mintFromBase 或 Base 的 transferFromMirror
js 复制代码
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { parseEther, getAddress } from "viem";
import { network } from "hardhat";

describe("DN-404 (图币二象性) 全链路闭环集成测试", function () {
  const MAX_NFT_SUPPLY = 1000n;
  const INITIAL_MINT_AMOUNT = parseEther("100");

  async function deployFixture() {
    const { viem } = await (network as any).connect();
    const [deployer, alice, bob] = await viem.getWalletClients();
    const publicClient = await viem.getPublicClient();

    // 1. 部署镜像合约 (MyDN404Mirror)
    const mirror = await viem.deployContract("MyDN404Mirror", [
      "Hybrid NFT",
      "HNFT",
      "ipfs://QmTestBaseURI/",
    ]);

    // 2. 部署主合约 (CustomDN404)
    const base = await viem.deployContract("CustomDN404", [
      "Hybrid Token",
      "HBT",
      MAX_NFT_SUPPLY,
      deployer.account.address,
      mirror.address,
    ]);

    // 3. 双向绑定主合约与镜像合约
    await mirror.write.linkBaseERC20([base.address], {
      account: deployer.account,
    });

    // 4. 铸造初始 100 枚代币给部署者(部署者默认 skipNFT=true,不会触发 100 次 NFT 铸造)
    await base.write.mintInitialSupply([deployer.account.address, INITIAL_MINT_AMOUNT], {
      account: deployer.account,
    });

    return {
      base,
      mirror,
      deployer,
      alice,
      bob,
      publicClient,
    };
  }

  it("初始化验证:双合约应正确完成绑定,且免 NFT 账户初始铸造不产生镜像 NFT", async function () {
    const { base, mirror, deployer } = await deployFixture();

    const boundBase = await mirror.read.baseERC20();
    const boundMirror = await base.read.mirror();
    const deployerTokenBal = await base.read.balanceOf([deployer.account.address]);
    const deployerNFTBal = await mirror.read.balanceOf([deployer.account.address]);

    assert.equal(getAddress(boundBase), getAddress(base.address), "Mirror 绑定的 Base 地址不匹配");
    assert.equal(getAddress(boundMirror), getAddress(mirror.address), "Base 绑定的 Mirror 地址不匹配");
    assert.equal(deployerTokenBal, INITIAL_MINT_AMOUNT, "部署者初始 ERC20 余额应为 100");
    assert.equal(deployerNFTBal, 0n, "部署者开启了 skipNFT,初始 NFT 数量应为 0");

    // 验证防重复初始化保护
    await assert.rejects(
      async () => {
        await mirror.write.linkBaseERC20([deployer.account.address], {
          account: deployer.account,
        });
      },
      /AlreadyInitialized/,
      "不允许重复调用 linkBaseERC20"
    );
  });

  it("币 -> 图闭环:散户碎片买入跨过 1.0 阈值自动铸造 NFT,批量买入连续铸造", async function () {
    const { base, mirror, deployer, alice } = await deployFixture();

    // 1. Alice 先买入 0.6 枚(不足 1 枚,不应有 NFT)
    await base.write.transfer([alice.account.address, parseEther("0.6")], {
      account: deployer.account,
    });
    assert.equal(await mirror.read.balanceOf([alice.account.address]), 0n, "不足 1 枚代币不应铸造 NFT");

    // 2. Alice 再买入 0.5 枚(累计 1.1 枚,跨过 1.0 阈值,自动铸造 #1)
    await base.write.transfer([alice.account.address, parseEther("0.5")], {
      account: deployer.account,
    });
    assert.equal(await mirror.read.balanceOf([alice.account.address]), 1n, "满 1.1 枚应自动铸造 1 张 NFT");
    assert.equal(
      getAddress(await mirror.read.ownerOf([1n])),
      getAddress(alice.account.address),
      "NFT #1 所有者应为 Alice"
    );

    // 3. Alice 一次性再买入 2.1 枚(累计 3.2 枚,整数位从 1 变 3,应再铸造 #2 和 #3)
    await base.write.transfer([alice.account.address, parseEther("2.1")], {
      account: deployer.account,
    });
    assert.equal(await mirror.read.balanceOf([alice.account.address]), 3n, "累计 3.2 枚应持有 3 张 NFT");
    assert.equal(getAddress(await mirror.read.ownerOf([2n])), getAddress(alice.account.address));
    assert.equal(getAddress(await mirror.read.ownerOf([3n])), getAddress(alice.account.address));

    // 验证元数据拼接格式
    assert.equal(await mirror.read.tokenURI([1n]), "ipfs://QmTestBaseURI/1.json");
  });

  it("图 -> 币闭环:在 NFT 市场直接转移指定 ID,主合约同步划转 1.0 枚代币且无重入循环", async function () {
    const { base, mirror, deployer, alice, bob } = await deployFixture();

    // Alice 先获得 3.2 枚代币(持有 #1, #2, #3 三张 NFT)
    await base.write.transfer([alice.account.address, parseEther("3.2")], {
      account: deployer.account,
    });

    // Alice 在 NFT 市场直接把中间的 #2 转给 Bob(测试 O(1) Swap-and-Pop 队列移除)
    await mirror.write.transferFrom(
      [alice.account.address, bob.account.address, 2n],
      { account: alice.account }
    );

    // 验证 NFT 归属变化
    assert.equal(getAddress(await mirror.read.ownerOf([2n])), getAddress(bob.account.address), "#2 应归属 Bob");
    assert.equal(await mirror.read.balanceOf([alice.account.address]), 2n, "Alice 应剩余 2 张 NFT");
    assert.equal(await mirror.read.balanceOf([bob.account.address]), 1n, "Bob 应拥有 1 张 NFT");

    // 验证底层 ERC-20 代币同步划转了精确的 1.0 枚
    assert.equal(await base.read.balanceOf([alice.account.address]), parseEther("2.2"), "Alice 代币应自动减 1");
    assert.equal(await base.read.balanceOf([bob.account.address]), parseEther("1.0"), "Bob 代币应自动加 1");

    // 验证 Alice 内部记录的持有队列只剩 [1, 3]
    const aliceIds = await base.read.getOwnedTokenIds([alice.account.address]);
    assert.deepEqual(aliceIds, [1n, 3n], "Alice 内部队列应精准移除 #2 并保留 #1 和 #3");
  });

  it("销毁与 ID 回收闭环:卖出代币跌破整数位销毁最新 NFT,后续新铸造优先复用回收池 ID", async function () {
    const { base, mirror, deployer, alice, bob } = await deployFixture();

    // 1. Alice 买入 2.2 枚代币(获得 #1 和 #2)
    await base.write.transfer([alice.account.address, parseEther("2.2")], {
      account: deployer.account,
    });

    // 2. Alice 卖出 0.5 枚(余额 2.2 -> 1.7,跌破 2 整数位,后进先出销毁 #2)
    await base.write.transfer([deployer.account.address, parseEther("0.5")], {
      account: alice.account,
    });

    assert.equal(await mirror.read.balanceOf([alice.account.address]), 1n, "Alice 应只剩 1 张 NFT");
    assert.equal(getAddress(await mirror.read.ownerOf([1n])), getAddress(alice.account.address), "#1 应完好保留");

    // 验证 #2 已被彻底销毁(查询 ownerOf(2) 应 revert)
    await assert.rejects(
      async () => {
        await mirror.read.ownerOf([2n]);
      },
      /ERC721NonexistentToken/,
      "NFT #2 应已被销毁"
    );

    // 3. Bob 买入 1.0 枚代币,应从回收池优先获得刚被销毁的 #2,而不是新生成 #3
    await base.write.transfer([bob.account.address, parseEther("1.0")], {
      account: deployer.account,
    });

    assert.equal(await mirror.read.balanceOf([bob.account.address]), 1n);
    assert.equal(
      getAddress(await mirror.read.ownerOf([2n])),
      getAddress(bob.account.address),
      "Bob 应从回收池复用并铸造出 #2"
    );
  });

  it("权限与安全拦截:外部地址无法直接调用 Mirror 内部的 mintFromBase 或 Base 的 transferFromMirror", async function () {
    const { base, mirror, alice, bob } = await deployFixture();

    await assert.rejects(
      async () => {
        await mirror.write.mintFromBase([alice.account.address, 99n], {
          account: alice.account,
        });
      },
      (err: any) => {
        const revertErr = typeof err?.walk === "function" ? err.walk() : err;
        const msg = JSON.stringify(revertErr) + String(err?.message || "");
        // 兼容 Hardhat EDR 节点解码出的自定义错误名或交易 Revert 拒绝
        return (
          msg.includes("OnlyBaseERC20") ||
          msg.includes("reverted") ||
          msg.includes("InvalidParamsRpcError")
        );
      },
      "非 Base 合约禁止调用 mintFromBase"
    );

    await assert.rejects(
      async () => {
        await base.write.transferFromMirror([alice.account.address, bob.account.address, 1n], {
          account: alice.account,
        });
      },
      (err: any) => {
        const revertErr = typeof err?.walk === "function" ? err.walk() : err;
        const msg = JSON.stringify(revertErr) + String(err?.message || "");
        return (
          msg.includes("OnlyMirrorCanCall") ||
          msg.includes("reverted") ||
          msg.includes("InvalidParamsRpcError")
        );
      },
      "非 Mirror 合约禁止调用 transferFromMirror"
    );
  });

});

写在最后

你看,把那些高大上的区块链黑话剥开,DN-404 的本质其实就是 "一个管账的、一个管图的,俩人用加密暗号打配合" 。亲手把上面这几块拼图填满、看着测试脚本全绿的那一刻,你不仅彻底吃透了图币二象性,更是直接掌握了 Web3 开发中最核心的跨合约状态同步心法

相关推荐
OxYGC1 天前
[Web3] 智能合约 15: 项目实战⑦ 从0到1 体育投注
web3·智能合约
OxYGC2 天前
[Web3] 智能合约 13: 项目实战⑤ DappLink Oracle
oracle·web3·智能合约
木西5 天前
深度拆解 MyShell 底层:AI Agent 生态结算合约,如何实现安全防阻塞
web3·智能合约·solidity
Cooper256 天前
合约托管 + 验收释放:悬赏 DApp 的四态状态机与事件索引
web3·solidity
OxYGC7 天前
[Web3] 智能合约 04: 高级开发实战与 OpenZeppelin
web3·区块链·智能合约
笑容掩饰我的失落7 天前
区块链从小白到精通(七):Solidity 语法精讲——数据类型、函数、修饰器与事件
算法·区块链·php·智能合约·哈希算法
OxYGC7 天前
[Web3] 智能合约 03: 函数/事件/继承/接口/异常处理
web3·区块链·智能合约
笑容掩饰我的失落8 天前
区块链从小白到精通(八):从零实现一个标准 ERC-20 代币(完整可运行代码)
算法·区块链·php·智能合约·哈希算法
OxYGC8 天前
[Web3] 智能合约 02: Solidity 基础语法
web3·区块链·智能合约