Merge pull request #305 from windingtree/add-LifChannels

Add Lif Channels

Author: AugustoL

contracts/LifChannels.sol

@@ -0,0 +1,302 @@
+pragma solidity ^0.4.18;
+
+import "zeppelin-solidity/contracts/token/ERC20.sol";
+import "zeppelin-solidity/contracts/math/SafeMath.sol";
+import "zeppelin-solidity/contracts/ECRecovery.sol";
+
+/**
+   @title LifChannels, State channels for ERC20 Lif Token
+
+   Contract that provides holders of a ERC20 compatible token the creation of
+   channels between two users, once a channel is open the users can exchange
+   signatures offchain to agree on the final value of the transfer.
+   Uses OpenZeppelin ERC20 and SafeMath lib.
+ */
+contract LifChannels {
+  using SafeMath for uint256;
+
+  // Add recover method for bytes32 using ECRecovery lib from OpenZeppelin
+  using ECRecovery for bytes32;
+
+  // The ERC20 token to be used
+  ERC20 public token;
+
+  // The amount of time that a receiver has to challenge the sender
+  uint256 public challengeTime;
+
+  // The channels opened
+  mapping (bytes32 => Channel) public channels;
+  struct Channel {
+    uint256 deposit;
+    uint8 nonce;
+  }
+
+  // The requests from sender to close a channel
+  mapping (bytes32 => ClosingRequest) public closingRequests;
+  struct ClosingRequest {
+    uint256 closingBalance;
+    uint256 closeTime;
+  }
+
+  /*
+   *  Events
+   */
+
+  event ChannelCreated(
+    address indexed sender,
+    address indexed receiver,
+    uint8 indexed nonce,
+    uint256 deposit
+  );
+  event ChannelCloseRequested(
+    address indexed sender,
+    address indexed receiver,
+    uint8 indexed nonce,
+    uint256 balance
+  );
+  event ChannelClosed(
+    address indexed sender,
+    address indexed receiver,
+    uint8 indexed nonce,
+    uint256 balance
+  );
+
+  /**
+   * @dev Constructor
+   * @param tokenAddress address, the address of the ERC20 token that will be used
+   * @param _challengeTime uint256, the time that a channel has before ends
+      with and uncoopertive close
+   */
+  function LifChannels(
+    address tokenAddress,
+    uint256 _challengeTime
+  ) public {
+    require(tokenAddress != address(0));
+    require(_challengeTime >= 0);
+
+    token = ERC20(tokenAddress);
+    challengeTime = _challengeTime;
+  }
+
+  /**
+   * @dev Creates a channel between the msg.sender and the receiver
+   * @param receiver address, the receiver of the channel
+   * @param deposit uint256, the balance taht I want to load in the channel
+   * @param nonce uint8, the nonce number of the channel
+   */
+  function openChannel(
+    address receiver,
+    uint256 deposit,
+    uint8 nonce
+  ) external {
+
+    require(nonce > 0);
+    require(receiver != address(0));
+    require(deposit > 0);
+
+    // Create unique identifier from sender, receiver and current block timestamp
+    bytes32 channelId = getChannelId(msg.sender, receiver, nonce);
+
+    // Check taht teh channel not exist
+    require(channels[channelId].deposit == 0);
+    require(channels[channelId].nonce == 0);
+    require(closingRequests[channelId].closeTime == 0);
+
+    // Store channel information
+    channels[channelId] = Channel({deposit: deposit, nonce: nonce});
+    ChannelCreated(msg.sender, receiver, nonce, deposit);
+
+    // transferFrom deposit from sender to contract
+    // ! needs prior approval from user
+    require(token.transferFrom(msg.sender, address(this), deposit));
+  }
+
+  /**
+   * @dev Starts a close channel request form the sender
+   * @param receiver address, the receiver of the channel
+   * @param nonce uint8, the nonce number of the channel
+   * @param balance uint256, the final balance of teh receiver
+   */
+  function uncooperativeClose(
+    address receiver,
+    uint8 nonce,
+    uint256 balance
+  ) external {
+    bytes32 channelId = getChannelId(msg.sender, receiver, nonce);
+
+    // Check that the closing request dont exist
+    require(closingRequests[channelId].closeTime == 0);
+
+    // Check that the balance is less that the deposited
+    require(balance <= channels[channelId].deposit);
+
+    // Mark channel as closed and create closing request
+    closingRequests[channelId].closeTime = block.timestamp.add(challengeTime);
+    require(closingRequests[channelId].closeTime > block.timestamp);
+    closingRequests[channelId].closingBalance = balance;
+    ChannelCloseRequested(msg.sender, receiver, nonce, balance);
+  }
+
+  /**
+   * @dev Close a channel with the agreement of the sender and receiver
+   * @param receiver address, the receiver of the channel
+   * @param nonce uint8, the nonce number of the channel
+   * @param balanceMsgSig bytes, the signature of the sender
+   * @param closingSig bytes, the signature of the receiver
+   */
+  function cooperativeClose(
+    address receiver,
+    uint8 nonce,
+    uint256 balance,
+    bytes balanceMsgSig,
+    bytes closingSig
+  ) external {
+    // Derive receiver address from signature
+    bytes32 msgHash = keccak256(balanceMsgSig);
+    require(receiver == msgHash.recover(closingSig));
+
+    // Derive sender address from signed balance proof
+    address sender = getSignerOfBalanceHash(receiver, nonce, balance, balanceMsgSig);
+
+    close(sender, receiver, nonce, balance);
+  }
+
+  /**
+   * @dev Close a channel with an existing closing request
+   * @param receiver address, the receiver of the channel
+   * @param nonce uint8, the nonce number of the channel
+   */
+  function closeChannel(address receiver, uint8 nonce) external {
+    bytes32 channelId = getChannelId(msg.sender, receiver, nonce);
+
+    // Check that the closing request was created
+    require(closingRequests[channelId].closeTime > 0);
+
+    // Make sure the challengeTime has ended
+    require(block.timestamp > closingRequests[channelId].closeTime);
+
+    close(msg.sender, receiver, nonce,
+      closingRequests[channelId].closingBalance
+    );
+  }
+
+  /**
+   * @dev Get the channel info
+   * @param sender address, the sender of the channel
+   * @param receiver address, the receiver of the channel
+   * @param nonce uint8, the nonce number of the channel
+   */
+  function getChannelInfo(
+    address sender,
+    address receiver,
+    uint8 nonce
+  ) external view returns (bytes32, uint256, uint256, uint256) {
+    bytes32 channelId = getChannelId(sender, receiver, nonce);
+    require(channels[channelId].nonce > 0);
+
+    return (
+      channelId,
+      channels[channelId].deposit,
+      closingRequests[channelId].closeTime,
+      closingRequests[channelId].closingBalance
+    );
+  }
+
+  /*
+   *  Public functions
+   */
+
+  /**
+   * @dev Get the signer of a balance hash signed with a generated hash on chain
+   * @param receiver address, the receiver to hash
+   * @param nonce uint8, the nonce number of the channel
+   * @param balance uint256, the balance to hash
+   * @param msgSigned bytes, the balance hash signed
+   */
+  function getSignerOfBalanceHash(
+    address receiver,
+    uint8 nonce,
+    uint256 balance,
+    bytes msgSigned
+  ) public view returns (address) {
+    bytes32 msgHash = generateBalanceHash(receiver, nonce, balance);
+    // Derive address from signature
+    address signer = msgHash.recover(msgSigned);
+    return signer;
+  }
+
+  /**
+   * @dev Generate a hash balance for an address
+   * @param receiver address, the receiver to hash
+   * @param nonce uint8, the nonce number of the channel
+   * @param balance uint256, the balance to hash
+   */
+  function generateBalanceHash(
+    address receiver,
+    uint8 nonce,
+    uint256 balance
+  ) public view returns (bytes32) {
+    return keccak256(receiver, nonce, balance, address(this));
+  }
+
+  /**
+   * @dev Generate a keccak256 hash
+   * @param message bytes, the mesage to hash
+   */
+  function generateKeccak256(bytes message) public pure returns(bytes32) {
+    return keccak256(message);
+  }
+
+  /**
+   * @dev Generate a channel id
+   * @param sender address, the sender in the channel
+   * @param receiver address, the receiver in the channel
+   * @param nonce uint8, the nonce number of the channel
+   */
+  function getChannelId(
+    address sender,
+    address receiver,
+    uint8 nonce
+  ) public pure returns (bytes32 data) {
+    return keccak256(sender, receiver, nonce);
+  }
+
+  /*
+   *  Internal functions
+   */
+
+  /**
+   * @dev Close a channel
+   * @param sender address, the sender in the channel
+   * @param receiver address, the receiver in the channel
+   * @param nonce uint8, the nonce number of the channel
+   * @param receiverBalance uint256, the final balance of the receiver
+   */
+  function close(
+    address sender,
+    address receiver,
+    uint8 nonce,
+    uint256 receiverBalance
+  ) internal {
+    bytes32 channelId = getChannelId(sender, receiver, nonce);
+    Channel memory channel = channels[channelId];
+
+    require(channel.nonce > 0);
+    require(receiverBalance <= channel.deposit);
+
+    // Remove closed channel structures
+    // channel.nonce will become 0
+    // Change state before transfer call
+    delete channels[channelId];
+    delete closingRequests[channelId];
+
+    // Send balance to the receiver, as it is always <= deposit
+    require(token.transfer(receiver, receiverBalance));
+
+    // Send deposit - balance back to sender
+    require(token.transfer(sender, channel.deposit.sub(receiverBalance)));
+
+    ChannelClosed(sender, receiver, nonce, receiverBalance);
+  }
+
+}