Mint Fund is ramping up efforts in 2024 with new initiatives to support artists. Since beginning in 2021, Mint Fund has become a resource for artists from all over the world to onboard into crypto, receive funds to mint their works, and put their art onchain.

This year, we continue on.

Introducing Artist Roundtables

Our hope is to create spaces for artists to come together, discuss their work, and become part of a community of like-minded peers. In a space that moves at lightspeed, fostering connections among artists, sharing resources, and offering mutual support will be critical for establishing enduring relationships. We want to become a hub for these kinds of interactions in 2024 with the introduction of Artist Roundtables.

Each month, we will host two Artist Roundtables. To participate, artists can submit a short application with information about their practice and the work they are interested in creating. A curated selection of 10 artists will be invited to join each Roundtable. If selected, please come prepared to share a bit about your work, along with any questions you may have about releasing your project onchain.

How to Apply

At the beginning of the month, we’ll open applications at themint.fund/apply. Submit your application here before the deadline and let us know which session you are able to attend. We’re on the lookout to support artists who are undertaking ambitious projects and have new works that they would like to mint. Each session will include a range of artists working in a multitude of mediums from all over the world.

Once applications close, confirmation emails will be sent to selected artists to begin onboarding. If you’re not selected, you are welcome to apply again for an upcoming month.

Receiving a Mint Fund Grant

After each Artist Roundtable, we’ll send participating artists a $500 USDC grant to mint their work. The grant can be used towards the creation and minting of new work, on any chain or platform of an artist’s choosing.

Mint Fund will publish an editorial recap featuring all of the participating artists and works that were minted to bring more visibility to the projects.

Plus, the Mint Fund Partner Program and Future Initiatives

Along with the introduction of Artist Roundtables and Mint Fund grants, we will continue to accept applications for our Partner Program. If you are an organization, or an artist, creative, or curator looking to make a larger initiative or group show come to life, we encourage you to apply. Applications for the Partner Program are reviewed and accepted on a rolling basis.

Thank you to all who have made it possible for us to continue our Mint Fund efforts. We look forward to bringing even more artists into the fold in 2024 and beyond.

Our goal at Mint Fund is to empower creatives. Largely, that has been through the thoughtful practice of onboarding global creatives to mint their first NFTs.

We've onboarded artists from 18 countries including the Philippines, Indonesia, Mexico, Venezuela, South Africa, Nigeria, Malaysia, and more. Selected artists complete onboarding and attend a series of workshops to then receive a grant. To date, Mint Fund has received ~42 ETH from ~74 contributors, and we have distributed ~12 ETH in total to artists. With gratitude to all who have contributed to the fund, 44 NFTs have been successfully minted by artists representing a diverse range of perspectives, practices, locations, and identities.

Some of the incredibly talented artists to join Mint Fund include: 3D artist Rimbawan Gerilya, multimedia artist Moyosore Briggs, photographer Ashmit Galav, designer Ravi Vasavan, musician Eddington Again, performance artist Niall Ashley, 3D artist The Glad Scientist, designer Gian Ferrer, illustrator O’Plerou, animator Tigris Li, concept artist Tondji, and so many more.

Behind-the-scenes, our core team continues to review applications based on curation criteria prioritizing BIPOC and LGBTQIA+ creators. With care and intention, we onboard batches, host workshops, and work closely with each artist throughout the minting process. Since we onboarded Batch 01 of 35 artists in late-February, we’ve reworked our process and took new learnings with us through to our latest Batch 04.

We also want to take a moment to thank all of the contributors who have volunteered to host educational workshops with us including Cooper Turley, Osinachi, Paris Rouzati, Gabrielle Micheletti, Shawna X, Sven Eberwein, and Bria Thomas.

INITIATIVES 🍃 SOTHEBY’S & THE DIGITAL DIASPORA

As our work to support a global network of artists progresses, we’ve garnered interest from organizations to further our mission. In May, Sotheby’s auction house organized Natively Digital: A Curated NFT Sale. As part of the lot, a percentage of the artwork sales will be donated to Mint Fund. We also had the opportunity to work with Michael Bouhanna, Deputy Director at Sotheby’s, and Ben Gentilli, founder of the Robert Alice Project, to identify an alumni of Mint Fund’s artist roster to participate in the auction. Brazilian artist, Ikaro Cavalcante (occulted), created a new work for the show—Perennial Links. Inclusion of work by an artist from Mint Fund gave us an important signal and glimpse into the future we are aiming to build, one where artists are able to achieve unimaginable heights by having access to minting NFTs alone.

https://twitter.com/occult3d/status/1403227316432654336

Along with our schedule of onboarding new creators through batches, Mint Fund was presented with the opportunity to provide support for The Digital Diaspora. Curator Diana Sinclair of Towards Utopia organized an exhibition of NFTs from 18 artists across the African diaspora to be released on Juneteenth. A portion of funds raised through the NFT auctions were donated to G.L.I.T.S. and herstoryDAO. Similar to the Sotheby’s project, Diana selected South African photographer Ayesha Kazim to represent Mint Fund in the dual exhibition and auction fundraiser.

FUTURE 🍃

The Digital Diaspora marked two inflection points for Mint Fund’s future: providing support for large-scale community-organized efforts, and collecting and preserving NFTs.

In the rapidly shifting and emergent space of NFTs, we are also evolving to further our mission of supporting and uplifting underrepresented creatives. We are proud to fund and support initiatives like The Digital Diaspora and look forward to utilizing the treasury for like-minded projects in the future. By participating in auctions and collecting Double Vision by BLACKSNEAKERS, we want to permanently record this moment in time and double down on our support for creators and initiatives that are pushing culture forward.

We will continue to onboard batches, but are now opening up applications for group shows and larger-initiatives to have access to Mint Fund’s treasury. Apply here.

MINT FUND MISSION STATEMENT 🍃

Mint Fund is a community dedicated to uplifting, supporting, and creating the next generation of global talent through NFTs. Mint Fund's goal is to create frictionless support for cultural communities to position their creatives for artistic success, longevity and becoming influential tastemakers in their own right.

By changing the state of play, we positively impact creativity, give larger agency for cultural communities to make their best works, leave rich histories for those who come after us, and build toward a more inclusive, equitable, and sustainable future.

themint.fund twitter.com/themintfund

Mint Fund Recap Series - Batch 01

On February 28th, we unveiled our first 35 artists. After two weeks of onboarding, planning, and networking, we knew it was time to mint. We instituted the “Round” method of minting works in groups every Wednesday and Saturday. To date, 14 of those artists have successfully minted and released their first NFTs out into the world. This post serves as a highlight and reference to memorialize the group that started it all.

Key Stats

14 Artists From Argentina to Indonesia (Representing 6 Countries) 2 Workshops (Featuring Cooper Turley and Osinachi) 2 Weeks 4 Rounds

Artists

✺ Eddington Again ✺ Tondji ✺ Cy Tone ✺ Kenneth Lartey ✺ Rimbawan Gerilya ✺ Ravi Vasavan ✺ Niall Ashley ✺ Sky Kawano ✺ Tigris ✺ Baran Acar ✺ Ikaro Cavalcante ✺ Magdalena Molinari ✺ Christopher de la Guardia / Dela ✺ Ben Makgetlane

What We Learned

During the onboarding & minting process, We recognized a few things:

Not everyone's NFT will sell immediately; Artists need more than just one stipend to mint creative works; Not every artist will mint in a specific timeframe.

To accommodate this, and to celebrate all of our artists, we are experimenting with $RECAP NFTs — a special 1/1 gif that cycles through the artwork of our batch groups that will be auctioned off with the proceeds being split among each artist of that batch group, $BOUNTY holders, $BOUNTY NFT Auction Winner and Mint Fund DAO (a total of 47 recipients).

To do this, we are deploying Mint Fund's crowdfunded Reserve Auction ($BOUNTY), and using Mirror recently introduced Splits Auction feature.

We believe in redistribution at every level, and with our $RECAP series, we can ensure that artists can earn ETH so they can continue minting.

Token #3051

Split Allocation

14 Batch 01 Artists / 80% 31 $BOUNTY Holders / 10% $BOUNTY NFT Auction Winner / 5% MintFund DAO / 5%

The Final distribution percentage was rounded for simplicity. A full breakdown of the Batch 01 Split allocations can be found here.

The Mints

Round One

FIRST MINT ✺ Vocalist and composer from Los Angeles, Eddington Again style ranges from classic soul, R&B bops, to experimental pop. Petrify: A visual collaboration with 011668. Sounds co-produced with Otxoa and Jerry Andrews.

NFT

SECOND MINT ✺ Deaf artist and designer, Ravi Vasavan lives, bakes, bikes, camps, sings, and loves in London. Ficus 1/3: After experiencing birth, existence, and death up-close, this work is reminder that we are in a constant state of rebirth.

NFT

THIRD MINT ✺ Kenneth Lartey is a filmmaker and DJ. Some Friend You Are: An unreleased work designed for legendary underground DMV artist Sir EU, originally used for one of his musical projects.

NFT

FOURTH MINT ✺ Cy Tone DISORDER: Inhale / Exhale / Inspire / Create "All Content is Copyright-free, everyone can use it as he/she/they prefer, we don't give a [ˈfʌk]. Culture is a human heritage not a mass production tool." “test, experiments, results”

NFT

FIFTH MINT ✺ Beninese 3D artist, Tondji style mixes Afrofuturism and conceptual art. Na Hangbé: Tondji tells the story of Tassi Hangbé, the queen of the kingdom of Dahomey. Her history will not go untold any longer.

NFT

SIXTH MINT ✺ Rimbawan Gerilya is a visual artist and VJ from S.E.Asia working mostly with the music scene. GMO Utility Trike: In 2020, Gabber Modus Operandi live gigs were cancelled. They brought the party to the masses through cyberspace with the help of Siko Setyanto, a dancer, and Rimbawan Gerilya, an animator.

NFT

Round Two

FIRST MINT ✺ Niall Ashley is a self-taught painter from Bristol, England. G-check: A depiction of roadmen in a non-binary context, questioning how we assume gender and overt masculinity.

NFT

SECOND MINT ✺ Tigris is 3D Motion Designer & Creative Technologist exploring emotional intelligence and biometrics. Curves as Deep as the Ocean: unveils the depth of waves that uncover serenity and peace within one’s body of the ocean.

NFT

THIRD MINT ✺ Japanese/British artist Sky Kawano specializes in mixed-media motion that captures chaos and ephemerality. TENACITY OF LIFE: A mixed-media digital poster inspired by the tenacity of ants as aspirational spirit animals.

NFT

Round Three

FIRST MINT ✺ Ikaro Cavalcante is a Brazilian Artist focused on CGI and Artmedia. Flowers of non-death: is the artists genesis piece and the first work in the "Blood Connection" series of three pieces.

NFT

SECOND MINT ✺ Baran Acar is a digital artist and student based in Eskisehir, Turkey. Caution: 3D illustration. 3000x3750

NFT

Round Four

FIRST MINT ✺ Magdalena Molinari is an Argentinian architect and artist. "IRIS N1" - A series of abstract video pieces where the colors from the sky and the circular movements are combined to create "skylike" sensations.

NFT

SECOND MINT ✺ Christopher de la Guardia / Dela is an artist based out of Miami, Florida "Beauty In Destruction" is about getting rid of the old world and creating a new one. We are on the cusp of digital freedom.

NFT

THIRD MINT ✺ Ben Makgetlane is a minimalist illustrator & graphic designer based in Pretoria, South Africa. Take Care: "Part of a series where i reimagine some of my favorite album covers using my minimalist illustration style".

https://rarible.com/token/0xd07dc4262bcdbf85190c01c996b4c06a461d2430:442193:0x1c9fefb363361b303f9ab3cb08395cf863461784

What’s Next?

Get familiar with the MintFund artist community by joining our discord, or following us on twitter. We are in the process of minting our second batch of artists and currently curating our third and fourth groups. We are actively looking for community moderators in multiple timezones, efforts in localizing resources in most common languages, and programming for our growing artist body.

MINT FUND NFT GALLERY + CURATION SPACE As we work with each creator to mint their first NFTs, we’ll be adding their work to our site. This is a space to nurture and highlight the artists we work with. A place to give them all some extra shine. In addition, we will enable auctions using the $BOUNTY auction method to help our artists sell their first NFTs. This also grants curators an opportunity to submit works for MintFund $BOUNTY holders to collect a % of the auction fee from curated sales.

Stay tuned. SOON™

About MintFund

MintFund is a community project created with the sole purpose to build a support network for artists interested in bringing their art into the world of NFTs/cryptomedia.

MintFund provides artists with the funds to mint NFTs (known as gas costs), and offers guidance, mentorship and advice for the growing community of cryptomedia artists. MintFund is accessible to all artists and we prioritize BIPOC and LGTBQIA+ artists, especially outside of North America and the European Union.

If you think you are the right candidate please email us at themintfund@gmail.com.

We're excited to announce a new experiment. We're using crypto to crowdfund a bounty to bring reserve auction functionality to MintFund.

Crowdfund Embed

Reserve auctions have seen significant traction as a mechanism for selling NFTs, but they have typically been limited to proprietary marketplaces. MintFund's mission is to expand opportunity for artists hoping to break out into the crypto art scene. Part of that mission is providing open access to best-in-class tools that artists need to thrive.

Today, we're launching a Mirror crowdfund contract to create a bounty for a talented Solidity developer to implement a robust and completely permissionless version of reserve auctions for NFTs. Unlike the previous $ESSAY and $VALUE campaigns, the output of this bounty will be written code instead of written text.

How it Works

• The bounty crowdfund has a hard-cap of 7 ETH

• Backers can send ETH to the crowdfund in exchange for $BOUNTY tokens

• If the funding target is hit, MintFund will hire a talented Solidity developer from the Ethereum community to implement the fully open-source smart contracts

• The codebase will be posted on Mirror as permanent, public data and mirrored on GitHub

• The codebase will be minted as an NFT on the Zora protocol, representing the first digitally unique and collectible codebase

• The final code will be deployed on mainnet and used to auction off this NFT

• If the NFT is sold, ETH will accrue to $BOUNTY tokens

• $BOUNTY tokens can be traded like any ERC-20 token, or redeemed for underlying ETH

• Participants in the crowdfund will be embedded in the code base forever as the supporters who made it possible

25% of $BOUNTY tokens will be retained by MintFund and 5% will go to the developer, the remaining 70% will be distributed to $BOUNTY backers.

The Power of Reserve Auctions

Since the advent of NFT transactions, reserve auctions have seen significant traction as a mechanism for selling NFTs. The hype, the intrigue, and the status involved in a singular moment in time where everyone's eyes are fixed upon a particular drop provides a narrative for all the artists who have sold work. Reserve auctions become a tool to connect both artist and collector, a story for communities to rally around—news to be told to the masses. They are a spotlight and turning point of an artist's career in the cryptosphere and we want to bring it to every artist. Reserve auctions started on SuperRare and have moved to other marketplaces such as Nifty Gateway. However, with a platform like Zora the permissionless nature of the zNFT smart contracts allows anyone to extend the bidding protocol, making it a great fit to add a reserve auction extension.

Why?

We believe that building the tools for creatives to push their best works unfettered by cost, access, and exposure yields the next generation of mind bending work and an ever growing community of shared talent, spirit, and wealth. MintFund is dedicated to giving all communities, with emphasis to BIPOC & LGBTQIA folks, the means to take cryptomedia / NFTs by storm and move culture along with them. We recognize that the key to achieving our goal of launching life-changing creative careers on the blockchain is threefold:

1. Cover gas fees to enable access to the tools to participate in the NFT ecosystem

2. Create tools for artists to increase their exposure and connect with collectors

3. Build a success-based funding source to ensure MintFund can continue to sustain its work without relying on donations

About the Bounty / Scope of Work

Requirements

1. Any owner of a Zora NFT should be able to permissionlessly kick off an auction. Kicking off an auction should not require deploying a new contract.

2. The auction should be configurable such that its constructor accepts (at minimum) two parameters

   1. Reserve Price (amount + currency address)

   2. Auction Duration (ex. 24 hours)

3. The auction should be binding, such that at the end of the Auction the highest bid is automatically accepted and the NFT is transferred to the highest bid's recipient address.

4. Bids on the auction are made in ETH and should be locked in escrow for the duration of the auction, but automatically returned if a higher bid is made.

5. If the Auction has not received a bid higher than the reserve price, the original owner can withdraw the NFT. Once a bid has been placed, the NFT is locked until the auction is completed.

6. Relevant events are emitted for each of the major function calls.

User Story

1. Alice grants permission to transfer the NFT to the auction contract

2. Calls createAuction with the tokenId, reservePrice, and creator address. This transfers the NFT to the contract.

3. Craig submits a bid below the reserve price, but it reverts

4. Bob calls createBid with a bid that is higher than the reserve price, which sets the currentBid to his address and amount.’ The contract receives Bob's ETH and holds it in escrow.

5. Craig calls endAuction, but it reverts because the current block time doesn't exceed the Auction's end-time

6. Danny calls createBid, which replaces Bob's bid as the current bid. Bob is refunded the ETH that he sent into the contract previously.

7. No new bids come in, and the current block time exceeds the Auction's end-time

8. Danny calls endAuction, which transfers the NFT to her address. Runs a payout according to the Zora market's BidShare data to send funds to the creator.

High Level Implementation Ideas

Each Auction is described by the following data:

• tokenId: The Zora market token ID for the NFT

• duration: The number seconds that the auction runs for after the first bid, e.g. 24 hours, which is extended with each new bid

• firstBidTime: Unix timestamp of the first bid

• reservePrice: Allow the creator to set a reserve price, below which the auction will not settle and the NFT is returned

• creator: Keep track of the creator in case we need to return the NFT. A single auction contract keeps track of multiple auctions, via a simple mapping of tokenId to Auction. This contract also keeps track of the current Bids for each Auction. Bids are mapped from tokenId to bid. A bid is composed of:

• Bidder

• Amount The contract has the following functionality:

• createAuction(uint tokenId, uint reservePrice, address creator)

  • Instantiates an Auction using the given parameters, and transfers the NFT to the contract itself, so that the contract controls the NFT

  • createBid (uint amount, uint tokenId) external payable

  • Checks that amount is greater than the current bid, and greater than the reserve price

  • Check that the msg.value == amount

  • "Start the clock" and increases the duration by

  • Refund the previous bid

• endAuction(uint tokenId)

  • Checks that the current time is greater than the end time

  • Transfers the NFT to the highest bidder, if there is one and is greater-or-equal the reserve price, else transfers back to the creator

• cancelAuction(uint tokenId)

  • Can only be called by the creator

  • Checks if there are no bids

  • Transfers the NFT back to the creator

What's Next?

This initiative, if executed successfully, will not only give new rise to creatives, but create a pipeline to mint their NFTs and expose them to the greater communities that have rallied around MintFund and our growing list of contributors and partners.

About Mint Fund.

MintFund is a community project created with the sole purpose to build a support network for artists interested in bringing their art into the world of NFTs/cryptomedia. MintFund provides artists with the funds to mint NFTs (known as gas costs), and offers guidance, mentorship and advice for the growing community of cryptomedia artists. MintFund is accessible to all artists and we prioritize BIPOC and LGTBQIA+ artists, especially outside of North America and the European Union.

Token #1522

Reserve Auctions are a mechanism for selling NFTs widely credited with creating more value for artists, but they have typically been limited to proprietary marketplaces. We wanted to bring a robust and completely permissionless version to anyone who wants to use it.

By open-sourcing this implementation of a reserve auction, we hope to directly empower creators by giving them the tools they need to freely sell their work, on their terms.

In just over an hour we raised 7 ETH from 40 backers, who in turn received $BOUNTY tokens representing their patronage of this community-focused initiative.

What made this approach to crowdfunding even more unique is that the resulting smart contract code would be made open source, minted as an NFT and then auctioned off, with the value of the NFT flowing back to $BOUNTY holders. See all the details of $BOUNTY in the original crowdfund post.

https://mint.mirror.xyz/mDws2xGmJCq55ehGDdcv8tGDCpSd_c_CfeqhexiKSqU

Today we’re excited to announce that $BOUNTY: The First Tokenized, Crowdfunded Smart Contract is officially minted and up for auction.

Importantly, this NFT is being auctioned using the auction code embedded in the NFT itself. Cue inception memes

At the end of this post is the initial commit of the smart contract code. Since this post is minted as an NFT, this code is immortalized as part of it. Owning this NFT means owning a 1/1 collectible representing the initial commit of the open-source implementation of reserve auctions, which will live on Mint Fund’s GitHub repo.

The Process

Initially Mint Fund created a bounty via a Mirror crowdfund to fund the development of an open source version of reserve auction smart contract, which was fulfilled by Solidity developer Billy Rennekamp.

The Mirror team took this code and improved on it until it was production ready. The final version (included at the bottom of this post) was used to auction off two NFTs on April 1st, 2021 for a combined value of 26.1 ETH.

In a testament to open source collaboration and smart contract composability, this auction code builds on top of the open Zora NFT protocol and honors the creator share of zNFTs.

Furthermore, it also supports specifying a curator fee for facilitating the auction. This enables organizations like Mint Fund or other galleries a potential business model to sustain their operations .

We’d like to credit projects that have pioneered and improved on the reserve auction mechanism and experience, such as SuperRare and Foundation.

Next Steps

The Zora team is working on adding functionality to the reserve auction code that more fully utilizes the power of the Zora Protocol. Zora's update will support bidding in any ERC20 token, and honoring the sell-on-share fee that users will know from the Zora interface.

What $BOUNTY holders get.

Following the initial crowdfund, $BOUNTY tokens were distributed to all backers. 25% of $BOUNTY tokens were retained by MintFund, with 5% allocated to the developer implementing the bounty. The remaining 70% were distributed to the $BOUNTY crowdfund backers.

$BOUNTY represents the shared value created through the crowdfunding, development and auction of the NFT. If the $BOUNTY NFT sells, the proceeds will go to the crowdfund and thereby the $BOUNTY backers. Holding $BOUNTY tokens also grant one access to a private channel on the Mint Fund discord only accessible by those holding at least 15 $BOUNTY.

The future of public goods funding

As far as we know, this has been the first experiment to combine crypto-native crowdfunding with public works minted as an NFT. Recently, Vitalik wrote about the potential to use token incentives, NFTs, and decentralized governance to fund public goods like scientific research, local journalism, and poverty relief.

We believe this new model has the opportunity to create win-win scenarios for all parties involved: backers, creators, developers, collectors, and end-consumers of these funded projects.

MintFund hopes to see others experiment with this model and push the boundaries of how creative work is financed, produced, and owned using the internet and crypto-native tools.

The Code

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity 0.6.8;
pragma experimental ABIEncoderV2;

// OpenZeppelin library for performing math operations without overflows.
import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
// OpenZeppelin security library for preventing reentrancy attacks.
import {
    ReentrancyGuard
} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
// For interacting with Zora's Market contract.
import {IMarket} from "./interfaces/IMarket.sol";
// For checking `supportsInterface`.
import {IERC165} from "@openzeppelin/contracts/introspection/IERC165.sol";
// For interacting with NFT tokens.
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";

contract IMediaModified {
    mapping(uint256 => address) public tokenCreators;
    address public marketContract;
}

interface IWETH {
    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);
}

contract ReserveAuctionV3 is ReentrancyGuard {
    // Use OpenZeppelin's SafeMath library to prevent overflows.
    using SafeMath for uint256;

    // ============ Constants ============

    // The minimum amount of time left in an auction after a new bid is created; 15 min.
    uint16 public constant TIME_BUFFER = 900;
    // The ETH needed above the current bid for a new bid to be valid; 0.001 ETH.
    uint8 public constant MIN_BID_INCREMENT_PERCENT = 10;
    // Interface constant for ERC721, to check values in constructor.
    bytes4 private constant ERC721_INTERFACE_ID = 0x80ac58cd;
    // Allows external read `getVersion()` to return a version for the auction.
    uint256 private constant RESERVE_AUCTION_VERSION = 1;

    // ============ Immutable Storage ============

    // The address of the ERC721 contract for tokens auctioned via this contract.
    address public immutable nftContract;
    // The address of the WETH contract, so that ETH can be transferred via
    // WETH if native ETH transfers fail.
    address public immutable wethAddress;
    // The address that initially is able to recover assets.
    address public immutable adminRecoveryAddress;

    // ============ Mutable Storage ============

    /**
     * To start, there will be an admin account that can recover funds
     * if anything goes wrong. Later, this public flag will be irrevocably
     * set to false, removing any admin privileges forever.
     *
     * To check if admin recovery is enabled, call the public function `adminRecoveryEnabled()`.
     */
    bool private _adminRecoveryEnabled;
    /**
     * The account `adminRecoveryAddress` can also pause the contracts
     * while _adminRecoveryEnabled is enabled. This prevents people from using
     * the contract if there is a known problem with it.
     */
    bool private _paused;

    // A mapping of all of the auctions currently running.
    mapping(uint256 => Auction) public auctions;

    // ============ Structs ============

    struct Auction {
        // The value of the current highest bid.
        uint256 amount;
        // The amount of time that the auction should run for,
        // after the first bid was made.
        uint256 duration;
        // The time of the first bid.
        uint256 firstBidTime;
        // The minimum price of the first bid.
        uint256 reservePrice;
        uint8 curatorFeePercent;
        // The address of the auction's curator. The curator
        // can cancel the auction if it hasn't had a bid yet.
        address curator;
        // The address of the current highest bid.
        address payable bidder;
        // The address that should receive funds once the NFT is sold.
        address payable fundsRecipient;
    }

    // ============ Events ============

    // All of the details of a new auction,
    // with an index created for the tokenId.
    event AuctionCreated(
        uint256 indexed tokenId,
        address nftContractAddress,
        uint256 duration,
        uint256 reservePrice,
        uint8 curatorFeePercent,
        address curator,
        address fundsRecipient
    );

    // All of the details of a new bid,
    // with an index created for the tokenId.
    event AuctionBid(
        uint256 indexed tokenId,
        address nftContractAddress,
        address sender,
        uint256 value
    );

    // All of the details of an auction's cancelation,
    // with an index created for the tokenId.
    event AuctionCanceled(
        uint256 indexed tokenId,
        address nftContractAddress,
        address curator
    );

    // All of the details of an auction's close,
    // with an index created for the tokenId.
    event AuctionEnded(
        uint256 indexed tokenId,
        address nftContractAddress,
        address curator,
        address winner,
        uint256 amount,
        address nftCreator,
        address payable fundsRecipient
    );

    // When the curator recevies fees, emit the details including the amount,
    // with an index created for the tokenId.
    event CuratorFeePercentTransfer(
        uint256 indexed tokenId,
        address curator,
        uint256 amount
    );

    // Emitted in the case that the contract is paused.
    event Paused(address account);
    // Emitted when the contract is unpaused.
    event Unpaused(address account);

    // ============ Modifiers ============

    // Reverts if the sender is not admin, or admin
    // functionality has been turned off.
    modifier onlyAdminRecovery() {
        require(
            // The sender must be the admin address, and
            // adminRecovery must be set to true.
            adminRecoveryAddress == msg.sender && adminRecoveryEnabled(),
            "Caller does not have admin privileges"
        );
        _;
    }

    // Reverts if the sender is not the auction's curator.
    modifier onlyCurator(uint256 tokenId) {
        require(
            auctions[tokenId].curator == msg.sender,
            "Can only be called by auction curator"
        );
        _;
    }

    // Reverts if the contract is paused.
    modifier whenNotPaused() {
        require(!paused(), "Contract is paused");
        _;
    }

    // Reverts if the auction does not exist.
    modifier auctionExists(uint256 tokenId) {
        // The auction exists if the curator is not null.
        require(!auctionCuratorIsNull(tokenId), "Auction doesn't exist");
        _;
    }

    // Reverts if the auction exists.
    modifier auctionNonExistant(uint256 tokenId) {
        // The auction does not exist if the curator is null.
        require(auctionCuratorIsNull(tokenId), "Auction already exists");
        _;
    }

    // Reverts if the auction is expired.
    modifier auctionNotExpired(uint256 tokenId) {
        require(
            // Auction is not expired if there's never been a bid, or if the
            // current time is less than the time at which the auction ends.
            auctions[tokenId].firstBidTime == 0 ||
                block.timestamp < auctionEnds(tokenId),
            "Auction expired"
        );
        _;
    }

    // Reverts if the auction is not complete.
    // Auction is complete if there was a bid, and the time has run out.
    modifier auctionComplete(uint256 tokenId) {
        require(
            // Auction is complete if there has been a bid, and the current time
            // is greater than the auction's end time.
            auctions[tokenId].firstBidTime > 0 &&
                block.timestamp >= auctionEnds(tokenId),
            "Auction hasn't completed"
        );
        _;
    }

    // ============ Constructor ============

    constructor(
        address nftContract_,
        address wethAddress_,
        address adminRecoveryAddress_
    ) public {
        require(
            IERC165(nftContract_).supportsInterface(ERC721_INTERFACE_ID),
            "Contract at nftContract_ address does not support NFT interface"
        );
        // Initialize immutable memory.
        nftContract = nftContract_;
        wethAddress = wethAddress_;
        adminRecoveryAddress = adminRecoveryAddress_;
        // Initialize mutable memory.
        _paused = false;
        _adminRecoveryEnabled = true;
    }

    // ============ Create Auction ============

    function createAuction(
        uint256 tokenId,
        uint256 duration,
        uint256 reservePrice,
        uint8 curatorFeePercent,
        address curator,
        address payable fundsRecipient
    ) external nonReentrant whenNotPaused auctionNonExistant(tokenId) {
        // Check basic input requirements are reasonable.
        require(curator != address(0));
        require(fundsRecipient != address(0));
        require(curatorFeePercent < 100, "Curator fee should be < 100");
        // Initialize the auction details, including null values.
        auctions[tokenId] = Auction({
            duration: duration,
            reservePrice: reservePrice,
            curatorFeePercent: curatorFeePercent,
            curator: curator,
            fundsRecipient: fundsRecipient,
            amount: 0,
            firstBidTime: 0,
            bidder: address(0)
        });
        // Transfer the NFT into this auction contract, from whoever owns it.
        IERC721(nftContract).transferFrom(
            IERC721(nftContract).ownerOf(tokenId),
            address(this),
            tokenId
        );
        // Emit an event describing the new auction.
        emit AuctionCreated(
            tokenId,
            nftContract,
            duration,
            reservePrice,
            curatorFeePercent,
            curator,
            fundsRecipient
        );
    }

    // ============ Create Bid ============

    function createBid(uint256 tokenId, uint256 amount)
        externalpayablenonReentrant
        whenNotPaused
        auctionExists(tokenId)
        auctionNotExpired(tokenId)
    {
        // Validate that the user's expected bid value matches the ETH deposit.
        require(amount == msg.value, "Amount doesn't equal msg.value");
        require(amount > 0, "Amount must be greater than 0");
        // Check if the current bid amount is 0.
        if (auctions[tokenId].amount == 0) {
            // If so, it is the first bid.
            auctions[tokenId].firstBidTime = block.timestamp;
            // We only need to check if the bid matches reserve bid for the first bid,
            // since future checks will need to be higher than any previous bid.
            require(
                amount >= auctions[tokenId].reservePrice,
                "Must bid reservePrice or more"
            );
        } else {
            // Check that the new bid is sufficiently higher than the previous bid, by
            // the percentage defined as MIN_BID_INCREMENT_PERCENT.
            require(
                amount >=
                    auctions[tokenId].amount.add(
                        // Add 10% of the current bid to the current bid.
                        auctions[tokenId]
                            .amount
                            .mul(MIN_BID_INCREMENT_PERCENT)
                            .div(100)
                    ),
                "Must bid more than last bid by MIN_BID_INCREMENT_PERCENT amount"
            );

            // Refund the previous bidder.
            transferETHOrWETH(
                auctions[tokenId].bidder,
                auctions[tokenId].amount
            );
        }
        // Update the current auction.
        auctions[tokenId].amount = amount;
        auctions[tokenId].bidder = msg.sender;
        // Compare the auction's end time with the current time plus the 15 minute extension,
        // to see whether we're near the auctions end and should extend the auction.
        if (auctionEnds(tokenId) < block.timestamp.add(TIME_BUFFER)) {
            // We add onto the duration whenever time increment is required, so
            // that the auctionEnds at the current time plus the buffer.
            auctions[tokenId].duration += block.timestamp.add(TIME_BUFFER).sub(
                auctionEnds(tokenId)
            );
        }
        // Emit the event that a bid has been made.
        emit AuctionBid(tokenId, nftContract, msg.sender, amount);
    }

    // ============ End Auction ============

    function endAuction(uint256 tokenId)
        externalnonReentrant
        whenNotPaused
        auctionComplete(tokenId)
    {
        // Store relevant auction data in memory for the life of this function.
        address winner = auctions[tokenId].bidder;
        uint256 amount = auctions[tokenId].amount;
        address curator = auctions[tokenId].curator;
        uint8 curatorFeePercent = auctions[tokenId].curatorFeePercent;
        address payable fundsRecipient = auctions[tokenId].fundsRecipient;
        // Remove all auction data for this token from storage.
        delete auctions[tokenId];
        // We don't use safeTransferFrom, to prevent reverts at this point,
        // which would break the auction.
        IERC721(nftContract).transferFrom(address(this), winner, tokenId);
        // First handle the curator's fee.
        if (curatorFeePercent > 0) {
            // Determine the curator amount, which is some percent of the total.
            uint256 curatorAmount = amount.mul(curatorFeePercent).div(100);
            // Send it to the curator.
            transferETHOrWETH(curator, curatorAmount);
            // Subtract the curator amount from the total funds available
            // to send to the funds recipient and original NFT creator.
            amount = amount.sub(curatorAmount);
            // Emit the details of the transfer as an event.
            emit CuratorFeePercentTransfer(tokenId, curator, curatorAmount);
        }
        // Get the address of the original creator, so that we can split shares
        // if appropriate.
        address payable nftCreator =
            payable(
                address(IMediaModified(nftContract).tokenCreators(tokenId))
            );
        // If the creator and the recipient of the funds are the same
        // (and we expect this to be common), we can just do one transaction.
        if (nftCreator == fundsRecipient) {
            transferETHOrWETH(nftCreator, amount);
        } else {
            // Otherwise, we should determine the percent that goes to the creator.
            // Collect share data from Zora.
            uint256 creatorAmount =
                // Call the splitShare function on the market contract, which
                // takes in a Decimal and an amount.
                IMarket(IMediaModified(nftContract).marketContract())
                    .splitShare(
                    // Fetch the decimal from the BidShares data on the market.
                    IMarket(IMediaModified(nftContract).marketContract())
                        .bidSharesForToken(tokenId)
                        .creator,
                    // Specify the amount.
                    amount
                );
            // Send the creator's share to the creator.
            transferETHOrWETH(nftCreator, creatorAmount);
            // Send the remainder of the amount to the funds recipient.
            transferETHOrWETH(fundsRecipient, amount.sub(creatorAmount));
        }
        // Emit an event describing the end of the auction.
        emit AuctionEnded(
            tokenId,
            nftContract,
            curator,
            winner,
            amount,
            nftCreator,
            fundsRecipient
        );
    }

    // ============ Cancel Auction ============

    function cancelAuction(uint256 tokenId)
        externalnonReentrant
        auctionExists(tokenId)
        onlyCurator(tokenId)
    {
        // Check that there hasn't already been a bid for this NFT.
        require(
            uint256(auctions[tokenId].firstBidTime) == 0,
            "Auction already started"
        );
        // Pull the creator address before removing the auction.
        address curator = auctions[tokenId].curator;
        // Remove all data about the auction.
        delete auctions[tokenId];
        // Transfer the NFT back to the curator.
        IERC721(nftContract).transferFrom(address(this), curator, tokenId);
        // Emit an event describing that the auction has been canceled.
        emit AuctionCanceled(tokenId, nftContract, curator);
    }

    // ============ Admin Functions ============

    // Irrevocably turns off admin recovery.
    function turnOffAdminRecovery() external onlyAdminRecovery {
        _adminRecoveryEnabled = false;
    }

    function pauseContract() external onlyAdminRecovery {
        _paused = true;
        emit Paused(msg.sender);
    }

    function unpauseContract() external onlyAdminRecovery {
        _paused = false;
        emit Unpaused(msg.sender);
    }

    // Allows the admin to transfer any NFT from this contract
    // to the recovery address.
    function recoverNFT(uint256 tokenId) external onlyAdminRecovery {
        IERC721(nftContract).transferFrom(
            // From the auction contract.
            address(this),
            // To the recovery account.
            adminRecoveryAddress,
            // For the specified token.
            tokenId
        );
    }

    // Allows the admin to transfer any ETH from this contract to the recovery address.
    function recoverETH(uint256 amount)
        externalonlyAdminRecovery
        returns (bool success)
    {
        // Attempt an ETH transfer to the recovery account, and return true if it succeeds.
        success = attemptETHTransfer(adminRecoveryAddress, amount);
    }

    // ============ Miscellaneous Public and External ============

    // Returns true if the contract is paused.
    function paused() public view returns (bool) {
        return _paused;
    }

    // Returns true if admin recovery is enabled.
    function adminRecoveryEnabled() public view returns (bool) {
        return _adminRecoveryEnabled;
    }

    // Returns the version of the deployed contract.
    function getVersion() external pure returns (uint256 version) {
        version = RESERVE_AUCTION_VERSION;
    }

    // ============ Private Functions ============

    // Will attempt to transfer ETH, but will transfer WETH instead if it fails.
    function transferETHOrWETH(address to, uint256 value) private {
        // Try to transfer ETH to the given recipient.
        if (!attemptETHTransfer(to, value)) {
            // If the transfer fails, wrap and send as WETH, so that
            // the auction is not impeded and the recipient still
            // can claim ETH via the WETH contract (similar to escrow).
            IWETH(wethAddress).deposit{value: value}();
            IWETH(wethAddress).transfer(to, value);
            // At this point, the recipient can unwrap WETH.
        }
    }

    // Sending ETH is not guaranteed complete, and the method used here will return false if
    // it fails. For example, a contract can block ETH transfer, or might use
    // an excessive amount of gas, thereby griefing a new bidder.
    // We should limit the gas used in transfers, and handle failure cases.
    function attemptETHTransfer(address to, uint256 value)
        privatereturns (bool)
    {
        // Here increase the gas limit a reasonable amount above the default, and try
        // to send ETH to the recipient.
        // NOTE: This might allow the recipient to attempt a limited reentrancy attack.
        (bool success, ) = to.call{value: value, gas: 30000}("");
        return success;
    }

    // Returns true if the auction's curator is set to the null address.
    function auctionCuratorIsNull(uint256 tokenId) private view returns (bool) {
        // The auction does not exist if the curator is the null address,
        // since the NFT would not have been transferred in `createAuction`.
        return auctions[tokenId].curator == address(0);
    }

    // Returns the timestamp at which an auction will finish.
    function auctionEnds(uint256 tokenId) private view returns (uint256) {
        // Derived by adding the auction's duration to the time of the first bid.
        // NOTE: duration can be extended conditionally after each new bid is added.
        return auctions[tokenId].firstBidTime.add(auctions[tokenId].duration);
    }
}