Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {Ownable} from "solady/auth/Ownable.sol";

/**
 * @title VkRegistry
 * @notice Manages a list of valid program verification keys (programVk) for ZK proof verification
 * @dev Based on MeasurementRegistry pattern for managing programVk list with add/delete operations
 */
contract VkRegistry is Ownable {
    mapping(bytes32 => bool) private programVkMap;
    bytes32[] private programVkList;

    error AlreadyExists();
    error NotExists();

    constructor() {
        _initializeOwner(msg.sender);
    }

    /**
     * @notice Add a new program verification key to the whitelist
     * @param programVk The 32-byte program verification key to add
     */
    function addProgramVk(bytes32 programVk) external onlyOwner {
        if (programVkMap[programVk]) revert AlreadyExists();
        programVkMap[programVk] = true;
        programVkList.push(programVk);
    }

    /**
     * @notice Remove a program verification key from the whitelist
     * @param programVk The 32-byte program verification key to remove
     */
    function deleteProgramVk(bytes32 programVk) external onlyOwner {
        if (!programVkMap[programVk]) revert NotExists();
        delete programVkMap[programVk];
        
        // Remove from list
        for (uint256 i = 0; i < programVkList.length; ++i) {
            if (programVkList[i] == programVk) {
                programVkList[i] = programVkList[programVkList.length - 1];
                programVkList.pop();
                break;
            }
        }
    }

    /**
     * @notice Get all whitelisted program verification keys
     * @return Array of all program verification keys
     */
    function getProgramVkList() external view returns (bytes32[] memory) {
        return programVkList;
    }

    /**
     * @notice Check if a program verification key is whitelisted
     * @param programVk The program verification key to check
     * @return True if the programVk is whitelisted
     */
    function isValidProgramVk(bytes32 programVk) external view returns (bool) {
        return programVkMap[programVk];
    }

    /**
     * @notice Clear all program verification keys (emergency cleanup)
     */
    function clearProgramVkList() external onlyOwner {
        for (uint256 i = 0; i < programVkList.length; ++i) {
            delete programVkMap[programVkList[i]];
        }
        delete programVkList;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

{
  "remappings": [
    "forge-std/=../libraries/lib/forge-std/src/",
    "solady/=../libraries/lib/solady/src/",
    "@sp1-contracts/=../libraries/lib/sp1-contracts/contracts/src/",
    "automata-dcap-attestation/=../libraries/lib/automata-dcap-attestation/",
    "automata-on-chain-pccs/=../libraries/lib/automata-dcap-attestation/evm/lib/automata-on-chain-pccs/",
    "ds-test/=../libraries/lib/automata-dcap-attestation/evm/lib/automata-on-chain-pccs/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=../libraries/lib/sp1-contracts/contracts/lib/openzeppelin-contracts/lib/erc4626-tests/",
    "halmos-cheatcodes/=../libraries/lib/automata-dcap-attestation/evm/lib/automata-on-chain-pccs/lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    "openzeppelin-contracts/=../libraries/lib/sp1-contracts/contracts/lib/openzeppelin-contracts/",
    "risc0-ethereum/=../libraries/lib/automata-dcap-attestation/evm/lib/risc0-ethereum/",
    "sp1-contracts/=../libraries/lib/sp1-contracts/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyExists","type":"error"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"NotExists","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"bytes32","name":"programVk","type":"bytes32"}],"name":"addProgramVk","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"clearProgramVkList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"programVk","type":"bytes32"}],"name":"deleteProgramVk","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getProgramVkList","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"programVk","type":"bytes32"}],"name":"isValidProgramVk","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"}]

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

336:2105:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2017:121;;;;;;;;;;-1:-1:-1;2017:121:1;;;;;:::i;:::-;2085:4;2108:23;;;;;;;;;;;;;;2017:121;;;;364:14:2;;357:22;339:41;;327:2;312:18;2017:121:1;;;;;;;;9021:617:0;;;:::i;:::-;;1097:475:1;;;;;;;;;;-1:-1:-1;1097:475:1;;;;;:::i;:::-;;:::i;729:207::-;;;;;;;;;;-1:-1:-1;729:207:1;;;;;:::i;:::-;;:::i;1709:106::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;9720:456:0:-;;;:::i;8762:100::-;;;:::i;2231:208:1:-;;;;;;;;;;;;;:::i;11408:182:0:-;;;;;;;;;;-1:-1:-1;;;11556:18:0;11408:182;;-1:-1:-1;;;;;1171:32:2;;;1153:51;;1141:2;1126:18;11408:182:0;1007:203:2;10363:708:0;;;;;;:::i;:::-;;:::i;8348:349::-;;;;;;:::i;:::-;;:::i;11693:435::-;;;;;;;;;;-1:-1:-1;11693:435:0;;;;;:::i;:::-;11963:19;11957:4;11950:33;;;11812:14;11996:26;;;;12106:4;12090:21;;12084:28;;11693:435;;;;1652:25:2;;;1640:2;1625:18;11693:435:0;1506:177:2;9021:617:0;9114:15;7972:9;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;1097:475:1:-;12517:13:0;:11;:13::i;:::-;1175:12:1::1;:23:::0;;;::::1;::::0;;;;;;;::::1;;1170:48;;1207:11;;-1:-1:-1::0;;;1207:11:1::1;;;;;;;;;;;1170:48;1235:12;:23:::0;;;::::1;::::0;;;;;;1228:30;;-1:-1:-1;;1228:30:1::1;::::0;;1305:261:::1;1329:13;:20:::0;1325:24;::::1;1305:261;;;1394:9;1374:13;1388:1;1374:16;;;;;;;;:::i;:::-;;;;;;;;;:29:::0;1370:186:::1;;1442:13;1456:20:::0;;:24:::1;::::0;1442:13;;1456:24:::1;:::i;:::-;1442:39;;;;;;;;:::i;:::-;;;;;;;;;1423:13;1437:1;1423:16;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;:58:::0;1499:13:::1;:19:::0;;;::::1;;;;:::i;:::-;;;;;;;;;;;;;;;;;;1305:261;1097:475:::0;:::o;1370:186::-:1;1351:3;;1305:261;;;;1097:475:::0;:::o;729:207::-;12517:13:0;:11;:13::i;:::-;803:12:1::1;:23:::0;;;::::1;::::0;;;;;;;::::1;;799:51;;;835:15;;-1:-1:-1::0;;;835:15:1::1;;;;;;;;;;;799:51;860:12;:23:::0;;;::::1;::::0;;;;;;:30;;-1:-1:-1;;860:30:1::1;886:4;860:30:::0;;::::1;::::0;;;900:29;;;;::::1;::::0;;;;;::::1;::::0;729:207::o;1709:106::-;1760:16;1795:13;1788:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1709:106;:::o;9720:456:0:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;8762:100::-;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;2231:208:1:-;12517:13:0;:11;:13::i;:::-;2295:9:1::1;2290:113;2314:13;:20:::0;2310:24;::::1;2290:113;;;2362:12;:30;2375:13;2389:1;2375:16;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;;::::1;::::0;2362:30;;;::::1;::::0;;;;;;;;2355:37;;-1:-1:-1;;2355:37:1::1;::::0;;;2336:3:::1;2290:113;;;-1:-1:-1::0;2412:20:1::1;2419:13;;2412:20;:::i;10363:708:0:-:0;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;10999:23:::0;;11041::::1;11051:12:::0;11041:9:::1;:23::i;:::-;10363:708:::0;:::o;8348:349::-;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;7292:355::-:0;-1:-1:-1;;7498:18:0;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;6145:1089;-1:-1:-1;;7093:16:0;;-1:-1:-1;;;;;6941:26:0;;;;;;7053:38;7050:1;;7042:78;7177:27;6145:1089::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:180:2:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:2;;14:180;-1:-1:-1;14:180:2:o;391:611::-;581:2;593:21;;;663:13;;566:18;;;685:22;;;533:4;;764:15;;;738:2;723:18;;;533:4;807:169;821:6;818:1;815:13;807:169;;;882:13;;870:26;;925:2;951:15;;;;916:12;;;;843:1;836:9;807:169;;;-1:-1:-1;993:3:2;;391:611;-1:-1:-1;;;;;391:611:2:o;1215:286::-;1274:6;1327:2;1315:9;1306:7;1302:23;1298:32;1295:52;;;1343:1;1340;1333:12;1295:52;1369:23;;-1:-1:-1;;;;;1421:31:2;;1411:42;;1401:70;;1467:1;1464;1457:12;1401:70;1490:5;1215:286;-1:-1:-1;;;1215:286:2:o;1688:127::-;1749:10;1744:3;1740:20;1737:1;1730:31;1780:4;1777:1;1770:15;1804:4;1801:1;1794:15;1820:225;1887:9;;;1908:11;;;1905:134;;;1961:10;1956:3;1952:20;1949:1;1942:31;1996:4;1993:1;1986:15;2024:4;2021:1;2014:15;1905:134;1820:225;;;;:::o;2050:127::-;2111:10;2106:3;2102:20;2099:1;2092:31;2142:4;2139:1;2132:15;2166:4;2163:1;2156:15

ipfs://6b2d01ebc87fb4a219c1af5d8733c13bfdf7c7c864d60774b83702864001bfa8