interfaceId

supportsInterface

vault

delegate

value

DelegateForAll

contract_

DelegateForContract

tokenId

DelegateForToken

RevokeAllDelegates

RevokeDelegate

checkDelegateForAll

checkDelegateForContract

checkDelegateForToken

delegateForAll

delegateForContract

delegateForToken

getContractLevelDelegations

contractDelegations

getDelegatesForAll

delegates

getDelegatesForContract

getDelegatesForToken

getDelegationsByDelegate

info

getTokenLevelDelegations

tokenDelegations

revokeAllDelegates

revokeDelegate

revokeSelf

DelegationRegistry

{
    { }
    function abi_decode_tuple_t_bytes4(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        let value := calldataload(headStart)
        if iszero(eq(value, and(value, shl(224, 0xffffffff)))) { revert(0, 0) }
        value0 := value
    }
    function abi_encode_tuple_t_bool__to_t_bool__fromStack_reversed(headStart, value0) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, iszero(iszero(value0)))
    }
    function abi_decode_address(offset) -> value
    {
        value := calldataload(offset)
        if iszero(eq(value, and(value, sub(shl(160, 1), 1)))) { revert(0, 0) }
    }
    function abi_decode_tuple_t_addresst_addresst_uint256(headStart, dataEnd) -> value0, value1, value2
    {
        if slt(sub(dataEnd, headStart), 96) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := abi_decode_address(add(headStart, 32))
        value2 := calldataload(add(headStart, 64))
    }
    function abi_encode_tuple_t_array$_t_address_$dyn_memory_ptr__to_t_array$_t_address_$dyn_memory_ptr__fromStack_reversed(headStart, value0) -> tail
    {
        let _1 := 32
        let tail_1 := add(headStart, _1)
        mstore(headStart, _1)
        let pos := tail_1
        let length := mload(value0)
        mstore(tail_1, length)
        pos := add(headStart, 64)
        let srcPtr := add(value0, _1)
        let i := 0
        for { } lt(i, length) { i := add(i, 1) }
        {
            mstore(pos, and(mload(srcPtr), sub(shl(160, 1), 1)))
            pos := add(pos, _1)
            srcPtr := add(srcPtr, _1)
        }
        tail := pos
    }
    function abi_decode_tuple_t_address(headStart, dataEnd) -> value0
    {
        if slt(sub(dataEnd, headStart), 32) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
    }
    function abi_decode_bool(offset) -> value
    {
        value := calldataload(offset)
        if iszero(eq(value, iszero(iszero(value)))) { revert(0, 0) }
    }
    function abi_decode_tuple_t_addresst_addresst_bool(headStart, dataEnd) -> value0, value1, value2
    {
        if slt(sub(dataEnd, headStart), 96) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := abi_decode_address(add(headStart, 32))
        value2 := abi_decode_bool(add(headStart, 64))
    }
    function panic_error_0x21()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x21)
        revert(0, 0x24)
    }
    function abi_encode_tuple_t_array$_t_struct$_DelegationInfo_$1903_memory_ptr_$dyn_memory_ptr__to_t_array$_t_struct$_DelegationInfo_$1903_memory_ptr_$dyn_memory_ptr__fromStack_reversed(headStart, value0) -> tail
    {
        let _1 := 32
        let tail_1 := add(headStart, _1)
        mstore(headStart, _1)
        let pos := tail_1
        let length := mload(value0)
        mstore(tail_1, length)
        let _2 := 64
        pos := add(headStart, _2)
        let srcPtr := add(value0, _1)
        let i := 0
        let i_1 := i
        for { } lt(i_1, length) { i_1 := add(i_1, 1) }
        {
            let _3 := mload(srcPtr)
            let _4 := mload(_3)
            let _5 := 4
            if iszero(lt(_4, _5))
            {
                mstore(i, shl(224, 0x4e487b71))
                mstore(_5, 0x21)
                revert(i, 0x24)
            }
            mstore(pos, _4)
            let memberValue0 := mload(add(_3, _1))
            let _6 := sub(shl(160, 1), 1)
            mstore(add(pos, _1), and(memberValue0, _6))
            mstore(add(pos, _2), and(mload(add(_3, _2)), _6))
            let _7 := 0x60
            mstore(add(pos, _7), and(mload(add(_3, _7)), _6))
            let _8 := 0x80
            mstore(add(pos, _8), mload(add(_3, _8)))
            pos := add(pos, 0xa0)
            srcPtr := add(srcPtr, _1)
        }
        tail := pos
    }
    function abi_decode_tuple_t_addresst_addresst_uint256t_bool(headStart, dataEnd) -> value0, value1, value2, value3
    {
        if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := abi_decode_address(add(headStart, 32))
        value2 := calldataload(add(headStart, 64))
        value3 := abi_decode_bool(add(headStart, 96))
    }
    function abi_decode_tuple_t_addresst_bool(headStart, dataEnd) -> value0, value1
    {
        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := abi_decode_bool(add(headStart, 32))
    }
    function abi_encode_tuple_t_array$_t_struct$_TokenDelegation_$1915_memory_ptr_$dyn_memory_ptr__to_t_array$_t_struct$_TokenDelegation_$1915_memory_ptr_$dyn_memory_ptr__fromStack_reversed(headStart, value0) -> tail
    {
        let _1 := 32
        let tail_1 := add(headStart, _1)
        mstore(headStart, _1)
        let pos := tail_1
        let length := mload(value0)
        mstore(tail_1, length)
        let _2 := 64
        pos := add(headStart, _2)
        let srcPtr := add(value0, _1)
        let i := 0
        for { } lt(i, length) { i := add(i, 1) }
        {
            let _3 := mload(srcPtr)
            let _4 := sub(shl(160, 1), 1)
            mstore(pos, and(mload(_3), _4))
            mstore(add(pos, _1), mload(add(_3, _1)))
            mstore(add(pos, _2), and(mload(add(_3, _2)), _4))
            pos := add(pos, 0x60)
            srcPtr := add(srcPtr, _1)
        }
        tail := pos
    }
    function abi_decode_tuple_t_addresst_addresst_address(headStart, dataEnd) -> value0, value1, value2
    {
        if slt(sub(dataEnd, headStart), 96) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := abi_decode_address(add(headStart, 32))
        value2 := abi_decode_address(add(headStart, 64))
    }
    function abi_decode_tuple_t_addresst_address(headStart, dataEnd) -> value0, value1
    {
        if slt(sub(dataEnd, headStart), 64) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := abi_decode_address(add(headStart, 32))
    }
    function abi_decode_tuple_t_addresst_addresst_addresst_uint256(headStart, dataEnd) -> value0, value1, value2, value3
    {
        if slt(sub(dataEnd, headStart), 128) { revert(0, 0) }
        value0 := abi_decode_address(headStart)
        value1 := abi_decode_address(add(headStart, 32))
        value2 := abi_decode_address(add(headStart, 64))
        value3 := calldataload(add(headStart, 96))
    }
    function abi_encode_tuple_t_array$_t_struct$_ContractDelegation_$1908_memory_ptr_$dyn_memory_ptr__to_t_array$_t_struct$_ContractDelegation_$1908_memory_ptr_$dyn_memory_ptr__fromStack_reversed(headStart, value0) -> tail
    {
        let _1 := 32
        let tail_1 := add(headStart, _1)
        mstore(headStart, _1)
        let pos := tail_1
        let length := mload(value0)
        mstore(tail_1, length)
        let _2 := 64
        pos := add(headStart, _2)
        let srcPtr := add(value0, _1)
        let i := 0
        for { } lt(i, length) { i := add(i, 1) }
        {
            let _3 := mload(srcPtr)
            let _4 := sub(shl(160, 1), 1)
            mstore(pos, and(mload(_3), _4))
            mstore(add(pos, _1), and(mload(add(_3, _1)), _4))
            pos := add(pos, _2)
            srcPtr := add(srcPtr, _1)
        }
        tail := pos
    }
    function panic_error_0x11()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x11)
        revert(0, 0x24)
    }
    function increment_t_uint256(value) -> ret
    {
        if eq(value, not(0)) { panic_error_0x11() }
        ret := add(value, 1)
    }
    function abi_encode_tuple_t_address__to_t_address__fromStack_reversed(headStart, value0) -> tail
    {
        tail := add(headStart, 32)
        mstore(headStart, and(value0, sub(shl(160, 1), 1)))
    }
    function abi_encode_tuple_t_address_t_address_t_address_t_bool__to_t_address_t_address_t_address_t_bool__fromStack_reversed(headStart, value3, value2, value1, value0) -> tail
    {
        tail := add(headStart, 128)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
        mstore(add(headStart, 64), and(value2, _1))
        mstore(add(headStart, 96), iszero(iszero(value3)))
    }
    function panic_error_0x41()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x41)
        revert(0, 0x24)
    }
    function panic_error_0x32()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x32)
        revert(0, 0x24)
    }
    function abi_encode_tuple_t_address_t_address_t_address_t_uint256_t_bool__to_t_address_t_address_t_address_t_uint256_t_bool__fromStack_reversed(headStart, value4, value3, value2, value1, value0) -> tail
    {
        tail := add(headStart, 160)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
        mstore(add(headStart, 64), and(value2, _1))
        mstore(add(headStart, 96), value3)
        mstore(add(headStart, 128), iszero(iszero(value4)))
    }
    function abi_encode_tuple_t_address_t_address_t_bool__to_t_address_t_address_t_bool__fromStack_reversed(headStart, value2, value1, value0) -> tail
    {
        tail := add(headStart, 96)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
        mstore(add(headStart, 64), iszero(iszero(value2)))
    }
    function abi_encode_tuple_t_address_t_address_t_address_t_uint256_t_uint256__to_t_address_t_address_t_address_t_uint256_t_uint256__fromStack_reversed(headStart, value4, value3, value2, value1, value0) -> tail
    {
        tail := add(headStart, 160)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
        mstore(add(headStart, 64), and(value2, _1))
        mstore(add(headStart, 96), value3)
        mstore(add(headStart, 128), value4)
    }
    function abi_encode_tuple_t_address_t_address_t_uint256_t_uint256__to_t_address_t_address_t_uint256_t_uint256__fromStack_reversed(headStart, value3, value2, value1, value0) -> tail
    {
        tail := add(headStart, 128)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
        mstore(add(headStart, 64), value2)
        mstore(add(headStart, 96), value3)
    }
    function abi_encode_tuple_t_address_t_address_t_address_t_uint256_t_uint256_t_uint256__to_t_address_t_address_t_address_t_uint256_t_uint256_t_uint256__fromStack_reversed(headStart, value5, value4, value3, value2, value1, value0) -> tail
    {
        tail := add(headStart, 192)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
        mstore(add(headStart, 64), and(value2, _1))
        mstore(add(headStart, 96), value3)
        mstore(add(headStart, 128), value4)
        mstore(add(headStart, 160), value5)
    }
    function abi_encode_tuple_t_address_t_address__to_t_address_t_address__fromStack_reversed(headStart, value1, value0) -> tail
    {
        tail := add(headStart, 64)
        let _1 := sub(shl(160, 1), 1)
        mstore(headStart, and(value0, _1))
        mstore(add(headStart, 32), and(value1, _1))
    }
    function checked_sub_t_uint256(x, y) -> diff
    {
        diff := sub(x, y)
        if gt(diff, x) { panic_error_0x11() }
    }
    function panic_error_0x31()
    {
        mstore(0, shl(224, 0x4e487b71))
        mstore(4, 0x31)
        revert(0, 0x24)
    }
}

#utility.yul

delegations

An immutable registry contract to be deployed as a standalone primitive

 @dev Implementation of the {IERC165} interface.
 Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 for the additional interface id that will be supported. For example:
 ```solidity
 function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 }
 ```
 Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.

ERC165

 @dev Interface of the ERC165 standard, as defined in the
 https://eips.ethereum.org/EIPS/eip-165[EIP].
 Implementers can declare support of contract interfaces, which can then be
 queried by others ({ERC165Checker}).
 For an implementation, see {ERC165}.

IERC165

 @dev Library for managing
 https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 types.
 Sets have the following properties:
 - Elements are added, removed, and checked for existence in constant time
 (O(1)).
 - Elements are enumerated in O(n). No guarantees are made on the ordering.
 ```
 contract Example {
     // Add the library methods
     using EnumerableSet for EnumerableSet.AddressSet;
     // Declare a set state variable
     EnumerableSet.AddressSet private mySet;
 }
 ```
 As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 and `uint256` (`UintSet`) are supported.
 [WARNING]
 ====
  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
  In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
 ====

EnumerableSet

_add

_remove

_contains

_length

_values

Bytes32Set

remove

contains

length

values

AddressSet

UintSet

 @title DelegationRegistry
 @custom:version 1.0
 @notice An immutable registry contract to be deployed as a standalone primitive.
 @dev See EIP-5639, new project launches can read previous cold wallet -> hot wallet delegations
 from here and integrate those permissions into their flow.
 @custom:coauthor foobar (0xfoobar)
 @custom:coauthor wwchung (manifoldxyz)
 @custom:coauthor purplehat (artblocks)
 @custom:coauthor ryley-o (artblocks)
 @custom:coauthor andy8052 (tessera)
 @custom:coauthor punk6529 (open metaverse)
 @custom:coauthor loopify (loopiverse)
 @custom:coauthor emiliano (nftrentals)
 @custom:coauthor arran (proof)
 @custom:coauthor james (collabland)
 @custom:coauthor john (gnosis safe)
 @custom:coauthor 0xrusowsky

vaultVersion

delegateVersion

delegationHashes

delegationInfo

_setDelegationValues

_computeAllDelegationHash

_computeContractDelegationHash

_computeTokenDelegationHash

_revokeDelegate

_getDelegatesForLevel

 @title An immutable registry contract to be deployed as a standalone primitive
 @dev See EIP-5639, new project launches can read previous cold wallet -> hot wallet delegations
 from here and integrate those permissions into their flow