Chainlink--CCIP--NFT 讲解

浪迹陨灭
发布于 2025-02-19 11:04
阅读 1139

代码详情：https://github.com/langjiyunmie/Chainlink-CCIP.git chainlink学习的官方视频链接：https://www.bilibili.com/video/BV1RFsfe5Ek5/

## ccip主要组件

### 三个领域

```
源链 (Source Chain)
├── Sender (发送方合约)
├── Router (路由合约)
└── Token Pool (代币池)

目标链 (Destination Chain)
├── Receiver (接收方合约)
├── Router (路由合约)
└── Token Pool (代币池)

链下部分 (Offchain)
├── Committing DON (提交DON网络)
├── Executing DON (执行DON网络)
└── RMN (风险管理网络)
```

### 工作流程

![image-20250118090921151.png](https://img.learnblockchain.cn/attachments/2025/02/5We0UjQ767b548d524519.png)

概括CCIP的三个部分的完整流程：

1. 源链（Source Chain）

用户 → Sender合约 → Router → OnRamp → Token Pool

具体流程：

1. 用户调用Sender合约发起跨链请求
   2. Router验证请求并计算费用
   3. OnRamp准备跨链数据
   4. Token Pool锁定用户代币
   5. 生成消息证明并等待DON处理
   6. 链下（Off-chain）

2. 链下（Off-chain）

Committing DON → RMN → Executing DON

具体流程：

1. Committing DON监听并验证源链消息
   2. 构建merkle树和收集DON签名
   3. RMN进行风险评估和安全检查
   4. 通过后，Executing DON准备目标链执行数据
   5. 将执行包发送到目标链
   6. 目标链（Destination Chain）

3. 目标链（Destination Chain）

OffRamp → Token Pool → Router → 接收方合约

具体流程：

1. OffRamp接收并验证DON发来的执行包
   2. Token Pool释放对应代币给接收方
   3. Router将消息路由到接收方合约
   4. 接收方合约执行最终的业务逻辑

#### 源链

1. 发起跨链请求：

用户使用sender合约，指定目标链，指定接收地址，准备要发送的代币，附带自定义消息数据

```solidity
   // 1. Sender发起跨链请求
   contract Sender {
       function sendMessage(
           uint64 destinationChainSelector,
           address receiver,
           bytes memory data,
           TokenTransfer[] memory tokens
       ) external {
           // 构造CCIP消息
           Message memory message = Message({
               sender: msg.sender,
               receiver: receiver,
               data: data,
               tokens: tokens
           });
           
           // 计算费用
           uint256 fee = router.getFee(destinationChainSelector, message);
           
           // 调用Router
           router.ccipSend{value: fee}(destinationChainSelector, message);
       }
   }  
   ```

Router合约源链路由器，验证消息格式，计算费用，处理代币锁定

```solidity
   // 2. Router验证并转发到OnRamp
   contract Router {
       function ccipSend(uint64 chainSelector, Message memory message) external {
           // 验证目标链
           validateDestination(chainSelector);
           
           // 获取对应的OnRamp
           OnRamp onRamp = getOnRamp(chainSelector);
           
           // 转发到OnRamp
           onRamp.forwardMessage(message);
       }
   }
   ```

OnRamp合约处理（源链）:接收Router的请求，验证消息格式和费用，与Token Pool交互锁定代币，生成跨链消息的证明

```solidity
   // 3. OnRamp处理并与Token Pool交互
   contract OnRamp {
       function forwardMessage(Message memory message) external {
           // 验证消息格式
           validateMessage(message);
           
           // 处理代币锁定
           for (TokenTransfer token : message.tokens) {
               tokenPool.lockTokens(
                   token.token,
                   token.amount,
                   message.sender
               );
           }
           
           // 生成merkle叶子
           bytes32 leaf = generateLeaf(message);
           
           // 提交到Commit Store
           commitStore.addMessage(leaf);
           
           // 触发事件供DON监听
           emit MessageSent(message);
       }
   }
   ```

Token Pool: 代币池锁定源链代币，管理流动性

**详细交互流程**：

- 第一阶段：源链发起
   - 用户通过Sender合约发起跨链请求
   - Router接收请求并验证基本参数
   - Fee Manager计算所需费用
   - Price Registry检查代币价格
   - ARM进行初步风险评估
   - OnRamp准备跨链数据
   - Token Pool锁定相应代币
   - 生成merkle叶子并提交到Commit Store

#### 链下

1. Committing DON 监听和处理

```js
   class CommittingDON {
       // 监听源链事件
       async listenToSourceChain() {
           sourceChain.on('MessageSent', async (event) => {
               const message = event.args.message;
               await this.processMessage(message);
           });
       }
   
       // 处理跨链消息
       async processMessage(message) {
           // 验证消息
           await this.validateMessage(message);
           
           // 构建 merkle 树
           const leaf = this.generateLeaf(message);
           const merkleTree = this.buildMerkleTree([leaf]);
           
           // 收集 DON 签名
           const signatures = await this.collectSignatures(merkleTree.root);
           
           // 提交到 RMN
           await this.submitToRMN(message, merkleTree, signatures);
       }
   
       // 生成 merkle 叶子
       generateLeaf(message) {
           return ethers.utils.keccak256(
               ethers.utils.defaultAbiCoder.encode(
                   ['address', 'address', 'bytes', 'uint256'],
                   [message.sender, message.receiver, message.data, message.nonce]
               )
           );
       }
   }
   ```

监听和收集：

- 监听源链上的MessageSent事件
   - 收集交易详情和证明
   - 验证交易状态

验证流程：

- 验证消息格式
   - 检查签名有效性
   - 验证代币锁定状态
   - 确认费用支付

数据整理：

- 构建merkle树
   - 生成merkle证明
   - 准跨链数据包

2. Lane Manager（通道管理）

```js
   class LaneManager {
       constructor() {
           this.lanes = new Map();
           this.limits = new Map();
       }
   
       // 检查通道状态
       async checkLane(sourceChain, destChain) {
           const lane = this.getLane(sourceChain, destChain);
           
           // 检查通道容量
           if (lane.messageCount >= lane.maxCapacity) {
               throw new Error('Lane capacity exceeded');
           }
           
           // 检查限额
           if (lane.totalValue >= this.limits.get(lane.id)) {
               throw new Error('Lane value limit exceeded');
           }
           
           // 更新统计
           await this.updateLaneStats(lane);
       }
   
       // 更新通道统计
       async updateLaneStats(lane) {
           lane.messageCount++;
           lane.lastUpdated = Date.now();
           await this.persistLaneData(lane);
       }
   }
   ```

通道状态管理：

- 检查源链-目标链通道状态
   - 验证通道容量和限额
   - 监控通道拥堵情况
   - 更新通道统计数据

流量控制：

- 管理消息队列
   - 控制处理速率
   - 优化资源分配
   - 负载均衡

3. Price Feed（价格预言机）：

```js
   class PriceFeed {
       // 获取实时价格
       async getPrice(token) {
           // 从多个源获取价格
           const prices = await Promise.all([
               this.getPriceFromSource1(token),
               this.getPriceFromSource2(token),
               this.getPriceFromSource3(token)
           ]);
           
           // 过滤和计算加权价格
           return this.calculateWeightedPrice(prices);
       }
   
       // 价格偏差检查
       async checkPriceDeviation(token, price) {
           const historicalPrice = await this.getHistoricalPrice(token);
           const deviation = Math.abs(price - historicalPrice) / historicalPrice;
           
           if (deviation > this.maxDeviation) {
               await this.triggerPriceProtection(token, price);
           }
       }
   }
   ```

价格数据服务：

- 收集多源价格数据
   - 过滤异常价格
   - 计算加权平均价
   - 提供实时价格更新

价格保护机制：

- 监控价格波动
   - 设置价格偏差阈值
   - 触发价格保护
   - 更新价格预警

4. Risk Management Network (RMN)：

```js
   class RiskManagementNetwork {
       // 风险评估
       async assessRisk(message, context) {
           const riskScore = await this.calculateRiskScore({
               // 交易相关风险
               transactionRisk: await this.assessTransactionRisk(message),
               // 地址风险
               addressRisk: await this.assessAddressRisk(message.sender),
               // 网络风险
               networkRisk: await this.assessNetworkRisk(context),
               // 代币风险
               tokenRisk: await this.assessTokenRisk(message.tokens)
           });
   
           return this.evaluateRiskScore(riskScore);
       }
   
       // 流动性检查
       async checkLiquidity(message) {
           const liquidityData = await this.getLiquidityData(message.destChain);
           
           return {
               isLiquidityOk: liquidityData.available >= message.value,
               liquidityRatio: liquidityData.available / liquidityData.total
           };
       }
   }
   ```

风险评估：

- 交易规模分析
   - 地址行为评估
   - 网络状态监控
   - 代币风险评级

安全检查：

- 重放攻击检测
   - 异常行为识别
   - 流动性风险评估
   - 网络安全监控

流动性管理：

- 检查目标链流动性
   - 评估Token Pool状态
   - 监控资金流向
   - 预警异常提现

5. Executing DON：

```js
   class ExecutingDON {
       // 准备执行
       async prepareExecution(message, proof) {
           // 验证所有条件
           await this.validateExecutionConditions(message);
           
           // 准备执行数据
           const executionData = await this.prepareExecutionData(message);
           
           // 收集执行签名
           const signatures = await this.collectExecutionSignatures(executionData);
           
           return { executionData, signatures };
       }
   
       // 执行共识
       async reachConsensus(executionData) {
           const nodes = await this.getActiveNodes();
           const votes = await this.collectNodeVotes(nodes, executionData);
           
           if (this.hasConsensus(votes)) {
               return this.prepareConsensusProof(votes);
           }
           throw new Error('Consensus not reached');
       }
   }
   ```

执行准备：

- 接收RMN确认信息
   - 验证所有必要条件
   - 准备执行数据包
   - 构建执行证明

共识过程：

- DON节点投票
   - 收集执行签名
   - 达成执行共识
   - 确认执行决策

执行触发：

- 准备目标链交易
   - 构建执行参数
   - 发送执行指令
   - 监控执行状态

6. 跨链消息传递流程：

消息封装：

- 源链交易信息
   - 代币转移数据
   - 执行指令
   - 证明数据

验证层级：

1. 基础验证
      - 格式检查
      - 参数验证
      - 签名确认

2. 共识验证
      - DON节点验证
      - 多重签名
      - 阈值确认

3. 风险验证
      - RMN评估
      - 安全检查
      - 异常识别

7. 监控和优化系统：

```js
   class MonitoringSystem {
       // 性能监控
       async monitorPerformance() {
           const metrics = {
               nodeLatency: await this.measureNodeLatency(),
               messageQueueSize: await this.getQueueSize(),
               processingTime: await this.getAverageProcessingTime(),
               resourceUsage: await this.getResourceMetrics()
           };
   
           await this.analyzeMetrics(metrics);
       }
   
       // 异常检测
       async detectAnomalies() {
           const patterns = await this.analyzePatterns();
           if (patterns.hasAnomaly) {
               await this.triggerAlert(patterns.anomalyType);
           }
       }
   }
   ```

性能监控：

- 节点响应时间
   - 网络延迟
   - 处理队列状态
   - 资源使用率

数据分析：

- 交易模式分析
   - 风险模型更新
   - 性能瓶颈识别
   - 优化建议生成

系统调优：

- 动态参数调整
   - 资源分配优化
   - 处理策略更新
   - 性能优化

8. 应急响应机制：

```js
   class EmergencyHandler {
       // 处理异常
       async handleEmergency(error) {
           // 记录错误
           await this.logError(error);
           
           // 执行应急预案
           const plan = await this.selectEmergencyPlan(error);
           await this.executeEmergencyPlan(plan);
           
           // 通知相关方
           await this.notifyStakeholders(error, plan);
       }
   
       // 恢复服务
       async recoverService() {
           // 检查系统状态
           const status = await this.checkSystemStatus();
           
           // 执行恢复步骤
           if (status.needsRecovery) {
               await this.executeRecoverySteps(status);
           }
           
           // 验证恢复结果
           await this.verifyRecovery();
       }
   }
   ```

异常处理：

- 检测异常情况
   - 触发应急预案
   - 执行恢复流程
   - 记录事件日志

故障恢复：

- 节点故障切换
   - 数据同步修复
   - 状态一致性检查
   - 服务恢复确认

#### 目标链

1. OffRamp接收和验证:

这是目标链上的入口合约，负责接收和处理来自链下DON网络的跨链消息。它会验证消息的有效性，包括检查消息证明和DON签名。一旦验证通过，它会协调TokenPool进行代币释放，并通过Router将消息转发给最终的接收方。可以把它理解为跨链消息在目标链上的"报关处"，负责验证和清关。

```js
   class OffRamp {
       async processIncomingMessage(message, proof) {
           // 1. 验证消息和证明
           await this.validateMessage(message, proof);
           
           // 2. 检查执行条件
           const executionContext = {
               message,
               proof,
               timestamp: await this.getBlockTimestamp(),
               gasPrice: await this.getGasPrice()
           };
           
           // 3. 准备执行
           await this.prepareExecution(executionContext);
       }
   
       async validateMessage(message, proof) {
           // 验证merkle证明
           const isValidProof = await this.verifyMerkleProof(
               message.leaf,
               proof.root,
               proof.path
           );
           
           // 验证DON签名
           const isValidSignature = await this.verifyDONSignatures(
               message,
               proof.signatures
           );
           
           if (!isValidProof || !isValidSignature) {
               throw new Error('Invalid message or proof');
           }
       }
   }
   ```

2. TokenPool合约:

这是代币管理合约，管理着目标链上用于跨链的代币流动性池。当OffRamp确认跨链消息有效后，TokenPool负责将对应数量的代币释放给接收方。它还管理流动性提供者的存款和取款，确保池中始终有足够的代币来满足跨链需求。这就像是一个银行金库，负责资金的安全存管和分发。

```solidity
   contract TokenPool {
       // 代币余额映射
       mapping(address => uint256) public poolBalance;
       mapping(address => uint256) public lockedAmount;
   
       // 释放代币给接收方
       function releaseTokens(
           address token,
           address receiver,
           uint256 amount
       ) external onlyOffRamp {
           require(
               poolBalance[token] >= amount,
               "Insufficient liquidity"
           );
   
           poolBalance[token] -= amount;
           IERC20(token).transfer(receiver, amount);
   
           emit TokensReleased(token, receiver, amount);
       }
   
       // 添加流动性
       function addLiquidity(
           address token,
           uint256 amount
       ) external {
           IERC20(token).transferFrom(
               msg.sender,
               address(this),
               amount
           );
           poolBalance[token] += amount;
   
           emit LiquidityAdded(token, amount);
       }
   }
   ```

3. Router合约

Router是消息路由合约，负责将验证过的跨链消息传递给正确的接收方合约。它会检查接收方是否是有效的合约地址，并调用接收方的ccipReceive函数。如果消息执行失败，Router还负责处理失败情况。它就像是一个邮递员，确保消息准确送达指定接收方。

```solidity
   contract Router {
       // 路由表
       mapping(address => bool) public whitelistedOffRamps;
       
       // 执行消息
       function routeMessage(
           OffRamp.CCIPMessage memory message
       ) external onlyOffRamp {
           // 验证接收方合约
           require(
               _isContract(message.receiver),
               "Receiver must be a contract"
           );
   
           // 调用接收方的ccipReceive函数
           try ICCIPReceiver(message.receiver).ccipReceive(
               message.sourceChainSelector,
               message.sender,
               message.data
           ) {
               emit MessageRouted(message.messageId);
           } catch Error(string memory reason) {
               emit MessageFailed(message.messageId, reason);
               _handleFailure(message);
           }
       }
   }
   ```

4. CommitStore合约:

这是消息存储和验证合约，存储了所有经过DON网络确认的消息根。当OffRamp收到跨链消息时，会向CommitStore验证该消息是否已经得到了DON网络的确认。它维护着一个可信消息的数据库，确保只有经过验证的消息才能被执行。这像是一个公证处，负责验证消息的真实性

```solidity
   contract CommitStore {
       // 存储已确认的消息根
       mapping(bytes32 => bool) public committedRoots;
       
       // DON签名者
       mapping(address => bool) public allowedSigners;
   
       // 验证并存储消息证明
       function verifyMessage(
           OffRamp.CCIPMessage memory message,
           bytes memory proof
       ) external returns (bool) {
           bytes32 root = _computeRoot(message);
           
           require(
               committedRoots[root],
               "Unknown message root"
           );
   
           require(
               _verifyProof(message, proof),
               "Invalid proof"
           );
   
           return true;
       }
   }
   ```

5. 接收方合约接口:

这是最终接收和处理跨链消息的合约，需要实现ccipReceive接口。当Router转发消息时，接收方合约会被调用，然后根据收到的消息执行相应的业务逻辑。这可以是任何需要接收跨链消息的智能合约，比如跨链桥、跨链交易所等。

```solidity
   interface ICCIPReceiver {
       function ccipReceive(
           uint64 sourceChainSelector,
           address sender,
           bytes calldata data
       ) external;
   }
   
   // 示例实现
   contract ExampleReceiver is ICCIPReceiver {
       // 只允许Router调用
       modifier onlyRouter() {
           require(
               msg.sender == address(router),
               "Only router can call"
           );
           _;
       }
   
       function ccipReceive(
           uint64 sourceChainSelector,
           address sender,
           bytes calldata data
       ) external override onlyRouter {
           // 解码数据
           (uint256 amount, bytes memory payload) = abi.decode(
               data,
               (uint256, bytes)
           );
   
           // 处理业务逻辑
           _handleBusinessLogic(sender, amount, payload);
       }
   }
   ```

6. 权限控制合约:

```solidity
   contract AccessControl {
       // 角色定义
       bytes32 public constant EXECUTOR_ROLE = keccak256("EXECUTOR_ROLE");
       bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
   
       // 角色管理
       mapping(bytes32 => mapping(address => bool)) public roles;
   
       modifier onlyRole(bytes32 role) {
           require(
               roles[role][msg.sender],
               "Caller is not authorized"
           );
           _;
       }
   }
   ```

**目标链流程**

消息。验证通过后，如果消息包含代币转移，OffRamp会通知TokenPool释放相应的代币。然后OffRamp将消息交给Router，Router负责将消息路由到正确的接收方合约。在这个过程中，CommitStore提供消息验证服务，确保只有经过DON网络确认的消息才会被处理。

## 跨链NFT

![image-20250119151854398.png](https://img.learnblockchain.cn/attachments/2025/02/ERt02gZc67b5490e38684.png)

### 源链发送消息

**原始模型**

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import {IRouterClient} from "@chainlink/contracts/src/v0.8/ccip/interfaces/IRouterClient.sol";
import {OwnerIsCreator} from "node_modules/@chainlink/contracts/src/v0.8/shared/access/OwnerIsCreator.sol";
import {Client} from "node_modules/@chainlink/contracts/src/v0.8/ccip/applications/CCIPReceiver.sol";
import {CCIPReceiver} from "@chainlink/contracts/src/v0.8/ccip/applications/CCIPReceiver.sol";
import {IERC20} from "node_modules/@chainlink/contracts/src/v0.8/vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "node_modules/@chainlink/contracts/src/v0.8/vendor/openzeppelin-solidity/v4.8.3/contracts/token/ERC20/utils/SafeERC20.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.
 */

/// @title - A simple messenger contract for sending/receving string data across chains.
contract Messenger is CCIPReceiver, OwnerIsCreator {
    using SafeERC20 for IERC20;

// Custom errors to provide more descriptive revert messages.
    error NotEnoughBalance(uint256 currentBalance, uint256 calculatedFees); // Used to make sure contract has enough balance.
    error NothingToWithdraw(); // Used when trying to withdraw Ether but there's nothing to withdraw.
    error FailedToWithdrawEth(address owner, address target, uint256 value); // Used when the withdrawal of Ether fails.

// Event emitted when a message is sent to another chain.
    event MessageSent(
        bytes32 indexed messageId, // The unique ID of the CCIP message.
        uint64 indexed destinationChainSelector, // The chain selector of the destination chain.
        address receiver, // The address of the receiver on the destination chain.
        bytes text, // The text being sent.
        address feeToken, // the token address used to pay CCIP fees.
        uint256 fees // The fees paid for sending the CCIP message.
    );

bytes32 private s_lastReceivedMessageId; // Store the last received messageId.
    string private s_lastReceivedText; // Store the last received text.

IERC20 private s_linkToken;
    
    // remember to add visibility for the variable 
    MyToken public nft;
    
    struct RequestData{
        uint256 tokenId;
        address newOwner;
    }

/// @notice Sends data to receiver on the destination chain.
    /// @notice Pay for fees in LINK.
    /// @dev Assumes your contract has sufficient LINK.
    /// @param _destinationChainSelector The identifier (aka selector) for the destination blockchain.
    /// @param _receiver The address of the recipient on the destination blockchain.
    /// @param _payload The data to be sent.
    /// @return messageId The ID of the CCIP message that was sent.
    function sendMessagePayLINK(
        uint64 _destinationChainSelector,
        address _receiver,
        bytes memory _payload
    )
        internal
        returns (bytes32 messageId)
    {
        // Create an EVM2AnyMessage struct in memory with necessary information for sending a cross-chain message
        Client.EVM2AnyMessage memory evm2AnyMessage = _buildCCIPMessage(
            _receiver,
            _payload,
            address(s_linkToken)
        );

// Initialize a router client instance to interact with cross-chain router
        IRouterClient router = IRouterClient(this.getRouter());

// Get the fee required to send the CCIP message
        uint256 fees = router.getFee(_destinationChainSelector, evm2AnyMessage);

if (fees > s_linkToken.balanceOf(address(this)))
            revert NotEnoughBalance(s_linkToken.balanceOf(address(this)), fees);

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

// Send the CCIP message through the router and store the returned CCIP message ID
        messageId = router.ccipSend(_destinationChainSelector, evm2AnyMessage);

// Emit an event with message details
        emit MessageSent(
            messageId,
            _destinationChainSelector,
            _receiver,
            _payload,
            address(s_linkToken),
            fees
        );

// Return the CCIP message ID
        return messageId;
    }

/// handle a received message
    function _ccipReceive(
        Client.Any2EVMMessage memory any2EvmMessage
    )
        internal
        override
    {
        s_lastReceivedMessageId = any2EvmMessage.messageId; // fetch the messageId
        RequestData memory requestData = abi.decode(any2EvmMessage.data, (RequestData));
        uint256 tokenId = requestData.tokenId;
        address newOwner = requestData.newOwner;
        require(tokenLocked[tokenId], "the NFT is not locked");
        nft.transferFrom(address(this), newOwner, tokenId);
        emit TokenUnlocked(tokenId, newOwner);
    }

/// @notice Construct a CCIP message.
    /// @dev This function will create an EVM2AnyMessage struct with all the necessary information for sending a text.
    /// @param _receiver The address of the receiver.
    /// @param _payload The string data to be sent.
    /// @param _feeTokenAddress The address of the token used for fees. Set address(0) for native gas.
    /// @return Client.EVM2AnyMessage Returns an EVM2AnyMessage struct which contains information for sending a CCIP message.
    function _buildCCIPMessage(
        address _receiver,
        bytes memory _payload,
        address _feeTokenAddress
    ) private pure returns (Client.EVM2AnyMessage memory) {
        // Create an EVM2AnyMessage struct in memory with necessary information for sending a cross-chain message
        return
            Client.EVM2AnyMessage({
                receiver: abi.encode(_receiver), // ABI-encoded receiver address
                data: _payload, // ABI-encoded string
                tokenAmounts: new Client.EVMTokenAmount[](0), // Empty array aas no tokens are transferred
                extraArgs: Client._argsToBytes(
                    // Additional arguments, setting gas limit
                    Client.EVMExtraArgsV1({gasLimit: 200_000})
                ),
                // Set the feeToken to a feeTokenAddress, indicating specific asset will be used for fees
                feeToken: _feeTokenAddress
            });
    }

/// @notice Fetches the details of the last received message.
    /// @return messageId The ID of the last received message.
    /// @return text The last received text.
    function getLastReceivedMessageDetails()
        external
        view
        returns (bytes32 messageId, string memory text)
    {
        return (s_lastReceivedMessageId, s_lastReceivedText);
    }

/// @notice Fallback function to allow the contract to receive Ether.
    /// @dev This function has no function body, making it a default function for receiving Ether.
    /// It is automatically called when Ether is sent to the contract without any data.
    receive() external payable {}

/// @notice Allows the contract owner to withdraw the entire balance of Ether from the contract.
    /// @dev This function reverts if there are no funds to withdraw or if the transfer fails.
    /// It should only be callable by the owner of the contract.
    /// @param _beneficiary The address to which the Ether should be sent.
    function withdraw(address _beneficiary) public onlyOwner {
        // Retrieve the balance of this contract
        uint256 amount = address(this).balance;

// Revert if there is nothing to withdraw
        if (amount == 0) revert NothingToWithdraw();

// Attempt to send the funds, capturing the success status and discarding any return data
        (bool sent, ) = _beneficiary.call{value: amount}("");

// Revert if the send failed, with information about the attempted transfer
        if (!sent) revert FailedToWithdrawEth(msg.sender, _beneficiary, amount);
    }

/// @notice Allows the owner of the contract to withdraw all tokens of a specific ERC20 token.
    /// @dev This function reverts with a 'NothingToWithdraw' error if there are no tokens to withdraw.
    /// @param _beneficiary The address to which the tokens will be sent.
    /// @param _token The contract address of the ERC20 token to be withdrawn.
    function withdrawToken(
        address _beneficiary,
        address _token
    ) public onlyOwner {
        // Retrieve the balance of this contract
        uint256 amount = IERC20(_token).balanceOf(address(this));

// Revert if there is nothing to withdraw
        if (amount == 0) revert NothingToWithdraw();

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

### NFT合约

```solidity
// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyNFT is ERC721, ERC721Enumerable, ERC721URIStorage, ERC721Burnable, Ownable {
    string constant public METADATA_URI = "ipfs://QmXw7TEAJWKjKifvLE25Z9yjvowWk2NWY3WgnZPUto9XoA";
    uint256 private _nextTokenId;

constructor(string memory tokenName, string memory tokenSymbol)
        ERC721(tokenName, tokenSymbol)
        Ownable(msg.sender)
    {}

function safeMint(address to)
        public
    {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, METADATA_URI);
    }

// The following functions are overrides required by Solidity.

function _update(address to, uint256 tokenId, address auth)
        internal
        override(ERC721, ERC721Enumerable)
        returns (address)
    {
        return super._update(to, tokenId, auth);
    }

function _increaseBalance(address account, uint128 value)
        internal
        override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }

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

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

```

### NFT-Locked-Release

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

/**
 * 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.
 */

/// @title - A simple messenger contract for sending/receving string data across chains.
contract NFTPoolLockAndRelease is CCIPReceiver, OwnerIsCreator {
    using SafeERC20 for IERC20;

bytes32 private s_lastReceivedMessageId; // Store the last received messageId.
    string private s_lastReceivedText; // Store the last received text.

IERC20 private s_linkToken;
    MyNFT public nft;//第一步先实例化一个nft对象，同时需要在构造函数中初始化
    
    // remember to add visibility for the variable 
    MyToken public nft;
    
    struct RequestData{
        uint256 tokenId;
        address newOwner;
    }

/// @notice Constructor initializes the contract with the router address.
    /// @param _router The address of the router contract.
    /// @param _link The address of the link contract.
    constructor(address _router, address _link, address nftAddr) CCIPReceiver(_router) {
        s_linkToken = IERC20(_link);
        nft = MyToken(nftAddr);
    }
   
    function lockAndSendNFT(
        uint256 tokenId,
        address newOwner,
        uint64 chainSelector,
        address receiver) public returns(bytes32 messageId){
        //transfer
        nft.transferFrom(msg.sender,address(this),tokenId);//从持有人地址转入当前地址
        //发送跨链消息：需要传入receiver地址和tokenid给到链下的ccip组件
        //通过加密，打包两个参数
        bytes memory payload = abi.encode(tokenId,newOwner);
        //发送消息，使用link支付
        bytes32 messageId = sendMessagePayLINK(chainSelector,receiver,payload);

}