ETH Price: $3,532.72 (+0.30%)

Token

sUSD/sETH Pool Certificate (UEPC)
 

Overview

Max Total Supply

4,310 UEPC

Holders

3,972

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

-
Balance
1 UEPC
0x8bbd6aec68aef08b2d4cdd93b2cffa48b6e10352
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information

Contract Source Code Verified (Exact Match)

Contract Name:
LiquidityCertificate

Compiler Version
v0.7.6

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity Standard Json-Input format)

File 1 of 16 : LiquidityCertificate.sol
//SPDX-License-Identifier: ISC
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2;

// Libraries
import "./synthetix/SafeDecimalMath.sol";

// Inherited
import "./openzeppelin-l2/ERC721.sol";
import "./interfaces/ILiquidityCertificate.sol";

/**
 * @title LiquidityCertificate
 * @author Lyra
 * @dev An ERC721 token which represents a share of the LiquidityPool.
 * It is minted when users deposit, and burned when users withdraw.
 */
contract LiquidityCertificate is ILiquidityCertificate, ERC721 {
  using SafeMath for uint;
  using SafeDecimalMath for uint;

  /// @dev The minimum amount of liquidity a certificate can be minted with.
  uint public constant override MIN_LIQUIDITY = 1e18;

  uint internal nextId;
  mapping(uint => CertificateData) internal _certificateData;
  address public override liquidityPool;
  bool internal initialized = false;

  /**
   * @param _name Token collection name
   * @param _symbol Token collection symbol
   */
  constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {}

  /**
   * @dev Initialize the contract.
   * @param _liquidityPool LiquidityPool address
   */
  function init(address _liquidityPool) external {
    require(!initialized, "already initialized");
    require(_liquidityPool != address(0), "liquidityPool cannot be 0 address");
    liquidityPool = _liquidityPool;
    initialized = true;
  }

  /**
   * @dev Returns all the certificates own by a given address.
   *
   * @param owner The owner of the certificates
   */
  function certificates(address owner) external view override returns (uint[] memory) {
    uint numCerts = balanceOf(owner);
    uint[] memory ids = new uint[](numCerts);

    for (uint i = 0; i < numCerts; i++) {
      ids[i] = tokenOfOwnerByIndex(owner, i);
    }

    return ids;
  }

  /**
   * @notice Returns certificate's `liquidity`.
   *
   * @param certificateId The id of the LiquidityCertificate.
   */
  function liquidity(uint certificateId) external view override returns (uint) {
    return _certificateData[certificateId].liquidity;
  }

  /**
   * @notice Returns certificate's `enteredAt`.
   *
   * @param certificateId The id of the LiquidityCertificate.
   */
  function enteredAt(uint certificateId) external view override returns (uint) {
    return _certificateData[certificateId].enteredAt;
  }

  /**
   * @notice Returns certificate's `burnableAt`.
   *
   * @param certificateId The id of the LiquidityCertificate.
   */
  function burnableAt(uint certificateId) external view override returns (uint) {
    return _certificateData[certificateId].burnableAt;
  }

  /**
   * @notice Returns a certificate's data.
   *
   * @param certificateId The id of the LiquidityCertificate.
   */
  function certificateData(uint certificateId)
    external
    view
    override
    returns (ILiquidityCertificate.CertificateData memory)
  {
    require(_certificateData[certificateId].liquidity != 0, "certificate does not exist");
    return _certificateData[certificateId];
  }

  /**
   * @dev Mints a new certificate and transfers it to `owner`.
   *
   * @param owner The account that will own the LiquidityCertificate.
   * @param liquidityAmount The amount of liquidity that has been deposited.
   * @param expiryAtCreation The time when the liquidity will become active.
   */
  function mint(
    address owner,
    uint liquidityAmount,
    uint expiryAtCreation
  ) external override onlyLiquidityPool returns (uint) {
    require(liquidityAmount >= MIN_LIQUIDITY, "liquidity value of certificate must be >= 1");

    uint certificateId = nextId++;
    _certificateData[certificateId] = CertificateData(liquidityAmount, expiryAtCreation, 0);
    _mint(owner, certificateId);

    emit CertificateDataModified(certificateId, liquidityAmount, expiryAtCreation, 0);
    return certificateId;
  }

  /**
   * @notice Sets `burnableAt` of a given certificate.
   *
   * @param certificateId The id of the LiquidityCertificate.
   * @param timestamp The time it will become burnable.
   */
  function setBurnableAt(
    address spender,
    uint certificateId,
    uint timestamp
  ) external override onlyLiquidityPool {
    require(_isApprovedOrOwner(spender, certificateId), "certificate does not exist or not owner");
    _certificateData[certificateId].burnableAt = timestamp;

    emit CertificateDataModified(
      certificateId,
      _certificateData[certificateId].liquidity,
      _certificateData[certificateId].enteredAt,
      timestamp
    );
  }

  /**
   * @notice Burns the LiquidityCertificate.
   *
   * @param spender The account which is performing the burn.
   * @param certificateId The id of the LiquidityCertificate.
   */
  function burn(address spender, uint certificateId) external override onlyLiquidityPool {
    require(_isApprovedOrOwner(spender, certificateId), "attempted to burn nonexistent certificate, or not owner");
    delete _certificateData[certificateId];
    _burn(certificateId);
  }

  /**
   * @notice Splits a LiquidityCertificate into two. Assigns `percentageSplit` of the original
   * liquidity to the new certificate.
   *
   * @param certificateId The id of the LiquidityCertificate.
   * @param percentageSplit The percentage of liquidity assigned to the new certificate.
   */
  function split(uint certificateId, uint percentageSplit) external override returns (uint) {
    require(percentageSplit < SafeDecimalMath.UNIT, "split must be less than 100%");
    require(ownerOf(certificateId) == msg.sender, "only the owner can split their certificate");
    CertificateData memory certData = _certificateData[certificateId];

    uint newCertLiquidity = certData.liquidity.multiplyDecimal(percentageSplit);
    uint oldCertLiquidity = certData.liquidity.sub(newCertLiquidity);

    require(
      newCertLiquidity >= MIN_LIQUIDITY && oldCertLiquidity >= MIN_LIQUIDITY,
      "liquidity value of both certificates must be >= 1"
    );

    _certificateData[certificateId].liquidity = oldCertLiquidity;

    uint newCertificateId = nextId++;
    _certificateData[newCertificateId] = CertificateData(newCertLiquidity, certData.enteredAt, certData.burnableAt);
    _mint(msg.sender, newCertificateId);

    emit CertificateSplit(certificateId, newCertificateId);
    emit CertificateDataModified(certificateId, oldCertLiquidity, certData.enteredAt, certData.burnableAt);
    emit CertificateDataModified(newCertificateId, newCertLiquidity, certData.enteredAt, certData.burnableAt);
    return newCertificateId;
  }

  /**
   * @dev Hook that is called before any token transfer. This includes minting and burning.
   */
  function _beforeTokenTransfer(
    address, // from
    address, // to
    uint tokenId
  ) internal view override {
    require(_certificateData[tokenId].burnableAt == 0, "cannot transfer certificates that have signalled exit");
  }

  modifier onlyLiquidityPool virtual {
    require(liquidityPool == msg.sender, "only LiquidityPool");
    _;
  }

  /**
   * @dev Emitted when a Certificate is minted, burnableAt is updated or it is split.
   */
  event CertificateDataModified(uint indexed certificateId, uint liquidity, uint enteredAt, uint burnableAt);

  /**
   * @dev Emitted when a Certificate is split.
   */
  event CertificateSplit(uint indexed certificateId, uint indexed newCertificateId);
}

File 2 of 16 : SafeDecimalMath.sol
//SPDX-License-Identifier: MIT
//
//Copyright (c) 2019 Synthetix
//
//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files (the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions:
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.

pragma solidity ^0.7.6;

// Libraries
import "@openzeppelin/contracts/math/SafeMath.sol";

// https://docs.synthetix.io/contracts/source/libraries/SafeDecimalMath/
library SafeDecimalMath {
  using SafeMath for uint;

  /* Number of decimal places in the representations. */
  uint8 public constant decimals = 18;
  uint8 public constant highPrecisionDecimals = 27;

  /* The number representing 1.0. */
  uint public constant UNIT = 10**uint(decimals);

  /* The number representing 1.0 for higher fidelity numbers. */
  uint public constant PRECISE_UNIT = 10**uint(highPrecisionDecimals);
  uint private constant UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR = 10**uint(highPrecisionDecimals - decimals);

  /**
   * @return Provides an interface to UNIT.
   */
  function unit() external pure returns (uint) {
    return UNIT;
  }

  /**
   * @return Provides an interface to PRECISE_UNIT.
   */
  function preciseUnit() external pure returns (uint) {
    return PRECISE_UNIT;
  }

  /**
   * @return The result of multiplying x and y, interpreting the operands as fixed-point
   * decimals.
   *
   * @dev A unit factor is divided out after the product of x and y is evaluated,
   * so that product must be less than 2**256. As this is an integer division,
   * the internal division always rounds down. This helps save on gas. Rounding
   * is more expensive on gas.
   */
  function multiplyDecimal(uint x, uint y) internal pure returns (uint) {
    /* Divide by UNIT to remove the extra factor introduced by the product. */
    return x.mul(y) / UNIT;
  }

  /**
   * @return The result of safely multiplying x and y, interpreting the operands
   * as fixed-point decimals of the specified precision unit.
   *
   * @dev The operands should be in the form of a the specified unit factor which will be
   * divided out after the product of x and y is evaluated, so that product must be
   * less than 2**256.
   *
   * Unlike multiplyDecimal, this function rounds the result to the nearest increment.
   * Rounding is useful when you need to retain fidelity for small decimal numbers
   * (eg. small fractions or percentages).
   */
  function _multiplyDecimalRound(
    uint x,
    uint y,
    uint precisionUnit
  ) private pure returns (uint) {
    /* Divide by UNIT to remove the extra factor introduced by the product. */
    uint quotientTimesTen = x.mul(y) / (precisionUnit / 10);

    if (quotientTimesTen % 10 >= 5) {
      quotientTimesTen += 10;
    }

    return quotientTimesTen / 10;
  }

  /**
   * @return The result of safely multiplying x and y, interpreting the operands
   * as fixed-point decimals of a precise unit.
   *
   * @dev The operands should be in the precise unit factor which will be
   * divided out after the product of x and y is evaluated, so that product must be
   * less than 2**256.
   *
   * Unlike multiplyDecimal, this function rounds the result to the nearest increment.
   * Rounding is useful when you need to retain fidelity for small decimal numbers
   * (eg. small fractions or percentages).
   */
  function multiplyDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
    return _multiplyDecimalRound(x, y, PRECISE_UNIT);
  }

  /**
   * @return The result of safely multiplying x and y, interpreting the operands
   * as fixed-point decimals of a standard unit.
   *
   * @dev The operands should be in the standard unit factor which will be
   * divided out after the product of x and y is evaluated, so that product must be
   * less than 2**256.
   *
   * Unlike multiplyDecimal, this function rounds the result to the nearest increment.
   * Rounding is useful when you need to retain fidelity for small decimal numbers
   * (eg. small fractions or percentages).
   */
  function multiplyDecimalRound(uint x, uint y) internal pure returns (uint) {
    return _multiplyDecimalRound(x, y, UNIT);
  }

  /**
   * @return The result of safely dividing x and y. The return value is a high
   * precision decimal.
   *
   * @dev y is divided after the product of x and the standard precision unit
   * is evaluated, so the product of x and UNIT must be less than 2**256. As
   * this is an integer division, the result is always rounded down.
   * This helps save on gas. Rounding is more expensive on gas.
   */
  function divideDecimal(uint x, uint y) internal pure returns (uint) {
    /* Reintroduce the UNIT factor that will be divided out by y. */
    return x.mul(UNIT).div(y);
  }

  /**
   * @return The result of safely dividing x and y. The return value is as a rounded
   * decimal in the precision unit specified in the parameter.
   *
   * @dev y is divided after the product of x and the specified precision unit
   * is evaluated, so the product of x and the specified precision unit must
   * be less than 2**256. The result is rounded to the nearest increment.
   */
  function _divideDecimalRound(
    uint x,
    uint y,
    uint precisionUnit
  ) private pure returns (uint) {
    uint resultTimesTen = x.mul(precisionUnit * 10).div(y);

    if (resultTimesTen % 10 >= 5) {
      resultTimesTen += 10;
    }

    return resultTimesTen / 10;
  }

  /**
   * @return The result of safely dividing x and y. The return value is as a rounded
   * standard precision decimal.
   *
   * @dev y is divided after the product of x and the standard precision unit
   * is evaluated, so the product of x and the standard precision unit must
   * be less than 2**256. The result is rounded to the nearest increment.
   */
  function divideDecimalRound(uint x, uint y) internal pure returns (uint) {
    return _divideDecimalRound(x, y, UNIT);
  }

  /**
   * @return The result of safely dividing x and y. The return value is as a rounded
   * high precision decimal.
   *
   * @dev y is divided after the product of x and the high precision unit
   * is evaluated, so the product of x and the high precision unit must
   * be less than 2**256. The result is rounded to the nearest increment.
   */
  function divideDecimalRoundPrecise(uint x, uint y) internal pure returns (uint) {
    return _divideDecimalRound(x, y, PRECISE_UNIT);
  }

  /**
   * @dev Convert a standard decimal representation to a high precision one.
   */
  function decimalToPreciseDecimal(uint i) internal pure returns (uint) {
    return i.mul(UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR);
  }

  /**
   * @dev Convert a high precision decimal to a standard decimal representation.
   */
  function preciseDecimalToDecimal(uint i) internal pure returns (uint) {
    uint quotientTimesTen = i / (UNIT_TO_HIGH_PRECISION_CONVERSION_FACTOR / 10);

    if (quotientTimesTen % 10 >= 5) {
      quotientTimesTen += 10;
    }

    return quotientTimesTen / 10;
  }
}

File 3 of 16 : ERC721.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.6;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Metadata.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@openzeppelin/contracts/introspection/ERC165.sol";
import "@openzeppelin/contracts/math/SafeMath.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/EnumerableSet.sol";
import "@openzeppelin/contracts/utils/EnumerableMap.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./Address.sol";

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
  using SafeMath for uint;
  using Address for address;
  using EnumerableSet for EnumerableSet.UintSet;
  using EnumerableMap for EnumerableMap.UintToAddressMap;
  using Strings for uint;

  // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
  // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
  bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

  // Mapping from holder address to their (enumerable) set of owned tokens
  mapping(address => EnumerableSet.UintSet) private _holderTokens;

  // Enumerable mapping from token ids to their owners
  EnumerableMap.UintToAddressMap private _tokenOwners;

  // Mapping from token ID to approved address
  mapping(uint => address) private _tokenApprovals;

  // Mapping from owner to operator approvals
  mapping(address => mapping(address => bool)) private _operatorApprovals;

  // Token name
  string private _name;

  // Token symbol
  string private _symbol;

  // Optional mapping for token URIs
  mapping(uint => string) private _tokenURIs;

  // Base URI
  string private _baseURI;

  /*
   *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
   *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
   *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
   *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
   *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
   *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
   *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
   *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
   *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
   *
   *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
   *        0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
   */
  bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

  /*
   *     bytes4(keccak256('name()')) == 0x06fdde03
   *     bytes4(keccak256('symbol()')) == 0x95d89b41
   *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
   *
   *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
   */
  bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

  /*
   *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
   *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
   *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
   *
   *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
   */
  bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

  /**
   * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
   */
  constructor(string memory name_, string memory symbol_) {
    _name = name_;
    _symbol = symbol_;

    // register the supported interfaces to conform to ERC721 via ERC165
    _registerInterface(_INTERFACE_ID_ERC721);
    _registerInterface(_INTERFACE_ID_ERC721_METADATA);
    _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
  }

  /**
   * @dev See {IERC721-balanceOf}.
   */
  function balanceOf(address owner) public view virtual override returns (uint) {
    require(owner != address(0), "ERC721: balance query for the zero address");
    return _holderTokens[owner].length();
  }

  /**
   * @dev See {IERC721-ownerOf}.
   */
  function ownerOf(uint tokenId) public view virtual override returns (address) {
    return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
  }

  /**
   * @dev See {IERC721Metadata-name}.
   */
  function name() public view virtual override returns (string memory) {
    return _name;
  }

  /**
   * @dev See {IERC721Metadata-symbol}.
   */
  function symbol() public view virtual override returns (string memory) {
    return _symbol;
  }

  /**
   * @dev See {IERC721Metadata-tokenURI}.
   */
  function tokenURI(uint tokenId) public view virtual override returns (string memory) {
    require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

    string memory _tokenURI = _tokenURIs[tokenId];
    string memory base = baseURI();

    // If there is no base URI, return the token URI.
    if (bytes(base).length == 0) {
      return _tokenURI;
    }
    // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
    if (bytes(_tokenURI).length > 0) {
      return string(abi.encodePacked(base, _tokenURI));
    }
    // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
    return string(abi.encodePacked(base, tokenId.toString()));
  }

  /**
   * @dev Returns the base URI set via {_setBaseURI}. This will be
   * automatically added as a prefix in {tokenURI} to each token's URI, or
   * to the token ID if no specific URI is set for that token ID.
   */
  function baseURI() public view virtual returns (string memory) {
    return _baseURI;
  }

  /**
   * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
   */
  function tokenOfOwnerByIndex(address owner, uint index) public view virtual override returns (uint) {
    return _holderTokens[owner].at(index);
  }

  /**
   * @dev See {IERC721Enumerable-totalSupply}.
   */
  function totalSupply() public view virtual override returns (uint) {
    // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
    return _tokenOwners.length();
  }

  /**
   * @dev See {IERC721Enumerable-tokenByIndex}.
   */
  function tokenByIndex(uint index) public view virtual override returns (uint) {
    (uint tokenId, ) = _tokenOwners.at(index);
    return tokenId;
  }

  /**
   * @dev See {IERC721-approve}.
   */
  function approve(address to, uint tokenId) public virtual override {
    address owner = ERC721.ownerOf(tokenId);
    require(to != owner, "ERC721: approval to current owner");

    require(
      _msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
      "ERC721: approve caller is not owner nor approved for all"
    );

    _approve(to, tokenId);
  }

  /**
   * @dev See {IERC721-getApproved}.
   */
  function getApproved(uint tokenId) public view virtual override returns (address) {
    require(_exists(tokenId), "ERC721: approved query for nonexistent token");

    return _tokenApprovals[tokenId];
  }

  /**
   * @dev See {IERC721-setApprovalForAll}.
   */
  function setApprovalForAll(address operator, bool approved) public virtual override {
    require(operator != _msgSender(), "ERC721: approve to caller");

    _operatorApprovals[_msgSender()][operator] = approved;
    emit ApprovalForAll(_msgSender(), operator, approved);
  }

  /**
   * @dev See {IERC721-isApprovedForAll}.
   */
  function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
    return _operatorApprovals[owner][operator];
  }

  /**
   * @dev See {IERC721-transferFrom}.
   */
  function transferFrom(
    address from,
    address to,
    uint tokenId
  ) public virtual override {
    //solhint-disable-next-line max-line-length
    require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

    _transfer(from, to, tokenId);
  }

  /**
   * @dev See {IERC721-safeTransferFrom}.
   */
  function safeTransferFrom(
    address from,
    address to,
    uint tokenId
  ) public virtual override {
    safeTransferFrom(from, to, tokenId, "");
  }

  /**
   * @dev See {IERC721-safeTransferFrom}.
   */
  function safeTransferFrom(
    address from,
    address to,
    uint tokenId,
    bytes memory _data
  ) public virtual override {
    require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
    _safeTransfer(from, to, tokenId, _data);
  }

  /**
   * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
   * are aware of the ERC721 protocol to prevent tokens from being forever locked.
   *
   * `_data` is additional data, it has no specified format and it is sent in call to `to`.
   *
   * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
   * implement alternative mechanisms to perform token transfer, such as signature-based.
   *
   * Requirements:
   *
   * - `from` cannot be the zero address.
   * - `to` cannot be the zero address.
   * - `tokenId` token must exist and be owned by `from`.
   * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
   *
   * Emits a {Transfer} event.
   */
  function _safeTransfer(
    address from,
    address to,
    uint tokenId,
    bytes memory _data
  ) internal virtual {
    _transfer(from, to, tokenId);
    require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
  }

  /**
   * @dev Returns whether `tokenId` exists.
   *
   * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
   *
   * Tokens start existing when they are minted (`_mint`),
   * and stop existing when they are burned (`_burn`).
   */
  function _exists(uint tokenId) internal view virtual returns (bool) {
    return _tokenOwners.contains(tokenId);
  }

  /**
   * @dev Returns whether `spender` is allowed to manage `tokenId`.
   *
   * Requirements:
   *
   * - `tokenId` must exist.
   */
  function _isApprovedOrOwner(address spender, uint tokenId) internal view virtual returns (bool) {
    require(_exists(tokenId), "ERC721: operator query for nonexistent token");
    address owner = ERC721.ownerOf(tokenId);
    return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
  }

  /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
  function _safeMint(address to, uint tokenId) internal virtual {
    _safeMint(to, tokenId, "");
  }

  /**
   * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
   * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
   */
  function _safeMint(
    address to,
    uint tokenId,
    bytes memory _data
  ) internal virtual {
    _mint(to, tokenId);
    require(
      _checkOnERC721Received(address(0), to, tokenId, _data),
      "ERC721: transfer to non ERC721Receiver implementer"
    );
  }

  /**
   * @dev Mints `tokenId` and transfers it to `to`.
   *
   * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
   *
   * Requirements:
   *
   * - `tokenId` must not exist.
   * - `to` cannot be the zero address.
   *
   * Emits a {Transfer} event.
   */
  function _mint(address to, uint tokenId) internal virtual {
    require(to != address(0), "ERC721: mint to the zero address");
    require(!_exists(tokenId), "ERC721: token already minted");

    _beforeTokenTransfer(address(0), to, tokenId);

    _holderTokens[to].add(tokenId);

    _tokenOwners.set(tokenId, to);

    emit Transfer(address(0), to, tokenId);
  }

  /**
   * @dev Destroys `tokenId`.
   * The approval is cleared when the token is burned.
   *
   * Requirements:
   *
   * - `tokenId` must exist.
   *
   * Emits a {Transfer} event.
   */
  function _burn(uint tokenId) internal virtual {
    address owner = ERC721.ownerOf(tokenId); // internal owner

    _beforeTokenTransfer(owner, address(0), tokenId);

    // Clear approvals
    _approve(address(0), tokenId);

    // Clear metadata (if any)
    if (bytes(_tokenURIs[tokenId]).length != 0) {
      delete _tokenURIs[tokenId];
    }

    _holderTokens[owner].remove(tokenId);

    _tokenOwners.remove(tokenId);

    emit Transfer(owner, address(0), tokenId);
  }

  /**
   * @dev Transfers `tokenId` from `from` to `to`.
   *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
   *
   * Requirements:
   *
   * - `to` cannot be the zero address.
   * - `tokenId` token must be owned by `from`.
   *
   * Emits a {Transfer} event.
   */
  function _transfer(
    address from,
    address to,
    uint tokenId
  ) internal virtual {
    require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
    require(to != address(0), "ERC721: transfer to the zero address");

    _beforeTokenTransfer(from, to, tokenId);

    // Clear approvals from the previous owner
    _approve(address(0), tokenId);

    _holderTokens[from].remove(tokenId);
    _holderTokens[to].add(tokenId);

    _tokenOwners.set(tokenId, to);

    emit Transfer(from, to, tokenId);
  }

  /**
   * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
   *
   * Requirements:
   *
   * - `tokenId` must exist.
   */
  function _setTokenURI(uint tokenId, string memory _tokenURI) internal virtual {
    require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
    _tokenURIs[tokenId] = _tokenURI;
  }

  /**
   * @dev Internal function to set the base URI for all token IDs. It is
   * automatically added as a prefix to the value returned in {tokenURI},
   * or to the token ID if {tokenURI} is empty.
   */
  function _setBaseURI(string memory baseURI_) internal virtual {
    _baseURI = baseURI_;
  }

  /**
   * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
   * The call is not executed if the target address is not a contract.
   *
   * @param from address representing the previous owner of the given token ID
   * @param to target address that will receive the tokens
   * @param tokenId uint256 ID of the token to be transferred
   * @param _data bytes optional data to send along with the call
   * @return bool whether the call correctly returned the expected magic value
   */
  function _checkOnERC721Received(
    address from,
    address to,
    uint tokenId,
    bytes memory _data
  ) private returns (bool) {
    if (!to.isContract()) {
      return true;
    }
    bytes memory returndata =
      to.functionCall(
        abi.encodeWithSelector(IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data),
        "ERC721: transfer to non ERC721Receiver implementer"
      );
    bytes4 retval = abi.decode(returndata, (bytes4));
    return (retval == _ERC721_RECEIVED);
  }

  /**
   * @dev Approve `to` to operate on `tokenId`
   *
   * Emits an {Approval} event.
   */
  function _approve(address to, uint tokenId) internal virtual {
    _tokenApprovals[tokenId] = to;
    emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner
  }

  /**
   * @dev Hook that is called before any token transfer. This includes minting
   * and burning.
   *
   * Calling conditions:
   *
   * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
   * transferred to `to`.
   * - When `from` is zero, `tokenId` will be minted for `to`.
   * - When `to` is zero, ``from``'s `tokenId` will be burned.
   * - `from` cannot be the zero address.
   * - `to` cannot be the zero address.
   *
   * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
   */
  function _beforeTokenTransfer(
    address from,
    address to,
    uint tokenId
  ) internal virtual {}
}

File 4 of 16 : ILiquidityCertificate.sol
//SPDX-License-Identifier: ISC
pragma solidity 0.7.6;
pragma experimental ABIEncoderV2;

interface ILiquidityCertificate {
  struct CertificateData {
    uint liquidity;
    uint enteredAt;
    uint burnableAt;
  }

  function MIN_LIQUIDITY() external view returns (uint);

  function liquidityPool() external view returns (address);

  function certificates(address owner) external view returns (uint[] memory);

  function liquidity(uint certificateId) external view returns (uint);

  function enteredAt(uint certificateId) external view returns (uint);

  function burnableAt(uint certificateId) external view returns (uint);

  function certificateData(uint certificateId) external view returns (CertificateData memory);

  function mint(
    address owner,
    uint liquidityAmount,
    uint expiryAtCreation
  ) external returns (uint);

  function setBurnableAt(
    address spender,
    uint certificateId,
    uint timestamp
  ) external;

  function burn(address spender, uint certificateId) external;

  function split(uint certificateId, uint percentageSplit) external returns (uint);
}

File 5 of 16 : SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

File 6 of 16 : IERC721.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

import "../../introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

File 7 of 16 : IERC721Metadata.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

import "./IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

File 8 of 16 : IERC721Enumerable.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.2 <0.8.0;

import "./IERC721.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

File 9 of 16 : IERC721Receiver.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}

File 10 of 16 : ERC165.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

import "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See {IERC165-supportsInterface}.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

File 11 of 16 : Context.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

File 12 of 16 : EnumerableSet.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @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.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

File 13 of 16 : EnumerableMap.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key) private view returns (bool) {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return _remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return _contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

   /**
    * @dev Returns the element stored at position `index` in the set. O(1).
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

File 14 of 16 : Strings.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}

File 15 of 16 : Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.7.6;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
  /**
   * @dev Returns true if `account` is a contract.
   *
   * [IMPORTANT]
   * ====
   * It is unsafe to assume that an address for which this function returns
   * false is an externally-owned account (EOA) and not a contract.
   *
   * Among others, `isContract` will return false for the following
   * types of addresses:
   *
   *  - an externally-owned account
   *  - a contract in construction
   *  - an address where a contract will be created
   *  - an address where a contract lived, but was destroyed
   * ====
   */
  function isContract(address account) internal view returns (bool) {
    // This method relies on extcodesize, which returns 0 for contracts in
    // construction, since the code is only stored at the end of the
    // constructor execution.

    uint size;
    // solhint-disable-next-line no-inline-assembly
    assembly {
      size := extcodesize(account)
    }
    return size > 0;
  }

  /**
   * @dev Performs a Solidity function call using a low level `call`. A
   * plain`call` is an unsafe replacement for a function call: use this
   * function instead.
   *
   * If `target` reverts with a revert reason, it is bubbled up by this
   * function (like regular Solidity function calls).
   *
   * Returns the raw returned data. To convert to the expected return value,
   * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
   *
   * Requirements:
   *
   * - `target` must be a contract.
   * - calling `target` with `data` must not revert.
   *
   * _Available since v3.1._
   */
  function functionCall(address target, bytes memory data) internal returns (bytes memory) {
    return functionCall(target, data, "Address: low-level call failed");
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
   * `errorMessage` as a fallback revert reason when `target` reverts.
   *
   * _Available since v3.1._
   */
  function functionCall(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal returns (bytes memory) {
    return functionCallWithoutValue(target, data, errorMessage);
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but also transferring `value` wei to `target`.
   *
   * Requirements:
   *
   * - the calling contract must have an ETH balance of at least `value`.
   * - the called Solidity function must be `payable`.
   *
   * _Available since v3.1._
   */
  function functionCallWithoutValue(address target, bytes memory data) internal returns (bytes memory) {
    return functionCallWithoutValue(target, data, "Address: low-level call with value failed");
  }

  /**
   * @dev Same as {xref-Address-functionCallWithoutValue-address-bytes-uint256-}[`functionCallWithoutValue`], but
   * with `errorMessage` as a fallback revert reason when `target` reverts.
   *
   * _Available since v3.1._
   */
  function functionCallWithoutValue(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal returns (bytes memory) {
    require(isContract(target), "Address: call to non-contract");

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = target.call(data);
    return _verifyCallResult(success, returndata, errorMessage);
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but performing a static call.
   *
   * _Available since v3.3._
   */
  function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
    return functionStaticCall(target, data, "Address: low-level static call failed");
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
   * but performing a static call.
   *
   * _Available since v3.3._
   */
  function functionStaticCall(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal view returns (bytes memory) {
    require(isContract(target), "Address: static call to non-contract");

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = target.staticcall(data);
    return _verifyCallResult(success, returndata, errorMessage);
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
   * but performing a delegate call.
   *
   * _Available since v3.4._
   */
  function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
    return functionDelegateCall(target, data, "Address: low-level delegate call failed");
  }

  /**
   * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
   * but performing a delegate call.
   *
   * _Available since v3.4._
   */
  function functionDelegateCall(
    address target,
    bytes memory data,
    string memory errorMessage
  ) internal returns (bytes memory) {
    require(isContract(target), "Address: delegate call to non-contract");

    // solhint-disable-next-line avoid-low-level-calls
    (bool success, bytes memory returndata) = target.delegatecall(data);
    return _verifyCallResult(success, returndata, errorMessage);
  }

  function _verifyCallResult(
    bool success,
    bytes memory returndata,
    string memory errorMessage
  ) private pure returns (bytes memory) {
    if (success) {
      return returndata;
    } else {
      // Look for revert reason and bubble it up if present
      if (returndata.length > 0) {
        // The easiest way to bubble the revert reason is using memory via assembly

        // solhint-disable-next-line no-inline-assembly
        assembly {
          let returndata_size := mload(returndata)
          revert(add(32, returndata), returndata_size)
        }
      } else {
        revert(errorMessage);
      }
    }
  }
}

File 16 of 16 : IERC165.sol
// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

/**
 * @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}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

Settings
{
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"certificateId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"enteredAt","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"burnableAt","type":"uint256"}],"name":"CertificateDataModified","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"certificateId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"newCertificateId","type":"uint256"}],"name":"CertificateSplit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MIN_LIQUIDITY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"certificateId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"certificateId","type":"uint256"}],"name":"burnableAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"certificateId","type":"uint256"}],"name":"certificateData","outputs":[{"components":[{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"enteredAt","type":"uint256"},{"internalType":"uint256","name":"burnableAt","type":"uint256"}],"internalType":"struct ILiquidityCertificate.CertificateData","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"certificates","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"certificateId","type":"uint256"}],"name":"enteredAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_liquidityPool","type":"address"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"certificateId","type":"uint256"}],"name":"liquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"liquidityAmount","type":"uint256"},{"internalType":"uint256","name":"expiryAtCreation","type":"uint256"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"certificateId","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"setBurnableAt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"certificateId","type":"uint256"},{"internalType":"uint256","name":"percentageSplit","type":"uint256"}],"name":"split","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000001a735553442f7345544820506f6f6c20436572746966696361746500000000000000000000000000000000000000000000000000000000000000000000000000045545504300000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): sUSD/sETH Pool Certificate
Arg [1] : _symbol (string): UEPC

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 000000000000000000000000000000000000000000000000000000000000001a
Arg [3] : 735553442f7345544820506f6f6c204365727469666963617465000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [5] : 5545504300000000000000000000000000000000000000000000000000000000


[ Download: CSV Export  ]
[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.