InviteLink module for ERC-1077

Readme.md

Invite Scheme explained

1. Alice generates random transit key pair and signs transit public key with her device's private key
2. Alice sends transit private key and transit signature to Bob
3. Clicking the link, Bob is directed to a webpage
4. Bob generates his own private key stored in the browser and uses the transit private key to sign his new address
5. Bob’s browser sends his two signatures to the relayer
6. The Relayer calls Alice’s identity contract
7. Then Alice’s identity contract creates an identity contract for Bob (if Bob didn't have Identity contract before)
8. Tokens are transfered from Alice's contract to Bob's new contract
9. Bob now got the tokens, and in addition has a Universal Login Contract and ENS name. The private key generated in p.4 is attached to Bobs Identity Contract

Bonus: In addition, Bob can now also help Alice recover access to her identity contract in the future using a social key recovery mechanism

InviteLink.sol

//import "openzeppelin-solidity/contracts/ECRecovery.sol";

contract InviteLink {
    using ECRecovery for bytes32;
    IERC1077 owner;
    
    // Mappings of transit pub key => true if link is used.
    mapping (bytes => bool) usedLinks;

    constructor(IERC1077 _owner) {
        owner = owner;
    }


    function transferTokensByLink(
        address receiverAddress,
        bytes transitPubKey,
        address tokenAddress,
        uint tokenAmount,
        uint gasPrice,
        address gasToken,                            
        bytes sigSender,
        bytes sigReceiver) public returns (bool) {
        
        // check that link is valid
        require(isLinkValid(
            receiverAddress,
            transitPubKey,
            tokenAddress,
            tokenAmount,
            gasPrice,
            gasToken,                            
            sigSender,
            sigReceiver     
        ));
        
        // mark link as used, so that it can be used only once
        usedLinks[transitPubKey] = true;
        
        //  transfer tokens
        _transferTokens(tokenAddress, tokenAmount, receiverAddress);
        
        return true;
    }
    
    
    function isLinkValid(
        address receiverAddress,
        bytes transitPubKey,
        address tokenAddress,
        uint tokenAmount,
        uint gasPrice,
        address gasToken,
        bytes sigSender,
        bytes sigReceiver) public returns (bool) {
    
        // 1. check that transitPubKey and transfer params were signed by sender
        require(checkSenderSignature(
            receiverAddress,
            transitPubKey,
            tokenAddress,
            tokenAmount,  
            sigSender
        ));
        
        // 2. check that Receiver's address was signed by transit key 
        require(checkReceiverSignature(
            receiverAddress, 
            transitPubKey, 
            sigReceiver));
        
        // 3. check that link hasn't been used before
        require(hasBeenUsed(transitPubKey) == false);
        
        return true;
    }
    
    
    function hasBeenUsed(address transitPubKey) returns (bool) {
        return usedLinks[transitPubKey];
    }
    
    
    function checkReceiverSignature(
        address receiverAddress, 
        bytes transitPubKey, 
        bytes sigReceiver) returns (bool) {
        
        // hash signed by receiver using transit private key
        bytes32 hash = keccak256(
            abi.encodePacked(
            receiverAddress,
            transitPubKey
        ));
        return hash.toEthSignedMessageHash().recover(signature);
    }
    

    function checkSenderSignature(
        address receiverAddress,
        bytes transitPubKey,
        address tokenAddress,
        uint tokenAmount,  
        bytes sigSender) internal returns(bool) {
        
        // calculate hash signed by sender
        bytes32 messageHash = keccak256(
            abi.encodePacked(
                tokenAddress,
                tokenAmount,
                transitPubKey,
                gasPrice,
                gasToken
        ));
        
        // check that the hash was signed by sender
        return owner.canExecute(
            address(this), // to
            0, // value (we can set it always to 0)
            messageHash, // data
            0, // nonce, do we need to have one here? 
            gasPrice,
            gasToken,
            100000, // gasLimit, can be hardcoded as we have the same use case for these transactions - transfer by link
            4, // OperationType, should we introduce special operationType for this purpose?
            sigSender);
    }
    
    
    function _transferTokens(
        address receiverAddress, 
        address tokenAddress,
        uint tokenAmount) internal returns (bool) {
        
        bytes data = abi.encodePacked(
            0xa9059cbb000000000000000000000000, // transfer method hardcoded
            tokenAmount,  
            receiverAddress
        );
        
        // execute function send token
        return owner.moduleExecute(
            tokenAddress,
            0,
            data
        );
    }


    // links module never executes
    function canExecute(
        address to,
        uint256 value,
        bytes data,
        uint nonce,
        uint gasPrice,
        address gasToken,
        uint gasLimit,
        IERC1077.OperationType operationType,
        bytes signatures) public view returns (bool) {
            //Ignore
            return false;
        }
    }
}