Contract Address Details

// File: @0xcert/ethereum-utils-contracts/src/contracts/permission/ownable.sol

pragma solidity 0.5.6;

/**
 * @dev The contract has an owner address, and provides basic authorization control whitch
 * simplifies the implementation of user permissions. This contract is based on the source code at:
 * https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/ownership/Ownable.sol
 */
contract Ownable
{

  /**
   * @dev Error constants.
   */
  string constant NOT_OWNER = "018001";
  string constant ZERO_ADDRESS = "018002";

  /**
   * @dev Address of the owner.
   */
  address public owner;

  /**
   * @dev An event which is triggered when the owner is changed.
   * @param previousOwner The address of the previous owner.
   * @param newOwner The address of the new owner.
   */
  event OwnershipTransferred(
    address indexed previousOwner,
    address indexed newOwner
  );

  /**
   * @dev The constructor sets the original `owner` of the contract to the sender account.
   */
  constructor()
    public
  {
    owner = msg.sender;
  }

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner()
  {
    require(msg.sender == owner, NOT_OWNER);
    _;
  }

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param _newOwner The address to transfer ownership to.
   */
  function transferOwnership(
    address _newOwner
  )
    public
    onlyOwner
  {
    require(_newOwner != address(0), ZERO_ADDRESS);
    emit OwnershipTransferred(owner, _newOwner);
    owner = _newOwner;
  }

}

// File: @0xcert/ethereum-utils-contracts/src/contracts/math/safe-math.sol

pragma solidity 0.5.6;

/**
 * @dev Math operations with safety checks that throw on error. This contract is based on the
 * source code at:
 * https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol.
 */
library SafeMath
{

  /**
   * @dev Error constants.
   */
  string constant OVERFLOW = "008001";
  string constant SUBTRAHEND_GREATER_THEN_MINUEND = "008002";
  string constant DIVISION_BY_ZERO = "008003";

  /**
   * @dev Multiplies two numbers, reverts on overflow.
   * @param _factor1 Factor number.
   * @param _factor2 Factor number.
   * @return The product of the two factors.
   */
  function mul(
    uint256 _factor1,
    uint256 _factor2
  )
    internal
    pure
    returns (uint256 product)
  {
    // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
    // benefit is lost if 'b' is also tested.
    // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
    if (_factor1 == 0)
    {
      return 0;
    }

    product = _factor1 * _factor2;
    require(product / _factor1 == _factor2, OVERFLOW);
  }

  /**
   * @dev Integer division of two numbers, truncating the quotient, reverts on division by zero.
   * @param _dividend Dividend number.
   * @param _divisor Divisor number.
   * @return The quotient.
   */
  function div(
    uint256 _dividend,
    uint256 _divisor
  )
    internal
    pure
    returns (uint256 quotient)
  {
    // Solidity automatically asserts when dividing by 0, using all gas.
    require(_divisor > 0, DIVISION_BY_ZERO);
    quotient = _dividend / _divisor;
    // assert(_dividend == _divisor * quotient + _dividend % _divisor); // There is no case in which this doesn't hold.
  }

  /**
   * @dev Substracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
   * @param _minuend Minuend number.
   * @param _subtrahend Subtrahend number.
   * @return Difference.
   */
  function sub(
    uint256 _minuend,
    uint256 _subtrahend
  )
    internal
    pure
    returns (uint256 difference)
  {
    require(_subtrahend <= _minuend, SUBTRAHEND_GREATER_THEN_MINUEND);
    difference = _minuend - _subtrahend;
  }

  /**
   * @dev Adds two numbers, reverts on overflow.
   * @param _addend1 Number.
   * @param _addend2 Number.
   * @return Sum.
   */
  function add(
    uint256 _addend1,
    uint256 _addend2
  )
    internal
    pure
    returns (uint256 sum)
  {
    sum = _addend1 + _addend2;
    require(sum >= _addend1, OVERFLOW);
  }

  /**
    * @dev Divides two numbers and returns the remainder (unsigned integer modulo), reverts when
    * dividing by zero.
    * @param _dividend Number.
    * @param _divisor Number.
    * @return Remainder.
    */
  function mod(
    uint256 _dividend,
    uint256 _divisor
  )
    internal
    pure
    returns (uint256 remainder)
  {
    require(_divisor != 0, DIVISION_BY_ZERO);
    remainder = _dividend % _divisor;
  }

}

// File: contracts/ArianeeCreditHistory.sol

pragma solidity 0.5.6;



contract ArianeeCreditHistory is
Ownable
{
  using SafeMath for uint256;

  /**
   * @dev Mapping from address to array of creditHistory by type of credit.
   */
  mapping(address => mapping(uint256=>CreditBuy[])) internal creditHistory;

  /**
   * @dev Mapping from address to creditHistory index by type of the credit.
   */
  mapping(address => mapping(uint256=>uint256)) internal historyIndex;

  /**
   * @dev Mapping from address to totalCredit by type of the credit.
   */
  mapping(address => mapping(uint256=>uint256)) internal totalCredits;

  /**
   * @dev Address of the actual store address.
   */
  address public arianeeStoreAddress;

  struct CreditBuy{
      uint256 price;
      uint256 quantity;
  }

  /**
   * @dev This emits when a new address is set.
   */
  event SetAddress(string _addressType, address _newAddress);

  modifier onlyStore(){
      require(msg.sender == arianeeStoreAddress, 'not called by store');
      _;
  }

  /**
   * @dev public function that change the store contract address.
   * @notice Can only be called by the contract owner.
   */
  function setArianeeStoreAddress(address _newArianeeStoreAdress) onlyOwner() external {
      arianeeStoreAddress = _newArianeeStoreAdress;
      emit SetAddress("arianeeStore", _newArianeeStoreAdress);
  }

  /**
   * @dev public funciton that add a credit history when credit are bought.
   * @notice can only be called by the store.
   * @param _spender address of the buyer
   * @param _price current price of the credit.
   * @param _quantity of credit buyed.
   * @param _type of credit buyed.
   */
  function addCreditHistory(address _spender, uint256 _price, uint256 _quantity, uint256 _type) external onlyStore() {

      CreditBuy memory _creditBuy = CreditBuy({
          price: _price,
          quantity: _quantity
          });

      creditHistory[_spender][_type].push(_creditBuy);
      totalCredits[_spender][_type] = SafeMath.add(totalCredits[_spender][_type], _quantity);
  }

  /**
   * @dev Public function that consume a given quantity of credit and return the price of the oldest non spent credit.
   * @notice Can only be called by the store.
   * @param _spender address of the buyer.
   * @param _type type of credit.
   * @return price of the credit.
   */
  function consumeCredits(address _spender, uint256 _type, uint256 _quantity) external onlyStore() returns (uint256) {
      require(totalCredits[_spender][_type]>0, "No credit of that type");
      uint256 _index = historyIndex[_spender][_type];
      require(creditHistory[_spender][_type][_index].quantity >= _quantity);

      uint256 price = creditHistory[_spender][_type][_index].price;
      creditHistory[_spender][_type][_index].quantity = SafeMath.sub(creditHistory[_spender][_type][_index].quantity, _quantity);
      totalCredits[_spender][_type] = SafeMath.sub(totalCredits[_spender][_type], 1);

      if(creditHistory[_spender][_type][_index].quantity == 0){
          historyIndex[_spender][_type] = SafeMath.add(historyIndex[_spender][_type], 1);
      }

      return price;
  }

  /**
   * @notice Give a specific credit history for a given spender, and type.
   * @param _spender for which we want the credit history.
   * @param _type of the credit for which we want the history.
   * @param _index of the credit for which we want the history.
   * @return Credit history.
   */
  function userCreditHistory(address _spender, uint256 _type, uint256 _index) external view returns (uint256 _price, uint256 _quantity) {
      _price = creditHistory[_spender][_type][_index].price;
      _quantity = creditHistory[_spender][_type][_index].quantity;
  }

  /**
   * @notice Get the actual index for a spender and a credit type.
   * @param _spender for which we want the credit history.
   * @param _type of the credit for which we want the history.
   * @return Current index.
   */
  function userIndex(address _spender, uint256 _type) external view returns(uint256 _historyIndex){
      _historyIndex = historyIndex[_spender][_type];
  }

  /**
   * @notice Give the total balance of credit for a spender.
   * @param _spender for which we want the credit history.
   * @param _type of the credit for which we want the history.
   * @return Balance of the spender.
   */
  function balanceOf(address _spender, uint256 _type) external view returns(uint256 _totalCredits){
      _totalCredits = totalCredits[_spender][_type];
  }

}