Bitget x Morph：重新定义 BGB 在 Web3 支付中的角色

Bitget Wallet 和 Morph 不仅仅是在构建工具；他们正在为一个面向数十亿用户的数字金融生态系统奠定基础。

简介：

Bitget 大胆地迈向扩展 Bitget Token (BGB) 现实世界效用的步伐，宣布与 Morph 建立独家战略合作伙伴关系，Morph 是一种为无缝加密支付而构建的下一代 Layer 2 解决方案。此次合作标志着 BGB 发展的一个转折点——从一个中心化交易所代币转变为驱动链上生态系统的核心资产。

关于 Bitget Wallet

Bitget Wallet 不仅仅是一个加密钱包，它是通往去中心化经济的门户。作为一个受到全球超过 8000 万用户信任的非托管钱包，它结合了简单性、安全性和可访问性，以帮助人们自信地驾驭复杂的数字资产世界。

Bitget Wallet 秉承 “人人享有加密货币” 的理念构建，在一个统一的平台上为用户提供一套综合服务。从跨数百个 DEX 的即时代币交换到最大化资产效用的质押和奖励，该钱包将日常加密货币交互转变为无缝体验。它的 DApp 浏览器打开了通往 Web3 最新创新技术的大门，而它的支付解决方案则弥合了传统金融和数字金融之间的差距。

Bitget Wallet 支持 130 多个区块链和数百万个代币，是多链互操作性领域的领导者，使用户能够通过集成的跨链桥在生态系统之间自由移动资产。凭借 3 亿美元以上的用户保护基金的支持，它为资产安全和信任设定了行业基准，确保初学者和高级用户都能安心无忧。

Bitget Wallet 的长期愿景很明确：通过使加密货币更简单、更安全，并成为日常生活中自然而然的一部分，让 10 亿人加入 Web3。

关于 Morph

Morph 代表着区块链可扩展性和可用性的下一个前沿领域——一个专门为链上消费者金融构建的 Layer 2 网络。与传统上只关注性能的 L2 不同，Morph 旨在赋能现实世界的金融用例，例如支付、储蓄、身份验证和奖励。

对于消费者而言，Morph Pay 在发送、接收和管理数字资产方面提供了顺畅的体验，将加密货币变成了一种主流支付解决方案。对于开发者而言，Morph Rails 提供了构建可扩展、合规且用户友好的 Web3 金融应用程序所需的基础设施。这些组件共同构成了数字经济的金融支柱，支持既去中心化又实用的日常使用产品和服务。

Morph 结合了高性能基础设施、成本效益和强大的开发者工具，以释放 Web3 在消费者金融领域的真正潜力。通过关注可用性和大规模采用，Morph 不仅仅是在扩展区块链，它还在扩展金融互联网上的信任、可访问性和现实世界的价值。

BGB 作为 Morph 链上的 Gas 和治理代币

作为此次合作的一部分，BGB 将同时作为 Morph 链的 gas 代币和治理代币。这意味着在 Morph 上执行的每笔交易都将消耗 BGB，将其价值直接锚定到网络活动。此外，BGB 持有者将获得对关键治理决策的影响力，从而影响行业内最有前途的 Layer 2 解决方案之一的开发。

这种转变将 BGB 定位于 Web3 支付的核心，超越了交易费用折扣和交易所特定的效用，进入更广泛的去中心化应用程序。

2.2 亿 BGB 销毁：稀缺性与效用的结合

为了进一步加强 BGB 的经济模型，Bitget 已经确认将销毁 2.2 亿 BGB，从而永久减少总供应量。这次大规模销毁创造了不断增加的稀缺性和不断上升的效用的强大结合——这种动态在历史上推动了代币经济中的长期价值升值。

随着流通中的代币减少以及用例的不断扩展，BGB 有望成为市场上最具战略地位的交易所代币之一。

Morph 的高性能基础设施

Morph 链带来了可扩展、低成本和高吞吐量的基础设施，专门针对加密支付和链上商业进行了优化。通过在底层集成 BGB，Morph 确保该代币不仅仅是一种被动资产，而是交易效率、治理参与和生态系统增长的积极驱动力。

此次合作还为 BGB 成为 Web3 支付系统的基石奠定了基础，弥合了中心化交易所生态系统和去中心化金融网络之间的差距。

Solidity 程序，定义并考虑作为一个示例

将 BGB 建模为具有治理功能（投票权）的 ERC-20 代币。

销毁 220,000,000 BGB 以减少供应并增加稀缺性。

pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol"; // 如果不可用，请使用 OZ v4 中的 IERC20Permit
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

interface IERC20Burnable is IERC20 {
    function burn(uint256 amount) external;
}

contract BurnVault is AccessControl, ReentrancyGuard {
    using SafeERC20 for IERC20;

    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");

    IERC20 public immutable BGB;
    address public immutable DEAD = 0x000000000000000000000000000000000000dEaD;

    // 将销毁量上限设置为 220,000,000 BGB（假设为 18 位小数）。
    uint256 public immutable MAX_BURN;
    uint256 public burnedSoFar;

    // 可选的滴灌计划：每次执行的最大销毁量
    uint256 public maxPerBurn; // 0 = 无限制
    event BurnExecuted(uint256 amount, uint256 burnedSoFar);
    event MaxPerBurnUpdated(uint256 newMax);

    constructor(address _bgb, uint256 _maxBurn) {
        require(_bgb != address(0), "BGB=0");
        BGB = IERC20(_bgb);
        MAX_BURN = _maxBurn;
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(OPERATOR_ROLE, msg.sender);
    }

    function setMaxPerBurn(uint256 _max) external onlyRole(DEFAULT_ADMIN_ROLE) {
        maxPerBurn = _max;
        emit MaxPerBurnUpdated(_max);
    }

    /// @notice 通过 transfer 将 BGB 推送到此处，或通过路由器中的 SafeERC20.safeTransferFrom 推送；然后调用 executeBurn。
    function executeBurn(uint256 amount) external nonReentrant onlyRole(OPERATOR_ROLE) {
        require(amount > 0, "amount=0");
        uint256 remainingCap = MAX_BURN - burnedSoFar;
        require(remainingCap > 0, "达到上限");

        if (amount > remainingCap) amount = remainingCap;
        if (maxPerBurn != 0 && amount > maxPerBurn) amount = maxPerBurn;

        // 如果支持，则尝试原生销毁
        try IERC20Burnable(address(BGB)).burn(amount) {
            // 成功路径使用原生销毁
        } catch {
            // 回退到死亡地址接收器
            BGB.safeTransfer(DEAD, amount);
        }

        burnedSoFar += amount;
        emit BurnExecuted(amount, burnedSoFar);
    }

    /// @notice 救援非 BGB 资产（例如，意外转账）
    function rescue(address token, uint256 amount, address to) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(token != address(BGB), "no rescue BGB");
        IERC20(token).safeTransfer(to, amount);
    }
}

contract BGBStaking is AccessControl, ReentrancyGuard {
    using SafeERC20 for IERC20;

    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
    IERC20 public immutable BGB;

    // 奖励会计（经典拉取模型）
    uint256 public rewardPerTokenScaled;
    uint256 public constant SCALE = 1e18;

    uint256 public totalStaked;
    mapping(address => uint256) public staked;
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    // 取消质押的冷静期（可选的治理安全）
    uint256 public unstakeDelay = 1 days;
    mapping(address => uint256) public unstakeAvailableAt;

    event Staked(address indexed user, uint256 amount, uint256 totalStaked);
    event UnstakeRequested(address indexed user, uint256 availableAt);
    event Unstaked(address indexed user, uint256 amount, uint256 totalStaked);
    event RewardAdded(uint256 amount, uint256 rewardPerTokenScaled);
    event RewardClaimed(address indexed user, uint256 amount);
    event UnstakeDelayUpdated(uint256 newDelay);

    constructor(address _bgb) {
        require(_bgb != address(0), "BGB=0");
        BGB = IERC20(_bgb);
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(OPERATOR_ROLE, msg.sender);
    }

    // ===== 查看助手 =====
    function _earned(address account) internal view returns (uint256) {
        uint256 rpt = rewardPerTokenScaled;
        return ((staked[account] * (rpt - userRewardPerTokenPaid[account])) / SCALE) + rewards[account];
    }

    function earned(address account) external view returns (uint256) {
        return _earned(account);
    }

    // ===== 核心质押 =====
    function stake(uint256 amount) external nonReentrant {
        require(amount > 0, "amount=0");
        // 更新奖励
        rewards[msg.sender] = _earned(msg.sender);
        userRewardPerTokenPaid[msg.sender] = rewardPerTokenScaled;

        totalStaked += amount;
        staked[msg.sender] += amount;

        BGB.safeTransferFrom(msg.sender, address(this), amount);
        emit Staked(msg.sender, amount, totalStaked);
    }

    function requestUnstake() external {
        require(staked[msg.sender] > 0, "no stake");
        unstakeAvailableAt[msg.sender] = block.timestamp + unstakeDelay;
        emit UnstakeRequested(msg.sender, unstakeAvailableAt[msg.sender]);
    }

    function unstake(uint256 amount) external nonReentrant {
        require(amount > 0, "amount=0");
        require(staked[msg.sender] >= amount, "超出质押量");
        require(block.timestamp >= unstakeAvailableAt[msg.sender], "冷静期");

        // 更新奖励
        rewards[msg.sender] = _earned(msg.sender);
        userRewardPerTokenPaid[msg.sender] = rewardPerTokenScaled;

        staked[msg.sender] -= amount;
        totalStaked -= amount;

        BGB.safeTransfer(msg.sender, amount);
        emit Unstaked(msg.sender, amount, totalStaked);
    }

    function claimReward() external nonReentrant {
        uint256 reward = _earned(msg.sender);
        require(reward > 0, "没有奖励");
        rewards[msg.sender] = 0;
        userRewardPerTokenPaid[msg.sender] = rewardPerTokenScaled;
        BGB.safeTransfer(msg.sender, reward);
        emit RewardClaimed(msg.sender, reward);
    }

    // ===== 资金（来自 PaymentProcessor 费用拆分）=====
    function notifyRewardAmount(uint256 amount) external nonReentrant onlyRole(OPERATOR_ROLE) {
        require(totalStaked > 0, "no stakers");
        BGB.safeTransferFrom(msg.sender, address(this), amount);
        rewardPerTokenScaled += (amount * SCALE) / totalStaked;
        emit RewardAdded(amount, rewardPerTokenScaled);
    }

    function setUnstakeDelay(uint256 secondsDelay) external onlyRole(DEFAULT_ADMIN_ROLE) {
        unstakeDelay = secondsDelay;
        emit UnstakeDelayUpdated(secondsDelay);
    }
}

contract PaymentProcessor is AccessControl, ReentrancyGuard {
    using SafeERC20 for IERC20;

    bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
    IERC20 public immutable BGB;

    // 外部模块
    BurnVault public immutable burnVault;
    BGBStaking public immutable staking;
    address public treasury; // 例如，多重签名

    // 全局协议费用（以基点为单位，10000 = 100%）
    uint16 public protocolFeeBps = 50; // 默认 0.50%
    // 费用拆分：一部分给销毁金库，其余给国库和质押奖励
    uint16 public burnShareBps = 6000;  // 60% 的费用用于销毁
    uint16 public stakingShareBps = 3000; // 30% 的费用用于质押者
    // 默认情况下，剩余部分 (10%) 给国库

    struct Merchant {
        address payout;
        uint16 feeBpsOverride; // 0 表示使用全局
        bool active;
    }

    mapping(address => Merchant> public merchants;

    // 基于质押余额的折扣等级
    struct DiscountTier {
        uint256 minStake;
        uint16 feeDiscountBps; // 协议费用的折扣
    }
    DiscountTier[] public discountTiers; // 按 minStake 升序排序

    // 可选的 ERC2771 转发器（元交易）
    address public trustedForwarder;

    event MerchantRegistered(address indexed merchant, address payout, uint16 feeBps, bool active);
    event MerchantUpdated(address indexed merchant, address payout, uint16 feeBps, bool active);
    event Payment(
        address indexed payer,
        address indexed merchant,
        uint256 grossAmount,
        uint256 netToMerchant,
        uint256 fee,
        uint256 burned,
        uint256 toStakers,
        uint256 toTreasury
    );
    event ProtocolFeeUpdated(uint16 bps);
    event FeeSplitUpdated(uint16 burnShareBps, uint16 stakingShareBps);
    event TreasuryUpdated(address treasury);
    event DiscountTierAdded(uint256 minStake, uint16 discountBps);
    event TrustedForwarderUpdated(address forwarder);

    constructor(
        address _bgb,
        address _burnVault,
        address _staking,
        address _treasury
    ) {
        require(_bgb != address(0) && _burnVault != address(0) && _staking != address(0) && _treasury != address(0), "addr=0");
        BGB = IERC20(_bgb);
        burnVault = BurnVault(_burnVault);
        staking = BGBStaking(_staking);
        treasury = _treasury;

        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(OPERATOR_ROLE, msg.sender);
    }

    // ===== 管理员配置 =====
    function setProtocolFee(uint16 bps) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(bps <= 1000, "费用太高"); // 硬性上限 10%
        protocolFeeBps = bps;
        emit ProtocolFeeUpdated(bps);
    }

    function setFeeSplit(uint16 _burnShareBps, uint16 _stakingShareBps) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(_burnShareBps + _stakingShareBps <= 10000, "split>100%");
        burnShareBps = _burnShareBps;
        stakingShareBps = _stakingShareBps;
        emit FeeSplitUpdated(_burnShareBps, _stakingShareBps);
    }

    function setTreasury(address _treasury) external onlyRole(DEFAULT_ADMIN_ROLE) {
        require(_treasury != address(0), "国库=0");
        treasury = _treasury;
        emit TreasuryUpdated(_treasury);
    }

    function addDiscountTier(uint256 minStake, uint16 discountBps) external onlyRole(DEFAULT_ADMIN_ROLE) {
        if (discountTiers.length > 0) {
            require(minStake > discountTiers[discountTiers.length - 1].minStake, "order");
        }
        require(discountBps <= 10000, "discount>100%");
        discountTiers.push(DiscountTier({minStake: minStake, feeDiscountBps: discountBps}));
        emit DiscountTierAdded(minStake, discountBps);
    }

    function setTrustedForwarder(address forwarder) external onlyRole(DEFAULT_ADMIN_ROLE) {
        trustedForwarder = forwarder;
        emit TrustedForwarderUpdated(forwarder);
    }

    // ===== 商户管理 =====
    function registerMerchant(address merchant, address payout, uint16 feeBps, bool active)
        external
        onlyRole(OPERATOR_ROLE)
    {
        require(merchant != address(0) && payout != address(0), "addr=0");
        merchants[merchant] = Merchant({payout: payout, feeBpsOverride: feeBps, active: active});
        emit MerchantRegistered(merchant, payout, feeBps, active);
    }

    function updateMerchant(address merchant, address payout, uint16 feeBps, bool active)
        external
        onlyRole(OPERATOR_ROLE)
    {
        require(merchants[merchant].payout != address(0), "not registered");
        merchants[merchant] = Merchant({payout: payout, feeBpsOverride: feeBps, active: active});
        emit MerchantUpdated(merchant, payout, feeBps, active);
    }

    // ===== 核心支付 =====

    /// @notice 以 BGB 向注册商户付款。可选的 EIP-2612 许可数据可避免预先批准。
    /// @param merchant 商户地址（用作密钥）
    /// @param amount BGB 总付款额
    /// @param permitData abi.encode(owner, spender (=address(this)), value, deadline, v,r,s) 或者跳过时为空
    function pay(address merchant, uint256 amount, bytes calldata permitData) external nonReentrant {
        Merchant memory m = merchants[merchant];
        require(m.active && m.payout != address(0), "商户未激活");

        // 可选的许可（尽力而为）
        if (permitData.length > 0) {
            (address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
                = abi.decode(permitData, (address, address, uint256, uint256, uint8, bytes32, bytes32));
            require(owner == _msgSender(), "permit owner mismatch");
            require(spender == address(this) && value >= amount, "permit too low");
            try IERC20Permit(address(BGB)).permit(owner, spender, value, deadline, v, r, s) {
                // 确定
            } catch {
                revert("permit failed");
            }
        }

        // 拉取资金
        BGB.safeTransferFrom(_msgSender(), address(this), amount);

        // 计算带有折扣的费用
        uint16 baseFee = m.feeBpsOverride == 0 ? protocolFeeBps : m.feeBpsOverride;
        uint16 discount = _discountBpsFor(_msgSender());
        uint256 effectiveFeeBps = baseFee > discount ? uint256(baseFee - discount) : 0;

        uint256 fee = (amount * effectiveFeeBps) / 10_000;
        uint256 netToMerchant = amount - fee;

        // 拆分费用：销毁、质押奖励、国库
        uint256 burnAmt    = (fee * burnShareBps) / 10_000;
        uint256 stakingAmt = (fee * stakingShareBps) / 10_000;
        uint256 treasuryAmt = fee - burnAmt - stakingAmt;

        // 发送商户收益
        BGB.safeTransfer(m.payout, netToMerchant);

        // 发送费用组成部分
        if (burnAmt > 0) {
            BGB.safeTransfer(address(burnVault), burnAmt);
            // 让操作员稍后根据上限/计划批量销毁
        }
        if (stakingAmt > 0) {
            // 转移到质押，然后通知（作为 OPERATOR）
            BGB.safeIncreaseAllowance(address(staking), stakingAmt);
            staking.notifyRewardAmount(stakingAmt); // 从津贴中提取
        }
        if (treasuryAmt > 0) {
            BGB.safeTransfer(treasury, treasuryAmt);
        }

        emit Payment(_msgSender(), merchant, amount, netToMerchant, fee, burnAmt, stakingAmt, treasuryAmt);
    }

    // ===== 内部函数 =====
    function _discountBpsFor(address payer) internal view returns (uint16) {
        uint256 s = staking.staked(payer);
        uint16 best = 0;
        for (uint256 i = 0; i < discountTiers.length; i++) {
            if (s >= discountTiers[i].minStake && discountTiers[i].feeDiscountBps > best) {
                best = discountTiers[i].feeDiscountBps;
            }
        }
        return best;
    }

    // 元交易支持（ERC-2771 样式）
    function _msgSender() internal view returns (address sender) {
        if (msg.data.length >= 20 && msg.sender == trustedForwarder) {
            // 从 calldata 中提取最后 20 个字节
            assembly {
                sender := shr(96, calldataload(sub(calldatasize(), 20)))
            }
        } else {
            sender = msg.sender;
        }
    }
}

结论：BGB 的新纪元

这一战略举措预示着 Bitget 及其社区的新纪元。通过与 Morph 结盟，Bitget 正在将 BGB 从交易所代币的界限推向多维资产，从而推动去中心化支付、治理和长期代币经济。

稀缺性（通过销毁）和效用（通过 Morph 集成）的融合使 BGB 成为下一代基于区块链的金融基础设施中的关键参与者。

🔑 本质上，Bitget x Morph 合作伙伴关系将 BGB 从以交易所为中心的代币转变为为 Web3 支付的未来提供动力的重要、通货紧缩且具有治理功能的资产。

协同作用下，Bitget Wallet 和 Morph 代表了可访问性和创新之间的强大交集：一个拥有安全、多链功能的全球用户群，以及一个专为支付和消费者采用而设计的下一代金融 Layer 2。

• 原文链接： blog.blockmagnates.com/b...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～