Yuga Labs

500 random holders of Nina Chanel's Super Cool World NFTs just received a brand new Super Punk World NFT. Each token ID to be dropped was hashed with block.prevrandao, a random value assigned to each block that is free of external manipulation. The hashed value was then converted to a token ID in the Super Cool World collection, and the owner of that token was transferred a Super Punk World NFT as long as they hadn't already been selected (1 per wallet limit). This method ensured that nobody could influence who gets selected or what token they get. However, the comes at a high cost, and for several reasons it was important that the full airdrop occur in a single transaction. For those that simply want to know that the airdrop happened, you can stop reading now. Below is for the curious - a somewhat technical story of a demoralizing but ultimately triumphant battle with gas. First, a bit of backstory. You are probably aware that when Super Punk World was announced last week, it was met with quite a bit of backlash. This led to a decision to cancel the auction, and instead airdrop the collection to Nina's truest fans: holders of her Super Cool World collection. In an effort to preserve the onchain story, we opted to continue on with the contract that had already been deployed at 0x0000000000003f07248DDFb9821770a8200EF77d. On to optimizing To airdrop, we first had to mint all 500 NFTs. Since it was an ERC721A contract, this was relatively painless (1.2M gas for the full collection). Next, we approve the new SuperPunkAirdropper contract to move NFTs on our behalf. Then, the big one: The SuperPunkAirdropper comes with an `airdrop` function that transfers all 500 NFTs to 500 different recipients. In order guarantee that a new recipient was selected for each token, an internal `_findEligibleRecipient` function recursively chooses random tokens until a recipient is found that did not yet have a Super Punk World NFT (balanceOf == 0). The initial naive approach to this cost ~49.2M gas over two transactions. Spanning the airdrop over two blocks opens up a window for manipulation/gaming the system between calls, so fitting the airdrop into single transaction was important. This meant we needed to get gas down under 30M units. Here are the tricks we used: - Transfer all of the odd token IDs first, then even (this saved 4M gas!). More info: (xitter.twitterapi.xyz/fulldecent/status/1491…) - Remove all state variable assignments that were needed in case we needed 2 transactions - Set a custom TransferValidator that doesn't do anything - Use unchecked math on loop iterators (this hilariously saved 37k gas) - Ditch the external balanceOf calls and use solidity's newly added transient storage to cheaply track who had already been dropped to - Similarly, use tstore to track token IDs that have already been randomly selected and fail early if one gets selected again - Rewrite everything from the ground up in assembly All in all, these tweaks brought the airdrop call down to 31.5M gas units. Close, but 30M is a hard limit and anything over won't cut it. I reached out to @0xjustadev to help optimize the assembly, and he was able to offer some insane memory management tricks to draw blood from a stone, cutting down the consumption down even further: 30.9M. At this point, it became clear that 30M was a pipe dream without some pre-call gymnastics. The only way to fit the full airdrop into a single call was to spend some gas up front: ERC721A transfers after a batch mint are expensive because most of the tokens don't have explicit owners set. Ownership has to be inferred by walking backwards until you find the "head" of the batch. The first time each token is transferred, explicit ownership of that token is set (which costs gas). So we just needed to pre-transfer some tokens. Luckily, ERC721A doesn't prevent self transfers, so this was a simple as adding a `prep` function that loops over some number of tokens (we chose 150) and self-transfers them, writing an explicit owner. All in all, `prep` cost ~8M gas, but shaved 5M off of the `airdrop` call. I've uploaded a gist of the old (not fully naive, but it was early in the process) contract and the final version here: gist.github.com/QuitCrypto/1… I encourage anybody to take a look and ask any questions they please about the code. I also challenge you to try to optimize further, and see if you can eliminate the need for the `prep` transaction (or a similar 2 transaction scheme). That's it! If you made it this far, you're a legend. Thanks for reading, and hit it with a like/retweet if you can. My goal is and has always been to spread education, and sharing really helps that.