busd智能合约代码

合约代码"/>

busd智能合约代码

busd智能合约代码

什么是busd

Binance USD (BUSD) 是一种新的美元计价的稳定币，由纽约州金融服务部 (NYDFS) 批准， Paxos 和 Binance 合作推出。

在 Paxos 平台上以美元或 PAX 获得 BUSD 1:1

以太链busd智能合约代码

/***Submitted for verification at Etherscan.io on 2019-09-09
*/// File: contracts/zeppelin/SafeMath.solpragma solidity 0.4.24;/*** @title SafeMath* @dev Math operations with safety checks that throw on error*/
library SafeMath {/*** @dev Subtracts two numbers, reverts on overflow (i.e. if subtrahend is greater than minuend).*/function sub(uint256 a, uint256 b) internal pure returns (uint256) {require(b <= a);uint256 c = a - b;return c;}/*** @dev Adds two numbers, reverts on overflow.*/function add(uint256 a, uint256 b) internal pure returns (uint256) {uint256 c = a + b;require(c >= a);return c;}
}// File: contracts/BUSDImplementation.solpragma solidity 0.4.24;
pragma experimental "v0.5.0";/*** @title BUSDImplementation* @dev this contract is a Pausable ERC20 token with Burn and Mint* controlled by a central SupplyController. By implementing BUSDImplementation* this contract also includes external methods for setting* a new implementation contract for the Proxy.* NOTE: The storage defined here will actually be held in the Proxy* contract and all calls to this contract should be made through* the proxy, including admin actions done as owner or supplyController.* Any call to transfer against this contract should fail* with insufficient funds since no tokens will be issued there.*/
contract BUSDImplementation {/*** MATH*/using SafeMath for uint256;/*** DATA*/// INITIALIZATION DATAbool private initialized = false;// ERC20 BASIC DATAmapping(address => uint256) internal balances;uint256 internal totalSupply_;string public constant name = "Binance USD"; // solium-disable-linestring public constant symbol = "BUSD"; // solium-disable-line uppercaseuint8 public constant decimals = 18; // solium-disable-line uppercase// ERC20 DATAmapping(address => mapping(address => uint256)) internal allowed;// OWNER DATAaddress public owner;address public proposedOwner;// PAUSABILITY DATAbool public paused = false;// ASSET PROTECTION DATAaddress public assetProtectionRole;mapping(address => bool) internal frozen;// SUPPLY CONTROL DATAaddress public supplyController;// DELEGATED TRANSFER DATAaddress public betaDelegateWhitelister;mapping(address => bool) internal betaDelegateWhitelist;mapping(address => uint256) internal nextSeqs;// EIP191 header for EIP712 prefixstring constant internal EIP191_HEADER = "\x19\x01";// Hash of the EIP712 Domain Separator Schemabytes32 constant internal EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256("EIP712Domain(string name,address verifyingContract)");bytes32 constant internal EIP712_DELEGATED_TRANSFER_SCHEMA_HASH = keccak256("BetaDelegatedTransfer(address to,uint256 value,uint256 fee,uint256 seq,uint256 deadline)");// Hash of the EIP712 Domain Separator data// solhint-disable-next-line var-name-mixedcasebytes32 public EIP712_DOMAIN_HASH;/*** EVENTS*/// ERC20 BASIC EVENTSevent Transfer(address indexed from, address indexed to, uint256 value);// ERC20 EVENTSevent Approval(address indexed owner,address indexed spender,uint256 value);// OWNABLE EVENTSevent OwnershipTransferProposed(address indexed currentOwner,address indexed proposedOwner);event OwnershipTransferDisregarded(address indexed oldProposedOwner);event OwnershipTransferred(address indexed oldOwner,address indexed newOwner);// PAUSABLE EVENTSevent Pause();event Unpause();// ASSET PROTECTION EVENTSevent AddressFrozen(address indexed addr);event AddressUnfrozen(address indexed addr);event FrozenAddressWiped(address indexed addr);event AssetProtectionRoleSet (address indexed oldAssetProtectionRole,address indexed newAssetProtectionRole);// SUPPLY CONTROL EVENTSevent SupplyIncreased(address indexed to, uint256 value);event SupplyDecreased(address indexed from, uint256 value);event SupplyControllerSet(address indexed oldSupplyController,address indexed newSupplyController);// DELEGATED TRANSFER EVENTSevent BetaDelegatedTransfer(address indexed from, address indexed to, uint256 value, uint256 seq, uint256 fee);event BetaDelegateWhitelisterSet(address indexed oldWhitelister,address indexed newWhitelister);event BetaDelegateWhitelisted(address indexed newDelegate);event BetaDelegateUnwhitelisted(address indexed oldDelegate);/*** FUNCTIONALITY*/// INITIALIZATION FUNCTIONALITY/*** @dev sets 0 initials tokens, the owner, and the supplyController.* this serves as the constructor for the proxy but compiles to the* memory model of the Implementation contract.*/function initialize() public {require(!initialized, "already initialized");owner = msg.sender;proposedOwner = address(0);assetProtectionRole = address(0);totalSupply_ = 0;supplyController = msg.sender;initialized = true;}/*** The constructor is used here to ensure that the implementation* contract is initialized. An uncontrolled implementation* contract might lead to misleading state* for users who accidentally interact with it.*/constructor() public {initialize();pause();// Added in V2initializeDomainSeparator();}/*** @dev To be called when upgrading the contract using upgradeAndCall to add delegated transfers*/function initializeDomainSeparator() public {// hash the name context with the contract addressEIP712_DOMAIN_HASH = keccak256(abi.encodePacked(// solium-disable-lineEIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,keccak256(bytes(name)),bytes32(address(this))));}// ERC20 BASIC FUNCTIONALITY/*** @dev Total number of tokens in existence*/function totalSupply() public view returns (uint256) {return totalSupply_;}/*** @dev Transfer token to a specified address from msg.sender* Note: the use of Safemath ensures that _value is nonnegative.* @param _to The address to transfer to.* @param _value The amount to be transferred.*/function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {require(_to != address(0), "cannot transfer to address zero");require(!frozen[_to] && !frozen[msg.sender], "address frozen");require(_value <= balances[msg.sender], "insufficient funds");balances[msg.sender] = balances[msg.sender].sub(_value);balances[_to] = balances[_to].add(_value);emit Transfer(msg.sender, _to, _value);return true;}/*** @dev Gets the balance of the specified address.* @param _addr The address to query the the balance of.* @return An uint256 representing the amount owned by the passed address.*/function balanceOf(address _addr) public view returns (uint256) {return balances[_addr];}// ERC20 FUNCTIONALITY/*** @dev Transfer tokens from one address to another* @param _from address The address which you want to send tokens from* @param _to address The address which you want to transfer to* @param _value uint256 the amount of tokens to be transferred*/function transferFrom(address _from,address _to,uint256 _value)publicwhenNotPausedreturns (bool){require(_to != address(0), "cannot transfer to address zero");require(!frozen[_to] && !frozen[_from] && !frozen[msg.sender], "address frozen");require(_value <= balances[_from], "insufficient funds");require(_value <= allowed[_from][msg.sender], "insufficient allowance");balances[_from] = balances[_from].sub(_value);balances[_to] = balances[_to].add(_value);allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);emit Transfer(_from, _to, _value);return true;}/*** @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.* Beware that changing an allowance with this method brings the risk that someone may use both the old* and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this* race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:* * @param _spender The address which will spend the funds.* @param _value The amount of tokens to be spent.*/function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {require(!frozen[_spender] && !frozen[msg.sender], "address frozen");allowed[msg.sender][_spender] = _value;emit Approval(msg.sender, _spender, _value);return true;}/*** @dev Function to check the amount of tokens that an owner allowed to a spender.* @param _owner address The address which owns the funds.* @param _spender address The address which will spend the funds.* @return A uint256 specifying the amount of tokens still available for the spender.*/function allowance(address _owner,address _spender)publicviewreturns (uint256){return allowed[_owner][_spender];}// OWNER FUNCTIONALITY/*** @dev Throws if called by any account other than the owner.*/modifier onlyOwner() {require(msg.sender == owner, "onlyOwner");_;}/*** @dev Allows the current owner to begin transferring control of the contract to a proposedOwner* @param _proposedOwner The address to transfer ownership to.*/function proposeOwner(address _proposedOwner) public onlyOwner {require(_proposedOwner != address(0), "cannot transfer ownership to address zero");require(msg.sender != _proposedOwner, "caller already is owner");proposedOwner = _proposedOwner;emit OwnershipTransferProposed(owner, proposedOwner);}/*** @dev Allows the current owner or proposed owner to cancel transferring control of the contract to a proposedOwner*/function disregardProposeOwner() public {require(msg.sender == proposedOwner || msg.sender == owner, "only proposedOwner or owner");require(proposedOwner != address(0), "can only disregard a proposed owner that was previously set");address _oldProposedOwner = proposedOwner;proposedOwner = address(0);emit OwnershipTransferDisregarded(_oldProposedOwner);}/*** @dev Allows the proposed owner to complete transferring control of the contract to the proposedOwner.*/function claimOwnership() public {require(msg.sender == proposedOwner, "onlyProposedOwner");address _oldOwner = owner;owner = proposedOwner;proposedOwner = address(0);emit OwnershipTransferred(_oldOwner, owner);}/*** @dev Reclaim all BUSD at the contract address.* This sends the BUSD tokens that this contract add holding to the owner.* Note: this is not affected by freeze constraints.*/function reclaimBUSD() external onlyOwner {uint256 _balance = balances[this];balances[this] = 0;balances[owner] = balances[owner].add(_balance);emit Transfer(this, owner, _balance);}// PAUSABILITY FUNCTIONALITY/*** @dev Modifier to make a function callable only when the contract is not paused.*/modifier whenNotPaused() {require(!paused, "whenNotPaused");_;}/*** @dev called by the owner to pause, triggers stopped state*/function pause() public onlyOwner {require(!paused, "already paused");paused = true;emit Pause();}/*** @dev called by the owner to unpause, returns to normal state*/function unpause() public onlyOwner {require(paused, "already unpaused");paused = false;emit Unpause();}// ASSET PROTECTION FUNCTIONALITY/*** @dev Sets a new asset Protection role address.* @param _newAssetProtectionRole The new address allowed to freeze/unfreeze addresses and seize their tokens.*/function setAssetProtectionRole(address _newAssetProtectionRole) public {require(msg.sender == assetProtectionRole || msg.sender == owner, "only assetProtectionRole or Owner");emit AssetProtectionRoleSet(assetProtectionRole, _newAssetProtectionRole);assetProtectionRole = _newAssetProtectionRole;}modifier onlyAssetProtectionRole() {require(msg.sender == assetProtectionRole, "onlyAssetProtectionRole");_;}/*** @dev Freezes an address balance from being transferred.* @param _addr The new address to freeze.*/function freeze(address _addr) public onlyAssetProtectionRole {require(!frozen[_addr], "address already frozen");frozen[_addr] = true;emit AddressFrozen(_addr);}/*** @dev Unfreezes an address balance allowing transfer.* @param _addr The new address to unfreeze.*/function unfreeze(address _addr) public onlyAssetProtectionRole {require(frozen[_addr], "address already unfrozen");frozen[_addr] = false;emit AddressUnfrozen(_addr);}/*** @dev Wipes the balance of a frozen address, burning the tokens* and setting the approval to zero.* @param _addr The new frozen address to wipe.*/function wipeFrozenAddress(address _addr) public onlyAssetProtectionRole {require(frozen[_addr], "address is not frozen");uint256 _balance = balances[_addr];balances[_addr] = 0;totalSupply_ = totalSupply_.sub(_balance);emit FrozenAddressWiped(_addr);emit SupplyDecreased(_addr, _balance);emit Transfer(_addr, address(0), _balance);}/*** @dev Gets whether the address is currently frozen.* @param _addr The address to check if frozen.* @return A bool representing whether the given address is frozen.*/function isFrozen(address _addr) public view returns (bool) {return frozen[_addr];}// SUPPLY CONTROL FUNCTIONALITY/*** @dev Sets a new supply controller address.* @param _newSupplyController The address allowed to burn/mint tokens to control supply.*/function setSupplyController(address _newSupplyController) public {require(msg.sender == supplyController || msg.sender == owner, "only SupplyController or Owner");require(_newSupplyController != address(0), "cannot set supply controller to address zero");emit SupplyControllerSet(supplyController, _newSupplyController);supplyController = _newSupplyController;}modifier onlySupplyController() {require(msg.sender == supplyController, "onlySupplyController");_;}/*** @dev Increases the total supply by minting the specified number of tokens to the supply controller account.* @param _value The number of tokens to add.* @return A boolean that indicates if the operation was successful.*/function increaseSupply(uint256 _value) public onlySupplyController returns (bool success) {totalSupply_ = totalSupply_.add(_value);balances[supplyController] = balances[supplyController].add(_value);emit SupplyIncreased(supplyController, _value);emit Transfer(address(0), supplyController, _value);return true;}/*** @dev Decreases the total supply by burning the specified number of tokens from the supply controller account.* @param _value The number of tokens to remove.* @return A boolean that indicates if the operation was successful.*/function decreaseSupply(uint256 _value) public onlySupplyController returns (bool success) {require(_value <= balances[supplyController], "not enough supply");balances[supplyController] = balances[supplyController].sub(_value);totalSupply_ = totalSupply_.sub(_value);emit SupplyDecreased(supplyController, _value);emit Transfer(supplyController, address(0), _value);return true;}// DELEGATED TRANSFER FUNCTIONALITY/*** @dev returns the next seq for a target address.* The transactor must submit nextSeqOf(transactor) in the next transaction for it to be valid.* Note: that the seq context is specific to this smart contract.* @param target The target address.* @return the seq.*///function nextSeqOf(address target) public view returns (uint256) {return nextSeqs[target];}/*** @dev Performs a transfer on behalf of the from address, identified by its signature on the delegatedTransfer msg.* Splits a signature byte array into r,s,v for convenience.* @param sig the signature of the delgatedTransfer msg.* @param to The address to transfer to.* @param value The amount to be transferred.* @param fee an optional ERC20 fee paid to the executor of betaDelegatedTransfer by the from address.* @param seq a sequencing number included by the from address specific to this contract to protect from replays.* @param deadline a block number after which the pre-signed transaction has expired.* @return A boolean that indicates if the operation was successful.*/function betaDelegatedTransfer(bytes sig, address to, uint256 value, uint256 fee, uint256 seq, uint256 deadline) public returns (bool) {require(sig.length == 65, "signature should have length 65");bytes32 r;bytes32 s;uint8 v;assembly {r := mload(add(sig, 32))s := mload(add(sig, 64))v := byte(0, mload(add(sig, 96)))}require(_betaDelegatedTransfer(r, s, v, to, value, fee, seq, deadline), "failed transfer");return true;}/*** @dev Performs a transfer on behalf of the from address, identified by its signature on the betaDelegatedTransfer msg.* Note: both the delegate and transactor sign in the fees. The transactor, however,* has no control over the gas price, and therefore no control over the transaction time.* Beta prefix chosen to avoid a name clash with an emerging standard in ERC865 or elsewhere.* Internal to the contract - see betaDelegatedTransfer and betaDelegatedTransferBatch.* @param r the r signature of the delgatedTransfer msg.* @param s the s signature of the delgatedTransfer msg.* @param v the v signature of the delgatedTransfer msg.* @param to The address to transfer to.* @param value The amount to be transferred.* @param fee an optional ERC20 fee paid to the delegate of betaDelegatedTransfer by the from address.* @param seq a sequencing number included by the from address specific to this contract to protect from replays.* @param deadline a block number after which the pre-signed transaction has expired.* @return A boolean that indicates if the operation was successful.*/function _betaDelegatedTransfer(bytes32 r, bytes32 s, uint8 v, address to, uint256 value, uint256 fee, uint256 seq, uint256 deadline) internal whenNotPaused returns (bool) {require(betaDelegateWhitelist[msg.sender], "Beta feature only accepts whitelisted delegates");require(value > 0 || fee > 0, "cannot transfer zero tokens with zero fee");require(block.number <= deadline, "transaction expired");// prevent sig malleability from ecrecover()require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "signature incorrect");require(v == 27 || v == 28, "signature incorrect");// EIP712 scheme: .mdbytes32 delegatedTransferHash = keccak256(abi.encodePacked(// solium-disable-lineEIP712_DELEGATED_TRANSFER_SCHEMA_HASH, bytes32(to), value, fee, seq, deadline));bytes32 hash = keccak256(abi.encodePacked(EIP191_HEADER, EIP712_DOMAIN_HASH, delegatedTransferHash));address _from = ecrecover(hash, v, r, s);require(_from != address(0), "error determining from address from signature");require(to != address(0), "canno use address zero");require(!frozen[to] && !frozen[_from] && !frozen[msg.sender], "address frozen");require(value.add(fee) <= balances[_from], "insufficent fund");require(nextSeqs[_from] == seq, "incorrect seq");nextSeqs[_from] = nextSeqs[_from].add(1);balances[_from] = balances[_from].sub(value.add(fee));if (fee != 0) {balances[msg.sender] = balances[msg.sender].add(fee);emit Transfer(_from, msg.sender, fee);}balances[to] = balances[to].add(value);emit Transfer(_from, to, value);emit BetaDelegatedTransfer(_from, to, value, seq, fee);return true;}/*** @dev Performs an atomic batch of transfers on behalf of the from addresses, identified by their signatures.* Lack of nested array support in arguments requires all arguments to be passed as equal size arrays where* delegated transfer number i is the combination of all arguments at index i* @param r the r signatures of the delgatedTransfer msg.* @param s the s signatures of the delgatedTransfer msg.* @param v the v signatures of the delgatedTransfer msg.* @param to The addresses to transfer to.* @param value The amounts to be transferred.* @param fee optional ERC20 fees paid to the delegate of betaDelegatedTransfer by the from address.* @param seq sequencing numbers included by the from address specific to this contract to protect from replays.* @param deadline block numbers after which the pre-signed transactions have expired.* @return A boolean that indicates if the operation was successful.*/function betaDelegatedTransferBatch(bytes32[] r, bytes32[] s, uint8[] v, address[] to, uint256[] value, uint256[] fee, uint256[] seq, uint256[] deadline) public returns (bool) {require(r.length == s.length && r.length == v.length && r.length == to.length && r.length == value.length, "length mismatch");require(r.length == fee.length && r.length == seq.length && r.length == deadline.length, "length mismatch");for (uint i = 0; i < r.length; i++) {require(_betaDelegatedTransfer(r[i], s[i], v[i], to[i], value[i], fee[i], seq[i], deadline[i]),"failed transfer");}return true;}/*** @dev Gets whether the address is currently whitelisted for betaDelegateTransfer.* @param _addr The address to check if whitelisted.* @return A bool representing whether the given address is whitelisted.*/function isWhitelistedBetaDelegate(address _addr) public view returns (bool) {return betaDelegateWhitelist[_addr];}/*** @dev Sets a new betaDelegate whitelister.* @param _newWhitelister The address allowed to whitelist betaDelegates.*/function setBetaDelegateWhitelister(address _newWhitelister) public {require(msg.sender == betaDelegateWhitelister || msg.sender == owner, "only Whitelister or Owner");betaDelegateWhitelister = _newWhitelister;emit BetaDelegateWhitelisterSet(betaDelegateWhitelister, _newWhitelister);}modifier onlyBetaDelegateWhitelister() {require(msg.sender == betaDelegateWhitelister, "onlyBetaDelegateWhitelister");_;}/*** @dev Whitelists an address to allow calling BetaDelegatedTransfer.* @param _addr The new address to whitelist.*/function whitelistBetaDelegate(address _addr) public onlyBetaDelegateWhitelister {require(!betaDelegateWhitelist[_addr], "delegate already whitelisted");betaDelegateWhitelist[_addr] = true;emit BetaDelegateWhitelisted(_addr);}/*** @dev Unwhitelists an address to disallow calling BetaDelegatedTransfer.* @param _addr The new address to whitelist.*/function unwhitelistBetaDelegate(address _addr) public onlyBetaDelegateWhitelister {require(betaDelegateWhitelist[_addr], "delegate not whitelisted");betaDelegateWhitelist[_addr] = false;emit BetaDelegateUnwhitelisted(_addr);}
}

以太链busd合约代码地址

链接: 代码地址

币安智能链busd智能合约代码

/***Submitted for verification at BscScan on 2020-09-02
*/pragma solidity 0.5.16;interface IBEP20 {/*** @dev Returns the amount of tokens in existence.*/function totalSupply() external view returns (uint256);/*** @dev Returns the token decimals.*/function decimals() external view returns (uint8);/*** @dev Returns the token symbol.*/function symbol() external view returns (string memory);/*** @dev Returns the token name.*/function name() external view returns (string memory);/*** @dev Returns the bep token owner.*/function getOwner() external view returns (address);/*** @dev Returns the amount of tokens owned by `account`.*/function balanceOf(address account) external view returns (uint256);/*** @dev Moves `amount` tokens from the caller's account to `recipient`.** Returns a boolean value indicating whether the operation succeeded.** Emits a {Transfer} event.*/function transfer(address recipient, uint256 amount) external returns (bool);/*** @dev Returns the remaining number of tokens that `spender` will be* allowed to spend on behalf of `owner` through {transferFrom}. This is* zero by default.** This value changes when {approve} or {transferFrom} are called.*/function allowance(address _owner, address spender) external view returns (uint256);/*** @dev Sets `amount` as the allowance of `spender` over the caller's tokens.** Returns a boolean value indicating whether the operation succeeded.** IMPORTANT: Beware that changing an allowance with this method brings the risk* that someone may use both the old and the new allowance by unfortunate* transaction ordering. One possible solution to mitigate this race* condition is to first reduce the spender's allowance to 0 and set the* desired value afterwards:* ** Emits an {Approval} event.*/function approve(address spender, uint256 amount) external returns (bool);/*** @dev Moves `amount` tokens from `sender` to `recipient` using the* allowance mechanism. `amount` is then deducted from the caller's* allowance.** Returns a boolean value indicating whether the operation succeeded.** Emits a {Transfer} event.*/function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);/*** @dev Emitted when `value` tokens are moved from one account (`from`) to* another (`to`).** Note that `value` may be zero.*/event Transfer(address indexed from, address indexed to, uint256 value);/*** @dev Emitted when the allowance of a `spender` for an `owner` is set by* a call to {approve}. `value` is the new allowance.*/event Approval(address indexed owner, address indexed spender, uint256 value);
}/** @dev Provides information about the current execution context, including the* sender of the transaction and its data. While these are generally available* via msg.sender and msg.data, they should not be accessed in such a direct* manner, since when dealing with GSN meta-transactions the account sending and* paying for execution may not be the actual sender (as far as an application* is concerned).** This contract is only required for intermediate, library-like contracts.*/
contract Context {// Empty internal constructor, to prevent people from mistakenly deploying// an instance of this contract, which should be used via inheritance.constructor () internal { }function _msgSender() internal view returns (address payable) {return msg.sender;}function _msgData() internal view returns (bytes memory) {this; // silence state mutability warning without generating bytecode - see  msg.data;}
}/*** @dev Wrappers over Solidity's arithmetic operations with added overflow* checks.** Arithmetic operations in Solidity wrap on overflow. This can easily result* in bugs, because programmers usually assume that an overflow raises an* error, which is the standard behavior in high level programming languages.* `SafeMath` restores this intuition by reverting the transaction when an* operation overflows.** Using this library instead of the unchecked operations eliminates an entire* class of bugs, so it's recommended to use it always.*/
library SafeMath {/*** @dev Returns the addition of two unsigned integers, reverting on* overflow.** Counterpart to Solidity's `+` operator.** Requirements:* - Addition cannot overflow.*/function add(uint256 a, uint256 b) internal pure returns (uint256) {uint256 c = a + b;require(c >= a, "SafeMath: addition overflow");return c;}/*** @dev Returns the subtraction of two unsigned integers, reverting on* overflow (when the result is negative).** Counterpart to Solidity's `-` operator.** Requirements:* - Subtraction cannot overflow.*/function sub(uint256 a, uint256 b) internal pure returns (uint256) {return sub(a, b, "SafeMath: subtraction overflow");}/*** @dev Returns the subtraction of two unsigned integers, reverting with custom message on* overflow (when the result is negative).** Counterpart to Solidity's `-` operator.** Requirements:* - Subtraction cannot overflow.*/function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {require(b <= a, errorMessage);uint256 c = a - b;return c;}/*** @dev Returns the multiplication of two unsigned integers, reverting on* overflow.** Counterpart to Solidity's `*` operator.** Requirements:* - Multiplication cannot overflow.*/function mul(uint256 a, uint256 b) internal pure returns (uint256) {// Gas optimization: this is cheaper than requiring 'a' not being zero, but the// benefit is lost if 'b' is also tested.// See:  (a == 0) {return 0;}uint256 c = a * b;require(c / a == b, "SafeMath: multiplication overflow");return c;}/*** @dev Returns the integer division of two unsigned integers. Reverts on* division by zero. The result is rounded towards zero.** Counterpart to Solidity's `/` operator. Note: this function uses a* `revert` opcode (which leaves remaining gas untouched) while Solidity* uses an invalid opcode to revert (consuming all remaining gas).** Requirements:* - The divisor cannot be zero.*/function div(uint256 a, uint256 b) internal pure returns (uint256) {return div(a, b, "SafeMath: division by zero");}/*** @dev Returns the integer division of two unsigned integers. Reverts with custom message on* division by zero. The result is rounded towards zero.** Counterpart to Solidity's `/` operator. Note: this function uses a* `revert` opcode (which leaves remaining gas untouched) while Solidity* uses an invalid opcode to revert (consuming all remaining gas).** Requirements:* - The divisor cannot be zero.*/function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {// Solidity only automatically asserts when dividing by 0require(b > 0, errorMessage);uint256 c = a / b;// assert(a == b * c + a % b); // There is no case in which this doesn't holdreturn c;}/*** @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),* Reverts when dividing by zero.** Counterpart to Solidity's `%` operator. This function uses a `revert`* opcode (which leaves remaining gas untouched) while Solidity uses an* invalid opcode to revert (consuming all remaining gas).** Requirements:* - The divisor cannot be zero.*/function mod(uint256 a, uint256 b) internal pure returns (uint256) {return mod(a, b, "SafeMath: modulo by zero");}/*** @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),* Reverts with custom message when dividing by zero.** Counterpart to Solidity's `%` operator. This function uses a `revert`* opcode (which leaves remaining gas untouched) while Solidity uses an* invalid opcode to revert (consuming all remaining gas).** Requirements:* - The divisor cannot be zero.*/function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {require(b != 0, errorMessage);return a % b;}
}/*** @dev Contract module which provides a basic access control mechanism, where* there is an account (an owner) that can be granted exclusive access to* specific functions.** By default, the owner account will be the one that deploys the contract. This* can later be changed with {transferOwnership}.** This module is used through inheritance. It will make available the modifier* `onlyOwner`, which can be applied to your functions to restrict their use to* the owner.*/
contract Ownable is Context {address private _owner;event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);/*** @dev Initializes the contract setting the deployer as the initial owner.*/constructor () internal {address msgSender = _msgSender();_owner = msgSender;emit OwnershipTransferred(address(0), msgSender);}/*** @dev Returns the address of the current owner.*/function owner() public view returns (address) {return _owner;}/*** @dev Throws if called by any account other than the owner.*/modifier onlyOwner() {require(_owner == _msgSender(), "Ownable: caller is not the owner");_;}/*** @dev Leaves the contract without owner. It will not be possible to call* `onlyOwner` functions anymore. Can only be called by the current owner.** NOTE: Renouncing ownership will leave the contract without an owner,* thereby removing any functionality that is only available to the owner.*/function renounceOwnership() public onlyOwner {emit OwnershipTransferred(_owner, address(0));_owner = address(0);}/*** @dev Transfers ownership of the contract to a new account (`newOwner`).* Can only be called by the current owner.*/function transferOwnership(address newOwner) public onlyOwner {_transferOwnership(newOwner);}/*** @dev Transfers ownership of the contract to a new account (`newOwner`).*/function _transferOwnership(address newOwner) internal {require(newOwner != address(0), "Ownable: new owner is the zero address");emit OwnershipTransferred(_owner, newOwner);_owner = newOwner;}
}contract BEP20Token is Context, IBEP20, Ownable {using SafeMath for uint256;mapping (address => uint256) private _balances;mapping (address => mapping (address => uint256)) private _allowances;uint256 private _totalSupply;uint8 public _decimals;string public _symbol;string public _name;constructor() public {_name = "BUSD Token";_symbol = "BUSD";_decimals = 18;_totalSupply = 31000000000000000000000000;_balances[msg.sender] = _totalSupply;emit Transfer(address(0), msg.sender, _totalSupply);}/*** @dev Returns the bep token owner.*/function getOwner() external view returns (address) {return owner();}/*** @dev Returns the token decimals.*/function decimals() external view returns (uint8) {return _decimals;}/*** @dev Returns the token symbol.*/function symbol() external view returns (string memory) {return _symbol;}/*** @dev Returns the token name.*/function name() external view returns (string memory) {return _name;}/*** @dev See {BEP20-totalSupply}.*/function totalSupply() external view returns (uint256) {return _totalSupply;}/*** @dev See {BEP20-balanceOf}.*/function balanceOf(address account) external view returns (uint256) {return _balances[account];}/*** @dev See {BEP20-transfer}.** Requirements:** - `recipient` cannot be the zero address.* - the caller must have a balance of at least `amount`.*/function transfer(address recipient, uint256 amount) external returns (bool) {_transfer(_msgSender(), recipient, amount);return true;}/*** @dev See {BEP20-allowance}.*/function allowance(address owner, address spender) external view returns (uint256) {return _allowances[owner][spender];}/*** @dev See {BEP20-approve}.** Requirements:** - `spender` cannot be the zero address.*/function approve(address spender, uint256 amount) external returns (bool) {_approve(_msgSender(), spender, amount);return true;}/*** @dev See {BEP20-transferFrom}.** Emits an {Approval} event indicating the updated allowance. This is not* required by the EIP. See the note at the beginning of {BEP20};** Requirements:* - `sender` and `recipient` cannot be the zero address.* - `sender` must have a balance of at least `amount`.* - the caller must have allowance for `sender`'s tokens of at least* `amount`.*/function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {_transfer(sender, recipient, amount);_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));return true;}/*** @dev Atomically increases the allowance granted to `spender` by the caller.** This is an alternative to {approve} that can be used as a mitigation for* problems described in {BEP20-approve}.** Emits an {Approval} event indicating the updated allowance.** Requirements:** - `spender` cannot be the zero address.*/function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));return true;}/*** @dev Atomically decreases the allowance granted to `spender` by the caller.** This is an alternative to {approve} that can be used as a mitigation for* problems described in {BEP20-approve}.** Emits an {Approval} event indicating the updated allowance.** Requirements:** - `spender` cannot be the zero address.* - `spender` must have allowance for the caller of at least* `subtractedValue`.*/function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));return true;}/*** @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing* the total supply.** Requirements** - `msg.sender` must be the token owner*/function mint(uint256 amount) public onlyOwner returns (bool) {_mint(_msgSender(), amount);return true;}/*** @dev Burn `amount` tokens and decreasing the total supply.*/function burn(uint256 amount) public returns (bool) {_burn(_msgSender(), amount);return true;}/*** @dev Moves tokens `amount` from `sender` to `recipient`.** This is internal function is equivalent to {transfer}, and can be used to* e.g. implement automatic token fees, slashing mechanisms, etc.** Emits a {Transfer} event.** Requirements:** - `sender` cannot be the zero address.* - `recipient` cannot be the zero address.* - `sender` must have a balance of at least `amount`.*/function _transfer(address sender, address recipient, uint256 amount) internal {require(sender != address(0), "BEP20: transfer from the zero address");require(recipient != address(0), "BEP20: transfer to the zero address");_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");_balances[recipient] = _balances[recipient].add(amount);emit Transfer(sender, recipient, amount);}/** @dev Creates `amount` tokens and assigns them to `account`, increasing* the total supply.** Emits a {Transfer} event with `from` set to the zero address.** Requirements** - `to` cannot be the zero address.*/function _mint(address account, uint256 amount) internal {require(account != address(0), "BEP20: mint to the zero address");_totalSupply = _totalSupply.add(amount);_balances[account] = _balances[account].add(amount);emit Transfer(address(0), account, amount);}/*** @dev Destroys `amount` tokens from `account`, reducing the* total supply.** Emits a {Transfer} event with `to` set to the zero address.** Requirements** - `account` cannot be the zero address.* - `account` must have at least `amount` tokens.*/function _burn(address account, uint256 amount) internal {require(account != address(0), "BEP20: burn from the zero address");_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");_totalSupply = _totalSupply.sub(amount);emit Transfer(account, address(0), amount);}/*** @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.** This is internal function is equivalent to `approve`, and can be used to* e.g. set automatic allowances for certain subsystems, etc.** Emits an {Approval} event.** Requirements:** - `owner` cannot be the zero address.* - `spender` cannot be the zero address.*/function _approve(address owner, address spender, uint256 amount) internal {require(owner != address(0), "BEP20: approve from the zero address");require(spender != address(0), "BEP20: approve to the zero address");_allowances[owner][spender] = amount;emit Approval(owner, spender, amount);}/*** @dev Destroys `amount` tokens from `account`.`amount` is then deducted* from the caller's allowance.** See {_burn} and {_approve}.*/function _burnFrom(address account, uint256 amount) internal {_burn(account, amount);_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance"));}
}

币安链busd合约代码地址

链接: 代码地址