What is Ethereum cross-chain technology? Please explain cross-chain bridges and asset transfer mechanisms - 面试题

Ethereum cross-chain technology is key technology for achieving interoperability of assets and data between different blockchains. Here's a comprehensive analysis of cross-chain technology:

Basic Concepts of Cross-Chain

Cross-chain technology allows communication and asset transfer between different blockchains, breaking blockchain islands and achieving true multi-chain ecosystem.

Cross-Chain Technology Types

1. Sidechains

Independent blockchains running in parallel with main chain.

Features:

Independent consensus mechanisms
Connected to mainnet through bridging
Higher throughput

Representative Projects:

Polygon: Ethereum sidechain
xDai: Stablecoin sidechain

2. State Channels

Conduct transactions off-chain, settle to main chain periodically.

Features:

Instant transaction confirmation
Low Gas fees
Requires participants to be online

Representative Projects:

Raiden Network: Ethereum payment channels
Connext: Cross-chain payment network

3. Parachains

Blockchains that verify states of other chains.

Features:

Light client verification
Cross-chain message passing
Security depends on relay chain

Representative Projects:

Polkadot: Multi-chain interoperability protocol
Cosmos: Blockchain internet

4. Hashed Timelock Contracts (HTLC)

Use hash and time locks to achieve cross-chain transactions.

Principle:

Sender locks assets on source chain, generates hash
Receiver locks equivalent value on target chain, provides hash preimage
Sender provides hash preimage, unlocks target chain assets
Receiver unlocks source chain assets

Implementation:

solidity
contract HTLC {
    struct Swap {
        bytes32 hashLock;
        address sender;
        address receiver;
        uint256 amount;
        uint256 timelock;
        bool claimed;
        bool refunded;
    }
    
    mapping(bytes32 => Swap) public swaps;
    
    event SwapCreated(bytes32 indexed swapId, address indexed sender, address indexed receiver, uint256 amount);
    event SwapClaimed(bytes32 indexed swapId, address indexed receiver, uint256 amount);
    event SwapRefunded(bytes32 indexed swapId, address indexed sender, uint256 amount);
    
    function createSwap(
        bytes32 hashLock,
        address receiver,
        uint256 timelock
    ) public payable {
        bytes32 swapId = keccak256(abi.encodePacked(msg.sender, receiver, block.timestamp));
        
        swaps[swapId] = Swap({
            hashLock: hashLock,
            sender: msg.sender,
            receiver: receiver,
            amount: msg.value,
            timelock: timelock,
            claimed: false,
            refunded: false
        });
        
        emit SwapCreated(swapId, msg.sender, receiver, msg.value);
    }
    
    function claimSwap(bytes32 swapId, bytes32 preimage) public {
        Swap storage swap = swaps[swapId];
        require(!swap.claimed, "Already claimed");
        require(!swap.refunded, "Already refunded");
        require(block.timestamp < swap.timelock, "Timelock expired");
        require(keccak256(preimage) == swap.hashLock, "Invalid preimage");
        require(msg.sender == swap.receiver, "Not receiver");
        
        swap.claimed = true;
        payable(swap.receiver).transfer(swap.amount);
        
        emit SwapClaimed(swapId, swap.receiver, swap.amount);
    }
    
    function refundSwap(bytes32 swapId) public {
        Swap storage swap = swaps[swapId];
        require(!swap.claimed, "Already claimed");
        require(!swap.refunded, "Already refunded");
        require(block.timestamp >= swap.timelock, "Timelock not expired");
        require(msg.sender == swap.sender, "Not sender");
        
        swap.refunded = true;
        payable(swap.sender).transfer(swap.amount);
        
        emit SwapRefunded(swapId, swap.sender, swap.amount);
    }
}

Cross-Chain Bridges

1. Simple Bridge

solidity
contract SimpleBridge {
    address public otherChainBridge;
    mapping(address => uint256) public balances;
    
    event Deposit(address indexed from, uint256 amount);
    event Withdraw(address indexed to, uint256 amount);
    
    constructor(address _otherChainBridge) {
        otherChainBridge = _otherChainBridge;
    }
    
    function deposit() public payable {
        balances[msg.sender] += msg.value;
        emit Deposit(msg.sender, msg.value);
    }
    
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "Insufficient balance");
        balances[msg.sender] -= amount;
        payable(msg.sender).transfer(amount);
        emit Withdraw(msg.sender, amount);
    }
    
    function relayWithdraw(address to, uint256 amount) public {
        require(msg.sender == otherChainBridge, "Not bridge");
        balances[to] += amount;
        emit Deposit(to, amount);
    }
}

2. Lock-Mint Bridge

solidity
contract LockMintBridge {
    IERC20 public sourceToken;
    IERC20 public targetToken;
    
    event Locked(address indexed from, uint256 amount);
    event Minted(address indexed to, uint256 amount);
    
    constructor(address _sourceToken, address _targetToken) {
        sourceToken = IERC20(_sourceToken);
        targetToken = IERC20(_targetToken);
    }
    
    function lock(uint256 amount) public {
        sourceToken.transferFrom(msg.sender, address(this), amount);
        emit Locked(msg.sender, amount);
    }
    
    function mint(address to, uint256 amount) public {
        require(msg.sender == bridgeOperator, "Not operator");
        targetToken.mint(to, amount);
        emit Minted(to, amount);
    }
    
    function burn(uint256 amount) public {
        targetToken.burnFrom(msg.sender, amount);
        emit Burned(msg.sender, amount);
    }
    
    function unlock(address to, uint256 amount) public {
        require(msg.sender == bridgeOperator, "Not operator");
        sourceToken.transfer(to, amount);
        emit Unlocked(to, amount);
    }
}

Cross-Chain Message Passing

1. Light Client Verification

solidity
contract LightClientBridge {
    struct BlockHeader {
        bytes32 parentHash;
        bytes32 stateRoot;
        bytes32 transactionsRoot;
        uint256 number;
        uint256 timestamp;
    }
    
    mapping(uint256 => BlockHeader) public blockHeaders;
    bytes32 public currentBlockHash;
    
    function submitBlockHeader(BlockHeader memory header) public {
        require(header.parentHash == currentBlockHash, "Invalid parent");
        require(header.timestamp <= block.timestamp, "Future block");
        
        blockHeaders[header.number] = header;
        currentBlockHash = keccak256(abi.encode(header));
    }
    
    function verifyTransaction(
        uint256 blockNumber,
        bytes32 txHash,
        bytes memory proof
    ) public view returns (bool) {
        BlockHeader memory header = blockHeaders[blockNumber];
        return verifyMerkleProof(txHash, proof, header.transactionsRoot);
    }
    
    function verifyMerkleProof(
        bytes32 leaf,
        bytes memory proof,
        bytes32 root
    ) internal pure returns (bool) {
        bytes32 computedHash = leaf;
        
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement;
            assembly {
                proofElement := mload(add(proof, mul(i, 32)))
            }
            
            if (computedHash < proofElement) {
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }
        
        return computedHash == root;
    }
}

2. Relayer Network

solidity
contract RelayerNetwork {
    struct Relayer {
        address addr;
        uint256 stake;
        uint256 lastActive;
        bool active;
    }
    
    mapping(address => Relayer) public relayers;
    address[] public relayerList;
    uint256 public minStake = 100 ether;
    uint256 public requiredRelayers = 3;
    
    event RelayerRegistered(address indexed relayer);
    event RelayerDeregistered(address indexed relayer);
    event MessageRelayed(bytes32 indexed messageId, address indexed relayer);
    
    function registerRelayer() public payable {
        require(msg.value >= minStake, "Insufficient stake");
        require(!relayers[msg.sender].active, "Already registered");
        
        relayers[msg.sender] = Relayer({
            addr: msg.sender,
            stake: msg.value,
            lastActive: block.timestamp,
            active: true
        });
        
        relayerList.push(msg.sender);
        emit RelayerRegistered(msg.sender);
    }
    
    function deregisterRelayer() public {
        require(relayers[msg.sender].active, "Not registered");
        
        payable(msg.sender).transfer(relayers[msg.sender].stake);
        relayers[msg.sender].active = false;
        
        emit RelayerDeregistered(msg.sender);
    }
    
    function relayMessage(
        bytes32 messageId,
        bytes calldata message,
        bytes[] calldata signatures
    ) public {
        require(relayers[msg.sender].active, "Not relayer");
        
        uint256 validSignatures = 0;
        for (uint256 i = 0; i < signatures.length; i++) {
            address signer = recoverSigner(messageId, signatures[i]);
            if (relayers[signer].active) {
                validSignatures++;
            }
        }
        
        require(validSignatures >= requiredRelayers, "Insufficient signatures");
        
        relayers[msg.sender].lastActive = block.timestamp;
        
        // Execute message
        executeMessage(message);
        
        emit MessageRelayed(messageId, msg.sender);
    }
    
    function recoverSigner(bytes32 messageId, bytes memory signature) internal pure returns (address) {
        bytes32 ethSignedMessageHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", messageId));
        return ecrecover(ethSignedMessageHash, signature);
    }
    
    function executeMessage(bytes memory message) internal {
        // Execute cross-chain message logic
    }
}

Cross-Chain Security

1. Multi-Signature Verification

solidity
contract SecureBridge {
    address[] public validators;
    mapping(address => bool) public isValidator;
    uint256 public requiredSignatures;
    
    constructor(address[] memory _validators, uint256 _required) {
        for (uint256 i = 0; i < _validators.length; i++) {
            validators.push(_validators[i]);
            isValidator[_validators[i]] = true;
        }
        requiredSignatures = _required;
    }
    
    function validateSignatures(
        bytes32 messageHash,
        bytes[] memory signatures
    ) public view returns (bool) {
        uint256 validSignatures = 0;
        
        for (uint256 i = 0; i < signatures.length; i++) {
            address signer = recoverSigner(messageHash, signatures[i]);
            if (isValidator[signer]) {
                validSignatures++;
            }
        }
        
        return validSignatures >= requiredSignatures;
    }
    
    function recoverSigner(bytes32 messageHash, bytes memory signature) internal pure returns (address) {
        bytes32 ethSignedMessageHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", messageHash));
        return ecrecover(ethSignedMessageHash, signature);
    }
}

2. Timelock

solidity
contract TimelockBridge {
    uint256 public delay = 2 days;
    mapping(bytes32 => bool) public queuedTransactions;
    
    function queueTransaction(bytes32 txHash) public {
        queuedTransactions[txHash] = true;
    }
    
    function executeTransaction(
        bytes32 txHash,
        uint256 timestamp
    ) public {
        require(queuedTransactions[txHash], "Not queued");
        require(block.timestamp >= timestamp + delay, "Too early");
        require(block.timestamp <= timestamp + delay + 30 days, "Too late");
        
        queuedTransactions[txHash] = false;
        // Execute transaction
    }
}

Cross-Chain Best Practices

Security First: Use multi-signature and timelocks
Adequate Testing: Thoroughly test on testnets
Monitoring and Alerts: Set up real-time monitoring and alerts
User Education: Provide clear usage guides
Emergency Plans: Prepare emergency pause mechanisms
Regular Audits: Conduct security audits on cross-chain contracts
Community Governance: Manage cross-chain parameters through DAO

Famous Cross-Chain Projects

Polygon Bridge: Ethereum-Polygon bridge
Multichain: Multi-chain cross-chain protocol
Wormhole: Solana-Ethereum bridge
Hop Protocol: Cross-chain transfer protocol
Connext: Cross-chain payment network

Cross-chain technology is promoting blockchain interoperability, laying foundation for development of multi-chain ecosystem.