1 of 1

练习 2: 创建你的首个跨链NFT

代码时间 🎉

CCIP 配置参数

开始使用

您可以使用任何区块链开发框架来使用Chainlink CCIP。对于本次训练营，我们准备了Hardhat、Foundry 和 Remix IDE 的步骤说明。

让我们创建一个新项目。

或者你可以克隆：

安装@chainlink/contracts-ccip NPM包

安装此包，请按照您用于本x的开发环境进行操作。

运行：

forge install smartcontractkit/ccip@ccip-develop

然后在您的 foundry.toml 或 remappings.txt 文件中设置 remappings 为

# foundry.toml
remappings = [
    '@chainlink/contracts-ccip/=lib/ccip/contracts/'
]

forge install smartcontractkit/chainlink

并设置remappings为：

# foundry.toml
remappings = [
    '@chainlink/contracts/=lib/chainlink/contracts/'
]

forge install OpenZeppelin/openzeppelin-contracts

并在 foundry.toml或 remappings.txt 文件中将 remappings 设置为 @openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/。

# foundry.toml
remappings = [
    '@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/'
]

创建一个新的 Solidity 文件，并粘贴上以下内容。这是一个空合约，只导入了 @chainlink/contracts-ccip 包中的一个合约。

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

import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract Empty {}

编译它。如果成功编译并生成了 .deps/npm/@chainlink/contracts-ccip、.deps/npm/@chainlink/contracts 和 .deps/npm/@openzeppelin/contracts 文件夹，意味着我们已将所有必要的包导入到了 Remix IDE 工作区。

水龙头

开发xNFT智能合约

在contracts文件夹中创建新文件XNFT.sol

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

import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import {ERC721URIStorage} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import {ERC721Burnable} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {Client} from "@chainlink/contracts-ccip/src/v0.8/ccip/libraries/Client.sol";
import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";
import {IAny2EVMMessageReceiver} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IAny2EVMMessageReceiver.sol";
import {OwnerIsCreator} from "@chainlink/contracts-ccip/src/v0.8/shared/access/OwnerIsCreator.sol";
import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol";

/**
 * THIS IS AN EXAMPLE CONTRACT THAT USES HARDCODED VALUES FOR CLARITY.
 * THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
 * DO NOT USE THIS CODE IN PRODUCTION.
 */
contract XNFT is
    ERC721,
    ERC721URIStorage,
    ERC721Burnable,
    IAny2EVMMessageReceiver,
    ReentrancyGuard,
    OwnerIsCreator
{
    using SafeERC20 for IERC20;

    enum PayFeesIn {
        Native,
        LINK
    }

    error InvalidRouter(address router);
    error OnlyOnArbitrumSepolia();
    error NotEnoughBalanceForFees(
        uint256 currentBalance,
        uint256 calculatedFees
    );
    error NothingToWithdraw();
    error FailedToWithdrawEth(address owner, address target, uint256 value);
    error ChainNotEnabled(uint64 chainSelector);
    error SenderNotEnabled(address sender);
    error OperationNotAllowedOnCurrentChain(uint64 chainSelector);

    struct XNftDetails {
        address xNftAddress;
        bytes ccipExtraArgsBytes;
    }

    uint256 constant ARBITRUM_SEPOLIA_CHAIN_ID = 421614;

    string[] characters = [
        "https://ipfs.io/ipfs/QmTgqnhFBMkfT9s8PHKcdXBn1f5bG3Q5hmBaR4U6hoTvb1?filename=Chainlink_Elf.png",
        "https://ipfs.io/ipfs/QmZGQA92ri1jfzSu61JRaNQXYg1bLuM7p8YT83DzFA2KLH?filename=Chainlink_Knight.png",
        "https://ipfs.io/ipfs/QmW1toapYs7M29rzLXTENn3pbvwe8ioikX1PwzACzjfdHP?filename=Chainlink_Orc.png",
        "https://ipfs.io/ipfs/QmPMwQtFpEdKrUjpQJfoTeZS1aVSeuJT6Mof7uV29AcUpF?filename=Chainlink_Witch.png"
    ];

    IRouterClient internal immutable i_ccipRouter;
    LinkTokenInterface internal immutable i_linkToken;
    uint64 private immutable i_currentChainSelector;

    uint256 private _nextTokenId;

    mapping(uint64 destChainSelector => XNftDetails xNftDetailsPerChain)
        public s_chains;

    event ChainEnabled(
        uint64 chainSelector,
        address xNftAddress,
        bytes ccipExtraArgs
    );
    event ChainDisabled(uint64 chainSelector);
    event CrossChainSent(
        address from,
        address to,
        uint256 tokenId,
        uint64 sourceChainSelector,
        uint64 destinationChainSelector
    );
    event CrossChainReceived(
        address from,
        address to,
        uint256 tokenId,
        uint64 sourceChainSelector,
        uint64 destinationChainSelector
    );

    modifier onlyRouter() {
        if (msg.sender != address(i_ccipRouter))
            revert InvalidRouter(msg.sender);
        _;
    }

    modifier onlyOnArbitrumSepolia() {
        if (block.chainid != ARBITRUM_SEPOLIA_CHAIN_ID)
            revert OnlyOnArbitrumSepolia();
        _;
    }

    modifier onlyEnabledChain(uint64 _chainSelector) {
        if (s_chains[_chainSelector].xNftAddress == address(0))
            revert ChainNotEnabled(_chainSelector);
        _;
    }

    modifier onlyEnabledSender(uint64 _chainSelector, address _sender) {
        if (s_chains[_chainSelector].xNftAddress != _sender)
            revert SenderNotEnabled(_sender);
        _;
    }

    modifier onlyOtherChains(uint64 _chainSelector) {
        if (_chainSelector == i_currentChainSelector)
            revert OperationNotAllowedOnCurrentChain(_chainSelector);
        _;
    }

    constructor(
        address ccipRouterAddress,
        address linkTokenAddress,
        uint64 currentChainSelector
    ) ERC721("Cross Chain NFT", "XNFT") {
        if (ccipRouterAddress == address(0)) revert InvalidRouter(address(0));
        i_ccipRouter = IRouterClient(ccipRouterAddress);
        i_linkToken = LinkTokenInterface(linkTokenAddress);
        i_currentChainSelector = currentChainSelector;
    }

    function mint() external onlyOnArbitrumSepolia {
        uint256 tokenId = _nextTokenId++;
        string memory uri = characters[tokenId % characters.length];
        _safeMint(msg.sender, tokenId);
        _setTokenURI(tokenId, uri);
    }

    function enableChain(
        uint64 chainSelector,
        address xNftAddress,
        bytes memory ccipExtraArgs
    ) external onlyOwner onlyOtherChains(chainSelector) {
        s_chains[chainSelector] = XNftDetails({
            xNftAddress: xNftAddress,
            ccipExtraArgsBytes: ccipExtraArgs
        });

        emit ChainEnabled(chainSelector, xNftAddress, ccipExtraArgs);
    }

    function disableChain(
        uint64 chainSelector
    ) external onlyOwner onlyOtherChains(chainSelector) {
        delete s_chains[chainSelector];

        emit ChainDisabled(chainSelector);
    }

    function crossChainTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        uint64 destinationChainSelector,
        PayFeesIn payFeesIn
    )
        external
        nonReentrant
        onlyEnabledChain(destinationChainSelector)
        returns (bytes32 messageId)
    {
        string memory tokenUri = tokenURI(tokenId);
        _burn(tokenId);

        Client.EVM2AnyMessage memory message = Client.EVM2AnyMessage({
            receiver: abi.encode(
                s_chains[destinationChainSelector].xNftAddress
            ),
            data: abi.encode(from, to, tokenId, tokenUri),
            tokenAmounts: new Client.EVMTokenAmount[](0),
            extraArgs: s_chains[destinationChainSelector].ccipExtraArgsBytes,
            feeToken: payFeesIn == PayFeesIn.LINK
                ? address(i_linkToken)
                : address(0)
        });

        // Get the fee required to send the CCIP message
        uint256 fees = i_ccipRouter.getFee(destinationChainSelector, message);

        if (payFeesIn == PayFeesIn.LINK) {
            if (fees > i_linkToken.balanceOf(address(this)))
                revert NotEnoughBalanceForFees(
                    i_linkToken.balanceOf(address(this)),
                    fees
                );

            // Approve the Router to transfer LINK tokens on contract's behalf. It will spend the fees in LINK
            i_linkToken.approve(address(i_ccipRouter), fees);

            // Send the message through the router and store the returned message ID
            messageId = i_ccipRouter.ccipSend(
                destinationChainSelector,
                message
            );
        } else {
            if (fees > address(this).balance)
                revert NotEnoughBalanceForFees(address(this).balance, fees);

            // Send the message through the router and store the returned message ID
            messageId = i_ccipRouter.ccipSend{value: fees}(
                destinationChainSelector,
                message
            );
        }

        emit CrossChainSent(
            from,
            to,
            tokenId,
            i_currentChainSelector,
            destinationChainSelector
        );
    }

    /// @inheritdoc IAny2EVMMessageReceiver
    function ccipReceive(
        Client.Any2EVMMessage calldata message
    )
        external
        virtual
        override
        onlyRouter
        nonReentrant
        onlyEnabledChain(message.sourceChainSelector)
        onlyEnabledSender(
            message.sourceChainSelector,
            abi.decode(message.sender, (address))
        )
    {
        uint64 sourceChainSelector = message.sourceChainSelector;
        (
            address from,
            address to,
            uint256 tokenId,
            string memory tokenUri
        ) = abi.decode(message.data, (address, address, uint256, string));

        _safeMint(to, tokenId);
        _setTokenURI(tokenId, tokenUri);

        emit CrossChainReceived(
            from,
            to,
            tokenId,
            sourceChainSelector,
            i_currentChainSelector
        );
    }

    function withdraw(address _beneficiary) public onlyOwner {
        uint256 amount = address(this).balance;

        if (amount == 0) revert NothingToWithdraw();

        (bool sent, ) = _beneficiary.call{value: amount}("");

        if (!sent) revert FailedToWithdrawEth(msg.sender, _beneficiary, amount);
    }

    function withdrawToken(
        address _beneficiary,
        address _token
    ) public onlyOwner {
        uint256 amount = IERC20(_token).balanceOf(address(this));

        if (amount == 0) revert NothingToWithdraw();

        IERC20(_token).safeTransfer(_beneficiary, amount);
    }

    function tokenURI(
        uint256 tokenId
    ) public view override(ERC721, ERC721URIStorage) returns (string memory) {
        return super.tokenURI(tokenId);
    }

    function getCCIPRouter() public view returns (address) {
        return address(i_ccipRouter);
    }

    function supportsInterface(
        bytes4 interfaceId
    ) public view override(ERC721, ERC721URIStorage) returns (bool) {
        return
            interfaceId == type(IAny2EVMMessageReceiver).interfaceId ||
            super.supportsInterface(interfaceId);
    }
}

运行以下指令来编译：

npx hardhat compile

在src文件夹中创建新文件XNFT.sol

点击“Create new file”按钮来创建新的Solidity文件XNFT.sol

准备部署

按照步骤添加必要的环境变量，以便部署这些合约并发送您的第一个 CCIP 消息。

该合约需要至少 0.8.20 的 Solidity 版本。因为在 0.8.20 版本的 Solc 中，默认的 EVM 版本为“上海”。在上海升级中，一个新的操作码 PUSH0 被添加到以太坊虚拟机中。

然而，除了以太坊外的大多数区块链尚未支持 PUSH0 操作码。

这意味着 PUSH0 操作码现在是合约字节码的一部分，如果您正在使用的链不支持它，它将会报出“无效操作码”错误。

为了了解更多信息，我们强烈建议您查看此 StackOverflow 的回复：

设置一个密码用于加密和解密环境变量文件。您可以稍后通过输入相同的命令来更改密码。

现在设置以下环境变量：PRIVATE_KEY、源区块链的 RPC URL、目标区块链的 RPC URL。在此示例中，我们将使用 Arbitrum Sepolia 和 Ethereum Sepolia。

要设置以上变量，请输入以下命令并按照终端中的说明进行操作：

完成以上操作后，.env.enc 文件将自动生成。如果您想验证您的输入，可以随时运行以下命令：

最后，扩展 hardhat.config 文件以支持这两个网络：

创建一个新文件.env。在其中填写您的钱包的 PRIVATE_KEY 以及至少两个区块链的 RPC URL。在此示例中，我们将使用 Arbitrum Sepolia 和 Ethereum Sepolia。

完成后，为了加载 .env 文件中的变量，请运行以下命令：

最后，扩展 foundry.toml文件以支持这两个网络：

点击进入到“Solidity compiler”选项卡

展开“Advanced Configurations”下拉菜单
展开“EVM VERSION”下拉菜单并选择“paris”而不是“default”

点击进入“Deploy & run transactions”选项卡，并从“Environment”下拉菜单中选择“Injected Provider - Metamask”选项。

如果您使用的是 Metamask 钱包，其中已经预装了Ethereum Sepolia 网络。确保您添加了 Arbitrum Sepolia 网络。

步骤1）在Ethereum Sepolia上部署XNFT.sol

进入scripts文件夹并创建一个名为 deployXNFT.ts的新文件。

运行部署脚本：

选项 1)

通过运行以下命令部署 XNFT.sol

选项 2)

在 scripts 文件夹下创建文件 XNFT.s.sol

运行以下指令来部署XNFT.sol：

打开 Metamask 钱包，切换到 Ethereum Sepolia 网络。

打开 XNFT.sol 文件。

打开“Solidity Compiler”选项卡，然后点击“Compile XNFT.sol”按钮。

打开“Deploy & run Transaction”选项卡，然后在“Environment”下拉菜单中选择“Injected Provider - Metamask”选项。确保`chainId`切换为11155111（如果没有切换，你需要在浏览器中刷新Remix IDE页面）

在“Contract”下拉菜单中，确保被选中的是“XNFT - XNFT.sol”。

找到橘黄色的按钮“Deploy”。在 ccipRouterAddress 中填入0x0bf3de8c5d3e8a2b34d2beeb17abfcebaf363a59，在 linkTokenAddress 中填入 0x779877A7B0D9E8603169DdbD7836e478b4624789，在 currentChainSelector 中填入 16015286601757825753。

点击橘黄色的“Deploy/Transact”按钮。

Metamask 通知会弹出来，对交易进行签名。

步骤 2) 在Arbitrum Sepolia上部署XNFT.sol

进入scripts文件夹并创建一个名为 deployXNFTArbitrum.ts的新文件。

运行部署脚本：

选项 1)

通过运行以下命令部署 XNFT.sol

选项 2)

在 scripts 文件夹下创建文件 XNFTArbitrum.s.sol

运行以下指令来部署XNFT.sol：

打开您的 Metamask 钱包并切换到 Arbitrum Sepolia 网络。

打开 XNFT.sol 文件。

点击进入“Solidity Compiler”选项卡并点击“Compile XNFT.sol”按钮。

点击进入“Deploy & run transactions”选项卡，并从“Environment”下拉菜单中选择“Injected Provider - Metamask”选项。确保 chainId 切换到 421614（如果没有，您可能需要刷新浏览器中的 Remix IDE 页面）。

在“Contract”下拉菜单中，确保选择了“XNFT - XNFT.sol”。

找到橙色的“Deploy”按钮。提供以下信息：

ccipRouterAddress：0x2a9c5afb0d0e4bab2bcdae109ec4b0c4be15a165
linkTokenAddress：0xb1D4538B4571d411F07960EF2838Ce337FE1E80E
currentChainSelector：3478487238524512106

点击橙色的“Deploy”/“Transact”按钮。

Metamask 通知将弹出。签署交易。

步骤 3) 在Ethereum Sepolia网络中, 调用enableChain方法

需要准备：

您之前部署到 Ethereum Sepolia 的 XNFT.sol 智能合约地址；
您之前部署到 Arbitrum Sepolia 的 XNFT.sol 智能合约地址；
chainSelector 参数：3478487238524512106，这是 Arbitrum Sepolia 网络的 CCIP Chain Selector；
ccipExtraArgs 参数：0x97a657c90000000000000000000000000000000000000000000000000000000000030d40，这是 CCIP extraArgs 的bytes版本，其中gasLimit为默认值 200_000。

如果您想自己计算这个值，可以重用以下辅助智能合约：

在scripts文件夹中创建TypeScript文件enableChain.ts：

运行以下指令来调用enableChain方法：

需要准备：

您之前部署到 Ethereum Sepolia 的 XNFT.sol 智能合约地址；
您之前部署到 Arbitrum Sepolia 的 XNFT.sol 智能合约地址；
chainSelector 参数：3478487238524512106，这是 Arbitrum Sepolia 网络的 CCIP Chain Selector；
ccipExtraArgs 参数：0x97a657c90000000000000000000000000000000000000000000000000000000000030d40，这是 CCIP extraArgs 的bytes版本，其中gasLimit为默认值 200_000。

如果您想自己计算这个值，可以重用以下辅助智能合约。在scripts文件夹内创建文件EncodeExtraArgs.s.sol并在其中粘贴以下代码：

运行：

在“Deployed Contracts”部分，您应该能找到之前部署到 Ethereum Sepolia 的 XNFT.sol 合约。找到 enableChain 函数并提供以下参数：

chainSelector 参数：3478487238524512106，这是 Arbitrum Sepolia 网络的 CCIP Chain Selector；
您之前部署到 Arbitrum Sepolia 的 XNFT.sol 智能合约地址，作为 xNftAddress 参数；
ccipExtraArgs 参数：0x97a657c90000000000000000000000000000000000000000000000000000000000030d40，这是 CCIP extraArgs 的bytes版本，其中gasLimit为默认值 200_000。

点击橙色的“Transact”按钮。如果您想自己计算这个值，可以重用以下辅助智能合约。创建 EncodeExtraArgs.sol 文件并粘贴以下代码：

步骤 4) 在Arbitrum Sepolia网络中, 调用enableChain方法

需要准备：

您之前部署到 Arbitrum Sepolia 的 XNFT.sol 智能合约地址；
您之前部署到 Ethereum Sepolia 的 XNFT.sol 智能合约地址，作为 xNftAddress 参数；
chainSelector 参数：16015286601757825753，这是 Ethereum Sepolia 网络的 CCIP Chain Selector；
ccipExtraArgs 参数：0x97a657c90000000000000000000000000000000000000000000000000000000000030d40，这是 CCIP extraArgs 的bytes版本，其中gasLimit为默认值 200_000。

如果您想自己计算这个值，可以重用以下辅助智能合约：

在scripts文件夹中创建TypeScript文件enableChainArbitrum.ts：

运行以下指令来调用enableChain方法：

需要准备：

您之前部署到 Arbitrum Sepolia 的 XNFT.sol 智能合约地址；
您之前部署到 Ethereum Sepolia 的 XNFT.sol 智能合约地址，作为参数xNftAddress；
chainSelector 参数：16015286601757825753，这是 Ethereum Sepolia 网络的 CCIP Chain Selector；
ccipExtraArgs 参数：0x97a657c90000000000000000000000000000000000000000000000000000000000030d40，这是 CCIP extraArgs 的bytes版本，其中gasLimit为默认值 200_000。

如果您想自己计算这个值，可以重用以下辅助智能合约。在scripts文件夹内创建文件EncodeExtraArgs.s.sol并在其中粘贴以下代码：

运行：

在“Deployed Contracts”部分，您应该能找到之前部署到 Arbitrum Sepolia 的 XNFT.sol 合约。找到 enableChain 函数并提供以下参数：

chainSelector 参数：16015286601757825753，这是 Ethereum Sepolia 网络的 CCIP Chain Selector；
您之前部署到 Ethereum Sepolia 的 XNFT.sol 智能合约地址，作为 xNftAddress 参数；
ccipExtraArgs 参数：0x97a657c90000000000000000000000000000000000000000000000000000000000030d40，这是 CCIP extraArgs 的bytes版本，其中gasLimit为默认值 200_000。

点击橙色的“Transact”按钮。如果您想自己计算这个值，可以重用以下辅助智能合约。创建 EncodeExtraArgs.sol 文件并粘贴以下代码：

步骤 5) 在Arbitrum Sepolia网络中, 为XNFT.sol充值3 LINK

为支付 CCIP 费用，向XNFT.sol充值一定数量的 LINK。3 个 LINK 对于此演示应该绰绰有余。当然，为了实现完整的功能，您还应在其他区块链上为XNFT.sol智能合约充值，以便在所有区块链之间执行跨链转账。

步骤 6) 在Arbitrum Sepolia网络中, 铸造新的xNFT

在scripts文件夹中创建TypeScript文件mint.ts：

运行以下指令调用mint方法：

执行:

在“Deployed Contracts”部分，您应该能找到之前部署到 Arbitrum Sepolia 的 XNFT.sol合约。找到 mint 函数，然后点击橙色的“Transact”按钮。

步骤 7) 在Arbitrum Sepolia网络中, 跨链转移xNFT

需要准备：

from 参数：您的 EOA 地址；
to 参数：您希望跨链转移您的 NFT 的另一个链上的 EOA 地址，可以是您的 EOA 地址；
tokenId 参数：您要跨链转移的 xNFT 的 ID；
destinationChainSelector 参数：16015286601757825753，这是 Ethereum Sepolia 区块链的 CCIP Chain Selector；
payFeesIn 参数：1，表示我们用 LINK 支付 CCIP 费用。

在 scripts 文件夹下创建一个 TypeScript 文件crossChainTransferFrom.ts

运行以下指令调用crossChainTransferFrom方法：

需要准备：

from 参数：您的 EOA 地址；
to 参数：您希望跨链转移您的 NFT 的另一个链上的 EOA 地址，可以是您的 EOA 地址；
tokenId 参数：您要跨链转移的 xNFT 的 ID；
destinationChainSelector 参数：16015286601757825753，这是 Ethereum Sepolia 区块链的 CCIP Chain Selector；
payFeesIn 参数：1，表示我们用 LINK 支付 CCIP 费用。

运行:

在“Deployed Contracts”部分，您应该能找到之前部署到 Arbitrum Sepolia 的 XNFT.sol 合约。找到 crossChainTransferFrom 函数并提供以下参数：

from 参数：您的 EOA 地址；
to 参数：您希望跨链转移您的 NFT 的另一个链上的 EOA 地址，可以是您的 EOA 地址；
tokenId 参数：您要跨链转移的 xNFT 的 ID；
destinationChainSelector 参数：16015286601757825753，这是 Ethereum Sepolia 区块链的 CCIP Chain Selector；
payFeesIn 参数：1，表示我们用 LINK 支付 CCIP 费用。

点击橙色的“Transact”按钮。

您现在可以在 CCIP Explorer 页面监控此次NFT的跨链转移。

一旦跨链 NFT 到达 Ethereum Sepolia，您可以在 Metamask 钱包中手动显示它。点击进入“NFT”选项卡并点击“Import NFT”按钮。

然后填写 Ethereum Sepolia 上的 XNFT.sol 智能合约地址和您收到的代币 ID（0）。

最后，您的 NFT 将显示在 Metamask 钱包中。