ステーキングおよびクロスチェーン取引DApp開発の完全ガイド

ステーキングとは何か?

ステーキングとは、ユーザーが暗号資産をブロックチェーンネットワークやDeFiプロトコルにロックし、それと引き換えにすることを指しますサイバーセキュリティ貢献報酬または合意された収益分配行動。 これはPoS(Proof-of-Stake)合意メカニズムの経済的基盤として機能します。

ステーキングの核心的価値

主流のパブリックチェーンステーキングデータ

ステーキングモードの分類

ステーキングシステムアーキテクチャ

本番環境のステーキングDAppのシステムアーキテクチャは、オンチェーン契約層とオフチェーンサービス層の両方をカバーしています。

コアデータフロー

1. ユーザーはDAppフロントエンドを通じてウォレットに接続し、ステーキング金額とバリデーターを選択します
2. フロントエンドはステーキングのヴォールト契約のステーク()メソッドを呼び出し、ユーザーは確認のために署名します
3. この契約はユーザーの資産をロックし、同等のLSTトークンを発行してユーザーに返還します
4. オフチェーンサービスはステーキングイベントを受信し、ユーザーステータスやグローバル統計を更新します
5. 利回り計算サービスは、ブロックごとにリアルタイムで報酬を蓄積します
6. ユーザーはいつでもunstake()を通じてリデンプションを申請し、アンロックキューに入ることができます

ステーキング契約開発

以下は、ステーキング、アンロック、報酬分配、スラッシングメカニズムを含む、完全に機能するステーキング契約の実装です。

// 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;
    }
}

契約設計の基本

• 精密な取り扱い:1e18の精度係数を用いて分割カットオフ損失を回避する
• 保護区域に再突入: すべての資金調達業務はReententryGuardで保護されています
• キューを解除する即時裁定取引やフラッシュローン攻撃を防ぐためのアンボンド期間
• 報酬債務モデル:rewardDebtは、新しいステーカーが過去の報酬を受け取らないことを保証します
• アップグレード可能な設計本番環境は契約アップグレードをサポートするためにUUPSプロキシを使用するべきです

リキッドステーキング

リキッドステーキングは、従来のステーキングで資産がロックされて使えなくなる問題を解決します。 ユーザーはステーキングして獲得しますLST(リキッドステーキングトークン)自由に取引できるバウチャートークンやDeFiポートフォリオに参加できるもの。

LST経済モデル

為替レートモードLST契約コア

// 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;
    }
}

DeFiにおけるLSTの複合応用

• 借入担保: stETHをAave/Compoundでステーキングし、ステーキング収入+レバレッジを達成するためにステーブルコインを貸し出してください
• 流動性供給: Curve stETH/ETHプールに流動性を提供して取引手数料を獲得
• 定期的なステーキング:LST→担保を取得してETHを貸し出し、再ステーク→、利回りを増幅させる→
• 所得の集計: LST(LST)をYearn/Pendleに預けて、自動的に利回り戦略を最適化します

再定拠

リステーキングは2024年の最も注目されるDeFiイノベーションの一つであり、EigenLayerによって先駆けられました。 その核心的な考え方は以下の通りです:ステークされたETHが他のプロトコルやサービスのセキュリティを同時に提供できるようにします資本効率を最大化するためです。

再ステーキングアーキテクチャ

再質入れ契約の核心的な論理

// 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;
        // 按比例罚没委托者
    }
}

クロスチェーン取引とは何ですか?

クロスチェーントランザクションとは異なるブロックチェーンネットワーク間で資産移転や情報伝達のための技術。 各ブロックチェーンは独立した「データアイランド」であり、クロスチェーン技術はこれらのアイランドを突破し、マルチチェーン間の相互運用性を実現します。

クロスチェーンの核心的な課題

クロスチェーン取引の種類

クロスチェーンプロトコルの原則

異なるクロスチェーンソリューションは、セキュリティ、分散化、遅延の間で異なるトレードオフを行います。

主流のクロスチェーン検証方式

LayerZeroクロスチェーンメッセージフロー

1. ソースチェーンコントラクトはLayerZeroエンドポイントのsend()メソッドを呼び出します
2. オラクルはソースチェーンのブロックヘッダーを読み取り、宛先チェーンにコミットします
3. リレイヤーはトランザクション証明を宛先チェーンに提出します
4. 宛先チェーンのエンドポイントはブロックヘッダーの妥当性を検証します + 証明
5. ターゲットリンクが契約のlzReceive()を受け取っていることを確認すると、
6. ターゲットチェーンコントラクトは対応するビジネスロジック(トークンの発行、操作の実行など)を実行します。

クロスチェーンブリッジアーキテクチャ

クロスチェーンブリッジは資産のクロスチェーン移転の中核インフラであり、以下は典型的なブリッジアーキテクチャです:

ロックミントモデルと流動性プールモデルの比較

クロスチェーン契約開発

以下のデモンストレーションは、LayerZero V2プロトコルに基づくクロスチェーントークンコントラクト(OFT - Omnichain Fungible Token)です。

// 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;
    }
}

クロスチェーンスワップ契約(ソースチェーン)

// 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);
    }
}

クロスチェーンセキュリティ

クロスチェーンブリッジはハッカー攻撃の被害が最も大きい場所であり、歴史上、ブリッジプロトコルで数億件の損失が発生しています。 クロスチェーンDAppにとって、安全な設計が最優先事項です。

歴史的な重大なセキュリティインシデント

クロスチェーンセキュリティのベストプラクティス

• メッセージ再生保護: 各メッセージは一意のノンスに割り当てられており、宛先チェーンは処理済みのノンスを記録して再プレイを防ぎます
• 最終待ち: ソースチェーン取引は、チェーン再構築による二重支出を防ぐために、リレー前に十分な確認数に達する必要があります
• 金額の確認: ターゲットチェーンは、発行・リリース量がソースチェーンのロック/焼却量と厳密に一致していることを検証します
• 定期監査契約変更はTrail of Bits、OpenZeppelin、その他の機関による監査および展開が必要です

DAppのフロントエンド統合

ステーキングやクロスチェーンDAppのフロントエンドは、マルチチェーン接続、トランザクション署名、状態追跡などの複雑なやり取りを処理する必要があります。

コアフロントエンドインタラクションフロー

// 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 };
}

マルチチェーンウォレット接続

• ワグミ+レインボーキット:EVMエコシステムが第一選択で、MetaMask、WalletConnect、Coinbase Walletをサポートしています
• @solana/ウォレットアダプター:Solanaエコシステムウォレット統合
• コスモスキット: Cosmosエコシステム Keplrウォレット接続
• クロスチェーン状態トラッキング: LayerZeroスキャン/ワームホールエクスプローラーAPIを通じてクロスチェーンメッセージの状況を追跡

推奨技術スタック

開発プロセス

NovaLinkRチームのステーキングおよびクロスチェーンプロジェクト提供の経験に基づき、以下の開発プロセスが推奨されます: