| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| originalContracts/ | +80.33% | +98/122 | +71.74% | +33/46 | +74.51% | +38/51 | +84.21% | +96/114 | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 | + + + + + + + + + + + + + +4× +4× +4× +4× +4× + +4× +4× + + + | pragma solidity ^0.4.4;
+import "./RecoveryQuorum.sol";
+
+contract IdentityFactory {
+ event IdentityCreated(
+ address indexed userKey,
+ address proxy,
+ address controller,
+ address recoveryQuorum);
+
+ mapping(address => address) public senderToProxy;
+
+ //cost ~2.4M gas
+ function CreateProxyWithControllerAndRecovery(address userKey, address[] delegates, uint longTimeLock, uint shortTimeLock) {
+ Proxy proxy = new Proxy();
+ RecoverableController controller = new RecoverableController(proxy, userKey, longTimeLock, shortTimeLock);
+ proxy.transfer(controller);
+ RecoveryQuorum recoveryQuorum = new RecoveryQuorum(controller, delegates);
+ controller.changeRecoveryFromRecovery(recoveryQuorum);
+
+ IdentityCreated(userKey, proxy, controller, recoveryQuorum);
+ senderToProxy[msg.sender] = proxy;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 | + + + + + + + + + + + + + +1× +1× +1× +1× + +1× +1× + + + | pragma solidity ^0.4.4;
+import "./RecoverableController.sol";
+
+contract IdentityFactoryWithRecoveryKey {
+ event IdentityCreated(
+ address indexed userKey,
+ address proxy,
+ address controller,
+ address recoveryKey);
+
+ mapping(address => address) public senderToProxy;
+
+ //cost ~2.4M gas
+ function CreateProxyWithControllerAndRecoveryKey(address userKey, address _recoveryKey, uint longTimeLock, uint shortTimeLock) {
+ Proxy proxy = new Proxy();
+ RecoverableController controller = new RecoverableController(proxy, userKey, longTimeLock, shortTimeLock);
+ proxy.transfer(controller);
+ controller.changeRecoveryFromRecovery(_recoveryKey);
+
+ IdentityCreated(userKey, proxy, controller, _recoveryKey);
+ senderToProxy[msg.sender] = proxy;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 | + + + + + + + + +10× +10× +10× +10× + + + | pragma solidity ^0.4.4;
+library Lib1{
+ function findAddress(address a, address[] storage arry) returns (int){
+ for (uint i = 0 ; i < arry.length ; i++){
+ if(arry[i] == a){return int(i);}
+ }
+ return -1;
+ }
+ function removeAddress(uint i, address[] storage arry){
+ uint lengthMinusOne = arry.length - 1;
+ arry[i] = arry[lengthMinusOne];
+ delete arry[lengthMinusOne];
+ arry.length = lengthMinusOne;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 | + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + | pragma solidity ^0.4.4;
+import "./Proxy.sol";
+contract MetaTxController {
+
+ Proxy public proxy;
+ address public userKey;
+ address public adminKey;
+ uint public referenceNonce;
+
+ modifier only(address key) { if (msg.sender == key) _;}
+
+ function MetaTxController(address proxyAddress, address _userKey, address _adminKey) {
+ proxy = Proxy(proxyAddress);
+ userKey = _userKey;
+ adminKey = _adminKey;
+ referenceNonce = 0;
+ }
+
+ function sendTx(address destination, uint value, bytes data, uint nonce, uint8 v, bytes32 r, bytes32 s) {
+
+ var h = sha3(destination, bytes32(value), bytes32(nonce), data);
+ var addressFromSig = ecrecover(h,v,r,s);
+
+ if (nonce == referenceNonce && addressFromSig == userKey) {
+ proxy.forward(destination, value, data);
+ referenceNonce += 1;
+ }
+ }
+
+ function updateUserKey(address newUserKey) only(adminKey) {
+ userKey = newUserKey;
+ }
+
+ function updateAdminKey(address newAdminKey) only(adminKey) {
+ adminKey = newAdminKey;
+ }
+
+ function transferOwnership(address newOwner) only(adminKey) {
+ // This will end the functionality of the Ownership contract
+ // since it's no longer allowed to forward transactions
+ // to the proxy
+ proxy.transfer(newOwner);
+ suicide(newOwner);
+ }
+
+}
+
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 | + + + + + + + + + + + + + + + + + | // A base Owned contract
+pragma solidity ^0.4.4;
+contract Owned {
+ address public owner;
+ modifier onlyOwner(){ if (isOwner(msg.sender)) _; }
+ modifier ifOwner(address sender) { if(isOwner(sender)) _; }
+
+ function Owned(){
+ owner = msg.sender;
+ }
+
+ function isOwner(address addr) public returns(bool) { return addr == owner; }
+
+ function transfer(address _owner) onlyOwner {
+ owner = _owner;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 | + + + + + + + + + + + + + + + + +2× + + + + + + + +7× +1× + +6× + + + + + + + +10× + + + + + +12× + + + | // The core proxy facade
+// - is owned by a user or implementation contract
+// - only forwards transactions for its owner
+pragma solidity ^0.4.4;
+
+contract Proxy {
+ event Forwarded (
+ address indexed destination,
+ uint value,
+ bytes data
+ );
+ event Received (
+ address indexed sender,
+ uint value
+ );
+
+ function () payable {
+ Received(msg.sender, msg.value);
+ }
+
+ function forward(address destination, uint value, bytes data) onlyOwner {
+ // If a contract tries to CALL or CREATE a contract with either
+ // (i) insufficient balance, or (ii) stack depth already at maximum (1024),
+ // the sub-execution and transfer do not occur at all, no gas gets consumed, and 0 is added to the stack.
+ // see: https://github.com/ethereum/wiki/wiki/Subtleties#exceptional-conditions
+ if (!destination.call.value(value)(data)) {
+ throw;
+ }
+ Forwarded(destination, value, data);
+ }
+
+ address public owner;
+ modifier onlyOwner(){ if (isOwner(msg.sender)) _; }
+ modifier ifOwner(address sender) { if(isOwner(sender)) _; }
+
+ function Proxy(){
+ owner = msg.sender;
+ }
+
+ function isOwner(address addr) public returns(bool) { return addr == owner; }
+
+ function transfer(address _owner) onlyOwner {
+ owner = _owner;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 | + + + + + + + + + + + + + + + + + + + + + + + + + + +12× +12× +12× +12× +12× +12× + + + +4× + + + +1× +1× +1× + + +2× +1× +1× + + + + +1× +1× +1× + + +2× +1× +1× + + + + +1× +1× +1× + + +2× +1× +1× +1× + + + + + +7× +7× + + + + | pragma solidity ^0.4.4;
+import "./Proxy.sol";
+
+contract RecoverableController {
+ uint public version;
+ Proxy public proxy;
+
+ address public userKey;
+ address public proposedUserKey;
+ uint public proposedUserKeyPendingUntil;
+
+ address public recoveryKey;
+ address public proposedRecoveryKey;
+ uint public proposedRecoveryKeyPendingUntil;
+
+ address public proposedController;
+ uint public proposedControllerPendingUntil;
+
+ uint public shortTimeLock;// use 900 for 15 minutes
+ uint public longTimeLock; // use 259200 for 3 days
+
+ event RecoveryEvent(string action, address initiatedBy);
+
+ modifier onlyUserKey() { if (msg.sender == userKey) _; }
+ modifier onlyRecoveryKey() { if (msg.sender == recoveryKey) _; }
+
+ function RecoverableController(address proxyAddress, address _userKey, uint _longTimeLock, uint _shortTimeLock) {
+ version = 1;
+ proxy = Proxy(proxyAddress);
+ userKey = _userKey;
+ shortTimeLock = _shortTimeLock;
+ longTimeLock = _longTimeLock;
+ recoveryKey = msg.sender;
+ }
+
+ function forward(address destination, uint value, bytes data) onlyUserKey {
+ proxy.forward(destination, value, data);
+ }
+ //pass 0x0 to cancel
+ function signRecoveryChange(address _proposedRecoveryKey) onlyUserKey{
+ proposedRecoveryKeyPendingUntil = now + longTimeLock;
+ proposedRecoveryKey = _proposedRecoveryKey;
+ RecoveryEvent("signRecoveryChange", msg.sender);
+ }
+ function changeRecovery() {
+ if(proposedRecoveryKeyPendingUntil < now && proposedRecoveryKey != 0x0){
+ recoveryKey = proposedRecoveryKey;
+ delete proposedRecoveryKey;
+ }
+ }
+ //pass 0x0 to cancel
+ function signControllerChange(address _proposedController) onlyUserKey{
+ proposedControllerPendingUntil = now + longTimeLock;
+ proposedController = _proposedController;
+ RecoveryEvent("signControllerChange", msg.sender);
+ }
+ function changeController() {
+ if(proposedControllerPendingUntil < now && proposedController != 0x0){
+ proxy.transfer(proposedController);
+ suicide(proposedController);
+ }
+ }
+ //pass 0x0 to cancel
+ function signUserKeyChange(address _proposedUserKey) onlyUserKey{
+ proposedUserKeyPendingUntil = now + shortTimeLock;
+ proposedUserKey = _proposedUserKey;
+ RecoveryEvent("signUserKeyChange", msg.sender);
+ }
+ function changeUserKey(){
+ if(proposedUserKeyPendingUntil < now && proposedUserKey != 0x0){
+ userKey = proposedUserKey;
+ delete proposedUserKey;
+ RecoveryEvent("changeUserKey", msg.sender);
+ }
+ }
+
+ function changeRecoveryFromRecovery(address _recoveryKey) onlyRecoveryKey{ recoveryKey = _recoveryKey; }
+ function changeUserKeyFromRecovery(address _userKey) onlyRecoveryKey{
+ delete proposedUserKey;
+ userKey = _userKey;
+ }
+}
+
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 | + + + + + + + + + + + + + + + + + + + +10× +10× +40× +40× + + + +50× +48× +48× +48× + + + +52× +6× +6× + +45× +14× + +45× + + + + + +16× +11× + +16× +16× +45× + +16× + + +71× +638× +82× + + + + + + + + +52× +554× + +52× + + +45× +39× +39× + + + +11× + +11× +4× + +7× + + + + + +16× +16× +66× +10× +10× +10× +10× + + + + +1287× + + + + + +1192× + + +638× + + + | pragma solidity ^0.4.4;
+import "./RecoverableController.sol";
+import "./Lib1.sol";
+
+contract RecoveryQuorum {
+ RecoverableController public controller;
+
+ address[] public delegateAddresses; // needed for iteration of mapping
+ mapping (address => Delegate) public delegates;
+ struct Delegate{
+ uint deletedAfter; // delegate exists if not 0
+ uint pendingUntil;
+ address proposedUserKey;
+ }
+
+ event RecoveryEvent(string action, address initiatedBy);
+
+ modifier onlyUserKey(){ if (msg.sender == controller.userKey()) _; }
+
+ function RecoveryQuorum(address _controller, address[] _delegates){
+ controller = RecoverableController(_controller);
+ for(uint i = 0; i < _delegates.length; i++){
+ delegateAddresses.push(_delegates[i]);
+ delegates[_delegates[i]] = Delegate({proposedUserKey: 0x0, pendingUntil: 0, deletedAfter: 31536000000000});
+ }
+ }
+ function signUserChange(address proposedUserKey) {
+ if(delegateRecordExists(delegates[msg.sender])) {
+ delegates[msg.sender].proposedUserKey = proposedUserKey;
+ changeUserKey(proposedUserKey);
+ RecoveryEvent("signUserChange", msg.sender);
+ }
+ }
+ function changeUserKey(address newUserKey) {
+ if(collectedSignatures(newUserKey) >= neededSignatures()){
+ controller.changeUserKeyFromRecovery(newUserKey);
+ for(uint i = 0 ; i < delegateAddresses.length ; i++){
+ //remove any pending delegates after a recovery
+ if(delegates[delegateAddresses[i]].pendingUntil > now){
+ delegates[delegateAddresses[i]].deletedAfter = now;
+ }
+ delete delegates[delegateAddresses[i]].proposedUserKey;
+ }
+ }
+ }
+
+ function replaceDelegates(address[] delegatesToRemove, address[] delegatesToAdd) onlyUserKey{
+ for(uint i = 0 ; i < delegatesToRemove.length ; i++){
+ removeDelegate(delegatesToRemove[i]);
+ }
+ garbageCollect();
+ for(uint j = 0 ; j < delegatesToAdd.length ; j++){
+ addDelegate(delegatesToAdd[j]);
+ }
+ RecoveryEvent("replaceDelegates", msg.sender);
+ }
+ function collectedSignatures(address _proposedUserKey) returns (uint signatures){
+ for(uint i = 0 ; i < delegateAddresses.length ; i++){
+ if (delegateHasValidSignature(delegates[delegateAddresses[i]]) && delegates[delegateAddresses[i]].proposedUserKey == _proposedUserKey){
+ signatures++;
+ }
+ }
+ }
+
+ function getAddresses() constant returns (address[]){ return delegateAddresses; }
+
+ function neededSignatures() returns (uint){
+ uint currentDelegateCount; //always 0 at this point
+ for(uint i = 0 ; i < delegateAddresses.length ; i++){
+ if(delegateIsCurrent(delegates[delegateAddresses[i]])){ currentDelegateCount++; }
+ }
+ return currentDelegateCount/2 + 1;
+ }
+ function addDelegate(address delegate) private {
+ if(!delegateRecordExists(delegates[delegate]) && delegateAddresses.length < 15) {
+ delegates[delegate] = Delegate({proposedUserKey: 0x0, pendingUntil: now + controller.longTimeLock(), deletedAfter: 31536000000000});
+ delegateAddresses.push(delegate);
+ }
+ }
+ function removeDelegate(address delegate) private {
+ Eif(delegates[delegate].deletedAfter > controller.longTimeLock() + now){
+ //remove right away if they are still pending
+ if(delegates[delegate].pendingUntil > now){
+ delegates[delegate].deletedAfter = now;
+ } else{
+ delegates[delegate].deletedAfter = controller.longTimeLock() + now;
+ }
+ }
+ }
+
+ function garbageCollect() private{
+ uint i = 0;
+ while(i < delegateAddresses.length){
+ if(delegateIsDeleted(delegates[delegateAddresses[i]])){
+ delegates[delegateAddresses[i]].deletedAfter = 0;
+ delegates[delegateAddresses[i]].pendingUntil = 0;
+ delegates[delegateAddresses[i]].proposedUserKey = 0;
+ Lib1.removeAddress(i, delegateAddresses);
+ }else{i++;}
+ }
+ }
+ function delegateRecordExists(Delegate d) private returns (bool){
+ return d.deletedAfter != 0;
+ }
+ function delegateIsDeleted(Delegate d) private returns (bool){
+ return d.deletedAfter <= now; //doesnt check record existence
+ }
+ function delegateIsCurrent(Delegate d) private returns (bool){
+ return delegateRecordExists(d) && !delegateIsDeleted(d) && now > d.pendingUntil;
+ }
+ function delegateHasValidSignature(Delegate d) private returns (bool){
+ return delegateIsCurrent(d) && d.proposedUserKey != 0x0;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 | + + + + + +6× + + + +1× + + + + | pragma solidity ^0.4.4;
+contract TestRegistry {
+
+ mapping(address => uint) public registry;
+
+ function register(uint x) {
+ registry[msg.sender] = x;
+ }
+
+ function testThrow() {
+ throw;
+ }
+
+}
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| IdentityFactory.sol | +100% | +7/7 | +100% | +0/0 | +100% | +1/1 | +100% | +7/7 | +|
| IdentityFactoryWithRecoveryKey.sol | +100% | +6/6 | +100% | +0/0 | +100% | +1/1 | +100% | +6/6 | +|
| Lib1.sol | +42.86% | +3/7 | +0% | +0/2 | +50% | +1/2 | +57.14% | +4/7 | +|
| MetaTxController.sol | +0% | +0/14 | +0% | +0/4 | +0% | +0/6 | +0% | +0/13 | +|
| Owned.sol | +0% | +0/5 | +0% | +0/4 | +0% | +0/5 | +0% | +0/2 | +|
| Proxy.sol | +88.89% | +8/9 | +66.67% | +4/6 | +85.71% | +6/7 | +100% | +6/6 | +|
| RecoverableController.sol | +100% | +28/28 | +100% | +10/10 | +100% | +12/12 | +100% | +28/28 | +|
| RecoveryQuorum.sol | +100% | +44/44 | +95% | +19/20 | +100% | +15/15 | +100% | +43/43 | +|
| TestRegistry.sol | +100% | +2/2 | +100% | +0/0 | +100% | +2/2 | +100% | +2/2 | +