Proof Of Attendance Verified

This hash is used for the delegation of signatures from one wallet to another. It is used to prevent the POAV owner from having to pay for gas, delegating that responsibility to another wallet. There are 2 domains that allow to generate the EIP712 Hash:

• EIP712DOMAIN_TYPEHASH.
• VERIFIABLE_CREDENTIAL_TYPEHASH.

You can find in the documentation the way of calculation; however, to facilitate the calculation process, the following APIs have been created that allow: Calculate it and verify the signature.

Rules

• The EIP712Domain is linked to the contract and the blockchain network used, preventing the operator from sending it to an improper network.

Contract (EIP712)

contract EIP712  {
  using ECDSA for bytes32;
  bytes32 DOMAIN_SEPARATOR;
  bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
  bytes32 constant internal VERIFIABLE_CREDENTIAL_TYPEHASH = keccak256("VerifiableCredential(address issuer,address subject,bytes32 POAV,uint256 validFrom,uint256 validTo)");
  struct EIP712Domain {string name;string version;uint256 chainId;address verifyingContract;}
  constructor()  {
        DOMAIN_SEPARATOR = hashEIP712Domain(
            EIP712Domain({
                name : "EIP712Domain",
                version : "1",
                chainId : 100,
                verifyingContract : address(this)
                }));
  }
  function hashEIP712Domain(EIP712Domain memory eip712Domain) internal pure returns (bytes32) {
        return keccak256(abi.encode(EIP712DOMAIN_TYPEHASH,keccak256(bytes(eip712Domain.name)),keccak256(bytes(eip712Domain.version)),eip712Domain.chainId,eip712Domain.verifyingContract));
    }

    function hashVerifiableCredential(address _issuer,address _subject,string memory POAVURI,uint256 _validFrom,uint256 _validTo) internal pure returns (bytes32) {//0xAABBCC11223344....556677
        return keccak256(abi.encode(VERIFIABLE_CREDENTIAL_TYPEHASH,_issuer,_subject,POAVURI,_validFrom,_validTo));
    }

    function _hashForSigned(string memory _credentialSubject, address _issuer, address _subject, uint validFrom, uint validTo) internal view returns (bytes32) {
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                DOMAIN_SEPARATOR,
                hashVerifiableCredential(_issuer, _subject, _credentialSubject, validFrom, validTo)
            )
        );
        return (digest);
    }
    
    function _validateSignature(string memory _credentialSubject, address _issuer, address _subject, uint validFrom, uint validTo,bytes32  _credentialHash, bytes memory _signature ) internal view 
        returns (address issuer, bytes32 hashSha256, bytes32 hashKeccak256) {
        return (_credentialHash.recover(_signature), _hashForSigned(_credentialSubject, _issuer, _subject, validFrom, validTo), 
        keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _hashForSigned(_credentialSubject, _issuer, _subject, validFrom, validTo))));
    }
}

The reputation of each member of a DAO is earned by participating in the events or social activities that are promoted by the DAO. When an attendee earns a POAV, she receives a number of tokens called FUNToken.

The operators of each DAO when they create a POAV, assign it the amount of reputation that each attendee of the event will earn.

Rules

• Reputation is not transferable.
• Assigned when a POAV is received.
• A POAV can assign reputation to attendees when they are created by a DAO.

Contract (EIP712)

contract FANToken {
  //DAO, address ==> Balance
  mapping(string => mapping(address => uint256)) internal _balanceFANOf;
  //POAV ==> claims
  mapping(string => uint256) internal _claimFANToken;

  function balanceFANOf (string memory DAOURI, address subject) external view returns(uint256) {
    return (_balanceFANOf[DAOURI][subject]);
  }

  function claimFANTokenOf (string memory POAVURI) external view returns(uint256) {
    return (_claimFANToken[POAVURI]);
  }
  
  function mintFromDAO(string memory DAOURI, string memory POAVURI, uint256 _FanToken);
  
  function _claim(string memory POAVURI, address _subject) private returns (uint256) {
         ...
        _balanceFANOf [DAOOf[POAVURI]][_subject] = _claimFANToken[POAVURI];
        ...
    }
}

In the case of minting a POAV within a DAO, the wallet is required to have the role of operator. This role is assigned by the creator of the DAO, which can be revoked at any time.

Consider that a DAO can escrow that wallet in a new contract that authorizes those approvals or revocations based on community votes.

In the case of minting a POAV without associating it to a DAO, it can be created by any wallet, no authorization is required.

Rules

• The POAV must be unique.
• The creator of the POAV must accredit the attendance of the participants.
• The creator of the POAV can change the status (Revoke it, delete it or reinstate it).
• The creator of the POAV can burn or closed it and from that moment on, new attendance accreditations can no longer be issued to the participants.

Contract (POAVToken)

contract POAVToken {
    ...
    function mintFromDAO(string memory DAOURI, string memory POAVURI, uint256 _FanToken) public returns (bool) {
       _validateDAO(DAOURI, POAVURI, msg.sender);
       _mintPOAV( DAOURI, POAVURI, msg.sender, block.timestamp, _FanToken);
        return true;
    }
    function mint(string memory POAVURI) public returns (bool) {
       _mintPOAV( "",POAVURI, msg.sender, block.timestamp, 0);
        return true;
    }
    function changeStatus(string memory POAVURI, address _subject, Status _status) public returns (bool) {
        require(issuersOfPOAV[POAVURI]==msg.sender, "Does not have access");
        require(statusOfPOAVSubject[POAVURI][_subject] != _status, "There is no change of state");
        statusOfPOAVSubject[POAVURI][_subject] = _status;
        emit POAVStatusChanged(POAVURI, _subject, _status);
        return true;
    }
    function burn(string memory POAVURI) public returns (bool) {
        require(issuersOfPOAV[POAVURI]==msg.sender, "Does not have access");
        delete issuersOfPOAV[POAVURI];
        delete validFromOfPOAV[POAVURI] ;
        return true;
    }
    function close(string memory POAVURI) public returns (bool) {
        require(issuersOfPOAV[POAVURI]==msg.sender, "Does not have access");
        issuersOfPOAV[POAVURI] = address(0);
        return true;
    }
    ...
}