区块链跨链技术深度解析：从原子交换到轻客户端验证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

interface CrossChainSolutions {
  centralized: {
    name: "中心化跨链桥",
    examples: ["Binance Bridge", "Core DAO Bridge"],
    pros: ["速度快", "用户体验好"],
    cons: ["需要信任", "单点故障风险"]
  },
  liquidity: {
    name: "流动性跨链桥",
    examples: ["Hop Protocol", "Across"],
    pros: ["去中心化", "速度快"],
    cons: ["依赖流动性提供者", "资金效率低"]
  },
  lightClient: {
    name: "轻客户端验证",
    examples: ["IBC (Cosmos)", "XCM (Polkadot)"],
    pros: ["安全性高", "真正的去中心化"],
    cons: ["实现复杂", "跨链速度慢"]
  },
  atomic: {
    name: "原子交换",
    examples: ["THORChain", "LIOS"],
    pros: ["无需信任", "点对点"],
    cons: ["只支持资产交换", "限制多"]
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

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

contract HTLC {
    struct Swap {
        address payable sender;
        address payable receiver;
        uint256 amount;
        bytes32 hashLock;      // 哈希锁
        uint256 timeLock;      // 时间锁
        bytes32 preimage;      // 原像（秘密）
        bool claimed;          // 是否已提取
        bool refunded;         // 是否已退款
    }

    mapping(bytes32 => Swap) public swaps;

    event SwapCreated(
        bytes32 indexed swapId,
        address indexed sender,
        address indexed receiver,
        uint256 amount,
        bytes32 hashLock,
        uint256 timeLock
    );

    event SwapClaimed(bytes32 indexed swapId, bytes32 preimage);
    event SwapRefunded(bytes32 indexed swapId);

    // 创建HTLC
    function createSwap(
        address payable _receiver,
        bytes32 _hashLock,
        uint256 _timeLock
    ) external payable returns (bytes32) {
        require(msg.value > 0, "Amount must be greater than 0");
        require(_timeLock > block.timestamp, "Time lock must be in future");

        bytes32 swapId = keccak256(
            abi.encodePacked(
                msg.sender,
                _receiver,
                msg.value,
                _hashLock,
                _timeLock,
                block.number
            )
        );

        swaps[swapId] = Swap({
            sender: payable(msg.sender),
            receiver: payable(_receiver),
            amount: msg.value,
            hashLock: _hashLock,
            timeLock: _timeLock,
            preimage: bytes32(0),
            claimed: false,
            refunded: false
        });

        emit SwapCreated(
            swapId,
            msg.sender,
            _receiver,
            msg.value,
            _hashLock,
            _timeLock
        );

        return swapId;
    }

    // 提取资金（需要知道preimage）
    function claimSwap(bytes32 _swapId, bytes32 _preimage) external {
        Swap storage swap = swaps[_swapId];

        require(swap.amount > 0, "Swap does not exist");
        require(!swap.claimed, "Already claimed");
        require(!swap.refunded, "Already refunded");
        require(swap.receiver == msg.sender, "Not the receiver");

        // 验证preimage
        require(
            keccak256(abi.encodePacked(_preimage)) == swap.hashLock,
            "Invalid preimage"
        );

        swap.preimage = _preimage;
        swap.claimed = true;

        emit SwapClaimed(_swapId, _preimage);

        // 转移资金
        swap.receiver.transfer(swap.amount);
    }

    // 退款（时间锁过期后）
    function refundSwap(bytes32 _swapId) external {
        Swap storage swap = swaps[_swapId];

        require(swap.amount > 0, "Swap does not exist");
        require(!swap.claimed, "Already claimed");
        require(!swap.refunded, "Already refunded");
        require(swap.sender == msg.sender, "Not the sender");
        require(block.timestamp >= swap.timeLock, "Time lock not expired");

        swap.refunded = true;

        emit SwapRefunded(_swapId);

        // 退还资金
        swap.sender.transfer(swap.amount);
    }
}

// 使用示例
// Alice想和Bob跨链交换1 ETH换100 USDT
// 1. Alice生成随机数secret，计算hashLock = keccak256(secret)
// 2. Alice在以太坊上创建HTLC，发送1 ETH，设置hashLock和时间锁
// 3. Bob在BSC上创建HTLC，发送100 USDT，使用相同的hashLock和时间锁
// 4. Bob在以太坊上调用claimSwap，提供secret，获得1 ETH
// 5. Alice从Bob的交易中获得secret
// 6. Alice在BSC上调用claimSwap，提供secret，获得100 USDT

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

interface AtomicSwapFlow {
  step1: "Alice生成随机数secret",
  step2: "Alice计算hashLock = H(secret)",
  step3: "Alice在Chain A创建HTLC（hashLock, 时间锁24小时）",
  step4: "Bob在Chain B创建HTLC（hashLock, 时间锁23小时）",
  step5: "Bob在Chain A调用claim(secret)提取资金",
  step6: "Alice从Chain A的交易中读取secret",
  step7: "Alice在Chain B调用claim(secret)提取资金",
  timeout: "如果24小时内Bob未提取，Alice可以退款"
}

// 实现原子交换
class AtomicSwap {
  async initiateSwap(
    fromChain: string,
    toChain: string,
    fromToken: string,
    toToken: string,
    amount: bigint,
    counterparty: string
  ): Promise<string> {
    // 1. 生成secret
    const secret = this.generateSecret()
    const hashLock = this.hashFunction(secret)

    // 2. 在源链创建HTLC
    const swapId = await this.createHTLC(
      fromChain,
      amount,
      hashLock,
      24 * 60 * 60 // 24小时时间锁
    )

    // 3. 发送hashLock给对方
    await this.notifyCounterparty(counterparty, {
      swapId,
      hashLock,
      toChain,
      toToken,
      amount
    })

    return swapId
  }

  async participateSwap(
    hashLock: string,
    toChain: string,
    toToken: string,
    amount: bigint
  ): Promise<string> {
    // 在目标链创建HTLC
    // 使用稍短的时间锁（23小时）
    const swapId = await this.createHTLC(
      toChain,
      amount,
      hashLock,
      23 * 60 * 60
    )

    return swapId
  }

  async claimSwap(
    chain: string,
    swapId: string,
    secret: string
  ): Promise<void> {
    // 调用claim合约方法
    const tx = await this.executeContract(
      chain,
      swapId,
      'claimSwap',
      [secret]
    )

    await tx.wait()
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

// SPV证明
interface MerkleProof {
  txId: string
  blockHash: string
  merkleProof: string[]
  blockHeader: BlockHeader
}

class SPVVerifier {
  /**
   * 验证交易是否在区块中
   */
  verifyTransaction(proof: MerkleProof): boolean {
    // 1. 验证区块头工作量证明
    const isValidPOW = this.verifyProofOfWork(proof.blockHeader)
    if (!isValidPOW) return false

    // 2. 计算Merkle根
    const calculatedRoot = this.calculateMerkleRoot(
      proof.txId,
      proof.merkleProof
    )

    // 3. 比较Merkle根
    return calculatedRoot === proof.blockHeader.merkleRoot
  }

  /**
   * 计算Merkle根
   */
  private calculateMerkleRoot(
    txId: string,
    proof: string[]
  ): string {
    let hash = txId

    for (const sibling of proof) {
      // 根据位置确定hash顺序
      if (this.isLeftChild(hash)) {
        hash = this.hashPair(hash, sibling)
      } else {
        hash = this.hashPair(sibling, hash)
      }
    }

    return hash
  }

  /**
   * 验证工作量证明
   */
  private verifyProofOfWork(header: BlockHeader): boolean {
    const target = this.calculateTarget(header.bits)
    const headerHash = this.hashHeader(header)

    return BigInt('0x' + headerHash) < target
  }

  /**
   * 双SHA256哈希
   */
  private sha256(data: string): string {
    return crypto.createHash('sha256')
      .update(data)
      .digest('hex')
  }

  private hashPair(a: string, b: string): string {
    return this.sha256(this.sha256(a + b))
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

import { ethers } from 'ethers'

class LightClient {
  private headers: Map<number, BlockHeader> = new Map()
  private currentHeight: number = 0

  /**
   * 添加新的区块头
   */
  async addHeader(header: BlockHeader): Promise<boolean> {
    // 验证区块头
    if (!this.verifyHeader(header)) {
      throw new Error('Invalid block header')
    }

    // 如果是第一个区块头
    if (this.headers.size === 0) {
      this.headers.set(header.number, header)
      this.currentHeight = header.number
      return true
    }

    // 验证区块连接
    const parentHeader = this.headers.get(header.number - 1)
    if (parentHeader && header.parentHash !== parentHeader.hash) {
      throw new Error('Block does not connect to known chain')
    }

    // 存储区块头
    this.headers.set(header.number, header)
    this.currentHeight = Math.max(this.currentHeight, header.number)

    // 限制存储大小
    if (this.headers.size > 1000) {
      const oldest = Math.min(...this.headers.keys())
      this.headers.delete(oldest)
    }

    return true
  }

  /**
   * 验证默克尔证明
   */
  verifyMerkleProof(
    blockNumber: number,
    txHash: string,
    proof: MerkleProof
  ): boolean {
    const header = this.headers.get(blockNumber)
    if (!header) {
      throw new Error('Unknown block')
    }

    // 计算根哈希
    let hash = txHash
    for (const sibling of proof.siblings) {
      if (proof.path % 2 === 0) {
        hash = ethers.utils.keccak256(
          ethers.utils.concat([hash, sibling])
        )
      } else {
        hash = ethers.utils.keccak256(
          ethers.utils.concat([sibling, hash])
        )
      )
      proof.path = Math.floor(proof.path / 2)
    }

    // 验证根哈希匹配
    return hash === header.transactionsRoot
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

// IBC核心组件
package ibc

// Channel握手状态
type ChannelState string

const (
    INIT           ChannelState = "INIT"
    TRYOPEN        ChannelState = "TRYOPEN"
    OPEN           ChannelState = "OPEN"
    CLOSED         ChannelState = "CLOSED"
)

// Channel结构
type Channel struct {
    State          ChannelState
    Ordering       Order
    Counterparty   Counterparty
    ConnectionHops []string
    Version        string
}

// IBC消息
type Message interface {
    Type() string
    ValidateBasic() error
}

// ChannelOpenInit消息
type MsgChannelOpenInit struct {
    PortId         string
    ChannelId      string
    Ordering       Order
    Counterparty   Counterparty
    Version        string
    Signer         string
}

func (msg MsgChannelOpenInit) ValidateBasic() error {
    if msg.PortId == "" {
        return fmt.Errorf("port ID cannot be empty")
    }
    if msg.ChannelId != "" {
        return fmt.Errorf("channel ID must be empty for Init")
    }
    return nil
}

// Packet数据结构
type Packet struct {
    Data           []byte
    TimeoutHeight  uint64
    TimeoutTimestamp uint64
    Sequence       uint64
    SourcePort     string
    SourceChannel  string
    DestPort       string
    DestChannel    string
}

// IBC Handler
type IBCModule interface {
    OnChanOpenInit(
        ctx sdk.Context,
        order ChannelOrder,
        connectionHops []string,
        portId string,
        channelId string,
        counterparty Counterparty,
        version string,
    ) (string, error)

    OnChanOpenTry(
        ctx sdk.Context,
        order ChannelOrder,
        connectionHops []string,
        portId string,
        channelId string,
        counterparty Counterparty,
        counterpartyVersion string,
    ) error

    OnChanOpenAck(
        ctx sdk.Context,
        portId string,
        channelId string,
        counterpartyChannelId string,
        counterpartyVersion string,
    ) error

    OnChanOpenConfirm(
        ctx sdk.Context,
        portId string,
        channelId string,
    ) error

    OnRecvPacket(
        ctx sdk.Context,
        packet Packet,
        relayer sdk.AccAddress,
    ) exported.Acknowledgement

    OnAcknowledgePacket(
        ctx sdk.Context,
        packet Packet,
        acknowledgement []byte,
        relayer sdk.AccAddress,
    ) error

    OnTimeoutPacket(
        ctx sdk.Context,
        packet Packet,
        relayer sdk.AccAddress,
    ) error
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// ICS-20: 跨链代币转账标准
package ics20

type TransferData struct {
    Sender   string
    Receiver string
    Amount   sdk.Int
    Denom    string
    Memo     string
}

type MsgTransfer struct {
    SourcePort       string
    SourceChannel    string
    Token            sdk.Coin
    Sender           string
    Receiver         string
    TimeoutHeight    uint64
    TimeoutTimestamp uint64
    Memo             string
}

func (msg MsgTransfer) ValidateBasic() error {
    if msg.Token.Amount.IsZero() || msg.Token.Amount.IsNegative() {
        return fmt.Errorf("amount must be positive")
    }
    if msg.Sender == "" || msg.Receiver == "" {
        return fmt.Errorf("sender and receiver cannot be empty")
    }
    return nil
}

// 转账逻辑
func (k Keeper) Transfer(
    ctx sdk.Context,
    msg MsgTransfer,
) error {
    // 1. 锁定或销毁代币
    sender, err := sdk.AccAddressFromBech32(msg.Sender)
    if err != nil {
        return err
    }

    if err := k.SendCoins(ctx, sender, msg.Token); err != nil {
        return err
    }

    // 2. 创建IBC Packet
    packet := channeltypes.Packet{
        Data: modulecdc.MustMarshalJSON(&TransferData{
            Sender:   msg.Sender,
            Receiver: msg.Receiver,
            Amount:   msg.Token.Amount,
            Denom:    msg.Token.Denom,
            Memo:     msg.Memo,
        }),
        TimeoutHeight: clienttypes.Height{
            RevisionNumber: 0,
            RevisionHeight: msg.TimeoutHeight,
        },
        TimeoutTimestamp: msg.TimeoutTimestamp,
    }

    // 3. 发送Packet
    _, err = k.channelKeeper.SendPacket(ctx, packet)
    if err != nil {
        return err
    }

    return nil
}

// 接收跨链代币
func (k Keeper) OnRecvPacket(
    ctx sdk.Context,
    packet channeltypes.Packet,
) exported.Acknowledgement {
    var data TransferData
    if err := modulecdc.UnmarshalJSON(packet.Data, &data); err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    // 铸造代币给接收者
    receiver, err := sdk.AccAddressFromBech32(data.Receiver)
    if err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    coins := sdk.NewCoins(sdk.NewCoin(data.Denom, data.Amount))
    if err := k.bankKeeper.MintCoins(ctx, coins); err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    if err := k.bankKeeper.SendCoins(ctx, k.GetAccount(ctx), receiver, coins); err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    return channeltypes.NewResultAcknowledgement([]byte{byte(1)})
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

// XCM (Cross-Consensus Message) 类型定义
use xcm::v3::{
    Xcm, Junction, Junctions::X1, MultiAsset, MultiLocation,
    Instruction, WeightLimit,
};

// 构建跨链转账XCM
fn create_transfer_xcm(
    dest: MultiLocation,
    amount: u128,
) -> Xcm<()> {
    Xcm(vec![
        // 1. 提取资产
        WithdrawAsset(MultiAsset::from((dest, amount))),

        // 2. 初始化资产
        InitiateReserveWithdraw(
            X1([Parachain(2000)]), // 中继链
            MultiAsset::from((dest, amount)),
        ),

        // 3. 跨链传输
        TransferReserveAsset(
            X1([Parachain(2000)]),
            X1([AccountId32 {
                network: None,
                id: [/* 目标账户 */],
            }]),
            MultiAsset::from((dest, amount)),
        ),
    ])
}

// XCM执行器
pub struct XcmExecutor;

impl XcmExecutor {
    pub fn execute_xcm(
        origin: MultiLocation,
        xcm: Xcm<()>,
    ) -> Result<XcmOutcome, XcmError> {
        match xcm {
            Xcm::TransferReserveAsset {
                assets,
                dest,
                xcm,
            } => {
                // 处理资产转移
                Self::handle_reserve_transfer(assets, dest, xcm)
            }

            Xcm::Transact {
                origin_kind,
                require_weight_at_most,
                call,
            } => {
                // 处理跨链调用
                Self::handle_transact(origin_kind, require_weight_at_most, call)
            }

            _ => Ok(XcmOutcome::Complete)
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

use xcm::v3::{Instruction, WeightLimit};

// 构建跨链合约调用XCM
fn create_cross_chain_call(
    target_chain: u32,
    contract_address: [u8; 32],
    call_data: Vec<u8>,
) -> Xcm<()> {
    Xcm(vec![
        // 设置权重限制
        SetAppendix(Xcm(vec![
            SetTopic([0u8; 32]),
        ])),

        // 执行远程调用
        Transact {
            origin_kind: OriginKind::SovereignAccount,
            require_weight_at_most: WeightLimit::Limited(3_000_000_000),
            call: {
                let encoded_call = Encode::encode(&Call::EVM(evm::Call::call(
                    contract_address.into(),
                    call_data,
                )));

                // 编码为XCM格式
                (/* 调用编码 */)
            },
        },
    ])
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

interface CrossChainAttackVectors {
    fakeDeposits: {
        name: "虚假存款攻击",
        description: "攻击者在源链存款后，在目标链欺骗性地铸造包装代币",
        mitigation: "使用轻客户端验证，等待足够的确认数"
    },
    dataAvailability: {
        name: "数据可用性攻击",
        description: "中继器提交虚假或无效的数据",
        mitigation: "多个独立中继器，欺诈证明机制"
    },
    doubleSpend: {
        name: "双花攻击",
        description: "利用跨链延迟在多条链上花费同一笔资产",
        mitigation: "适当的锁定期和确认数"
    },
    bridgeCompromise: {
        name: "桥合约被攻破",
        description: "智能合约漏洞导致资产被盗",
        mitigation: "多重签名、时间锁、渐进式去中心化"
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

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

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";

contract SecureBridge is ReentrancyGuard, Pausable, AccessControl {
    bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
    bytes32 public constant RELAYER_ROLE = keccak256("RELAYER_ROLE");

    // 映射：源链交易哈希 -> 是否已处理
    mapping(bytes32 => bool) public processedTransactions;

    // 桥接配置
    uint256 public minConfirmations = 6;
    uint256 public maxDailyTransfer = 1000000 * 1e18;
    uint256 public dailyTransferLimit = 100000 * 1e18;

    mapping(address => uint256) public userDailyTransfer;
    mapping(uint256 => uint256) public dailyTotalTransfer;

    event Deposit(
        address indexed user,
        uint256 amount,
        bytes32 indexed destTxHash
    );

    event Withdraw(
        address indexed user,
        uint256 amount,
        bytes32 indexed srcTxHash
    );

    modifier onlyRelayer() {
        require(
            hasRole(RELAYER_ROLE, msg.sender),
            "Not a relayer"
        );
        _;
    }

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(GUARDIAN_ROLE, msg.sender);
    }

    // 存款（源链）
    function deposit(
        bytes32 destTxHash,
        address recipient,
        uint256 amount
    ) external whenNotPaused nonReentrant {
        require(amount > 0, "Amount must be greater than 0");

        // 检查每日限额
        uint256 currentDay = block.timestamp / 1 days;
        uint256 userDaily = userDailyTransfer[recipient];
        uint256 dailyTotal = dailyTotalTransfer[currentDay];

        require(
            userDaily + amount <= dailyTransferLimit,
            "User daily limit exceeded"
        );
        require(
            dailyTotal + amount <= maxDailyTransfer,
            "Bridge daily limit exceeded"
        );

        // 更新限额
        userDailyTransfer[recipient] = userDaily + amount;
        dailyTotalTransfer[currentDay] = dailyTotal + amount;

        // 转入资金
        IERC20(USDT).transferFrom(msg.sender, address(this), amount);

        emit Deposit(msg.sender, amount, destTxHash);
    }

    // 取款（目标链，由中继器触发）
    function withdraw(
        bytes32 srcTxHash,
        address recipient,
        uint256 amount,
        uint256 confirmations,
        bytes memory proof
    ) external onlyRelayer whenNotPaused nonReentrant {
        // 检查是否已处理
        require(
            !processedTransactions[srcTxHash],
            "Transaction already processed"
        );

        // 验证证明
        require(
            verifyWithdrawProof(srcTxHash, recipient, amount, confirmations, proof),
            "Invalid proof"
        );

        // 检查确认数
        require(confirmations >= minConfirmations, "Not enough confirmations");

        // 标记为已处理
        processedTransactions[srcTxHash] = true;

        // 转出资金
        uint256 balance = IERC20(USDT).balanceOf(address(this));
        uint256 amountToTransfer = amount > balance ? balance : amount;

        if (amountToTransfer > 0) {
            IERC20(USDT).transfer(recipient, amountToTransfer);
        }

        emit Withdraw(recipient, amountToTransfer, srcTxHash);
    }

    // 验证取款证明（使用轻客户端验证）
    function verifyWithdrawProof(
        bytes32 srcTxHash,
        address recipient,
        uint256 amount,
        uint256 confirmations,
        bytes memory proof
    ) internal view returns (bool) {
        // 这里实现轻客户端验证逻辑
        // 验证：
        // 1. 交易确实存在于源链
        // 2. 有足够的确认数
        // 3. 证明由多个独立的中继器签名
        // 简化实现，实际应用中需要完整的SPV验证
        return true;
    }

    // 紧急暂停
    function pause() external onlyRole(GUARDIAN_ROLE) {
        _pause();
    }

    function unpause() external onlyRole(GUARDIAN_ROLE) {
        _unpause();
    }

    // 更新配置（需要多签）
    function setMinConfirmations(uint256 _minConfirmations)
        external
        onlyRole(DEFAULT_ADMIN_ROLE)
    {
        minConfirmations = _minConfirmations;
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107

import { ethers } from 'ethers'
import axios from 'axios'

class EVMCrossChainBridge {
  private sourceChain: ethers.providers.Provider
  private destChain: ethers.providers.Provider
  private bridgeContract: ethers.Contract

  constructor(
    sourceRpc: string,
    destRpc: string,
    bridgeAddress: string,
    privateKey: string
  ) {
    this.sourceChain = new ethers.JsonRpcProvider(sourceRpc)
    this.destChain = new ethers.JsonRpcProvider(destRpc)

    const wallet = new ethers.Wallet(privateKey, this.destChain)

    this.bridgeContract = new ethers.Contract(
      bridgeAddress,
      [
        'function deposit(bytes32 destTxHash, address recipient, uint256 amount)',
        'function withdraw(bytes32 srcTxHash, address recipient, uint256 amount, uint256 confirmations, bytes proof)',
        'event Deposit(address indexed user, uint256 amount, bytes32 indexed destTxHash)',
        'event Withdraw(address indexed user, uint256 amount, bytes32 indexed srcTxHash)'
      ],
      wallet
    )
  }

  /**
   * 跨链转移资产
   */
  async transfer(
    fromAddress: string,
    toAddress: string,
    amount: bigint,
    tokenAddress: string
  ): Promise<string> {
    // 1. 在源链授权
    const tokenContract = new ethers.Contract(
      tokenAddress,
      ['function approve(address spender, uint256 amount)'],
      new ethers.Wallet(process.env.PRIVATE_KEY, this.sourceChain)
    )

    const approveTx = await tokenContract.approve(
      this.bridgeContract.address,
      amount
    )
    await approveTx.wait()

    // 2. 存款到桥合约
    const destTxHash = ethers.utils.keccak256(
      ethers.utils.defaultAbiCoder.encode(
        ['address', 'uint256', 'uint256'],
        [toAddress, amount, Date.now()]
      )
    )

    const depositTx = await this.bridgeContract.deposit(
      destTxHash,
      toAddress,
      amount
    )

    const receipt = await depositTx.wait()

    // 3. 等待确认后，在目标链提取
    const srcTxHash = receipt.transactionHash
    await this.waitForConfirmations(srcTxHash, 6)

    // 4. 提取资金
    const withdrawTx = await this.bridgeContract.withdraw(
      srcTxHash,
      toAddress,
      amount,
      6, // 确认数
      '0x' // 证明（简化）
    )

    await withdrawTx.wait()

    return withdrawTx.hash
  }

  /**
   * 等待足够的确认数
   */
  private async waitForConfirmations(
    txHash: string,
    confirmations: number
  ): Promise<void> {
    while (true) {
      const tx = await this.sourceChain.getTransaction(txHash)
      const currentBlock = await this.sourceChain.getBlockNumber()
      const confirmations = currentBlock - tx.blockNumber

      if (confirmations >= confirmations) {
        break
      }

      await new Promise(resolve => setTimeout(resolve, 10000)) // 等待10秒
    }
  }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

package ibc

import (
    sdk "github.com/cosmos/cosmos-sdk/types"
    banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
)

type IBCTransferKeeper struct {
    bankKeeper    banktypes.Keeper
    channelKeeper ChannelKeeper
    portKeeper    PortKeeper
}

// 跨链转账
func (k IBCTransferKeeper) Transfer(
    ctx sdk.Context,
    sourcePort string,
    sourceChannel string,
    token sdk.Coin,
    sender sdk.AccAddress,
    receiver string,
    timeoutHeight uint64,
) error {
    // 1. 验证参数
    if token.Amount.IsZero() {
        return fmt.Errorf("amount must be positive")
    }

    // 2. 从发送者账户扣除代币
    if err := k.bankKeeper.SendCoins(
        ctx,
        sender,
        accountAddr,
        sdk.NewCoins(token),
    ); err != nil {
        return err
    }

    // 3. 创建IBC数据包
    packetData := TransferData{
        Sender:   sender.String(),
        Receiver: receiver,
        Amount:   token,
        Memo:     "",
    }

    packetBz := modulecdc.MustMarshalJSON(&packetData)

    packet := channeltypes.Packet{
        Data:              packetBz,
        TimeoutHeight:     clienttypes.Height{RevisionNumber: 0, RevisionHeight: timeoutHeight},
        TimeoutTimestamp:  0,
    }

    // 4. 发送数据包
    _, err := k.channelKeeper.SendPacket(ctx, packet)
    if err != nil {
        return err
    }

    ctx.EventManager().EmitEvents(
        sdk.Events{
            sdk.NewEvent(
                "ibc_transfer",
                sdk.NewAttribute("sender", sender.String()),
                sdk.NewAttribute("receiver", receiver),
                sdk.NewAttribute("amount", token.String()),
            ),
        },
    )

    return nil
}

// 接收跨链代币
func (k IBCTransferKeeper) OnRecvPacket(
    ctx sdk.Context,
    packet channeltypes.Packet,
    relayer sdk.AccAddress,
) exported.Acknowledgement {
    var data TransferData
    if err := modulecdc.UnmarshalJSON(packet.Data, &data); err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    // 解析接收者地址
    receiver, err := sdk.AccAddressFromBech32(data.Receiver)
    if err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    // 铸造代币
    coins := sdk.NewCoins(data.Amount)
    if err := k.bankKeeper.MintCoins(ctx, coins); err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    // 发送给接收者
    if err := k.bankKeeper.SendCoins(
        ctx,
        accountAddr,
        receiver,
        coins,
    ); err != nil {
        return channeltypes.NewErrorAcknowledgement(err)
    }

    // 记录事件
    ctx.EventManager().EmitEvents(
        sdk.Events{
            sdk.NewEvent(
                "ibc_receive",
                sdk.NewAttribute("receiver", receiver.String()),
                sdk.NewAttribute("amount", data.Amount.String()),
            ),
        },
    )

    return channeltypes.NewResultAcknowledgement([]byte{0x01})
}