PFP NFT Collection Development

PFP NFT Collection Development

PFP (Profile Picture) collection — 10,000 unique images generated from trait layers: background, body, clothing, head, accessories. Technically this is a specific pipeline: image generator + rarity distribution algorithm + ERC-721 contract with reveal mechanic + IPFS hosting. The task isn't "make NFT" — the task is to do it right from security and fair rarity distribution perspective.

Where PFP Projects Break

Predictable Rarity Reveal

Most common mistake: metadata revealed immediately at mint. Token holder gets #4521, goes to rarity.tools — sees it's top-1% rarity. Experienced players scan transactions in real-time and front-run rare token mints, predicting token ID by transaction order.

Solution — delayed reveal: all tokens show placeholder on mint. After mint ends, project owner sets baseURI with real metadata via setBaseURI. But this creates another problem: team knows final tokenId → trait mapping in advance and can reserve rare tokens.

Honest reveal — via Chainlink VRF. After mint ends, request random number from VRF, use it as offset: tokenId #5000 gets metadata from file (5000 + offset) % totalSupply. Neither team nor minters know final mapping until randomness received.

Uneven Distribution During Generation

Naive generator randomly selects each trait with weights — but doesn't verify combinations. Result: "rare" trait accidentally appears more often than expected due to correlation with popular base traits. Right approach: specify exact count of each trait, generator shuffles and distributes deterministically, verifies final rarity table before finalization.

Public Mint Without Bot Protection

Without protection, first 1000 tokens go to MEV bots in one block. Standard mechanics:

• Merkle proof whitelist: only addresses from list can mint. MerkleProof.verify from OpenZeppelin — cheap on gas.
• Commit-reveal: user first fixes mint intent (commit), after N blocks claims token (reveal). Prevents atomic snipe bots.
• Max per wallet via mapping — basic protection. Bypassed via contracts unless you add require(tx.origin == msg.sender) or ERC-721Psi with packed ownership.

How We Build Collection

Image Generator

Python script on Pillow basis: loads PNG layers with transparency, composites by priority, saves final image. Config for each trait: {name, weight, files[]}. Generator guarantees uniqueness via hash of generated combinations, on collision repeats generation.

Final step — validation script: checks no duplicates, weights match expected rarity distribution (±2%), correctness of all metadata files.

ERC-721 Contract

Based on ERC-721A (from Azuki) — optimized implementation allowing batch minting of several tokens in one transaction with almost same gas cost as single token. Original OpenZeppelin ERC-721 updates _owners mapping for each tokenId — this is O(n) on gas when minting n tokens. ERC-721A uses lazy initialization: _owners updated only for first token in batch.

Savings are substantial: minting 5 ERC-721A tokens costs ~120k gas vs ~400k for standard ERC-721. On mainnet at 50 gwei that's $20 vs $66 per transaction.

Additional components: EIP-2981 for royalties (supported by OpenSea, Blur, LooksRare), Ownable2Step instead of Ownable (protection from accidental rights transfer), ERC721Burnable if burn mechanic planned.

Metadata Storage

IPFS via Pinata or NFT.Storage. Structure: all images upload to single IPFS directory, get directory CID. Metadata JSON references ipfs://{CID}/{tokenId}.png. baseURI in contract — ipfs://{CID}/.

Metadata format per OpenSea standard:

{
  "name": "Collection #1234",
  "description": "...",
  "image": "ipfs://Qm.../1234.png",
  "attributes": [
    {"trait_type": "Background", "value": "Blue"},
    {"trait_type": "Eyes", "value": "Laser"}
  ]
}

trait_type and value must match rarity table exactly — correctness of display on OpenSea and rarity aggregators depends on it.

Development Process

Art and Layers (parallel with development). Receive from client: PNG layers with transparency, trait weight config. Generate preview sample of 100 tokens for approval.

Generator and Rarity (2–3 days). Final generation of 10K images, rarity table, uniqueness validation.

IPFS Upload (1 day). Upload via Pinata API, get CID.

Contract and Tests (3–4 days). ERC-721A + VRF reveal + whitelist. Foundry tests: mint, reveal, transfer, royalty.

Deployment (1–2 days). Testnet (Sepolia) → approval → mainnet. Verification on Etherscan. Collection setup on OpenSea (description, royalties, banner).

Timeline Estimates

From receiving art files to mainnet deployment — 1.5–2 weeks. Separate mechanics (staking, token merging, on-chain generation) add 1–2 weeks each.