Mythics Eggs

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {BitMaps} from "openzeppelin-contracts/utils/structs/BitMaps.sol";
import {ERC4906} from "ethier/erc721/ERC4906.sol";

import {MythicsEggErrors} from "./MythicsEggErrors.sol";

interface MythicEggActivatorEvents {
    /**
     * @notice Emitted when an egg has been activated.
     */
    event EggActivated(uint256 indexed tokenId);
}

/**
 * @title Mythics: Egg activation module
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
abstract contract MythicEggActivator is ERC4906, MythicsEggErrors, MythicEggActivatorEvents {
    using BitMaps for BitMaps.BitMap;

    /**
     * @notice Throws if activating an egg that has already been activated.
     */
    error EggAlreadyActivated(uint256);

    /**
     * @notice Thrown if one tries to activate too many eggs at once.
     */
    error ActivatingTooManyEggs(uint256 requested, uint256 numLeft);

    /**
     * @notice Keeps track of eggs that have already been activated.
     */
    BitMaps.BitMap private _activated;

    /**
     * @notice The maximum number of eggs that can be activated during one day.
     */
    uint32 internal _maxNumActivationsPerDay = 50;

    /**
     * @notice The last day on which an egg was activated.
     */
    uint32 private _lastActivationDay;

    /**
     * @notice The number of eggs that have been activated today.
     * @dev Will be reset to 0 in `_activate` at the start of each day.
     */
    uint32 private _numActivatedToday;

    /**
     * @notice Helper function to get the current day number.
     */
    function _currentDay() private view returns (uint32) {
        return uint32(block.timestamp / (1 days));
    }

    /**
     * @notice Sets the maximum number of activations per day.
     */
    function _setMaxNumActivationsPerDay(uint32 maxNumActivationsPerDay) internal {
        _maxNumActivationsPerDay = maxNumActivationsPerDay;
    }

    /**
     * @notice Activates an array of eggs.
     * @dev Will revert if the number of eggs to activate exceeds the maximum number of activations per day.
     */
    function _activate(uint256[] calldata tokenIds) internal {
        if (_currentDay() > _lastActivationDay) {
            _numActivatedToday = 0;
            _lastActivationDay = _currentDay();
        }

        uint256 numLeft = _maxNumActivationsPerDay - _numActivatedToday;
        if (tokenIds.length > numLeft) {
            revert ActivatingTooManyEggs(tokenIds.length, numLeft);
        }

        for (uint256 i; i < tokenIds.length; ++i) {
            uint256 tokenId = tokenIds[i];

            if (activated(tokenId)) {
                revert EggAlreadyActivated(tokenId);
            }

            if (!_exists(tokenId)) {
                revert NonexistentEgg(tokenId);
            }

            _activated.set(tokenId);
            _refreshMetadata(tokenId);
            emit EggActivated(tokenId);
        }
        _numActivatedToday += uint32(tokenIds.length);
    }

    /**
     * @notice Returns whether an egg has already been activated.
     */
    function activated(uint256 tokenId) public view returns (bool) {
        if (!_exists(tokenId)) {
            revert NonexistentEgg(tokenId);
        }

        return _activated.get(tokenId);
    }

    /**
     * @notice Returns whether a token exists.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool);
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {IEntropyOracle} from "proof/entropy/IEntropyOracle.sol";

import {MythicsEggErrors} from "./MythicsEggErrors.sol";
import {
    StochasticSampler, StochasticSamplerWithCDFStorage, StochasticSamplerWithOracle
} from "./StochasticSampling.sol";

/**
 * @title Mythics: Egg type sampling module
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
abstract contract MythicEggSampler is StochasticSamplerWithCDFStorage, StochasticSamplerWithOracle, MythicsEggErrors {
    /**
     * @notice The different types of eggs.
     */
    enum EggType {
        Stone,
        Runic,
        Legendary
    }

    /**
     * @notice Number of egg types
     */
    uint8 public constant NUM_EGG_TYPES = 3;

    /**
     * @notice Trait ID for the egg type
     */
    uint8 private constant _EGG_TYPE_TRAIT_ID = 0;

    /**
     * @notice Token-specific parameters for sampling the egg type
     * @dev Will be determined at mint.
     * @param revealBlockNumber Number of the block whose entropy will be used to reaveal the egg type.
     * @param distributionVersion The version/index of probability distribution to sample the egg type.
     * @param mixHash Part of the block mixHash to blind the entropy oracle.
     */
    struct SamplingParams {
        uint64 revealBlockNumber;
        uint16 distributionVersion;
        uint128 mixHash;
    }

    /**
     * @notice Egg-type sampling parameters keyed by token ID.
     */
    mapping(uint256 => SamplingParams) private _samplingParams;

    /**
     * @dev Constructor helper function.
     */
    function _numPerTrait() private pure returns (uint256[] memory) {
        uint256[] memory numPerTrait = new uint256[](1);
        numPerTrait[_EGG_TYPE_TRAIT_ID] = NUM_EGG_TYPES;
        return numPerTrait;
    }

    constructor(IEntropyOracle oracle)
        StochasticSamplerWithCDFStorage(_numPerTrait())
        StochasticSamplerWithOracle(oracle)
    {}

    /**
     * @notice Returns the egg-type sampling parameters for a given token ID.
     */
    function samplingParams(uint256 tokenId) public view returns (SamplingParams memory) {
        if (!_exists(tokenId)) {
            revert NonexistentEgg(tokenId);
        }

        return _samplingParams[tokenId];
    }

    /**
     * @inheritdoc StochasticSamplerWithCDFStorage
     * @dev Reads the token-specific parameters.
     */
    function _distributionVersion(uint256 tokenId, uint256 traitId) internal view virtual override returns (uint256) {
        assert(traitId == _EGG_TYPE_TRAIT_ID);
        return _samplingParams[tokenId].distributionVersion;
    }

    /**
     * @inheritdoc StochasticSamplerWithOracle
     * @dev Reads the token-specific parameters.
     */
    function _revealBlockNumber(uint256 tokenId) internal view virtual override returns (uint256) {
        return _samplingParams[tokenId].revealBlockNumber;
    }

    /**
     * @notice Registers a token for egg-type sampling using the currently set probability distribution.
     * @dev Must be called upon token mint.
     */
    function _registerForSampling(uint256 tokenId) internal {
        uint256 revealBlockNumber = block.number;

        _samplingParams[tokenId] = SamplingParams({
            revealBlockNumber: uint64(revealBlockNumber),
            distributionVersion: uint16(_latestDistributionVersion(_EGG_TYPE_TRAIT_ID)),
            // Smearing out single-bit-of-influence from the prevrandao since we're just using 128 bits (mainly to
            // prevent the forge fuzzer from finding breaking runs which would force us to add circular testing logic).
            mixHash: uint128(uint256(keccak256(abi.encode(block.prevrandao))))
        });
        entropyOracle.requestEntropy(revealBlockNumber);
    }

    /**
     * @notice Sets the probability distribution for egg types.
     */
    function _setEggProbabilities(uint64[NUM_EGG_TYPES] memory pdf) internal {
        uint64[] memory p = new uint64[](NUM_EGG_TYPES);
        for (uint256 i = 0; i < NUM_EGG_TYPES; i++) {
            p[i] = pdf[i];
        }
        _pushProbabilities(_EGG_TYPE_TRAIT_ID, p);
    }

    /**
     * @inheritdoc StochasticSamplerWithOracle
     * @dev Mixes the seed with the token-specific parameters to blind the EntropyOracle.
     */
    function _seed(uint256 tokenId)
        internal
        view
        virtual
        override(StochasticSampler, StochasticSamplerWithOracle)
        returns (bytes32, bool)
    {
        (bytes32 seed, bool revealed) = StochasticSamplerWithOracle._seed(tokenId);
        return (keccak256(abi.encode(seed, samplingParams(tokenId))), revealed);
    }

    /**
     * @notice Returns the egg type of a given token ID and a boolean flag to indicate whether it was already revealed.
     */
    function eggType(uint256 tokenId) public view returns (EggType, bool) {
        (uint256 sample, bool revealed) = _sampleTrait(tokenId, _EGG_TYPE_TRAIT_ID);
        return (EggType(sample), revealed);
    }

    /**
     * @notice Returns whether a token exists.
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool);
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {ERC721A, ERC721ACommon, BaseTokenURI, ERC721ACommonBaseTokenURI} from "ethier/erc721/BaseTokenURI.sol";
import {OperatorFilterOS} from "ethier/erc721/OperatorFilterOS.sol";
import {ERC4906} from "ethier/erc721/ERC4906.sol";

import {IEntropyOracle} from "proof/entropy/IEntropyOracle.sol";
import {RedeemableERC721ACommon} from "proof/redemption/voucher/RedeemableERC721ACommon.sol";
import {SellableERC721ACommon} from "proof/sellers/sellable/SellableERC721ACommon.sol";

import {MythicEggSampler} from "./MythicEggSampler.sol";
import {MythicEggActivator} from "./MythicEggActivator.sol";

/**
 * @title Mythics: Egg
 * @notice A redeemable token claimable by all diamond nested Moonbirds.
 * @author David Huber (@cxkoda)
 * @custom:reviewer Arran Schlosberg (@divergencearran)
 */
contract MythicsEgg is
    ERC721ACommonBaseTokenURI,
    OperatorFilterOS,
    SellableERC721ACommon,
    RedeemableERC721ACommon,
    MythicEggSampler,
    MythicEggActivator
{
    constructor(address admin, address steerer, address payable secondaryReceiver, IEntropyOracle oracle)
        ERC721ACommon(admin, steerer, "Mythics: Egg", "EGG", secondaryReceiver, 500)
        BaseTokenURI("https://metadata.proof.xyz/mythics/egg/")
        MythicEggSampler(oracle)
    {
        _setEggProbabilities([uint64(0), uint64(40), uint64(60)]);
    }

    // =================================================================================================================
    //                          Information Getter
    // =================================================================================================================

    /**
     * @notice Encodes information about a token.
     * @dev Intended to be used off-chain.
     */
    struct TokenInfo {
        bool revealed;
        EggType eggType;
        bool activated;
    }

    /**
     * @notice Returns information about given egg token.
     * @dev Not optimised, intended to be used off-chain only.
     */
    function tokenInfos(uint256[] calldata tokenIds) external view returns (TokenInfo[] memory) {
        TokenInfo[] memory infos = new TokenInfo[](tokenIds.length);
        for (uint256 i = 0; i < tokenIds.length; i++) {
            (EggType eggT, bool revealed) = eggType(tokenIds[i]);
            infos[i] = TokenInfo({revealed: revealed, eggType: eggT, activated: activated(tokenIds[i])});
        }
        return infos;
    }

    // =================================================================================================================
    //                          Steering
    // =================================================================================================================

    /**
     * @notice Sets the probability distribution for egg types.
     */
    function setEggProbabilities(uint64[NUM_EGG_TYPES] memory pdf) external onlyRole(DEFAULT_STEERING_ROLE) {
        _setEggProbabilities(pdf);
    }

    /**
     * @notice Sets the entropy oracle.
     */
    function setEntropyOracle(IEntropyOracle newOracle) external onlyRole(DEFAULT_STEERING_ROLE) {
        entropyOracle = newOracle;
    }

    /**
     * @notice Sets the maximum number of activations per day.
     */
    function setMaxNumActivationsPerDay(uint32 maxNumActivationsPerDay) external onlyRole(DEFAULT_STEERING_ROLE) {
        _setMaxNumActivationsPerDay(maxNumActivationsPerDay);
    }

    /**
     * @notice Activates an array of eggs.
     */
    function activate(uint256[] calldata tokenIds) external onlyRole(DEFAULT_STEERING_ROLE) {
        _activate(tokenIds);
    }

    // =================================================================================================================
    //                          Inheritance Resolution
    // =================================================================================================================

    /**
     * @inheritdoc SellableERC721ACommon
     * @dev Registers the minted tokens for sampling.
     */
    function _handleSale(address to, uint64 num, bytes calldata data) internal virtual override {
        uint256 startTokenId = _nextTokenId();
        for (uint256 i; i < num; ++i) {
            _registerForSampling(startTokenId + i);
        }

        super._handleSale(to, num, data);
    }

    function _exists(uint256 tokenId)
        internal
        view
        virtual
        override(ERC721A, MythicEggActivator, MythicEggSampler)
        returns (bool)
    {
        return ERC721A._exists(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721ACommon, ERC721ACommonBaseTokenURI, SellableERC721ACommon, RedeemableERC721ACommon, ERC4906)
        returns (bool)
    {
        return RedeemableERC721ACommon.supportsInterface(interfaceId)
            || SellableERC721ACommon.supportsInterface(interfaceId) || ERC4906.supportsInterface(interfaceId)
            || ERC721ACommonBaseTokenURI.supportsInterface(interfaceId);
    }

    function _baseURI() internal view virtual override(ERC721A, ERC721ACommonBaseTokenURI) returns (string memory) {
        return ERC721ACommonBaseTokenURI._baseURI();
    }

    function setApprovalForAll(address operator, bool approved) public virtual override(ERC721A, OperatorFilterOS) {
        OperatorFilterOS.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId) public payable virtual override(ERC721A, OperatorFilterOS) {
        OperatorFilterOS.approve(operator, tokenId);
    }

    function transferFrom(address from, address to, uint256 tokenId)
        public
        payable
        virtual
        override(ERC721A, OperatorFilterOS)
    {
        OperatorFilterOS.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId)
        public
        payable
        virtual
        override(ERC721A, OperatorFilterOS)
    {
        OperatorFilterOS.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        payable
        virtual
        override(ERC721A, OperatorFilterOS)
    {
        OperatorFilterOS.safeTransferFrom(from, to, tokenId, data);
    }
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

interface MythicsEggErrors {
    /**
     * @notice Thrown if one attempts an action on a nonexistent egg.
     */
    error NonexistentEgg(uint256 tokenId);
}

// SPDX-License-Identifier: MIT
// Copyright 2023 PROOF Holdings Inc
pragma solidity ^0.8.15;

import {IEntropyOracle} from "proof/entropy/IEntropyOracle.sol";

/**
 * @notice Helper libray for sampling from a discrete probability distribution.
 */
library StochasticSamplingLib {
    /**
     * @notice Computes the cumulative probability distribution from a discrete probability distribution.
     */
    function computeCDF(uint64[] memory pdf) internal pure returns (uint64[] memory) {
        uint64[] memory cdf = new uint64[](pdf.length);
        cdf[0] = pdf[0];
        for (uint256 i = 1; i < pdf.length; ++i) {
            cdf[i] = cdf[i - 1] + pdf[i];
        }

        return cdf;
    }

    /**
     * @notice Samples from a discrete cumulative probability distribution.
     * @dev This function assumes that rand is uniform in [0,2^256) and that `cdf[cdf.length - 1] << 2^256`. If not the
     * outcome will be biased
     */
    function sampleWithCDF(uint256 rand, uint64[] memory cdf) internal pure returns (uint256) {
        rand = rand % cdf[cdf.length - 1];

        for (uint256 i; i < cdf.length; ++i) {
            if (rand < cdf[i]) {
                return i;
            }
        }

        // This will never be reached given the above bounds of rand.
        assert(false);
        return 0;
    }
}

/**
 * @notice A contract that can sample token traits from discrete probability distributions.
 * @dev The probability distributions and seed derivation functions are implemented in the inheriting contracts.
 * @dev The functions defined here might be gas-heavy and are therefore intended to be used in view-calls only.
 */
abstract contract StochasticSampler {
    /**
     * @notice Returns a random seed for a given token and a boolean indicating whether the seed is available.
     */
    function _seed(uint256 tokenId) internal view virtual returns (bytes32, bool);

    /**
     * @notice Returns the cumulative probability distribution for a given trait of a given token.
     */
    function _cdf(uint256 tokenId, uint256 traitId) internal view virtual returns (uint64[] memory);

    /**
     * @notice Samples a trait for a given token.
     * @dev Returns the sampled trait and a boolean indicating whether the trait was already revealed (i.e. if the seed
     * for the given token is available).
     */
    function _sampleTrait(uint256 tokenId, uint256 traitId) internal view returns (uint256, bool) {
        (bytes32 seed, bool revealed) = _seed(tokenId);
        seed = keccak256(abi.encodePacked(seed, traitId));
        return (StochasticSamplingLib.sampleWithCDF(uint256(seed), _cdf(tokenId, traitId)), revealed);
    }
}

/**
 * @notice A contract that can sample token traits from discrete probability distributions loaded from storage.
 */
abstract contract StochasticSamplerWithCDFStorage is StochasticSampler {
    using StochasticSamplingLib for uint64[];

    /**
     * @notice Thrown if the traitId is invalid, i.e. if it exceeds the number of traits.
     */
    error InvalidTraitId(uint256 traitId);

    /**
     * @notice Thrown if the length of the given PDF does not match the number of realisations in a given trait.
     */
    error IncorrectPDFLength(uint256 gotLength, uint256 traitId, uint256 wantLength);

    /**
     * @notice Thrown if the given PDF cannot be normalised, i.e. if the sum of the probabilities is zero.
     */
    error ConstantZeroPDF();

    /**
     * @notice The number of realisations for each trait.
     */
    uint256[] private _numPerTrait;

    /**
     * @notice The cumulative probability distributions for each trait.
     * @dev Indexed by traitId, distributionVersion, sample.
     * @dev The distributionVersion is intended to allow having multiple "versions" of the probability distributions.
     */
    uint64[][][] private _cdfs;

    constructor(uint256[] memory numPerTrait) {
        _numPerTrait = numPerTrait;
        for (uint256 i; i < numPerTrait.length; ++i) {
            _cdfs.push(new uint64[][](0));
        }
        assert(_cdfs.length == numPerTrait.length);
    }

    /**
     * @notice Adds a new probability distribution for a given trait.
     */
    function _pushProbabilities(uint256 traitId, uint64[] memory pdf) internal {
        if (traitId >= _numPerTrait.length) {
            revert InvalidTraitId(traitId);
        }

        if (pdf.length != _numPerTrait[traitId]) {
            revert IncorrectPDFLength(pdf.length, traitId, _numPerTrait[traitId]);
        }

        uint64[] memory cdf = pdf.computeCDF();
        if (cdf[cdf.length - 1] == 0) {
            revert ConstantZeroPDF();
        }
        _cdfs[traitId].push(cdf);
    }

    /**
     * @notice Returns the version/index of the latest probability distribution for a given trait.
     */
    function _latestDistributionVersion(uint256 traitId) internal view returns (uint256) {
        return _cdfs[traitId].length - 1;
    }

    /**
     * @notice Returns the version/index of the probability distribution that is used for a given token and trait.
     * @dev This function is intended to be overridden by inheriting contracts.
     */
    function _distributionVersion(uint256 tokenId, uint256 traitId) internal view virtual returns (uint256);

    /**
     * @inheritdoc StochasticSampler
     * @dev Returns the probability distribution that is index by `_distributionVersion`.
     */
    function _cdf(uint256 tokenId, uint256 traitId) internal view virtual override returns (uint64[] memory) {
        if (traitId >= _numPerTrait.length) {
            revert InvalidTraitId(traitId);
        }
        return _cdfs[traitId][_distributionVersion(tokenId, traitId)];
    }
}

/**
 * @notice A contract that can sample token traits from discrete probability distributions using entropy provided by the
 * EntropyOracle.
 */
abstract contract StochasticSamplerWithOracle is StochasticSampler {
    /**
     * @notice The entropy oracle.
     */
    IEntropyOracle public entropyOracle;

    constructor(IEntropyOracle entropyOracle_) {
        entropyOracle = entropyOracle_;
    }

    /**
     * @inheritdoc StochasticSampler
     * @dev Uses the entropy of the block at `_revealBlockNumber(tokenId)`.
     */
    function _seed(uint256 tokenId) internal view virtual override returns (bytes32, bool) {
        bytes32 entropy = entropyOracle.blockEntropy(_revealBlockNumber(tokenId));
        return (keccak256(abi.encode(entropy, tokenId)), entropy != 0);
    }

    /**
     * @notice The blocknumber at which a given token will be revealed.
     * @dev The entropy provided by `entropyOracle` for this block will be used as seed for trait sampling.
     */
    function _revealBlockNumber(uint256 tokenId) internal view virtual returns (uint256);
}

{
  "compilationTarget": {
    "src/MythicsEgg.sol": "MythicsEgg"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 9999
  },
  "remappings": [
    ":@divergencetech/ethier/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ethier_0-55-0/",
    ":@openzeppelin/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/",
    ":ERC721A/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ERC721A_4-2-3/contracts/",
    ":ERC721A_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ERC721A_4-2-3/",
    ":delegation-registry/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/delegation-registry_2d1a158b/src/",
    ":delegation-registry_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/delegation-registry_2d1a158b/",
    ":ds-test/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ds-test_013e6c64/src/",
    ":ds-test_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ds-test_013e6c64/",
    ":erc721a/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ERC721A_4-2-3/",
    ":ethier/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ethier_0-55-0/contracts/",
    ":ethier_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/ethier_0-55-0/",
    ":forge-std/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/forge-std_1-4-0/src/",
    ":openzeppelin-contracts/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/contracts/",
    ":openzeppelin-contracts/contracts/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/contracts/",
    ":openzeppelin-contracts_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/openzeppelin-contracts_4-8-1/",
    ":operator-filter-registry/src/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/operator-filter-registry_1-4-1/src/",
    ":operator-filter-registry_root/=/home/dave/.cache/bazel/_bazel_dave/b9a57168317213f9241a484d2ee2d038/external/operator-filter-registry_1-4-1/",
    ":proof/constants/=/home/dave/proof/proof-seller/contracts/constants/src/",
    ":proof/entropy/=/home/dave/proof/proof-seller/contracts/entropy/",
    ":proof/redemption/=/home/dave/proof/proof-seller/contracts/redemption/src/",
    ":proof/sellers/=/home/dave/proof/proof-seller/contracts/sellers/src/"
  ]
}