separation of delegates and challenges

src/contracts/alternative setup/Challenge.sol

@@ -0,0 +1,8 @@
+contract Challenge{
+
+    event error();
+    event success();
+
+    function authorize(uint8 v, bytes32 r, bytes32 s, address party, address grant){}
+
+}

src/contracts/alternative setup/Grant.sol

@@ -0,0 +1,28 @@
+contract Grant {
+
+    address client;
+    address owner;
+
+    function Grant(address _client) {
+        client = _client;
+    }
+
+    /*
+     * authorize the grant contract
+     * this can only be done once
+     */
+    function authorize() {
+        if(msg.sender != owner) throw;
+        owner = msg.sender;
+    }
+
+    /*
+     * revoke the grant contract
+     * this can be done by the client or owner
+     */
+    function revoke() {
+        if(msg.sender != client &&  msg.sender != owner) throw;
+        suicide(msg.sender);
+    }
+
+}

src/contracts/alternative setup/Party.sol

@@ -0,0 +1,67 @@
+contract Party {
+
+    mapping (address => uint) delegates;
+
+    mapping(address=>bool) challenges;
+    mapping(address=>bool) usedChallenges;
+
+    modifier isTrusted(uint a){
+        if(delegates[msg.sender] < a){
+            return;
+        }
+    }
+
+    modifier isNewChallenge(){
+        if(!challenges[msg.sender]){throw;}
+        if(usedChallenges[msg.sender]){throw;}
+    }
+    /*
+     * constructor set sender as first delegate
+     */
+    function Party () {
+        delegates[msg.sender] = 2;
+        //TODO add challenges
+    }
+
+    /*
+     * authorize contract of type grant
+     */
+    function authorize (address grant) isTrusted(2) {
+
+        Grant(grant).authorize();
+    }
+
+    /*
+     * enroll new address as delegate to the contract
+     */
+    function enroll (address delegate) isTrusted(2){
+
+        delegates[delegate] = 1;
+    }
+
+    /*
+     * increase trustlevel
+     */
+     function increaseTrust(address delegate) isNewChallenge{
+         delegates[delegate] += 1;
+         usedChallenges[msg.sender] = true;
+     }
+
+     /*
+      * add challenge
+      */
+      function addChallenge(address challenge) isTrusted(4){
+          challenges[challenge]= true;
+          //TODO challenges must be invoked from here.
+      }
+
+    /*
+     * abandon a delegate from the contract
+     */
+    function abandon (address delegate) isTrusted(2) {
+
+        if(delegates[delegate] == 0) throw;
+        delete delegates[delegate];
+    }
+
+}

src/contracts/alternative setup/PasswordChallenge.sol

@@ -0,0 +1,36 @@
+contract PasswordChallenge is Challenge{
+
+    bytes32 private salt;
+    bytes32 private challenge;
+    bytes20 private response;
+
+    function PasswordChallenge(bytes20 _response, bytes32 _salt){
+        response = _response;
+        salt = _salt;
+        challenge = sha3(_salt);
+    }
+
+    function getSalt() constant returns(bytes32){
+        return salt;
+    }
+
+    function getChallenge() constant returns(bytes32){
+        return challenge;
+    }
+
+    function getResponse() constant returns(bytes20){
+        return response;
+    }
+
+    function increaseTrust(uint8 v, bytes32 r, bytes32 s, address party, address grant) {
+        if(!verify(v, r, s)) return error();
+        Party(party).increaseTrust(msg.sender);
+        return success();
+    }
+
+    function verify(uint8 v, bytes32 r, bytes32 s) returns (bool) {
+        var result =  (bytes20(ecrecover(challenge, v, r, s)) == response);
+        challenge = sha3(challenge);
+        return result;
+    }
+}