1

I use remix and I want only to send 10 tokens to someone if a condition is fulfilled. For that I use transfer function from an already deployed contract ERC20 (deployed on the Ropsten Testnet and the address is 0xc7398563377a6f11EDA8D9Fb6962CA79f20D5B86)

Here is my SC :

pragma solidity 0.4.21;
import "./ICO.sol";

contract Test2 {

   function SendCoin(uint8 x, address jack) public {
   uint8 x1=9 ;
   uint8 x2=11;
   uint8 value = 90;
   if ( x1<x && x<x2 ){
   Test(0xc7398563377a6f11EDA8D9Fb6962CA79f20D5B86).transfer(jack,value);
    }
   }
}

My line : Test(0xc7398563377a6f11EDA8D9Fb6962CA79f20D5B86).transfer(jack,value); doesn't work

And when I put for example: 10,"0x48a484a13bb7b08c8f0022c538e871cb4417e5c9" I have error as:

Error: gas required exceeds allowance or always failing transaction

Here is the code of my SC to create a token ERC20:

pragma solidity 0.4.21;

contract ERC20Basic {
  uint256 public totalSupply;
  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);
}

library SafeMath {
      function mul(uint256 a, uint256 b) internal pure returns (uint256) {
    if (a == 0) {
      return 0;
    }
    uint256 c = a * b;
    assert(c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal pure returns (uint256) {
// assert(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
// assert(a == b * c + a % b); 
    return c;
  }

  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) {
uint256 c = a + b;
assert(c >= a);
return c;
  }
}


contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);

// SafeMath.sub will throw if there is not enough balance.
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 balance) {
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, _to, _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, _spender, 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, _spender, allowed[msg.sender][_spender]);
return true;
  }

    }

contract Ownable {
   address public owner;


   event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


  function Ownable() 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 Pausable is Ownable {
   event Pause();
   event Unpause();

  bool public paused = false;

  modifier whenNotPaused() {
require(!paused);
_;
  }

  modifier whenPaused() {
require(paused);
_;
  }

  function pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
  }

   function unpause() onlyOwner whenPaused public {
paused = false;
emit Unpause();
  }
 }

contract PausableToken is StandardToken, Pausable {

  function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transfer(_to, _value);
  }

   function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
   }

  function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
  }

  function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
  }

   function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
 }
}

contract Test is StandardToken, PausableToken {
   string public constant name = 'Test';                                      // Set the token name for display
   string public constant symbol = 'TEST';                                       // Set the token symbol for display
   uint8 public constant decimals = 18;                                          // Set the number of decimals for display
   uint256 public constant INITIAL_SUPPLY = 50000000000 * 10**uint256(decimals);  // 50 billions 

  function Test() public{
totalSupply = INITIAL_SUPPLY;                               // Set the total supply
balances[msg.sender] = INITIAL_SUPPLY;                      // Creator address is assigned all
emit Transfer(0x0, msg.sender, INITIAL_SUPPLY);
  }

   function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
require(_to != address(0));
return super.transfer(_to, _value);
   }

   function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
require(_to != address(0));
return super.transferFrom(_from, _to, _value);
   }

  function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
return super.approve(_spender, _value);
  }

    event Burn(address indexed _burner, uint _value);

    function burn(uint _value) public returns (bool)
{
    balances[msg.sender] = balances[msg.sender].sub(_value);
    totalSupply = totalSupply.sub(_value);
    emit Burn(msg.sender, _value);
    emit Transfer(msg.sender, address(0x0), _value);
    return true;
    }
 } 

Thanks in advance for your help !

closed as unclear what you're asking by smarx, Richard Horrocks, mirg, eth May 27 '18 at 1:52

Please clarify your specific problem or add additional details to highlight exactly what you need. As it's currently written, it’s hard to tell exactly what you're asking. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

  • Comments are not for extended discussion; this conversation has been moved to chat. – eth May 27 '18 at 1:52