前言:从"硬塞缝合怪"到"双子星联动"
上一篇咱们聊透了"图币二象性"的前世今生。怕有刚刷到的兄弟没看上集,咱们花 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 个完整代币(10^18 最小单位) = 1 张 NFT 卡片。不多不少,童叟无欺。 -
攒够整币,自动吐卡(币驱动图) :
- 你在交易所零敲碎打买代币,只要钱包里的整币数量往上跳了一格 (比如从
0.8变成1.2),售货机立刻"咔嚓"一声,往你钱包里吐出1张 NFT。 - 反过来,如果你卖掉了一点币,整币数量往下掉了一格 (比如从
1.2变成0.9),机器二话不说,直接把你手里最后拿到的一张卡收回去销毁(行话叫 LIFO:后进先出,就像一摞盘子,永远先拿最上面那个)。
- 你在交易所零敲碎打买代币,只要钱包里的整币数量往上跳了一格 (比如从
-
转走卡片,钱自动跟过去(图驱动币) :
- 如果你直接在 OpenSea 上把这张 NFT 转送给了好兄弟,镜像合约在过户卡片的同时,会偷偷给本体合约发个暗号:"兄弟,把这哥们账户里的
1个整币也划给人家!" 确保图在人在,图走钱消。
- 如果你直接在 OpenSea 上把这张 NFT 转送给了好兄弟,镜像合约在过户卡片的同时,会偷偷给本体合约发个暗号:"兄弟,把这哥们账户里的
-
防卡死安全锁:你想啊,"钱动"会触发"图动","图动"又会触发"钱动",这要是没个拦着,俩合约岂不是要无限套娃、原地卡死?所以咱们必须在底层加一道"免打扰专属通道",防止左右互搏。
二、 动手造轮子:双子星核心合约
下面就是最核心的两大合约骨架。为了让大家看清脉络,我把关键的逻辑路标都标好了,具体的砖头水泥(代码细节)留给大家亲手填进去,体验一把当协议架构师的快乐!
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 爆炸,多半是栽在了下面这三个坑里:
- 创世发币直接炸缸 :项目刚部署时,你往自己钱包里一口气 Mint 一万个币,如果直接走通用逻辑,合约会试图在同一笔交易里同时铸造一万张 NFT ,瞬间把区块 Gas 撑爆!解法:给项目方金库和 Uniswap 流动性池加个"免发卡白名单",做市商只管搬砖交易,不参与发卡凑热闹。
- 左手倒右手的乌龙 :如果某个闲得无聊的用户,自己给自己转了
1个整币,你不做拦截的话,合约会傻乎乎地先销毁他一张卡,再重新发他一张新卡,白白浪费手续费。解法 :钩子开头第一行直接写死if (from == to) return;。 - 丝滑的免二次授权体验 :用户在 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 开发中最核心的跨合约状态同步心法