BNB代码解读

最新推荐文章于 2024-01-17 12:09:14 发布
最新推荐文章于 2024-01-17 12:09:14 发布
阅读量5k 收藏 7
点赞数
分类专栏： 区块链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43977647/article/details/106072133
版权

1.BNB代码

我们先来看下BNB的代码，没错就是这短短100多行代码，市值可是好多好多亿呢哈哈哈哈。

/**
 *Submitted for verification at Etherscan.io on 2017-07-06
*/

pragma solidity ^0.4.8;

/**
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
    assert(b > 0);
    uint256 c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

  function safeSub(uint256 a, uint256 b) internal returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }

  function assert(bool assertion) internal {
    if (!assertion) {
      throw;
    }
  }
}
contract BNB is SafeMath{
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
	address public owner;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
	mapping (address => uint256) public freezeOf;
    mapping (address => mapping (address => uint256)) public allowance;

    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);
	
	/* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);
	
	/* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);

    /* Initializes contract with initial supply tokens to the creator of the contract */
    function BNB(
        uint256 initialSupply,
        string tokenName,
        uint8 decimalUnits,
        string tokenSymbol
        ) {
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        totalSupply = initialSupply;                        // Update total supply
        name = tokenName;                                   // Set the name for display purposes
        symbol = tokenSymbol;                               // Set the symbol for display purposes
        decimals = decimalUnits;                            // Amount of decimals for display purposes
		owner = msg.sender;
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (_to == 0x0) throw;                               // Prevent transfer to 0x0 address. Use burn() instead
		if (_value <= 0) throw; 
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

    /* Allow another contract to spend some tokens in your behalf */
    function approve(address _spender, uint256 _value)
        returns (bool success) {
		if (_value <= 0) throw; 
        allowance[msg.sender][_spender] = _value;
        return true;
    }
       

    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (_to == 0x0) throw;                                // Prevent transfer to 0x0 address. Use burn() instead
		if (_value <= 0) throw; 
        if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw;     // Check allowance
        balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);                           // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                             // Add the same to the recipient
        allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
        Transfer(_from, _to, _value);
        return true;
    }

    function burn(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
		if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        totalSupply = SafeMath.safeSub(totalSupply,_value);                                // Updates totalSupply
        Burn(msg.sender, _value);
        return true;
    }
	
	function freeze(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
		if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);                                // Updates totalSupply
        Freeze(msg.sender, _value);
        return true;
    }
	
	function unfreeze(uint256 _value) returns (bool success) {
        if (freezeOf[msg.sender] < _value) throw;            // Check if the sender has enough
		if (_value <= 0) throw; 
        freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);                      // Subtract from the sender
		balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
        Unfreeze(msg.sender, _value);
        return true;
    }
	
	// transfer balance to owner
	function withdrawEther(uint256 amount) {
		if(msg.sender != owner)throw;
		owner.transfer(amount);
	}
	
	// can accept ether
	function() payable {
    }
}

以上就是BNB的全部代码。
注意 这个里面做判断的时候用的都是if…throw，现在不推荐这种做法了，大部分使用的是require做判断。

2.解释器声明

pragma solidity ^0.4.8;
声明了solidity的解释器，说的是解释器版本要在0.4.8以上，注意现在一般用>=来表示以上也就是pragma solidity >=0.4.8;

3.SafeMath合约声明

这里我们看到有一个SafeMath的合约，其实合约的写法和类很像，我们可以用类来理解合约。

contract SafeMath {
  function safeMul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeDiv(uint256 a, uint256 b) internal returns (uint256) {
    assert(b > 0);
    uint256 c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

  function safeSub(uint256 a, uint256 b) internal returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function safeAdd(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c>=a && c>=b);
    return c;
  }

  function assert(bool assertion) internal {
    if (!assertion) {
      throw;
    }
  }
}

这里声明了以一个SafeMath合约，里面有5个函数，最后一个函数是用来做判断的，我们呢其实可以用require()来代替它，其余的4个函数分别实现了乘法、除法、加法和减法，为什么它的实现这么复杂呢，且给人一种这不是显而易见的感觉吗，我们拿它的除法举个例子。
assert(b > 0);
它首先要求b要大于0，但是其实你仔细看它声明的参数是uint也就是无符号整型，这无符号哪来的大于0或是小于0呢，应该都是大于0的才对，但是它还是要判断一下。
uint256 c = a / b;
这个就是我们理解的正经的除法。
assert(a == b * c + a % b);
你看这里，是不是觉得又是多此一举呢，它判断要a是等于b乘上c加上a除以b的余数。
return c;
最后输出c

注意我们所谓的多此一举，在这里其实都是安全，你再想想它的市值，是不是有点数不过来呀，要是在做除法的时候程序被篡改了，那最后它一定不满足assert(a == b * c + a % b);这个等式，然后理所当然的就是终止交易有内鬼哈哈哈。

4.BNB合约声明

contract BNB is SafeMath{
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
	address public owner;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
	mapping (address => uint256) public freezeOf;
    mapping (address => mapping (address => uint256)) public allowance;

    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);
	
	/* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);
	
	/* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);

    /* Initializes contract with initial supply tokens to the creator of the contract */
    function BNB(
        uint256 initialSupply,
        string tokenName,
        uint8 decimalUnits,
        string tokenSymbol
        ) {
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        totalSupply = initialSupply;                        // Update total supply
        name = tokenName;                                   // Set the name for display purposes
        symbol = tokenSymbol;                               // Set the symbol for display purposes
        decimals = decimalUnits;                            // Amount of decimals for display purposes
		owner = msg.sender;
    }

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (_to == 0x0) throw;                               // Prevent transfer to 0x0 address. Use burn() instead
		if (_value <= 0) throw; 
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

    /* Allow another contract to spend some tokens in your behalf */
    function approve(address _spender, uint256 _value)
        returns (bool success) {
		if (_value <= 0) throw; 
        allowance[msg.sender][_spender] = _value;
        return true;
    }
       

    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (_to == 0x0) throw;                                // Prevent transfer to 0x0 address. Use burn() instead
		if (_value <= 0) throw; 
        if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw;     // Check allowance
        balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);                           // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                             // Add the same to the recipient
        allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
        Transfer(_from, _to, _value);
        return true;
    }

    function burn(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
		if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        totalSupply = SafeMath.safeSub(totalSupply,_value);                                // Updates totalSupply
        Burn(msg.sender, _value);
        return true;
    }
	
	function freeze(uint256 _value) returns (bool success) {
        if (balanceOf[msg.sender] < _value) throw;            // Check if the sender has enough
		if (_value <= 0) throw; 
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                      // Subtract from the sender
        freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);                                // Updates totalSupply
        Freeze(msg.sender, _value);
        return true;
    }
	
	function unfreeze(uint256 _value) returns (bool success) {
        if (freezeOf[msg.sender] < _value) throw;            // Check if the sender has enough
		if (_value <= 0) throw; 
        freezeOf[msg.sender] = SafeMath.safeSub(freezeOf[msg.sender], _value);                      // Subtract from the sender
		balanceOf[msg.sender] = SafeMath.safeAdd(balanceOf[msg.sender], _value);
        Unfreeze(msg.sender, _value);
        return true;
    }
	
	// transfer balance to owner
	function withdrawEther(uint256 amount) {
		if(msg.sender != owner)throw;
		owner.transfer(amount);
	}
	
	// can accept ether
	function() payable {
    }
}
（一）BNB类是SafeMath的子类

contract BNB is SafeMath
说的是BNB这个类是SafeMath的子类，那么SafeMath里面定义的函数我在BNB这里类里面都可以直接拿来用。

 string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;
	address public owner;

    /* This creates an array with all balances */
    mapping (address => uint256) public balanceOf;
	mapping (address => uint256) public freezeOf;
    mapping (address => mapping (address => uint256)) public allowance;

    /* This generates a public event on the blockchain that will notify clients */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /* This notifies clients about the amount burnt */
    event Burn(address indexed from, uint256 value);
	
	/* This notifies clients about the amount frozen */
    event Freeze(address indexed from, uint256 value);
	
	/* This notifies clients about the amount unfrozen */
    event Unfreeze(address indexed from, uint256 value);

这里定义了这个类有的状态变量，从上到下依次是发行代币的名字、标志、小数点后的位数（这里想解释一下，由于以太坊上发送币都是用bigNumber来计算的，这样举个例子，以太币是小数点后18位，但是发币的时候我们不会写0.0000000000000000001好多个0，我们就会写1，因为以太币的单位就是以最小单元为1的，我们要发一个以太币，那么我们需要写1000000000000000000，好多个0，这也就是我们呢经常说的bigNumber）、所有币的数量以及所有者。

上面定义了一般的数据，接下来它定义了三个mapping，什么是mapping呢，mapping就是一个映射，我们来看下第一个mappingmapping (address => uint256) public balanceOf;这个mapping说的是把address对象映射成为uint256，含义是每个地址账户的人所拥有的子代币的数目。第二个mapping就是用户冻结的子代币数，第三个mapping是用户授权的子代币数。

（二）BNB的构造函数

后面定义了一些event事件，就是我们要传播出去的，可以用web3监听到的事件，注意其中定义了indexed的关键词可以方便后期的查询。

 function BNB(
        uint256 initialSupply,
        string tokenName,
        uint8 decimalUnits,
        string tokenSymbol
        ) {
        balanceOf[msg.sender] = initialSupply;              // Give the creator all initial tokens
        totalSupply = initialSupply;                        // Update total supply
        name = tokenName;                                   // Set the name for display purposes
        symbol = tokenSymbol;                               // Set the symbol for display purposes
        decimals = decimalUnits;                            // Amount of decimals for display purposes
		owner = msg.sender;
    }

这个是构造函数需要传入4个参数，传入的参数大家也可以看到，分别是初始子货币量、子货币完整名字、小数点位数以及子货币简称。函数中就是一系列的赋值，把初始货币都放到发送合约者的名下，要是你发的自然所有的货币都会在你的名下。

（三）我该怎么给别人转钱呢
 /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (_to == 0x0) throw;                               // Prevent transfer to 0x0 address. Use burn() instead
		if (_value <= 0) throw; 
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);                     // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

以上代码是发送货币的函数，前面几个全是判断，这里就解释一下第一个，按照它说的你不能给地址全为0的地方发送货币，为什么呢，原来在编写子货币的代码中通常有一个共识，就是说你想地址为0的地方发送货币就相当于是销毁货币一样，当然你是铸币者也同有有机制来销毁你铸的货币，这样才是平衡的嘛，哈哈哈出来混不也是早晚要还的嘛。接下来的就是转币人的货币减少，被转人的货币增加，然后再抛出一个事件这些事件都会记录再日志中，一起被挖矿，所以你在搜索摸一个交易的时候也可也看到其所附带的日志。

（四）身为老板不来个授权人吗

下面就不一一来说了，这里给大家一下transferFrom。
介绍这个之前呢，想和大家聊聊什么是allowance，allowance就是授权，比如我有1000块钱，我授权你可以花100快，这个对应于我们之前定义的状态变量mapping (address => mapping (address => uint256)) public allowance;，第一个address就是我的地址，第二个address就是你的地址，uint256就是100块钱。

 /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (_to == 0x0) throw;                                // Prevent transfer to 0x0 address. Use burn() instead
		if (_value <= 0) throw; 
        if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw;     // Check allowance
        balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);                           // Subtract from the sender
        balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);                             // Add the same to the recipient
        allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
        Transfer(_from, _to, _value);
        return true;
    }

前面依旧是一系列的判断，后面函数里面无非就是减掉我转出的，我转给的那人加上我转出的币数，减掉发起这笔交易人的授权币数。

若水上善666
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
智能合约实战 solidity 语法学习 10 [ BNB合约解读 ] 附代码
www_vane的专栏
06-19 2030
1. ether官网搜索BNB
bnbapi源码
11-20
bnbapi源码
一起BnB-TOGETHER BnB（Build.8318119-修正.03.3-中文语音+DLC-恋爱模拟）
最新发布
qq_42118493的博客
01-17 1958
最受欢迎的即时战略游戏之一将随《帝国时代 IV》荣耀回归，让您置身于塑造现代世界的史诗般历史战役的中心。的一代：《帝国时代 IV》能为新手玩家带来愉快的游戏体验，内含专供学习即时战略游戏精华的教程系统，以及特别设计的战役故事模式，让新手玩家能轻松完成设置、获得胜利；在预告中，可以看到不同时代和地区的战争场面，从罗马帝国到近代海战，美洲的征服，法国革命，以及日本战国，相信本作的内容同样会非常丰富。运用模组自定义游戏：预计于 2022 年初推出的新功能，让您能运用用户生成的内容工具和模组随心所欲玩自定义游戏。
dev-bnb
03-04
由团队创建的用生成的Rails应用程序。
实现批量一对多转账bnbmbox等erc20token
09-22 594
实现批量一对多转账bnbmbox等erc20token https://download.csdn.net/download/QQ3447673281/24241244https://download.csdn.net/download/QQ3447673281/24241244
bnb首页
02-15
bnb首页
HP BNB 笔记本选型教程
02-25
HP BNB FY16Q3 Basic 产品认证有声课程 V201607212121212
BNB.rar_bnb_动态规划_规划
09-24
这个压缩包包含了一个名为“BNB.txt”的文件，我们可以假设这是对这个问题的描述或代码实现。 动态规划是一种强大的算法设计方法，常用于解决复杂的问题，通过将大问题分解为更小的子问题来求解。在C++中，动态规划...
BNB20.zip_bnb20_zip
07-15
mixed integer programming
matlab代码
04-14
% *bnb18 - 非线性整数规划(在MATLAB5.3使用) % *bnbgui - 非线性整数规划图形工具(在MATLAB5.3使用) % *mintreek - 最小生成树kruskal算法 % *minroute - 最短路dijkstra算法 % *krusk - 最小生成树kruskal算法mex...
together进度报告10
DesGuan的博客
06-10 877
这周剩下的时间完成了移动端的改动： 具体判断代码如下： try{ //若是手机端则切换界面 if (/Android|webOS|iPhone|iPod|BlackBerry/i.test(navigator.userAgent)) { window.location.href="index1.html"; } }catch(e){}若是手机端进
340-浅析BNBContractCode
Lich Howger
04-12 298
pragma solidity ^0.4.8; /** * Math operations with safety checks */ contract SafeMath { function safeMul(uint256 a, uint256 b) internal returns (uint256) { uint256 c = a * b; assert(a ==...
【我的区块链之路】- 在Ethereum上发布自己的token
qq_25870633的博客
07-19 971
【转载请标明出处】：https://blog.csdn.net/qq_25870633/article/details/80761410 废话不多说。基于以太坊ERC20标准发行token我们需要先做几步准备工作；首先，需要安装chrome的插件metamask，如下图所示：（具体安装插件，这里不做赘述）                                             ...
以太坊的一个TOKEN合约的发布
fpcc的专栏
07-27 1470
以太坊的一个TOKEN合约的发布   需要搞一个TOKEN的发布合约，先试一下水，从官网上找到了一个例子如下： pragma solidity ^0.4.8; contract Token{     // token总量，默认会为public变量生成一个getter函数接口，名称为totalSupply().     uint256 public totalSupply;     ...
我理解的以太坊
weixin_43977647的博客
05-11 476
1.以太坊简介 以太坊（英文Ethereum）是一个开源的有智能合约功能的公共区块链平台，通过其专用加密货币以太币（Ether，简称“ETH”）提供去中心化的以太虚拟机（Ethereum Virtual Machine）来处理点对点合约。 以太坊的概念首次在2013至2014年间由程序员Vitalik Buterin受比特币启发后提出，大意为“下一代加密货币与去中心化应用平台”，在2014年通过ICO众筹开始得以发展。 它和比特币最大的区别就是智能合约，类似于我有一段可以放在以太坊节点上跑的程序，而比特币的
智能合约代码LCS
智能合约代码
04-11 720
/** *Submitted for verification at Etherscan.io on 2019-07-25 */ pragma solidity ^0.4.24; interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _e...
Solidity 基础（二）语言描述-类型
chinusyan的专栏
12-20 1323
Solidity 基础（二）语言描述-类型
从零构建以太坊（Ethereum）智能合约到项目实战——第20章 搭建自己的私有链网络...
weixin_30722589的博客
02-10 556
P75 、1-以太坊私网建立 、合约编译、部署完全教程（1） 使用此博文进行安装配置：https://blog.csdn.net/w88193363/article/details/79402074 一、搭建私有链所需的依赖环境 操作系统：ubuntu16.04，开虚拟机的话要至少2G，否则会影响测试挖矿时的速度 软件：geth客户端 版本：1.8.1-stable-1e67410e 二...
Solidity
右见小栈
08-13 683
solidity的基本使用介绍
Delphi 区块链 bnb
05-28
Delphi是一种编程语言，而Binance Smart Chain (BSC)是一种基于区块链技术的公链，BNB是Binance Smart Chain上的原生代币。Delphi可以用于开发区块链应用程序，但是它与Binance Smart Chain或BNB没有直接关系。如果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值