本页面使用机器翻译自英语，可能包含错误或不清楚的语言。如需最准确的信息，请参阅英文原文。由于更新频繁，部分内容可能与英文原文有出入。请加入我们在 Crowdin 上的努力，帮助我们改进本页面的翻译。 (Crowdin translation page, Contributing guide)

利用链式链接 CCIP 在 Kaia 上构建跨链 NFT：实用指南

介绍

NFT 已成为区块链技术最广为人知的用例之一，能够创建独一无二、可验证的数字资产。然而，传统的 NFT 实现方式被束缚在单个区块链上。这种限制降低了灵活性，使资产无法在社区、流动性和效用可能不同的生态系统中自由流动。

跨链 NFT 允许 NFT 在区块链之间无缝移动，同时保留其唯一性和出处，从而解决了这一难题。借助 Chainlink 的跨链互操作性协议 (CCIP)，开发人员可以使用标准化的安全消息框架在链之间建立可靠的桥梁。

在本指南中，您将使用 "先烧后铸 "模式构建和部署跨链 NFT。 NFT 将在源链上刻录，并以相同的 tokenId 和元数据在目标链上重新铸模，确保任何时候都只存在一个有效副本。

要求

开始之前，请确保您已做好以下设置：

Node.js 和 npm
硬礼帽
- 安装：npm install --save-dev hardhat
- 初始化项目： npx hardhat --init
MetaMask 钱包
- 创建或设置开发钱包。
- 将 Kaia Kairos 测试网络和以太坊 Sepolia 网络添加到 MetaMask 中。
从水龙头测试代币
- KAIA: 在部署合约或发送交易时支付 Kaia 上的燃气费。
- LINK (testnet)：使用 LINK 支付时涵盖 CCIP 费用。
- Sepolia ETH: 支付 Sepolia 上的燃气费，如果选择，还可支付本地 ETH 中的 CCIP 费用。
Filebase 账户
- 需要上传和检索 NFT 元数据（IPFS 存储）。

跨链 NFT 如何工作？

NFT 是记录在单一区块链上的唯一数字代币。其核心行为，包括铸币、转让和所有权，由与该链绑定的智能合约定义。正因为如此，如果没有额外的机制，NFT 无法自然地在区块链之间移动。为了实现互操作性，开发人员会在多个链上部署配套合约，并通过跨链消息传递将它们连接起来。这就是跨链 NFT：存在于不同区块链上的等价代币，但在任何时候都只有一个副本处于活动状态。

跨链 NFT 通常有三种实现方式：

焚烧和铸币：在源链上烧制 NFT，然后在目的链上铸造等价物。
锁定和铸币：在源链上锁定 NFT，并在目标链上铸造副本。返回时需要烧毁复制品才能解锁原件。
锁定和解锁：在多个链上部署相同的集合。所有者锁定一条链上的 NFT，就能解锁另一条链上的对应 NFT，确保一次只能使用一个副本。

在本指南中，我们将在跨链 NFT 中使用燃烧和薄荷模型。 NFT 将从一条链上移除，然后在另一条链上重新创建，整个过程由 Chainlink CCIP 提供动力。

入门

在本指南中，您将使用 Chainlink CCIP 在 Kaia Kairos Testnet 和 Ethereum Sepolia 之间铸币和传输跨链 NFT。

到最后，您将能够

初始化为 Kairos Testnet 和 Ethereum Sepolia 配置的 Hardhat 项目
将 Chainlink CCIP 合同和接口添加为依赖项
实施跨链 NFT 合约，为跨链转账提供烧钱机制
将合同部署到两个网络，并跨链发送 NFT。

创建硬礼帽项目

在本教程中，我们将使用 Hardhat 3 来部署合同并与之交互。 Hardhat 3 提供了一些新功能，例如对加密密钥存储的本地支持、在 Solidity 中编写测试的能力以及改进的项目工具。

请按照以下步骤设置项目：

验证 Node.js 和 npm 的安装

运行以下命令验证 Node.js 和 npm 是否已安装：


node -v
npm -v

初始化新项目目录

创建一个新文件夹，导航进入，然后初始化一个 Node.js 项目：


mkdir ccip-nft-kaia-hardhat-example  
cd ccip-nft-kaia-hardhat-example  
npm init -y

创建 Hardhat 项目

运行：


npx hardhat --init

出现提示时，选择包含 Node.js 测试运行器和ether 的示例项目。在当前目录下对其进行初始化，并安装所有需要的依赖项。

安装所需合同

安装 Chainlink CCIP 合同：


npm i @chainlink/contracts-ccip --save-dev

安装标准链锁合同：


npm i @chainlink/contracts --save-dev

安装 OpenZeppelin 合约（提供 ERC-721 和其他基本实现）：


npm i @openzeppelin/contracts --save-dev

配置 NFT 元数据

在撰写合同之前，让我们先确定一下我们要铸造的 NFT 的规格。每个 NFT 都需要描述其名称、说明和图像的元数据，这些数据存储在一个 JSON 文件中，并托管在 IPFS 上。

在本指南中，我们将使用 Filebase 来存储图像和元数据。如果您想创建自己的 NFT，请通过 Filebase 将图像和元数据 JSON 文件上传到 IPFS。上传后，单击 "文件 "选项卡中的文件名并复制 IPFS URL。它看起来类似于这样：


https://disastrous-turquoise-parakeet.myfilebase.com/ipfs/QmY1LZF8JHo2r3h4X5VzLLXtJujqnBFGTyo2aqR9joXnt8

下面是您可以使用的元数据文件示例：


{
    "name": "Kairos NFT",
    "description": "gkaia frens! gazuaaaaa!!!",
    "image": "https://disastrous-turquoise-parakeet.myfilebase.com/ipfs/QmRvQc4wZCp6NF7dFL4ywiWTG7FSH3KKGUAkXGgsdYfcKi"
}

编写智能合约

在本节中，您将使用由 Chainlink CCIP 支持的 "烧钱-铸币 "模式来实现在区块链之间进行 NFT 传输的合约。

在项目的合约目录下新建一个名为 "CrosschainNFT.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/contracts/libraries/Client.sol";
import {IRouterClient} from "@chainlink/contracts-ccip/contracts/interfaces/IRouterClient.sol";
import {IAny2EVMMessageReceiver} from "@chainlink/contracts-ccip/contracts/interfaces/IAny2EVMMessageReceiver.sol";
import {OwnerIsCreator} from "@chainlink/contracts/src/v0.8/shared/access/OwnerIsCreator.sol";
import {LinkTokenInterface} from "@chainlink/contracts/src/v0.8/shared/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.
 */
 // Source chain is Ethereum Sepolia
 // Destination chain is Kairos Testnet
contract CrosschainNFT is ERC721, ERC721URIStorage, ERC721Burnable, IAny2EVMMessageReceiver, ReentrancyGuard, OwnerIsCreator {
    using SafeERC20 for IERC20;
    enum PayFeesIn {
        Native,
        LINK
    }
    error InvalidRouter(address router);
    error OnlyOnEthereumSepolia();
    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 crosschainNFTDetails {
        address crosschainNFTAddress;
        bytes ccipExtraArgsBytes;
    }
    uint256 constant ETHEREUM_SEPOLIA_CHAIN_ID = 11155111;
    string tokenNFTURI = "https://disastrous-turquoise-parakeet.myfilebase.com/ipfs/QmY1LZF8JHo2r3h4X5VzLLXtJujqnBFGTyo2aqR9joXnt8";
    IRouterClient internal immutable i_ccipRouter;
    LinkTokenInterface internal immutable i_linkToken;
    uint64 private immutable i_currentChainSelector;
    uint256 private _nextTokenId;
    mapping(uint64 destChainSelector => crosschainNFTDetails crosschainNFTPerChain) 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 onlyOnEthereumSepolia() {
        if (block.chainid != ETHEREUM_SEPOLIA_CHAIN_ID) {
            revert OnlyOnEthereumSepolia();
        }
        _;
    }
    modifier onlyEnabledChain(uint64 _chainSelector) {
        if (s_chains[_chainSelector].crosschainNFTAddress == address(0)) {
            revert ChainNotEnabled(_chainSelector);
        }
        _;
    }
    modifier onlyEnabledSender(uint64 _chainSelector, address _sender) {
        if (s_chains[_chainSelector].crosschainNFTAddress != _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 onlyOnEthereumSepolia {
        uint256 tokenId = _nextTokenId++;
        _safeMint(msg.sender, tokenId);
        _setTokenURI(tokenId, tokenNFTURI);
    }
    function enableChain(uint64 chainSelector, address crosschainNFTAddress, bytes memory ccipExtraArgs)
        external
        onlyOwner
        onlyOtherChains(chainSelector)
    {
        s_chains[chainSelector] = crosschainNFTDetails({crosschainNFTAddress: crosschainNFTAddress, ccipExtraArgsBytes: ccipExtraArgs});
        emit ChainEnabled(chainSelector, crosschainNFTAddress, 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].crosschainNFTAddress),
            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);
    }
}

代码演练

CrosschainNFT 是一种 ERC-721 合约，它集成了 Chainlink CCIP，可在区块链之间传输 NFT。它会在源链上刻录 NFT，并用相同的 tokenId 和 tokenURI 在目标链上重新刻录。该合约通过 enableChain 维护经批准的目标链注册表，依靠 Chainlink 路由器（IRouterClient）进行跨链消息传递，并支持以本地天然气代币或 LINK 支付费用。

主要功能

启用链

允许合约所有者注册目标区块链。它会在 s_chains 映射中存储对应的 NFT 合约地址和 CCIP 参数，将链作为有效的传输目标列入白名单。设置完成后，会发出 ChainEnabled 事件。

交叉链转移从

执行 NFT 跨链转移。它首先检查目标链是否已启用，然后检索 NFT 元数据（tokenURI）并在源链上刻录令牌。然后，它将建立一个包含转账详情的 CCIP 报文，计算所需费用，并以 LINK 或本地天然气支付。一旦信息通过路由器发送，就会发出 CrossChainSent 事件来记录传输过程。

现在，"CrosschainNFT.sol "的核心流程已经清楚，让我们进入下一步。

编译智能合约

要编译智能合约，请运行


npx hardhat build

部署智能合约

在本节中，我们将配置必要的变量，然后在 Ethereum Sepolia（源链）和 Kairos Testnet（目的链）上部署 "CrosschainNFT.sol "合约。

使用加密密钥库

Hardhat 3 的优势之一是能将私钥和 RPC URL 等敏感值存储在加密的密钥库中，而不是纯文本文件中。在本指南中，我们将为 Sepolia 和 Kairos 的 PRIVATE_KEY 和 RPC URL 加密。

添加私人密钥


npx hardhat keystore set PRIVATE_KEY

第一次运行该命令时，Hardhat 会提示你为密钥存储创建一个密码。每次添加或更新值时都需要这个密码。

为每个网络添加 RPC URL


npx hardhat keystore set KAIROS_RPC_URL
npx hardhat keystore set SEPOLIA_RPC_URL

最后，编辑 hardhat.config.ts 文件，加载这些加密值并配置两个网络。


import type { HardhatUserConfig } from "hardhat/config";
import hardhatToolboxMochaEthersPlugin from "@nomicfoundation/hardhat-toolbox-mocha-ethers";
import { configVariable } from "hardhat/config";
const config: HardhatUserConfig = {
  plugins: [hardhatToolboxMochaEthersPlugin],
  solidity: {
    profiles: {
      default: {
        version: "0.8.28",
      },
      production: {
        version: "0.8.28",
        settings: {
          optimizer: {
            enabled: true,
            runs: 200,
          },
        },
      },
    },
  },
  networks: {
    hardhatMainnet: {
      type: "edr-simulated",
      chainType: "l1",
    },
    hardhatOp: {
      type: "edr-simulated",
      chainType: "op",
    },
    kairosTestnet: {
      type: "http",
      chainType: "l1",
      url: configVariable("KAIROS_RPC_URL"),
      accounts: [configVariable("PRIVATE_KEY")],
    },
    ethereumSepolia: {
      type: "http",
      chainType: "l1",
      url: configVariable("SEPOLIA_RPC_URL"),
      accounts: [configVariable("PRIVATE_KEY")],
    },
  },
};
export default config;

下一步是分别在 Ethereum Sepolia 和 Kairos Testnet 上部署 CrosschainNFT 智能合约。

在以太坊 Sepolia 上部署 CrosschainNFT.sol

部署前，从 Chainlink CCIP Directory 中获取以太坊 Sepolia 的以下值：

链条选择器
CCIP 路由器地址
LINK 令牌地址

您的部署脚本将需要这些值。接下来，导航到项目中的_ignition/modules_文件夹，创建一个名为 "deployEthereumSepolia.ts "的新文件，并粘贴以下代码：


// This setup uses Hardhat Ignition to manage smart contract deployments.
// Learn more about it at https://hardhat.org/ignition
import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
const ETHEREUM_SEPOLIA_ROUTER_ADDRESS = `0x0BF3dE8c5D3e8A2B34D2BEeB17ABfCeBaf363A59`;
const ETHEREUM_SEPOLIA_LINK_TOKEN_ADDRESS = `0x779877A7B0D9E8603169DdbD7836e478b4624789`;
const ETHEREUM_SEPOLIA_CHAIN_SELECTOR = `16015286601757825753`;
const CrosschainNFTSepoliaModule = buildModule("CrosschainNFTSepoliaModule", (m) => {
  const crosschainNFTSepolia = m.contract("CrosschainNFT", [ETHEREUM_SEPOLIA_ROUTER_ADDRESS, ETHEREUM_SEPOLIA_LINK_TOKEN_ADDRESS, ETHEREUM_SEPOLIA_CHAIN_SELECTOR], {
  });
  return { crosschainNFTSepolia };
});
export default CrosschainNFTSepoliaModule;

运行部署脚本：


npx hardhat ignition deploy ignition/modules/deployEthereumSepolia.ts --network ethereumSepolia

将 CrosschainNFT.sol 部署到 Kairos 测试网

部署前，从 Chainlink CCIP Directory 中获取下列 Kairos Testnet 的值：

链条选择器
CCIP 路由器地址
LINK 令牌地址

您的部署脚本将需要这些值。然后，导航到项目中的 ignition/modules 文件夹，创建一个名为 deployKairosTestnet.ts 的新文件，并粘贴以下代码：


// This setup uses Hardhat Ignition to manage smart contract deployments.
// Learn more about it at https://hardhat.org/ignition
import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
const KAIROS_TESTNET_ROUTER_ADDRESS = `0x41477416677843fCE577748D2e762B6638492755`;
const KAIROS_TESTNET_LINK_TOKEN_ADDRESS = `0xAF3243f975afe2269Da8Ffa835CA3A8F8B6A5A36`;
const KAIROS_TESTNET_CHAIN_SELECTOR = `2624132734533621656`;
const CrosschainNFTKairosModule = buildModule("CrosschainNFTKairosModule", (m) => {
  const crosschainNFTKairos = m.contract("CrosschainNFT", [KAIROS_TESTNET_ROUTER_ADDRESS, KAIROS_TESTNET_LINK_TOKEN_ADDRESS, KAIROS_TESTNET_CHAIN_SELECTOR], {
  });
  return { crosschainNFTKairos };
});
export default CrosschainNFTKairosModule;

运行部署脚本：


npx hardhat ignition deploy ignition/modules/deployKairosTestnet.ts --network kairosTestnet

与智能合约互动

在本节中，我们将分别通过执行 enableChain、mint 和 crosschainTransfer 函数与已部署的 CrosschainNFT 智能合约进行交互。

步骤 1：在以太坊 Sepolia 上，调用 enableChain

在调用 enableChain 之前，请准备好以下值：

Sepolia合约地址：部署在以太坊Sepolia上的CrosschainNFT.sol合约的地址。
Kairos 合约地址：部署在 Kairos Testnet 上的 CrosschainNFT.sol 合约的地址。
链选择器：2624132734533621656（Kairos Testnet 的 CCIP 链选择器）。
CCIP extraArgs：0x97a657c900000000000000000000000000000000000000000007A120 （这是 extraArgs 的默认编码值，gasLimit 设置为 500,000）。

接下来，在脚本文件夹中新建一个 TypeScript 文件，命名为 "enableChainSepolia.ts"，并粘贴以下代码：


// scripts/enableChainSepolia.ts
import { network } from "hardhat";
async function main() {
  const connection = await network.connect({
    network: "ethereumSepolia"
  });
  const { ethers } = connection;
  const [signer] = await ethers.getSigners();
  console.log(`Using account: ${signer.address}`);
  // Get the contract factory by name
  const CrosschainNFT = await ethers.getContractFactory("CrosschainNFT", signer);
  // Contract addresses and parameters
  const crosschainNFTAddressEthereumSepolia = `0xb1fe42BBd7842703820C7480c22409b872319B22`;
  const crosschainNFTAddressKairosTestnet = `0x8c464Bb9Bf364F68b898ed0708b8f5F66EF6Cfb1`;
  const chainSelectorKairosTestnet = `2624132734533621656`;
  const ccipExtraArgs = `0x97a657c9000000000000000000000000000000000000000000000000000000000007A120`;
  // Attach to the deployed contract
  const crosschainNFTSepolia = CrosschainNFT.attach(crosschainNFTAddressEthereumSepolia);
  console.log(`Enabling chain for Kairos Testnet...`);
  const tx = await crosschainNFTSepolia.enableChain(
    chainSelectorKairosTestnet,
    crosschainNFTAddressKairosTestnet,
    ccipExtraArgs
  );
  console.log(`Transaction hash: ${tx.hash}`);
  console.log(`Waiting for confirmation...`);
  const receipt = await tx.wait();
  
  console.log(`Transaction confirmed in block: ${receipt?.blockNumber}`);
  console.log(`Chain enabled successfully!`);
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

运行以下命令调用该函数：


npx hardhat run scripts/enableChainSepolia.ts --network ethereumSepolia

步骤 2：在 Kairos Testnet 上，调用 enableChain

在调用 enableChain 之前，请准备好以下值：

Kairos合约地址：部署在Kairos测试网上的CrosschainNFT.sol合约的地址
Sepolia合约地址：部署在以太坊Sepolia上的CrosschainNFT.sol合约的地址
链选择器：16015286601757825753 （Kairos Testnet 的 CCIP 链选择器）
CCIP extraArgs：0x97a657c900000000000000000000000000000000000000000007A120 （这是 extraArgs 的默认编码值，气体限值设置为 500,000）

接下来，在脚本文件夹中新建一个 TypeScript 文件，命名为 "enableChainKairos.ts"，并粘贴以下代码：


// scripts/enableChainKairos.ts
import { network } from "hardhat";
async function main() {
  const connection = await network.connect({
    network: "kairosTestnet"
  });
  const { ethers } = connection;
  const [signer] = await ethers.getSigners();
  console.log(`Using account: ${signer.address}`);
  // Get the contract factory by name
  const CrosschainNFT = await ethers.getContractFactory("CrosschainNFT", signer);
  // Contract addresses and parameters 
  const crosschainNFTAddressKairosTestnet = `0x8c464Bb9Bf364F68b898ed0708b8f5F66EF6Cfb1`;
  const crosschainNFTAddressEthereumSepolia = `0xb1fe42BBd7842703820C7480c22409b872319B22`;
  const chainSelectorEthereumSepolia = `16015286601757825753`;
  const ccipExtraArgs = `0x97a657c9000000000000000000000000000000000000000000000000000000000007A120`;
  // Attach to the deployed contract on Kairos
  const crosschainNFTKairos = CrosschainNFT.attach(crosschainNFTAddressKairosTestnet);
  console.log(`Enabling chain for Ethereum Sepolia...`);
  const tx = await crosschainNFTKairos.enableChain(
    chainSelectorEthereumSepolia,         
    crosschainNFTAddressEthereumSepolia,    
    ccipExtraArgs                 
  );
  console.log(`Transaction hash: ${tx.hash}`);
  console.log(`Waiting for confirmation...`);
  const receipt = await tx.wait();
  
  console.log(`Transaction confirmed in block: ${receipt?.blockNumber}`);
  console.log(`Chain enabled successfully!`);
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

运行以下命令调用该函数：


npx hardhat run scripts/enableChainKairos.ts --network KairosTestnet

第 3 步：在以太坊 Sepolia 上使用 LINK 为合约提供资金

为支付 CCIP 费用，请使用 LINK 为部署在以太坊 Sepolia（crosschainNFTAddressEthereumSepolia）上的 CrosschainNFT 合约提供资金。您可以从提供的水龙头中获取测试 LINK。在本指南中，发送 3 个 LINK 即可。

步骤 4：在以太坊 Sepolia 上铸币一个新的 CrosschainNFT

接下来，在部署到以太坊 Sepolia 的 CrosschainNFT 合约上创建一个新的 NFT。

在脚本文件夹中创建一个新的 TypeScript 文件，命名为 "mint.ts"，并粘贴以下代码：


// scripts/mint.ts
import { network } from "hardhat";
async function main() {
  // Connect to the network
  const connection = await network.connect({
    network: "ethereumSepolia"
  });
if (connection.networkName !== "ethereumSepolia") {
    console.error(`Must be called from Ethereum Sepolia`);
    process.exitCode = 1;
    return;
  }
  const { ethers } = connection;
  const [signer] = await ethers.getSigners();
  console.log(`Using account: ${signer.address}`);
  // Get the contract factory
  const CrosschainNFT = await ethers.getContractFactory("CrosschainNFT", signer);
  const crosschainNFTAddressEthereumSepolia = `0xb1fe42BBd7842703820C7480c22409b872319B22`
  // Attach to the deployed contract
  const crosschainNFT = CrosschainNFT.attach(crosschainNFTAddressEthereumSepolia);
  console.log(`Minting NFT...`);
  const tx = await crosschainNFT.mint();
  console.log(`Transaction hash: ${tx.hash}`);
  console.log(`Waiting for confirmation...`);
  const receipt = await tx.wait();
  
  console.log(`Transaction confirmed in block: ${receipt?.blockNumber}`);
  console.log(`NFT minted successfully!`);
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

该脚本将处理铸币过程，并为跨链传输 NFT 做好准备。

运行以下命令调用该函数：


npx hardhat run scripts/mint.ts --network ethereumSepolia

步骤 5：跨链转移 NFT

在以太坊 Sepolia 上，您将调用 crossChainTransferFrom 函数将您的 NFT 发送到 Kairos Testnet。

准备以下值：

来自：您在以太坊 Sepolia 上的 EOA 地址
收件人*：收件人在 Kairos Testnet 上的 EOA 地址（也可以是您自己的地址）
tokenId：要转移的 NFT 的 ID
目标链选择器：2624132734533621656（Kairos Testnet 的 CCIP 链选择器）
payFeesIn：1（表示将在 LINK 中支付 CCIP 费用）

运行传输脚本

在脚本文件夹中新建一个 TypeScript 文件，命名为 "crossChainTransferNFT.ts"，并粘贴以下代码：


// scripts/crossChainTransferNFT.ts
import { network } from "hardhat";
async function main() {
  // Connect to the network
  const connection = await network.connect({
    network: "ethereumSepolia"
  });
    // Check if we're on the correct network
  if (connection.networkName !== "ethereumSepolia") {
    console.error(`Must be called from Ethereum Sepolia`);
    process.exitCode = 1;
    return;
  }
  const { ethers } = connection;
  const [signer] = await ethers.getSigners();
  console.log(`Using account: ${signer.address}`);
  // Get the contract factory
  const CrosschainNFT = await ethers.getContractFactory("CrosschainNFT", signer);
  const crosschainNFTAddressEthereumSepolia = `0xb1fe42BBd7842703820C7480c22409b872319B22`;
  // Transfer parameters
  const from = `0x7b467A6962bE0ac80784F131049A25CDE27d62Fb`;
  const to = `0x7b467A6962bE0ac80784F131049A25CDE27d62Fb`;
  const tokenId = 0; // Put NFT token id here
  const destinationChainSelector = "2624132734533621656"; // Kairos Testnet
  const payFeesIn = 1; // 0 - Native, 1 - LINK
  // Attach to the deployed contract
  const crosschainNFT = CrosschainNFT.attach(crosschainNFTAddressEthereumSepolia);
  const tx = await crosschainNFT.crossChainTransferFrom(
    from,
    to,
    tokenId,
    destinationChainSelector,
    payFeesIn
  );
  console.log(`Transaction hash: ${tx.hash}`);
  console.log(`Waiting for confirmation...`);
  const receipt = await tx.wait();
  
  console.log(`Transaction confirmed in block: ${receipt?.blockNumber}`);
  console.log(`Cross-chain transfer initiated successfully!`);
  console.log(`Note: The NFT will arrive on Kairos Testnet after CCIP processes the message.`);
}
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

然后用


npx hardhat run scripts/crossChainTransferNFT.ts --network ethereumSepolia

验证转移

您可以在 CCIP Explorer 上监控跨链转账，在 Kaiascan 上确认交易。

NFT 到达 Kairos Testnet 后，将其添加到您的 MetaMask 钱包中：

在 MetaMask 中打开 NFT 选项卡。
单击导入 NFT。
输入 Kairos Testnet 上的 CrosschainNFT 合约地址和您收到的 tokenId（例如 0）。

现在，您的 NFT 将出现在 MetaMask 钱包中。

结论

在本教程中，您将学习如何使用 Chainlink CCIP 在 Kaia Kairos Testnet 和 Ethereum Sepolia 之间使用烧毁和铸币模型传输 NFT。

要深入了解 CCIP 并探索其他用例，请访问官方Chainlink CCIP Documentation。

介绍​

要求​

跨链 NFT 如何工作？​

入门​

创建硬礼帽项目​

安装所需合同​

配置 NFT 元数据​

编写智能合约​

代码演练​

编译智能合约​

部署智能合约​

使用加密密钥库​

在以太坊 Sepolia 上部署 CrosschainNFT.sol​

将 CrosschainNFT.sol 部署到 Kairos 测试网​

与智能合约互动​

步骤 1：在以太坊 Sepolia 上，调用 enableChain​

步骤 2：在 Kairos Testnet 上，调用 enableChain​

第 3 步：在以太坊 Sepolia 上使用 LINK 为合约提供资金​

步骤 4：在以太坊 Sepolia 上铸币一个新的 CrosschainNFT​

步骤 5：跨链转移 NFT​

结论​

介绍

要求

跨链 NFT 如何工作？

入门

创建硬礼帽项目

安装所需合同

配置 NFT 元数据

编写智能合约

代码演练

编译智能合约

部署智能合约

使用加密密钥库

在以太坊 Sepolia 上部署 CrosschainNFT.sol

将 CrosschainNFT.sol 部署到 Kairos 测试网

与智能合约互动

步骤 1：在以太坊 Sepolia 上，调用 enableChain

步骤 2：在 Kairos Testnet 上，调用 enableChain

第 3 步：在以太坊 Sepolia 上使用 LINK 为合约提供资金

步骤 4：在以太坊 Sepolia 上铸币一个新的 CrosschainNFT

步骤 5：跨链转移 NFT

结论