upload workshop

Author: Rahat-ch

.gitignore

@@ -0,0 +1,11 @@
+node_modules
+.env
+coverage
+coverage.json
+typechain
+typechain-types
+
+#Hardhat files
+cache
+artifacts
+

README.md

@@ -0,0 +1,55 @@
+# Polygon ID SBT Age Credential
+
+This is a basic Hardhat project showcasing how to create a Soulbound Token using an Age Credential from Polygon ID!
+
+Tutorial: Video coming soon
+
+Presentation Slids: https://pitch.com/public/0e72b224-f3f4-465e-93c0-3ff03f1fdc86
+
+This tutorial uses [Hardhat](https://hardhat.org/) as a development environment and Polygon Mumbai testnet as the network.
+
+## Polygon ID Wallet setup
+
+1. Download the Polygon ID mobile app on the [Google Play](https://play.google.com/store/apps/details?id=com.polygonid.wallet) or [Apple app store](https://apps.apple.com/us/app/polygon-id/id1629870183)
+
+2. Open the app and set a pin for security
+
+3. Follow the [Issue a Polygon ID claim](https://polygontechnology.notion.site/Issue-yourself-a-KYC-Age-Credential-claim-a06a6fe048c34115a3d22d7d1ea315ea) doc to issue yourself a KYC Age Credential attesting your date of birth.
+
+
+## Instructions to compile and deploy the smart contract
+
+1. Create a .env file in the root of this repo. Copy in .env.sample to add keys
+    `touch .env`
+
+2. Install dependencies
+    `npm i`
+
+3. Compile smart contracts
+    `npx hardhat compile`
+
+4. Deploy smart contracts
+    `npx hardhat run --network mumbai scripts/deploy.js`
+ - results in x tx hash: 0xecf178144CceC09417412D66E2ecC8a2841eE228
+ - example contract creation: https://mumbai.polygonscan.com/address/0xecf178144ccec09417412d66e2ecc8a2841ee228
+
+5. Update the `ERC721VerifierAddress` variable in scripts/set-request.js with your deployed contract address
+
+6. Run set-request to send the zk request to the smart contract
+    `npx hardhat run --network mumbai scripts/set-request.js`
+    - Successful tx means the age query has been set up: https://mumbai.polygonscan.com/tx/0x2ddb2db7b3d35cf7cdf658209b257fd2a51c49df2249bf46ede8979eb8410ffb
+
+
+## Claim SBT from a frontend
+
+1. Design a proof request (see my example in qrValueProofRequestExample.json) and more info in the docs: [Query Based Requests](https://0xpolygonid.github.io/tutorials/wallet/proof-generation/types-of-auth-requests-and-proofs/#query-based-request)
+    - Update the `contract_address` field to your deployed contract address
+
+2. Create a frontend with a QR code to the proof request. [Codesandbox example](https://codesandbox.io/s/frontend-claim-an-erc20-zk-airdrop-on-polygon-mumbai-forked-vu49os?file=/index.js) A user should be able to scan the QR code from the Polygon ID app and trustlessly prove that they are old enough to mint an SBT 
+
+## More Resources
+
+Additional Tutorials from Steph and Manny:
+https://github.com/oceans404/tutorial-examples/tree/main/on-chain-verification
+https://github.com/codingwithmanny/polygonid-on-chain-verification
+

contracts/ERC721Verifier.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
+import "@openzeppelin/contracts/utils/Counters.sol";
+import "@openzeppelin/contracts/utils/Strings.sol";
+import "@openzeppelin/contracts/utils/Base64.sol";
+import "./lib/GenesisUtils.sol";
+import "./interfaces/ICircuitValidator.sol";
+import "./verifiers/ZKPVerifier.sol";
+
+contract ERC721Verifier is ERC721URIStorage, ZKPVerifier {
+
+    uint64 public constant TRANSFER_REQUEST_ID = 1;
+
+    mapping(uint256 => address) public idToAddress;
+    mapping(address => uint256) public addressToId;
+
+    using Strings for uint256;
+    using Counters for Counters.Counter;
+    Counters.Counter private _tokenIds;
+
+    constructor() ERC721 ("SocialAgeCheck", "SACK"){
+    }    
+
+    function _beforeProofSubmit(
+        uint64, /* requestId */
+        uint256[] memory inputs,
+        ICircuitValidator validator
+    ) internal view override {
+        // check that challenge input of the proof is equal to the msg.sender 
+        address addr = GenesisUtils.int256ToAddress(
+            inputs[validator.getChallengeInputIndex()]
+        );
+        require(
+            _msgSender() == addr,
+            "address in proof is not a sender address"
+        );
+    }
+
+    function _afterProofSubmit(
+        uint64 requestId,
+        uint256[] memory inputs,
+        ICircuitValidator validator
+    ) internal override {
+        require(
+            requestId == TRANSFER_REQUEST_ID && addressToId[_msgSender()] == 0,
+            "proof can not be submitted more than once"
+        );
+
+        uint256 id = inputs[validator.getChallengeInputIndex()];
+        // execute the token mint
+        if (idToAddress[id] == address(0)) {
+            _tokenIds.increment();
+            uint256 newItemId = _tokenIds.current();
+            _safeMint(msg.sender, newItemId);
+            _setTokenURI(newItemId, getTokenURI(newItemId));
+        }
+    }
+
+    function _beforeTokenTransfer(address from, address to, uint256) pure override internal {
+        require(from == address(0) || to == address(0), "Your age is your own not someone elses.");
+    }
+
+    function generateSVGforToken() public pure returns(string memory){
+        bytes memory svg = abi.encodePacked(
+            '<svg xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet" viewBox="0 0 350 350">',
+            '<style>.base { fill: white; font-family: serif; font-size: 14px; }</style>',
+            '<rect width="100%" height="100%" fill="black" />',
+            '<text x="50%" y="50%" class="base" dominant-baseline="middle" text-anchor="middle">',"Verifed 13 or older",'</text>',
+            '</svg>'
+        );
+        return string(
+            abi.encodePacked(
+                "data:image/svg+xml;base64,",
+                Base64.encode(svg)
+            ));
+    }
+
+    function getTokenURI(uint256 tokenId) public pure returns (string memory){
+        bytes memory dataURI = abi.encodePacked(
+            '{',
+                '"name": "Thirteen Check #', tokenId.toString(), '",',
+                '"description": "Verified credential of age over 13",',
+                '"image": "', generateSVGforToken(), '"',
+            '}'
+        );
+        return string(
+            abi.encodePacked(
+                "data:application/json;base64,",
+                Base64.encode(dataURI)
+            )
+        );
+    }
+
+    
+}

contracts/interfaces/ICircuitValidator.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ICircuitValidator {
+    struct CircuitQuery {
+        uint256 schema;
+        uint256 slotIndex;
+        uint256 operator;
+        uint256[] value;
+        string circuitId;
+    }
+
+    function verify(
+        uint256[] memory inputs,
+        uint256[2] memory a,
+        uint256[2][2] memory b,
+        uint256[2] memory c,
+        CircuitQuery memory query
+    ) external view returns (bool r);
+
+    function getCircuitId() external pure returns (string memory id);
+
+    function getChallengeInputIndex() external pure returns (uint256 index);
+
+    function getUserIdInputIndex() external pure returns (uint256 index);
+}

contracts/interfaces/IZKPVerifier.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./ICircuitValidator.sol";
+
+interface IZKPVerifier {
+    function submitZKPResponse(
+        uint64 requestId,
+        uint256[] memory inputs,
+        uint256[2] memory a,
+        uint256[2][2] memory b,
+        uint256[2] memory c
+    ) external returns (bool);
+
+    function setZKPRequest(
+        uint64 requestId,
+        ICircuitValidator validator,
+        ICircuitValidator.CircuitQuery memory query
+    ) external returns (bool);
+
+    function getZKPRequest(uint64 requestId)
+        external
+        returns (ICircuitValidator.CircuitQuery memory);
+}

contracts/lib/GenesisUtils.sol

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: GPL-3.0
+pragma solidity ^0.8.0;
+
+import "solidity-bytes-utils/contracts/BytesLib.sol";
+
+library GenesisUtils {
+    /**
+     * @dev int256ToBytes
+     */
+    function int256ToBytes(uint256 x) internal pure returns (bytes memory b) {
+        b = new bytes(32);
+        assembly {
+            mstore(add(b, 32), x)
+        }
+    }
+
+    /**
+     * @dev reverse
+     */
+    function reverse(uint256 input) internal pure returns (uint256 v) {
+        v = input;
+
+        // swap bytes
+        v =
+            ((v &
+                0xFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00) >>
+                8) |
+            ((v &
+                0x00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF) <<
+                8);
+
+        // swap 2-byte long pairs
+        v =
+            ((v &
+                0xFFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000) >>
+                16) |
+            ((v &
+                0x0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF) <<
+                16);
+
+        // swap 4-byte long pairs
+        v =
+            ((v &
+                0xFFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000) >>
+                32) |
+            ((v &
+                0x00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF) <<
+                32);
+
+        // swap 8-byte long pairs
+        v =
+            ((v &
+                0xFFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF0000000000000000) >>
+                64) |
+            ((v &
+                0x0000000000000000FFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF) <<
+                64);
+
+        // swap 16-byte long pairs
+        v = (v >> 128) | (v << 128);
+    }
+
+    /**
+     *   @dev sum
+     */
+    function sum(bytes memory array) internal pure returns (uint16 s) {
+        require(array.length == 29, "Checksum requires 29 length array");
+
+        for (uint256 i = 0; i < array.length; ++i) {
+            s += uint16(uint8(array[i]));
+        }
+    }
+
+    /**
+     * @dev bytesToHexString
+     */
+    function bytesToHexString(bytes memory buffer)
+        internal
+        pure
+        returns (string memory)
+    {
+        // Fixed buffer size for hexadecimal convertion
+        bytes memory converted = new bytes(buffer.length * 2);
+
+        bytes memory _base = "0123456789abcdef";
+
+        for (uint256 i = 0; i < buffer.length; i++) {
+            converted[i * 2] = _base[uint8(buffer[i]) / _base.length];
+            converted[i * 2 + 1] = _base[uint8(buffer[i]) % _base.length];
+        }
+
+        return string(abi.encodePacked("0x", converted));
+    }
+
+    /**
+     * @dev compareStrings
+     */
+    function compareStrings(string memory a, string memory b)
+        internal
+        pure
+        returns (bool)
+    {
+        return (keccak256(abi.encodePacked((a))) ==
+            keccak256(abi.encodePacked((b))));
+    }
+
+    /**
+     * @dev isGenesisState
+     */
+    function isGenesisState(uint256 id, uint256 idState)
+        internal
+        pure
+        returns (bool)
+    {
+        uint256 userSwappedState = reverse(idState);
+
+        bytes memory userStateB1 = int256ToBytes(userSwappedState);
+
+        bytes memory cutState = BytesLib.slice(
+            userStateB1,
+            userStateB1.length - 27,
+            27
+        );
+
+        bytes memory typDefault = hex"0000";
+
+        bytes memory beforeChecksum = BytesLib.concat(typDefault, cutState);
+        require(
+            beforeChecksum.length == 29,
+            "Checksum requires 29 length array"
+        );
+
+        uint16 s = sum(beforeChecksum);
+
+        bytes memory checkSumBytes = abi.encodePacked(s);
+
+        bytes memory idBytes = BytesLib.concat(beforeChecksum, checkSumBytes);
+        require(idBytes.length == 31, "idBytes requires 31 length array");
+
+        return id == reverse(toUint256(idBytes));
+    }
+
+    /**
+     * @dev toUint256
+     */
+    function toUint256(bytes memory _bytes)
+        internal
+        pure
+        returns (uint256 value)
+    {
+        assembly {
+            value := mload(add(_bytes, 0x20))
+        }
+    }
+
+    /**
+     * @dev bytesToAddress
+     */
+    function bytesToAddress(bytes memory bys)
+        internal
+        pure
+        returns (address addr)
+    {
+        assembly {
+            addr := mload(add(bys, 20))
+        }
+    }
+
+    /**
+     * @dev int256ToAddress
+     */
+    function int256ToAddress(uint256 input) internal pure returns (address) {
+        return bytesToAddress(int256ToBytes(reverse(input)));
+    }
+}