A complete guide to staking and cross-chain trading DApp development

What is Staking?

Staking refers to when users lock their crypto assets in a blockchain network or DeFi protocol in exchange for themCybersecurity contribution rewardsorAgreed revenue sharingbehavior. It serves as the economic foundation for the PoS (Proof-of-Stake) consensus mechanism.

The core value of staking

Mainstream public chain staking data

Staking mode classification

Staking system architecture

The system architecture of a production-grade staking DApp covers both the on-chain contract layer and the off-chain service layer:

Core data flow

1. Users connect to their wallets through the DApp frontend and select the staking amount and validator
2. The front-end calls the stake() method of the staking vault contract, and the user signs to confirm
3. The contract locks user assets and mints an equivalent amount of LST tokens to return to users
4. Off-chain services listen to staking events and update user status and global statistics
5. The yield calculation service accumulates rewards in real time by block
6. Users can request redemption through unstake() at any time to enter the unlock queue

Staking contract development

The following is a fully functional staking contract implementation, including staking, unlocking, reward distribution, and slashing mechanisms:

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

/// @title StakingVault - 质押金库合约
/// @notice 支持灵活期限质押、动态APY和罚没机制
contract StakingVault is ReentrancyGuard, Ownable {
    using SafeERC20 for IERC20;

    IERC20 public stakingToken;
    IERC20 public rewardToken;

    uint256 public rewardPerSecond;
    uint256 public lastUpdateTime;
    uint256 public accRewardPerShare;  // 每份累积奖励（精度1e18）
    uint256 public totalStaked;
    uint256 public unbondingPeriod = 7 days;

    struct UserInfo {
        uint256 amount;           // 质押数量
        uint256 rewardDebt;       // 奖励债务（用于精确计算）
        uint256 pendingRewards;   // 待领取奖励
        uint256 unstakeRequestTime;
        uint256 unstakeAmount;
    }

    mapping(address => UserInfo) public userInfo;

    event Staked(address indexed user, uint256 amount);
    event UnstakeRequested(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardClaimed(address indexed user, uint256 amount);
    event Slashed(address indexed user, uint256 amount, string reason);

    constructor(address _stakingToken, address _rewardToken, uint256 _rewardPerSecond) {
        stakingToken = IERC20(_stakingToken);
        rewardToken = IERC20(_rewardToken);
        rewardPerSecond = _rewardPerSecond;
        lastUpdateTime = block.timestamp;
    }

    /// @notice 更新全局奖励累积
    function updatePool() public {
        if (block.timestamp <= lastUpdateTime || totalStaked == 0) {
            lastUpdateTime = block.timestamp;
            return;
        }
        uint256 elapsed = block.timestamp - lastUpdateTime;
        uint256 reward = elapsed * rewardPerSecond;
        accRewardPerShare += (reward * 1e18) / totalStaked;
        lastUpdateTime = block.timestamp;
    }

    /// @notice 质押代币
    function stake(uint256 amount) external nonReentrant {
        require(amount > 0, "Cannot stake 0");
        updatePool();

        UserInfo storage user = userInfo[msg.sender];

        // 结算已有奖励
        if (user.amount > 0) {
            uint256 pending = (user.amount * accRewardPerShare / 1e18) - user.rewardDebt;
            user.pendingRewards += pending;
        }

        stakingToken.safeTransferFrom(msg.sender, address(this), amount);
        user.amount += amount;
        user.rewardDebt = user.amount * accRewardPerShare / 1e18;
        totalStaked += amount;

        emit Staked(msg.sender, amount);
    }

    /// @notice 请求解除质押（进入解锁期）
    function requestUnstake(uint256 amount) external nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        require(user.amount >= amount, "Insufficient staked balance");
        updatePool();

        // 结算奖励
        uint256 pending = (user.amount * accRewardPerShare / 1e18) - user.rewardDebt;
        user.pendingRewards += pending;

        user.amount -= amount;
        user.rewardDebt = user.amount * accRewardPerShare / 1e18;
        totalStaked -= amount;

        user.unstakeAmount += amount;
        user.unstakeRequestTime = block.timestamp;

        emit UnstakeRequested(msg.sender, amount);
    }

    /// @notice 解锁期满后提取
    function withdraw() external nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        require(user.unstakeAmount > 0, "No pending withdrawal");
        require(
            block.timestamp >= user.unstakeRequestTime + unbondingPeriod,
            "Still in unbonding period"
        );

        uint256 amount = user.unstakeAmount;
        user.unstakeAmount = 0;
        stakingToken.safeTransfer(msg.sender, amount);

        emit Withdrawn(msg.sender, amount);
    }

    /// @notice 领取奖励
    function claimRewards() external nonReentrant {
        updatePool();
        UserInfo storage user = userInfo[msg.sender];

        uint256 pending = (user.amount * accRewardPerShare / 1e18) - user.rewardDebt;
        uint256 totalReward = user.pendingRewards + pending;
        require(totalReward > 0, "No rewards");

        user.pendingRewards = 0;
        user.rewardDebt = user.amount * accRewardPerShare / 1e18;
        rewardToken.safeTransfer(msg.sender, totalReward);

        emit RewardClaimed(msg.sender, totalReward);
    }

    /// @notice 罚没机制（管理员调用）
    function slash(address account, uint256 amount, string calldata reason) external onlyOwner {
        UserInfo storage user = userInfo[account];
        uint256 slashAmount = amount > user.amount ? user.amount : amount;
        user.amount -= slashAmount;
        totalStaked -= slashAmount;
        // 罚没资产转入保险基金
        stakingToken.safeTransfer(owner(), slashAmount);
        emit Slashed(account, slashAmount, reason);
    }

    /// @notice 查看待领取奖励
    function pendingReward(address account) external view returns (uint256) {
        UserInfo storage user = userInfo[account];
        uint256 _accRewardPerShare = accRewardPerShare;
        if (block.timestamp > lastUpdateTime && totalStaked > 0) {
            uint256 elapsed = block.timestamp - lastUpdateTime;
            _accRewardPerShare += (elapsed * rewardPerSecond * 1e18) / totalStaked;
        }
        return user.pendingRewards + (user.amount * _accRewardPerShare / 1e18) - user.rewardDebt;
    }
}

Contract design essentials

• Precision handling: Use the 1e18 precision factor to avoid the division cut-off loss
• Re-enter the protection: All funding operations are protected using ReentrancyGuard
• Unlock the queue:unbonding period to prevent instant arbitrage and flash loan attacks
• Reward debt model:rewardDebt ensures that new stakers do not receive historical rewards
• Upgradable design: The production environment should use UUPS Proxy to support contract upgrades

Liquid Staking

Liquid staking solves the problem of assets being locked and unusable in traditional staking. Users stake and earnLST（Liquid Staking Token）Voucher tokens that can be freely traded or participate in DeFi portfolios.

LST Economic Model

Exchange rate mode LST contract core

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

/// @title LiquidStakingToken - 流动性质押凭证
contract LiquidStakingToken is ERC20 {
    uint256 public totalPooledAssets;  // 池中总资产（含奖励）
    uint256 public totalShares;        // 总份额

    constructor() ERC20("Staked ETH", "stETH") {}

    /// @notice 质押 ETH 获得 LST 份额
    function stake() external payable returns (uint256 shares) {
        require(msg.value > 0, "Cannot stake 0");

        if (totalShares == 0) {
            shares = msg.value;
        } else {
            // 按当前汇率计算应得份额
            shares = (msg.value * totalShares) / totalPooledAssets;
        }

        totalPooledAssets += msg.value;
        totalShares += shares;
        _mint(msg.sender, shares);
    }

    /// @notice 燃烧 LST 赎回底层资产
    function unstake(uint256 shares) external returns (uint256 assets) {
        require(shares > 0 && shares <= balanceOf(msg.sender), "Invalid shares");

        // 按当前汇率计算应得资产
        assets = (shares * totalPooledAssets) / totalShares;

        totalPooledAssets -= assets;
        totalShares -= shares;
        _burn(msg.sender, shares);

        // 实际项目中这里会进入提款队列
        payable(msg.sender).transfer(assets);
    }

    /// @notice 获取当前汇率 (1 LST = ? ETH)
    function exchangeRate() external view returns (uint256) {
        if (totalShares == 0) return 1e18;
        return (totalPooledAssets * 1e18) / totalShares;
    }

    /// @notice Oracle 报告验证者奖励（仅授权调用）
    function reportRewards(uint256 rewardAmount) external {
        // 奖励直接增加池中资产，汇率自动升高
        totalPooledAssets += rewardAmount;
    }
}

Combined applications of LSTs in DeFi

• Borrowing collateral: Stake stETH in Aave/Compound to lend stablecoins to achieve staking income + leverage
• Liquidity provision: Provide liquidity in the Curve stETH/ETH pool to earn trading fees
• Recurring staking: Staking → to obtain LST → collateral to lend ETH → and re-stake, amplifying the yield
• Income aggregation: Deposit LST into Yearn/Pendle to automatically optimize yield strategies

Restaking

Re-staking is one of the hottest DeFi innovations of 2024, pioneered by EigenLayer. Its core idea is:Let the staked ETH provide security for other protocols/services at the same timeto maximize capital efficiency.

Re-staking architecture

The core logic of the re-pledge contract

// restaking/RestakingManager.sol
contract RestakingManager {
    struct Operator {
        address addr;
        uint256 totalDelegated;
        mapping(address => uint256) delegations;
        address[] registeredAVS;  // 注册的主动验证服务
    }

    mapping(address => Operator) public operators;
    mapping(address => uint256) public withdrawalDelay;  // AVS 指定的提款延迟

    /// @notice 将 LST 委托给运营商
    function delegateTo(address operator, uint256 amount) external {
        // 转入 LST 代币
        lstToken.transferFrom(msg.sender, address(this), amount);
        operators[operator].delegations[msg.sender] += amount;
        operators[operator].totalDelegated += amount;
    }

    /// @notice 运营商注册 AVS 服务
    function registerAVS(address avs) external {
        Operator storage op = operators[msg.sender];
        op.registeredAVS.push(avs);
        // AVS 可以对该运营商的质押资产执行 Slash
    }

    /// @notice AVS 触发罚没
    function slashOperator(address operator, uint256 amount, bytes calldata proof) external {
        require(isRegisteredAVS(msg.sender, operator), "Not registered AVS");
        require(verifySlashingProof(proof), "Invalid proof");
        
        Operator storage op = operators[operator];
        op.totalDelegated -= amount;
        // 按比例罚没委托者
    }
}

What is cross-chain trading?

Cross-chain transaction refers to thebetween different blockchain networksTechnology for transferring assets or passing on information. Each blockchain is an independent "data island", and cross-chain technology breaks through these islands and realizes multi-chain interoperability.

The core challenge of cross-chain

Cross-chain transaction types

Cross-chain protocol principles

Different cross-chain solutions make different trade-offs between security, decentralization, and latency:

Mainstream cross-chain verification scheme

LayerZero cross-chain message flow

1. The source chain contract calls the send() method of the LayerZero Endpoint
2. The oracle reads the source chain block header and commits it to the destination chain
3. The Relayer submits the transaction proof to the destination chain
4. The destination chain Endpoint verifies the validity of the block header + proof
5. After verifying that the target link receives the contract's lzReceive()
6. The target chain contract executes the corresponding business logic (minting tokens, executing operations, etc.)

Cross-chain bridge architecture

Cross-chain bridges are the core infrastructure for cross-chain transfers of assets, and the following are typical bridge architectures:

Lock-mint model vs liquidity pool model

Cross-chain contract development

The following demonstration is a cross-chain token contract (OFT - Omnichain Fungible Token) based on the LayerZero V2 protocol:

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

import { OFT } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/OFT.sol";
import { SendParam, MessagingFee } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/interfaces/IOFT.sol";

/// @title CrossChainToken - 全链代币
/// @notice 部署在每条链上，支持跨链无缝转移
contract CrossChainToken is OFT {
    constructor(
        string memory _name,
        string memory _symbol,
        address _lzEndpoint,
        address _owner
    ) OFT(_name, _symbol, _lzEndpoint, _owner) {
        // 初始链上铸造初始供应
        _mint(_owner, 1_000_000 * 1e18);
    }

    /// @notice 跨链转账
    /// @param _dstEid 目标链的 LayerZero Endpoint ID
    /// @param _to 目标链接收地址（bytes32格式）
    /// @param _amount 转账数量
    function bridge(
        uint32 _dstEid,
        bytes32 _to,
        uint256 _amount
    ) external payable {
        SendParam memory sendParam = SendParam({
            dstEid: _dstEid,
            to: _to,
            amountLD: _amount,
            minAmountLD: _amount * 99 / 100,  // 允许 1% 滑点
            extraOptions: bytes(""),
            composeMsg: bytes(""),
            oftCmd: bytes("")
        });

        MessagingFee memory fee = _quote(sendParam, false);
        require(msg.value >= fee.nativeFee, "Insufficient fee");

        _send(sendParam, fee, msg.sender);
    }

    /// @notice 预估跨链费用
    function quoteBridge(
        uint32 _dstEid,
        bytes32 _to,
        uint256 _amount
    ) external view returns (uint256 nativeFee) {
        SendParam memory sendParam = SendParam({
            dstEid: _dstEid,
            to: _to,
            amountLD: _amount,
            minAmountLD: _amount * 99 / 100,
            extraOptions: bytes(""),
            composeMsg: bytes(""),
            oftCmd: bytes("")
        });

        MessagingFee memory fee = _quote(sendParam, false);
        return fee.nativeFee;
    }
}

Cross-chain swap contract (source chain)

// crosschain/SwapBridge.sol - 跨链兑换
contract CrossChainSwap {
    ILayerZeroEndpoint public lzEndpoint;
    mapping(uint32 => address) public peerContracts;  // 对端合约

    struct SwapOrder {
        address sender;
        address tokenIn;
        uint256 amountIn;
        address tokenOut;     // 目标链上期望收到的代币
        uint256 minAmountOut;
        uint32 dstEid;
    }

    /// @notice 发起跨链Swap
    function initiateSwap(SwapOrder calldata order) external payable {
        // 1. 锁定源链资产
        IERC20(order.tokenIn).transferFrom(msg.sender, address(this), order.amountIn);

        // 2. 编码跨链消息
        bytes memory payload = abi.encode(
            order.sender,
            order.tokenOut,
            order.minAmountOut
        );

        // 3. 发送跨链消息到目标链
        lzEndpoint.send{value: msg.value}(
            order.dstEid,
            abi.encodePacked(peerContracts[order.dstEid]),
            payload,
            payable(msg.sender),
            address(0),
            bytes("")
        );
    }

    /// @notice 目标链接收并执行Swap
    function _lzReceive(bytes calldata payload) internal {
        (address recipient, address tokenOut, uint256 minAmount) = 
            abi.decode(payload, (address, address, uint256));

        // 从流动性池中兑换并转给用户
        uint256 amountOut = _executeSwap(tokenOut, minAmount);
        IERC20(tokenOut).transfer(recipient, amountOut);
    }
}

Cross-chain security

Cross-chain bridges are the hardest hit by hacker attacks - many hundreds of millions of losses have occurred on bridge protocols in history. Secure design is a top priority for cross-chain DApps.

Historical major security incidents

Cross-chain security best practices

• Message replay protection: Each message is bound to a unique nonce, and the destination chain records the processed noncees to prevent replay
• Final waiting: Source chain transactions must reach a sufficient number of confirmations before relaying to prevent chain restructuring from leading to double-spending
• Amount verification: The target chain verifies that the minting/release amount is strictly consistent with the source chain locked/burned amount
• Regular audits: Contract changes must be audited and deployed by Trail of Bits, OpenZeppelin, and other institutions

DApp front-end integration

The frontend of staking and cross-chain DApps needs to handle complex interactions such as multi-chain connections, transaction signing, and state tracking:

Core front-end interaction flow

// frontend/hooks/useStaking.ts - React 质押 Hook
import { useWriteContract, useReadContract, useWaitForTransaction } from 'wagmi';
import { parseEther, formatEther } from 'viem';
import { stakingVaultABI } from '../abis/StakingVault';

export function useStaking(vaultAddress: `0x${string}`) {
  const { writeContract, data: hash } = useWriteContract();
  const { isLoading } = useWaitForTransaction({ hash });

  // 读取用户质押信息
  const { data: userInfo } = useReadContract({
    address: vaultAddress,
    abi: stakingVaultABI,
    functionName: 'userInfo',
    args: [userAddress],
  });

  // 读取待领取奖励
  const { data: pendingReward } = useReadContract({
    address: vaultAddress,
    abi: stakingVaultABI,
    functionName: 'pendingReward',
    args: [userAddress],
  });

  // 执行质押
  const stake = async (amount: string) => {
    await writeContract({
      address: vaultAddress,
      abi: stakingVaultABI,
      functionName: 'stake',
      args: [parseEther(amount)],
    });
  };

  // 请求解除质押
  const requestUnstake = async (amount: string) => {
    await writeContract({
      address: vaultAddress,
      abi: stakingVaultABI,
      functionName: 'requestUnstake',
      args: [parseEther(amount)],
    });
  };

  // 领取奖励
  const claimRewards = async () => {
    await writeContract({
      address: vaultAddress,
      abi: stakingVaultABI,
      functionName: 'claimRewards',
    });
  };

  return { stake, requestUnstake, claimRewards, userInfo, pendingReward, isLoading };
}

// frontend/hooks/useCrossChainBridge.ts - 跨链桥 Hook
export function useBridge(bridgeAddress: `0x${string}`) {
  const { switchChain } = useSwitchChain();

  const bridge = async (params: {
    dstChainId: number;
    token: string;
    amount: string;
    recipient: string;
  }) => {
    // 1. 预估跨链费用
    const fee = await readContract({
      address: bridgeAddress,
      abi: bridgeABI,
      functionName: 'quoteBridge',
      args: [params.dstChainId, params.recipient, parseEther(params.amount)],
    });

    // 2. 授权代币
    await writeContract({
      address: params.token,
      abi: erc20ABI,
      functionName: 'approve',
      args: [bridgeAddress, parseEther(params.amount)],
    });

    // 3. 发起跨链
    await writeContract({
      address: bridgeAddress,
      abi: bridgeABI,
      functionName: 'bridge',
      args: [params.dstChainId, params.recipient, parseEther(params.amount)],
      value: fee,
    });
  };

  return { bridge };
}

Multi-chain wallet connection

• wagmi + RainbowKit: The EVM ecosystem is the first choice, supporting MetaMask, WalletConnect, and Coinbase Wallet
• @solana/wallet-adapter: Solana ecosystem wallet integration
• CosmosKit: Cosmos ecosystem Keplr wallet connection
• Cross-chain state tracking: Track cross-chain message status through the LayerZero Scan / Wormhole Explorer API

Recommended technology stack

Development process

Based on the NovaLinkR team's experience in staking and cross-chain project delivery, the following development processes are recommended: