Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

import {IDelegateRegistry} from "./interfaces/IDelegateRegistry.sol";

/**
 * @title ExclusiveDelegateResolver
 * @author 0xQuit
 * @notice A contract to resolve a single canonical delegated owner for a given ERC721 token
 * @dev This contract is designed to be used in conjunction with a delegate registry to resolve the most specific
 * delegation that matches the rights, with specificity being determined by delegation type in order of ERC721 >
 * CONTRACT > ALL. ERC20 and ERC1155 are not supported. If multiple delegations of the same specificity match the rights,
 * the most recent one is respected. If no delegation matches the rights, global delegations (bytes24(0) are considered,
 * but MUST have an expiration greater than 0 to avoid conflicts with pre-existing delegations.
 * If no delegation matches the rights and there are no empty delegations, the owner is returned.
 * Expirations are supported by extracting a uint40 from the final 40 bits of a given delegation's rights value.
 * If the expiration is past, the delegation is not considered to match the request.
 */
contract ExclusiveDelegateResolver {
    /// @dev The address of the Delegate Registry contract
    address public immutable DELEGATE_REGISTRY;

    /// @dev The rights value for a global delegation. These are considered only if no delegation by rights matches the request.
    bytes24 public constant GLOBAL_DELEGATION = bytes24(0);

    constructor(address delegateRegistry) {
        DELEGATE_REGISTRY = delegateRegistry;
    }

    /**
     * @notice Gets an exclusive wallet delegation, resolved through delegatexyz if possible
     * @param vault The vault address
     * @param rights The rights to check
     * @return owner The vault wallet address or delegated wallet if one exists
     * @notice returns the most recent delegation that matches the rights for an entire wallet delegation
     * (type ALL) if multiple delegations of the same specificity match the rights, the most recent one is respected.
     * If no delegation matches the rights, global delegations (bytes24(0) are considered,
     * but MUST have an expiration greater than 0 to avoid conflicts with pre-existing delegations.
     * If no delegation matches the rights and there are no empty delegations, the owner is returned.
     * Expirations are supported by extracting a uint40 from the final 40 bits of a given delegation's rights value.
     * If the expiration is past, the delegation is not considered to match the request.
     */
    function exclusiveWalletByRights(address vault, bytes24 rights) public view returns (address) {
        IDelegateRegistry.Delegation[] memory delegations =
            IDelegateRegistry(DELEGATE_REGISTRY).getOutgoingDelegations(vault);

        IDelegateRegistry.Delegation memory delegationToReturn;

        for (uint256 i = delegations.length; i > 0;) {
            unchecked {
                --i;
            }
            IDelegateRegistry.Delegation memory delegation = delegations[i];

            if (_delegationMatchesRequest(delegation, rights)) {
                if (_delegationOutranksCurrent(delegationToReturn, delegation)) {
                    // re-check rights here to ensure global delegation does not get early returned
                    if (
                        delegation.type_ == IDelegateRegistry.DelegationType.ALL && bytes24(delegation.rights) == rights
                    ) {
                        return delegation.to;
                    }
                    delegationToReturn = delegation;
                }
            }
        }

        return delegationToReturn.to == address(0) ? vault : delegationToReturn.to;
    }

    /**
     * @notice Gets all wallets that have delegated to a given wallet
     * @param wallet The wallet to check
     * @param rights The rights to check
     * @return wallets The wallets that have delegated to the given wallet
     * @notice returns all wallets that have delegated to the given wallet, filtered by the rights
     * if multiple delegations of the same specificity match the rights, the most recent one is respected.
     * If no delegation matches the rights, global delegations (bytes24(0)) are considered,
     * but MUST have an expiration greater than 0 to avoid conflicts with pre-existing delegations.
     * Expirations are supported by extracting a uint40 from the final 40 bits of a given delegation's rights value.
     * If the expiration is past, the delegation is not considered to match the request.
     */
    function delegatedWalletsByRights(address wallet, bytes24 rights) external view returns (address[] memory) {
        IDelegateRegistry.Delegation[] memory delegations =
            IDelegateRegistry(DELEGATE_REGISTRY).getIncomingDelegations(wallet);

        uint256 matchesCount = 0;
        bool[] memory matches = new bool[](delegations.length);

        for (uint256 i; i < delegations.length; ++i) {
            IDelegateRegistry.Delegation memory delegation = delegations[i];

            if (_delegationMatchesRequest(delegation, rights)) {
                if (exclusiveWalletByRights(delegation.from, rights) == wallet) {
                    matches[i] = true;
                    matchesCount++;
                }
            }
        }

        address[] memory matchesArray = new address[](matchesCount);
        uint256 matchesIndex = 0;
        // filter to the delegated wallets that match the request
        for (uint256 i; i < delegations.length; ++i) {
            if (matches[i]) {
                matchesArray[matchesIndex] = delegations[i].from;
                matchesIndex++;
            }
        }
        return matchesArray;
    }

    /**
     * @notice Gets the owner of an ERC721 token, resolved through delegatexyz if possible
     * @param contractAddress The ERC721 contract address
     * @param tokenId The token ID to check
     * @return owner The owner address or delegated owner if one exists
     * @notice returns the most specific delegation that matches the rights, with specificity being determined
     * by delegation type in order of ERC721 > CONTRACT > ALL. ERC20 and ERC1155 are not supported
     * if multiple delegations of the same specificity match the rights, the most recent one is respected.
     * If no delegation matches the rights, global delegations (bytes24(0) are considered,
     * but MUST have an expiration greater than 0 to avoid conflicts with pre-existing delegations.
     * If no delegation matches the rights and there are no empty delegations, the owner is returned.
     * Expirations are supported by extracting a uint40 from the final 40 bits of a given delegation's rights value.
     * If the expiration is past, the delegation is not considered to match the request.
     */
    function exclusiveOwnerByRights(address contractAddress, uint256 tokenId, bytes24 rights)
        external
        view
        returns (address owner)
    {
        owner = _getOwner(contractAddress, tokenId);

        IDelegateRegistry.Delegation[] memory delegations =
            IDelegateRegistry(DELEGATE_REGISTRY).getOutgoingDelegations(owner);

        IDelegateRegistry.Delegation memory delegationToReturn;

        for (uint256 i = delegations.length; i > 0;) {
            unchecked {
                --i;
            }
            IDelegateRegistry.Delegation memory delegation = delegations[i];

            if (_delegationMatchesRequest(delegation, contractAddress, tokenId, rights)) {
                if (_delegationOutranksCurrent(delegationToReturn, delegation)) {
                    // re-check rights here to ensure global ERC721 type delegations do not get early returned
                    if (
                        delegation.type_ == IDelegateRegistry.DelegationType.ERC721
                            && bytes24(delegation.rights) == rights
                    ) {
                        return delegation.to;
                    }

                    delegationToReturn = delegation;
                }
            }
        }

        return delegationToReturn.to == address(0) ? owner : delegationToReturn.to;
    }

    /**
     * @notice Decodes a rights bytes32 value into its identifier and expiration
     * @param rights The rights bytes32 value
     * @return rightsIdentifier The rights identifier
     * @return expiration The expiration timestamp
     */
    function decodeRightsExpiration(bytes32 rights) public pure returns (bytes24, uint40) {
        bytes24 rightsIdentifier = bytes24(rights);
        uint40 expiration = uint40(uint256(rights));

        return (rightsIdentifier, expiration);
    }

    /**
     * @notice Convenience function to generate a rights bytes32 rights value with an expiration
     * @param rightsIdentifier The rights identifier
     * @param expiration The expiration timestamp
     * @return rights The rights bytes32 value
     */
    function generateRightsWithExpiration(bytes24 rightsIdentifier, uint40 expiration)
        external
        pure
        returns (bytes32)
    {
        uint256 rights = uint256(uint192(rightsIdentifier)) << 64;
        return bytes32(rights | uint256(expiration));
    }

    function _delegationMatchesRequest(IDelegateRegistry.Delegation memory delegation, bytes24 rights)
        internal
        view
        returns (bool)
    {
        (bytes24 rightsIdentifier, uint40 expiration) = decodeRightsExpiration(delegation.rights);

        if (block.timestamp > expiration) {
            return false;
        } else if (rightsIdentifier != rights && rightsIdentifier != GLOBAL_DELEGATION) {
            return false;
        } else if (delegation.type_ == IDelegateRegistry.DelegationType.ALL) {
            return true;
        } else {
            return false;
        }
    }

    function _delegationMatchesRequest(
        IDelegateRegistry.Delegation memory delegation,
        address contractAddress,
        uint256 tokenId,
        bytes24 rights
    ) internal view returns (bool) {
        // Extract rights identifier (remaining 192 bits)
        (bytes24 rightsIdentifier, uint40 expiration) = decodeRightsExpiration(delegation.rights);

        if (block.timestamp > expiration) {
            return false;
        } else if (rightsIdentifier != rights && rightsIdentifier != GLOBAL_DELEGATION) {
            return false;
        } else if (delegation.type_ == IDelegateRegistry.DelegationType.ALL) {
            return true;
        } else if (delegation.type_ == IDelegateRegistry.DelegationType.CONTRACT) {
            return delegation.contract_ == contractAddress;
        } else if (delegation.type_ == IDelegateRegistry.DelegationType.ERC721) {
            return delegation.contract_ == contractAddress && delegation.tokenId == tokenId;
        } else {
            return false;
        }
    }

    function _delegationOutranksCurrent(
        IDelegateRegistry.Delegation memory currentDelegation,
        IDelegateRegistry.Delegation memory newDelegation
    ) internal pure returns (bool) {
        bytes24 currentRightsIdentifier = bytes24(currentDelegation.rights);
        bytes24 newRightsIdentifier = bytes24(newDelegation.rights);

        if (currentRightsIdentifier == newRightsIdentifier) {
            return newDelegation.type_ > currentDelegation.type_;
        } else if (currentRightsIdentifier == GLOBAL_DELEGATION) {
            return true;
        } else {
            return false;
        }
    }

    function _getOwner(address contractAddress, uint256 tokenId) internal view returns (address owner) {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40)
            mstore(m, 0x6352211e00000000000000000000000000000000000000000000000000000000)
            mstore(add(m, 0x04), tokenId)
            let success := staticcall(gas(), contractAddress, m, 0x24, m, 0x20)
            if iszero(success) {
                mstore(0x00, 0x3204506f) // CallFailed()
                revert(0x1c, 0x04)
            }
            owner := mload(m)
        }
    }
}

// SPDX-License-Identifier: CC0-1.0
pragma solidity >=0.8.13;

/**
 * @title IDelegateRegistry
 * @custom:version 2.0
 * @custom:author foobar (0xfoobar)
 * @notice A standalone immutable registry storing delegated permissions from one address to another
 */
interface IDelegateRegistry {
    /// @notice Delegation type, NONE is used when a delegation does not exist or is revoked
    enum DelegationType {
        NONE,
        ALL,
        CONTRACT,
        ERC721,
        ERC20,
        ERC1155
    }

    /// @notice Struct for returning delegations
    struct Delegation {
        DelegationType type_;
        address to;
        address from;
        bytes32 rights;
        address contract_;
        uint256 tokenId;
        uint256 amount;
    }

    /// @notice Emitted when an address delegates or revokes rights for their entire wallet
    event DelegateAll(address indexed from, address indexed to, bytes32 rights, bool enable);

    /// @notice Emitted when an address delegates or revokes rights for a contract address
    event DelegateContract(
        address indexed from, address indexed to, address indexed contract_, bytes32 rights, bool enable
    );

    /// @notice Emitted when an address delegates or revokes rights for an ERC721 tokenId
    event DelegateERC721(
        address indexed from,
        address indexed to,
        address indexed contract_,
        uint256 tokenId,
        bytes32 rights,
        bool enable
    );

    /// @notice Emitted when an address delegates or revokes rights for an amount of ERC20 tokens
    event DelegateERC20(
        address indexed from, address indexed to, address indexed contract_, bytes32 rights, uint256 amount
    );

    /// @notice Emitted when an address delegates or revokes rights for an amount of an ERC1155 tokenId
    event DelegateERC1155(
        address indexed from,
        address indexed to,
        address indexed contract_,
        uint256 tokenId,
        bytes32 rights,
        uint256 amount
    );

    /// @notice Thrown if multicall calldata is malformed
    error MulticallFailed();

    /**
     * -----------  WRITE -----------
     */

    /**
     * @notice Call multiple functions in the current contract and return the data from all of them if they all succeed
     * @param data The encoded function data for each of the calls to make to this contract
     * @return results The results from each of the calls passed in via data
     */
    function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for all contracts
     * @param to The address to act as delegate
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateAll(address to, bytes32 rights, bool enable) external payable returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific contract
     * @param to The address to act as delegate
     * @param contract_ The contract whose rights are being delegated
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateContract(address to, address contract_, bytes32 rights, bool enable)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific ERC721 token
     * @param to The address to act as delegate
     * @param contract_ The contract whose rights are being delegated
     * @param tokenId The token id to delegate
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param enable Whether to enable or disable this delegation, true delegates and false revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateERC721(address to, address contract_, uint256 tokenId, bytes32 rights, bool enable)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific amount of ERC20 tokens
     * @dev The actual amount is not encoded in the hash, just the existence of a amount (since it is an upper bound)
     * @param to The address to act as delegate
     * @param contract_ The address for the fungible token contract
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param amount The amount to delegate, > 0 delegates and 0 revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateERC20(address to, address contract_, bytes32 rights, uint256 amount)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * @notice Allow the delegate to act on behalf of `msg.sender` for a specific amount of ERC1155 tokens
     * @dev The actual amount is not encoded in the hash, just the existence of a amount (since it is an upper bound)
     * @param to The address to act as delegate
     * @param contract_ The address of the contract that holds the token
     * @param tokenId The token id to delegate
     * @param rights Specific subdelegation rights granted to the delegate, pass an empty bytestring to encompass all rights
     * @param amount The amount of that token id to delegate, > 0 delegates and 0 revokes
     * @return delegationHash The unique identifier of the delegation
     */
    function delegateERC1155(address to, address contract_, uint256 tokenId, bytes32 rights, uint256 amount)
        external
        payable
        returns (bytes32 delegationHash);

    /**
     * ----------- CHECKS -----------
     */

    /**
     * @notice Check if `to` is a delegate of `from` for the entire wallet
     * @param to The potential delegate address
     * @param from The potential address who delegated rights
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return valid Whether delegate is granted to act on the from's behalf
     */
    function checkDelegateForAll(address to, address from, bytes32 rights) external view returns (bool);

    /**
     * @notice Check if `to` is a delegate of `from` for the specified `contract_` or the entire wallet
     * @param to The delegated address to check
     * @param contract_ The specific contract address being checked
     * @param from The cold wallet who issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return valid Whether delegate is granted to act on from's behalf for entire wallet or that specific contract
     */
    function checkDelegateForContract(address to, address from, address contract_, bytes32 rights)
        external
        view
        returns (bool);

    /**
     * @notice Check if `to` is a delegate of `from` for the specific `contract` and `tokenId`, the entire `contract_`, or the entire wallet
     * @param to The delegated address to check
     * @param contract_ The specific contract address being checked
     * @param tokenId The token id for the token to delegating
     * @param from The wallet that issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return valid Whether delegate is granted to act on from's behalf for entire wallet, that contract, or that specific tokenId
     */
    function checkDelegateForERC721(address to, address from, address contract_, uint256 tokenId, bytes32 rights)
        external
        view
        returns (bool);

    /**
     * @notice Returns the amount of ERC20 tokens the delegate is granted rights to act on the behalf of
     * @param to The delegated address to check
     * @param contract_ The address of the token contract
     * @param from The cold wallet who issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return balance The delegated balance, which will be 0 if the delegation does not exist
     */
    function checkDelegateForERC20(address to, address from, address contract_, bytes32 rights)
        external
        view
        returns (uint256);

    /**
     * @notice Returns the amount of a ERC1155 tokens the delegate is granted rights to act on the behalf of
     * @param to The delegated address to check
     * @param contract_ The address of the token contract
     * @param tokenId The token id to check the delegated amount of
     * @param from The cold wallet who issued the delegation
     * @param rights Specific rights to check for, pass the zero value to ignore subdelegations and check full delegations only
     * @return balance The delegated balance, which will be 0 if the delegation does not exist
     */
    function checkDelegateForERC1155(address to, address from, address contract_, uint256 tokenId, bytes32 rights)
        external
        view
        returns (uint256);

    /**
     * ----------- ENUMERATIONS -----------
     */

    /**
     * @notice Returns all enabled delegations a given delegate has received
     * @param to The address to retrieve delegations for
     * @return delegations Array of Delegation structs
     */
    function getIncomingDelegations(address to) external view returns (Delegation[] memory delegations);

    /**
     * @notice Returns all enabled delegations an address has given out
     * @param from The address to retrieve delegations for
     * @return delegations Array of Delegation structs
     */
    function getOutgoingDelegations(address from) external view returns (Delegation[] memory delegations);

    /**
     * @notice Returns all hashes associated with enabled delegations an address has received
     * @param to The address to retrieve incoming delegation hashes for
     * @return delegationHashes Array of delegation hashes
     */
    function getIncomingDelegationHashes(address to) external view returns (bytes32[] memory delegationHashes);

    /**
     * @notice Returns all hashes associated with enabled delegations an address has given out
     * @param from The address to retrieve outgoing delegation hashes for
     * @return delegationHashes Array of delegation hashes
     */
    function getOutgoingDelegationHashes(address from) external view returns (bytes32[] memory delegationHashes);

    /**
     * @notice Returns the delegations for a given array of delegation hashes
     * @param delegationHashes is an array of hashes that correspond to delegations
     * @return delegations Array of Delegation structs, return empty structs for nonexistent or revoked delegations
     */
    function getDelegationsFromHashes(bytes32[] calldata delegationHashes)
        external
        view
        returns (Delegation[] memory delegations);

    /**
     * ----------- STORAGE ACCESS -----------
     */

    /**
     * @notice Allows external contracts to read arbitrary storage slots
     */
    function readSlot(bytes32 location) external view returns (bytes32);

    /**
     * @notice Allows external contracts to read an arbitrary array of storage slots
     */
    function readSlots(bytes32[] calldata locations) external view returns (bytes32[] memory);
}

{
  "remappings": [
    "solady/=lib/solady/src/",
    "forge/=lib/forge-std/src/",
    "forge-std/=lib/forge-std/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"delegateRegistry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DELEGATE_REGISTRY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GLOBAL_DELEGATION","outputs":[{"internalType":"bytes24","name":"","type":"bytes24"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"rights","type":"bytes32"}],"name":"decodeRightsExpiration","outputs":[{"internalType":"bytes24","name":"","type":"bytes24"},{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"bytes24","name":"rights","type":"bytes24"}],"name":"delegatedWalletsByRights","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes24","name":"rights","type":"bytes24"}],"name":"exclusiveOwnerByRights","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"bytes24","name":"rights","type":"bytes24"}],"name":"exclusiveWalletByRights","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes24","name":"rightsIdentifier","type":"bytes24"},{"internalType":"uint40","name":"expiration","type":"uint40"}],"name":"generateRightsWithExpiration","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"}]

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

00000000000000000000000000000000000000447e69651d841bd8d104bed493

-----Decoded View---------------
Arg [0] : delegateRegistry (address): 0x00000000000000447e69651d841bD8D104Bed493

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000447e69651d841bd8d104bed493

1145:10973:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8453:246;;;;;;:::i;:::-;8584:6;;;8453:246;;;;;-1:-1:-1;;389:36:2;;;371:55;;474:12;462:25;;;457:2;442:18;;435:53;344:18;8453:246:0;;;;;;;;2572:1164;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1307:32:2;;;1289:51;;1277:2;1262:18;2572:1164:0;1143:203:2;6850:1349:0;;;;;;:::i;:::-;;:::i;1245:42::-;;;;;8968:271;;;;;;:::i;:::-;9212:19;;;-1:-1:-1;;9138:40:0;;9203:28;8968:271;;;;;;;;2248:25:2;;;2236:2;2221:18;8968:271:0;2102:177:2;1423:54:0;;1475:1;1423:54;;;;;-1:-1:-1;;2448:36:2;;;2430:55;;2418:2;2403:18;1423:54:0;2284:207:2;4589:1158:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2572:1164::-;2740:66;;-1:-1:-1;;;2740:66:0;;-1:-1:-1;;;;;1307:32:2;;;2740:66:0;;;1289:51:2;2657:7:0;;;;2758:17;2740:59;;;;1262:18:2;;2740:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2740:66:0;;;;;;;;;;;;:::i;:::-;2676:130;;2817:54;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2817:54:0;2899:18;;2882:763;2919:5;;2882:763;;2969:3;;;;;;3000:46;3049:11;3061:1;3049:14;;;;;;;;:::i;:::-;;;;;;;3000:63;;3082:45;3108:10;3120:6;3082:25;:45::i;:::-;3078:557;;;3151:58;3178:18;3198:10;3151:26;:58::i;:::-;3147:474;;;3382:36;3362:16;;:56;;;;;;;;:::i;:::-;;:96;;;;;3452:6;3422:36;;;3430:10;:17;;;3422:36;;;;3362:96;3333:217;;;3514:13;;;;-1:-1:-1;3507:20:0;;-1:-1:-1;;;3507:20:0;3333:217;3592:10;3571:31;;3147:474;2927:718;2882:763;;;-1:-1:-1;3662:21:0;;;;-1:-1:-1;;;;;3662:35:0;;:67;;3708:18;:21;;;3662:67;;;3700:5;3662:67;3655:74;;;;2572:1164;;;;;:::o;6850:1349::-;6987:13;7024:35;7034:15;7051:7;7024:9;:35::i;:::-;7134:66;;-1:-1:-1;;;7134:66:0;;-1:-1:-1;;;;;1307:32:2;;;7134:66:0;;;1289:51:2;7016:43:0;;-1:-1:-1;7070:49:0;;7152:17;7134:59;;;;1262:18:2;;7134:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7134:66:0;;;;;;;;;;;;:::i;:::-;7070:130;;7211:54;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7211:54:0;7293:18;;7276:832;7313:5;;7276:832;;7363:3;;;;;;7394:46;7443:11;7455:1;7443:14;;;;;;;;:::i;:::-;;;;;;;7394:63;;7476:71;7502:10;7514:15;7531:7;7540:6;7476:25;:71::i;:::-;7472:626;;;7571:58;7598:18;7618:10;7571:26;:58::i;:::-;7567:517;;;7813:39;7793:16;;:59;;;;;;;;:::i;:::-;;:127;;;;;7914:6;7884:36;;;7892:10;:17;;;7884:36;;;;7793:127;7764:248;;;7976:13;;;;-1:-1:-1;7969:20:0;;-1:-1:-1;;;7969:20:0;7764:248;8055:10;8034:31;;7567:517;7321:787;7276:832;;;-1:-1:-1;8125:21:0;;;;-1:-1:-1;;;;;8125:35:0;;:67;;8171:18;:21;;;8125:67;;;8163:5;8125:67;8118:74;;;;6850:1349;;;;;;:::o;4589:1158::-;4770:67;;-1:-1:-1;;;4770:67:0;;-1:-1:-1;;;;;1307:32:2;;;4770:67:0;;;1289:51:2;4678:16:0;;4706:49;;4788:17;4770:59;;;;1262:18:2;;4770:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4770:67:0;;;;;;;;;;;;:::i;:::-;4706:131;;4848:20;4871:1;4848:24;;4882:21;4917:11;:18;4906:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4906:30:0;;4882:54;;4952:9;4947:388;4967:11;:18;4963:1;:22;4947:388;;;5006:46;5055:11;5067:1;5055:14;;;;;;;;:::i;:::-;;;;;;;5006:63;;5088:45;5114:10;5126:6;5088:25;:45::i;:::-;5084:241;;;5209:6;-1:-1:-1;;;;;5157:58:0;:48;5181:10;:15;;;5198:6;5157:23;:48::i;:::-;-1:-1:-1;;;;;5157:58:0;;5153:158;;5252:4;5239:7;5247:1;5239:10;;;;;;;;:::i;:::-;:17;;;:10;;;;;;;;;;;:17;5278:14;;;;:::i;:::-;;;;5153:158;-1:-1:-1;4987:3:0;;4947:388;;;;5345:29;5391:12;5377:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5377:27:0;-1:-1:-1;5345:59:0;-1:-1:-1;5414:20:0;;5514:198;5534:11;:18;5530:1;:22;5514:198;;;5577:7;5585:1;5577:10;;;;;;;;:::i;:::-;;;;;;;5573:129;;;5636:11;5648:1;5636:14;;;;;;;;:::i;:::-;;;;;;;:19;;;5607:12;5620;5607:26;;;;;;;;:::i;:::-;-1:-1:-1;;;;;5607:48:0;;;:26;;;;;;;;;;;:48;5673:14;;;;:::i;:::-;;;;5573:129;5554:3;;5514:198;;;-1:-1:-1;5728:12:0;;4589:1158;-1:-1:-1;;;;;;;4589:1158:0:o;9245:606::-;9391:4;9412:24;9438:17;9459:41;9482:10;:17;;;8584:6;;;8453:246;9459:41;9411:89;;;;9533:10;9515:28;;:15;:28;9511:334;;;9566:5;9559:12;;;;;;9511:334;-1:-1:-1;;9592:26:0;;;;;;;;;;:67;;-1:-1:-1;;;9622:37:0;;;;9592:67;9588:257;;;9682:5;9675:12;;;;;;9588:257;9728:36;9708:16;;:56;;;;;;;;:::i;:::-;;9704:141;;9787:4;9780:11;;;;;;9704:141;9829:5;9822:12;;;;;;10898:620;11143:24;;;;;11216:20;;;;11085:4;;11143:24;-1:-1:-1;;11252:46:0;;;;;;;11248:264;;11343:23;;11321:45;;;;;;;;:::i;:::-;:19;;:45;;;;;;;;:::i;:::-;;11314:52;;;;;;11248:264;-1:-1:-1;;11387:44:0;;11383:129;;11454:4;11447:11;;;;;;11524:592;11608:13;11714:4;11708:11;-1:-1:-1;;;11739:1:0;11732:77;11843:7;11836:4;11833:1;11829:12;11822:29;11926:4;11923:1;11917:4;11914:1;11897:15;11890:5;11879:52;11954:7;11944:126;;11994:10;11988:4;11981:24;12051:4;12045;12038:18;11944:126;-1:-1:-1;12092:8:0;;11524:592;-1:-1:-1;;;11524:592:0:o;9857:1035::-;10059:4;10134:24;10160:17;10181:41;10204:10;:17;;;8584:6;;;8453:246;10181:41;10133:89;;;;10255:10;10237:28;;:15;:28;10233:653;;;10288:5;10281:12;;;;;;10233:653;-1:-1:-1;;10314:26:0;;;;;;;;;;:67;;-1:-1:-1;;;10344:37:0;;;;10314:67;10310:576;;;10404:5;10397:12;;;;;;10310:576;10450:36;10430:16;;:56;;;;;;;;:::i;:::-;;10426:460;;10509:4;10502:11;;;;;;10426:460;10554:41;10534:16;;:61;;;;;;;;:::i;:::-;;10530:356;;10642:15;-1:-1:-1;;;;;10618:39:0;:10;:20;;;-1:-1:-1;;;;;10618:39:0;;10611:46;;;;;;10530:356;10698:39;10678:16;;:59;;;;;;;;:::i;:::-;;10674:212;;10784:15;-1:-1:-1;;;;;10760:39:0;:10;:20;;;-1:-1:-1;;;;;10760:39:0;;:72;;;;;10825:7;10803:10;:18;;;:29;10760:72;10753:79;;;;;;10674:212;10870:5;10863:12;;;;9857:1035;;;;;;;:::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;499:131::-;-1:-1:-1;;;;;574:31:2;;564:42;;554:70;;620:1;617;610:12;554:70;499:131;:::o;635:177::-;703:20;;-1:-1:-1;;752:35:2;;742:46;;732:74;;802:1;799;792:12;732:74;635:177;;;:::o;817:321::-;885:6;893;946:2;934:9;925:7;921:23;917:32;914:52;;;962:1;959;952:12;914:52;1001:9;988:23;1020:31;1045:5;1020:31;:::i;:::-;1070:5;-1:-1:-1;1094:38:2;1128:2;1113:18;;1094:38;:::i;:::-;1084:48;;817:321;;;;;:::o;1351:389::-;1428:6;1436;1444;1497:2;1485:9;1476:7;1472:23;1468:32;1465:52;;;1513:1;1510;1503:12;1465:52;1552:9;1539:23;1571:31;1596:5;1571:31;:::i;:::-;1621:5;-1:-1:-1;1673:2:2;1658:18;;1645:32;;-1:-1:-1;1696:38:2;1730:2;1715:18;;1696:38;:::i;:::-;1686:48;;1351:389;;;;;:::o;1745:352::-;1812:6;1820;1873:2;1861:9;1852:7;1848:23;1844:32;1841:52;;;1889:1;1886;1879:12;1841:52;1912:29;1931:9;1912:29;:::i;:::-;1902:39;;1991:2;1980:9;1976:18;1963:32;2035:12;2028:5;2024:24;2017:5;2014:35;2004:63;;2063:1;2060;2053:12;2004:63;2086:5;2076:15;;;1745:352;;;;;:::o;2496:637::-;2686:2;2698:21;;;2768:13;;2671:18;;;2790:22;;;2638:4;;2869:15;;;2843:2;2828:18;;;2638:4;2912:195;2926:6;2923:1;2920:13;2912:195;;;2991:13;;-1:-1:-1;;;;;2987:39:2;2975:52;;3056:2;3082:15;;;;3047:12;;;;3023:1;2941:9;2912:195;;;-1:-1:-1;3124:3:2;;2496:637;-1:-1:-1;;;;;2496:637:2:o;3138:127::-;3199:10;3194:3;3190:20;3187:1;3180:31;3230:4;3227:1;3220:15;3254:4;3251:1;3244:15;3270:253;3342:2;3336:9;3384:4;3372:17;;3419:18;3404:34;;3440:22;;;3401:62;3398:88;;;3466:18;;:::i;:::-;3502:2;3495:22;3270:253;:::o;3528:275::-;3599:2;3593:9;3664:2;3645:13;;-1:-1:-1;;3641:27:2;3629:40;;3699:18;3684:34;;3720:22;;;3681:62;3678:88;;;3746:18;;:::i;:::-;3782:2;3775:22;3528:275;;-1:-1:-1;3528:275:2:o;3808:138::-;3887:13;;3909:31;3887:13;3909:31;:::i;3951:1775::-;4073:6;4126:2;4114:9;4105:7;4101:23;4097:32;4094:52;;;4142:1;4139;4132:12;4094:52;4175:9;4169:16;4208:18;4200:6;4197:30;4194:50;;;4240:1;4237;4230:12;4194:50;4263:22;;4316:4;4308:13;;4304:27;-1:-1:-1;4294:55:2;;4345:1;4342;4335:12;4294:55;4378:2;4372:9;4404:18;4396:6;4393:30;4390:56;;;4426:18;;:::i;:::-;4466:40;4502:2;4493:6;4490:1;4486:14;4482:23;4466:40;:::i;:::-;4528:3;4552:6;4547:3;4540:19;4584:2;4579:3;4575:12;4568:19;;4642:2;4634:4;4626:6;4622:17;4618:2;4614:26;4610:35;4596:49;;4668:7;4660:6;4657:19;4654:39;;;4689:1;4686;4679:12;4654:39;4721:2;4717;4713:11;4702:22;;4733:963;4749:6;4744:3;4741:15;4733:963;;;4831:4;4825:3;4816:7;4812:17;4808:28;4805:48;;;4849:1;4846;4839:12;4805:48;4879:22;;:::i;:::-;4935:3;4929:10;4974:1;4965:7;4962:14;4952:42;;4990:1;4987;4980:12;4952:42;5007:22;;5065:43;5104:2;5095:12;;5065:43;:::i;:::-;5060:2;5053:5;5049:14;5042:67;5145:43;5184:2;5179:3;5175:12;5145:43;:::i;:::-;5140:2;5129:14;;5122:67;5257:2;5248:12;;;5242:19;5281:14;;;5274:31;5342:44;5381:3;5372:13;;5342:44;:::i;:::-;5336:3;5325:15;;5318:69;5455:3;5446:13;;;5440:20;5480:15;;;5473:32;5573:3;5564:13;;;5558:20;5598:15;;;5591:32;5636:18;;4775:4;4766:14;;;;5683:2;5674:12;;;;4733:963;;;5715:5;3951:1775;-1:-1:-1;;;;;;3951:1775:2:o;5731:127::-;5792:10;5787:3;5783:20;5780:1;5773:31;5823:4;5820:1;5813:15;5847:4;5844:1;5837:15;5863:127;5924:10;5919:3;5915:20;5912:1;5905:31;5955:4;5952:1;5945:15;5979:4;5976:1;5969:15;5995:232;6034:3;6055:17;;;6052:140;;6114:10;6109:3;6105:20;6102:1;6095:31;6149:4;6146:1;6139:15;6177:4;6174:1;6167:15;6052:140;-1:-1:-1;6219:1:2;6208:13;;5995:232::o

ipfs://48edc444b38fb6d60e20e13d741fac40201f6d15b16c1050e54790de597c59d0