merge factory and basic note/coupon contracts code

contracts/EIP20.sol

@@ -0,0 +1,71 @@
+/*
+Implements EIP20 token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
+.*/
+
+
+pragma solidity ^0.4.21;
+
+import "./EIP20Interface.sol";
+
+contract EIP20 is EIP20Interface {
+
+    uint256 constant private MAX_UINT256 = 2**256 - 1;
+    mapping (address => uint256) public balances;
+    mapping (address => mapping (address => uint256)) public allowed;
+    /*
+    NOTE:
+    The following variables are OPTIONAL vanities. One does not have to include them.
+    They allow one to customise the token contract & in no way influences the core functionality.
+    Some wallets/interfaces might not even bother to look at this information.
+    */
+    string public name;                   //fancy name: eg Simon Bucks
+    uint8 public decimals;                //How many decimals to show.
+    string public symbol;                 //An identifier: eg SBX
+
+    function EIP20(
+        uint256 _initialAmount,
+        string _tokenName,
+        uint8 _decimalUnits,
+        string _tokenSymbol
+    ) public {
+        balances[msg.sender] = _initialAmount;               // Give the creator all initial tokens
+        totalSupply = _initialAmount;                        // Update total supply
+        name = _tokenName;                                   // Set the name for display purposes
+        decimals = _decimalUnits;                            // Amount of decimals for display purposes
+        symbol = _tokenSymbol;                               // Set the symbol for display purposes
+    }
+
+    function transfer(address _to, uint256 _value) public returns (bool success) {
+        require(balances[msg.sender] >= _value);
+        balances[msg.sender] -= _value;
+        balances[_to] += _value;
+        emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
+        return true;
+    }
+
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
+        uint256 allowance = allowed[_from][msg.sender];
+        require(balances[_from] >= _value && allowance >= _value);
+        balances[_to] += _value;
+        balances[_from] -= _value;
+        if (allowance < MAX_UINT256) {
+            allowed[_from][msg.sender] -= _value;
+        }
+        emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
+        return true;
+    }
+
+    function balanceOf(address _owner) public view returns (uint256 balance) {
+        return balances[_owner];
+    }
+
+    function approve(address _spender, uint256 _value) public returns (bool success) {
+        allowed[msg.sender][_spender] = _value;
+        emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
+        return true;
+    }
+
+    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
+        return allowed[_owner][_spender];
+    }
+}

contracts/EIP20Interface.sol

@@ -0,0 +1,50 @@
+// Abstract contract for the full ERC 20 Token standard
+// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md
+pragma solidity ^0.4.21;
+
+
+contract EIP20Interface {
+    /* This is a slight change to the ERC20 base standard.
+    function totalSupply() constant returns (uint256 supply);
+    is replaced with:
+    uint256 public totalSupply;
+    This automatically creates a getter function for the totalSupply.
+    This is moved to the base contract since public getter functions are not
+    currently recognised as an implementation of the matching abstract
+    function by the compiler.
+    */
+    /// total amount of tokens
+    uint256 public totalSupply;
+
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return The balance
+    function balanceOf(address _owner) public view returns (uint256 balance);
+
+    /// @notice send `_value` token to `_to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transfer(address _to, uint256 _value) public returns (bool success);
+
+    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
+    /// @param _from The address of the sender
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
+
+    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @param _value The amount of tokens to be approved for transfer
+    /// @return Whether the approval was successful or not
+    function approve(address _spender, uint256 _value) public returns (bool success);
+
+    /// @param _owner The address of the account owning tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @return Amount of remaining tokens allowed to spent
+    function allowance(address _owner, address _spender) public view returns (uint256 remaining);
+
+    // solhint-disable-next-line no-simple-event-func-name
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
+}

contracts/RGEInterface.sol

@@ -0,0 +1,31 @@
+/*
+
+  RGE token Interface
+
+*/
+
+pragma solidity ^0.4.23;
+
+import "./EIP20Interface.sol";
+
+contract RGEToken is EIP20Interface {
+
+    string public name;
+    string public symbol;
+    uint8 public decimals;
+
+    address public crowdsale;
+    uint public endTGE;
+    string public version;
+    uint256 public reserveY1;
+    uint256 public reserveY2;
+
+    address public factory;
+
+    function newCampaign(uint32 _issuance, uint256 _value) public;
+
+    event Burn(address indexed burner, uint256 value);
+
+    function burn(uint256 _value) public returns (bool success);
+
+}

contracts/RougeFactory.sol

@@ -0,0 +1,55 @@
+/*
+
+  Simple Rouge factory and campaign contracts
+
+*/
+
+pragma solidity ^0.4.23;
+
+import "./SimpleRougeCampaign.sol";
+
+// XXX RougeRegistry is temporary helper
+
+import "./RougeRegistry.sol";
+
+contract RougeFactory is RougeRegistry {
+
+    // The Rouge Token contract address
+    RGEToken public rge;
+
+    address owner;
+
+    mapping (address => uint256) public deposit; // per campaign ... 
+
+    constructor() public {
+        owner = msg.sender;
+    }
+
+    modifier onlyBy(address _address) {
+        require(msg.sender == _address);
+        _;
+    }
+
+    function setParams ( address _rge ) onlyBy(owner) public {
+        rge = RGEToken(_rge);
+    }
+
+    event NewRougeCampaign(address issuer, address campaign, uint32 _issuance);
+
+    function createCampaign(address _issuer, uint32 _issuance, uint256 _tokens) public {
+
+        SimpleRougeCampaign c = new SimpleRougeCampaign(_issuer, _issuance, rge, this);
+
+        // XXX no need to check rge set ? transfer would revert ...
+        rge.transfer(c, _tokens);     // transfer tokens to the campaign contract ...
+
+        emit NewRougeCampaign(_issuer, c, _issuance);
+
+        // XXX beta sugar getters / not stricly necessary...
+
+        deposit[c] = _tokens;
+        add_campaign(_issuer, c);
+
+    }
+
+}

contracts/CouponDemoRegistry.sol → contracts/RougeRegistry.sol

@@ -1,9 +1,9 @@
 
 pragma solidity ^0.4.23;
 
-import "./RegistryInterface.sol";
+import "./RougeRegistryInterface.sol";
 
-contract CouponDemoRegistry is RegistryInterface {
+contract RougeRegistry is RougeRegistryInterface {
 
     string public version = 'v0.2';
 
@@ -16,22 +16,17 @@ contract CouponDemoRegistry is RegistryInterface {
     mapping (address => bool) public is_campaign;
     mapping (address => address[]) campaigns;
 
-    modifier onlyBy(address _account) {
-        require(msg.sender == _account);
-        _;
-    }
-
     constructor() public {
         owner = msg.sender;
     }
 
-    function add_campaign(address _a) public {
-        if (!is_issuer[msg.sender]) {
-            is_issuer[msg.sender] = true;
-            issuers.push(msg.sender);
+    function add_campaign(address _issuer, address _a) internal {
+        if (!is_issuer[_issuer]) {
+            is_issuer[_issuer] = true;
+            issuers.push(_issuer);
         }
         all_campaigns.push(_a);
-        campaigns[msg.sender].push(_a);
+        campaigns[_issuer].push(_a);
         is_campaign[_a] = true;
     }
 

contracts/RegistryInterface.sol → contracts/RougeRegistryInterface.sol

@@ -1,9 +1,8 @@
 
 pragma solidity ^0.4.23;
 
-contract RegistryInterface {
+contract RougeRegistryInterface {
 
-    function add_campaign(address _a) public;
     function get_all_count() public view returns(uint count);
     function get_all_campaign(uint index) public view returns(address);
     function get_count(address issuer) public view returns(uint count);