我部署了一个 ico 代码,但是每当我将以太坊转移到该地址时,我都不会得到任何代币作为回报

问题描述

所以这是我的代码,它在 remix.ethereum 中正确编译,我成功地将它部署在 ropsten 测试链上我在 etherscan(https://ropsten.etherscan.io/address/0x22f27d3812a4d8bd2b6d870c300ea741906a7875) 上验证了代码,我可以启动 ICO,但是当我没有收到令牌时将eth转移到创建者地址

pragma solidity ^0.4.23;

library SafeMath {
    
    function mul(uint256 a,uint256 b) internal pure returns (uint256 c) {
        if (a == 0) {
            return 0;
        }
        c = a * b;
        assert(c / a == b);
        return c;
    }
    
 
    function div(uint256 a,uint256 b) internal pure returns (uint256) {
       
        return a / b;
    }
    
 
    function sub(uint256 a,uint256 b) internal pure returns (uint256) {
        assert(b <= a);
        return a - b;
    }
    
  
    function add(uint256 a,uint256 b) internal pure returns (uint256 c) {
        c = a + b;
        assert(c >= a);
        return c;
    }
}

 
contract Ownable {
    address public owner;
    event OwnershipTransferred(address indexed prevIoUsOwner,address indexed newOwner);

   constructor() public {
      owner = msg.sender;
    }
    

    modifier onlyOwner() {
      require(msg.sender == owner);
      _;
    }
    

    function transferOwnership(address newOwner) public onlyOwner {
      require(newOwner != address(0));
      emit OwnershipTransferred(owner,newOwner);
      owner = newOwner;
    }
}

contract ERC20Basic {
    function totalSupply() public view returns (uint256);
    function balanceOf(address who) public view returns (uint256);
    function transfer(address to,uint256 value) public returns (bool);
    event Transfer(address indexed from,address indexed to,uint256 value);
}

contract ERC20 is ERC20Basic {
    function allowance(address owner,address spender) public view returns (uint256);
    function transferFrom(address from,address to,uint256 value) public returns (bool);
    function approve(address spender,uint256 value) public returns (bool);
    event Approval(address indexed owner,address indexed spender,uint256 value);
}

contract BasicToken is ERC20Basic {
    using SafeMath for uint256;
    mapping(address => uint256) balances;
    uint256 totalSupply_;
    
  
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }
    
  
    function transfer(address _to,uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
        
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        emit Transfer(msg.sender,_to,_value);
        return true;
    }
    
   
    function balanceOf(address _owner) public view returns (uint256) {
        return balances[_owner];
    }
}
contract StandardToken is ERC20,BasicToken {
    mapping (address => mapping (address => uint256)) internal allowed;
  
    function transferFrom(address _from,address _to,uint256 _value) public returns (bool) {
        require(_to != address(0));
        require(_value <= balances[_from]);
        require(_value <= allowed[_from][msg.sender]);
    
        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,_value);
        return true;
    }
    
 
    function approve(address _spender,uint256 _value) public returns (bool) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender,_spender,_value);
        return true;
    }
    
    
    function allowance(address _owner,address _spender) public view returns (uint256) {
        return allowed[_owner][_spender];
    }
    
 
    function increaseApproval(address _spender,uint _addedValue) public returns (bool) {
        allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
        emit Approval(msg.sender,allowed[msg.sender][_spender]);
        return true;
    }
    
    
    function decreaseApproval(address _spender,uint _subtractedValue) public returns (bool) {
        uint oldValue = allowed[msg.sender][_spender];
        if (_subtractedValue > oldValue) {
            allowed[msg.sender][_spender] = 0;
        } else {
            allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
        }
        emit Approval(msg.sender,allowed[msg.sender][_spender]);
        return true;
    }
}

contract Configurable {
    uint256 public constant cap = 1000000*10**18;
    uint256 public constant basePrice = 100*10**18; // tokens per 1 ether
    uint256 public tokensSold = 0;
    
    uint256 public constant tokenReserve = 1000000*10**18;
    uint256 public remainingTokens = 0;
}

contract Crowdsaletoken is StandardToken,Configurable,Ownable {
 
     enum Stages {
        none,icoStart,icoEnd
    }
    
    Stages currentStage;
  
   
    constructor() public {
        currentStage = Stages.none;
        balances[owner] = balances[owner].add(tokenReserve);
        totalSupply_ = totalSupply_.add(tokenReserve);
        remainingTokens = cap;
        emit Transfer(address(this),owner,tokenReserve);
    }
    
 
    function () public payable {
        require(currentStage == Stages.icoStart);
        require(msg.value > 0);
        require(remainingTokens > 0);
        
        
        uint256 weiAmount = msg.value; 
        uint256 tokens = weiAmount.mul(basePrice).div(1 ether);
        uint256 returnWei = 0;
        
        if(tokensSold.add(tokens) > cap){
            uint256 newTokens = cap.sub(tokensSold);
            uint256 newWei = newTokens.div(basePrice).mul(1 ether);
            returnWei = weiAmount.sub(newWei);
            weiAmount = newWei;
            tokens = newTokens;
        }
        
        tokensSold = tokensSold.add(tokens); 
        remainingTokens = cap.sub(tokensSold);
        if(returnWei > 0){
            msg.sender.transfer(returnWei);
            emit Transfer(address(this),msg.sender,returnWei);
        }
        
        balances[msg.sender] = balances[msg.sender].add(tokens);
        emit Transfer(address(this),tokens);
        totalSupply_ = totalSupply_.add(tokens);
        owner.transfer(weiAmount);
    }

    function startIco() public onlyOwner {
        require(currentStage != Stages.icoEnd);
        currentStage = Stages.icoStart;
    }

    function endIco() internal {
        currentStage = Stages.icoEnd;
             if(remainingTokens > 0)
            balances[owner] = balances[owner].add(remainingTokens);
             owner.transfer(address(this).balance); 
    }

    function finalizeIco() public onlyOwner {
        require(currentStage != Stages.icoEnd);
        endIco();
    }
    
}

contract PkpICOTest is Crowdsaletoken {
    string public constant name = "PkpICOTest";
    string public constant symbol = "PKPICT";
    uint32 public constant decimals = 18;
}

解决方法

暂无找到可以解决该程序问题的有效方法,小编努力寻找整理中!

如果你已经找到好的解决方法,欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@)