$THODL — Whitepaper (V2)

The first on-chain treasury for TDH. A solid, perpetual protocol that gives you fast, liquid exposure to the entire 6529 Memes ecosystem in a single token.

Version: V2 — deployed on Ethereum mainnet 2026-05-13. V1 status: deprecated, sale permanently bricked (see Appendix A). V1 buyers receive a +100% migration airdrop on V2; no action required.

TL;DR

$THODL V2 is an immutable ERC20 on Ethereum mainnet that turns every DEX swap into a perpetual accumulation of 6529 Meme NFTs, ranked by their Price-Per-TDH (PPTDH) efficiency. 9% of every swap feeds the on-chain treasury, which automatically buys the most TDH-efficient card on the market via Seaport. 1% goes to the developer wallet as the only source of dev income — there is no pre-minted founder allocation, no public ETH sale, no investor round.

The contract itself is the vault: purchased NFTs are held inside it and no function exists to withdraw them. Initial liquidity is seeded by the dev (from off-protocol Meme card mint revenue) and the LP tokens are sent to 0x000…dEaD, making the liquidity permanently locked. A 2-of-3 Safe multisig is the only admin, and emergency powers self-destruct one-shot post-launch via disableEmergency().

Distribution is by merkle airdrop only — no public ETH sale. The airdrop bucket holds 47,026,560 $THODL (67.74% of supply) for up to 420 entries of 111,968 $THODL each. Eligible: V1 migrants (+100% bonus) and Meme card minters (snapshot after the 6529 Submission window closes). The airdrop is open indefinitely; the owner closes it manually via either burnRemainingAirdrop (terminal burn) or start4xSale(deadline ≤ +62d) which sells unclaimed slots at 0.25 ETH each — 100% of that ETH to the treasury, 100% of unsold THODL burned.

For a holder, owning $THODL is a single-token, liquid claim on a permanently-growing stack of high-conviction 6529 Memes — plus a proportional share of the governance weight (TDH) those NFTs generate inside the 6529 ecosystem. As the supply of Memes is finite, every purchase permanently reduces the tradable float of the collection.

Activation milestone: when the treasury accumulates 100,000 TDH, the protocol opens shared TDH usage — $THODL holders will be able to direct and benefit from the vault's TDH in the 6529 ecosystem (governance, gated drops, community access). See §6.4.

1. Background — what is TDH?

TDH ("Total Days Held") is the 6529 community's on-chain reputation and governance primitive. For every 6529 Meme NFT a wallet holds, that wallet earns a daily TDH score, weighted by the card's edition size. A card with a small edition carries more TDH weight per copy than a card with a large edition:

Per-copy-per-day TDH rate = 3941 / edition_size      (unboosted, official 6529 formula)

where 3941 is the edition size of FirstGM, the 6529 reference card whose per-copy weight is 1. So holding one copy of a card with 300-edition accrues 3941/300 ≈ 13.14 TDH per day, while a 1000-edition card accrues 3.941 per day per copy.

TDH gates voting power on 6529.io governance, access to community features, and is commonly referenced in the 6529 ecosystem as a measure of "commitment to the memes". There is no way to buy TDH directly — you must hold the NFTs over time.

PPTDH = price / TDH, i.e. how much ETH you pay per unit of TDH yield generated. Lower PPTDH = better deal. The PPTDH ratio across the 6529 Memes collection is published at 6529nfts.io/memes/prices-and-valuations and is the central primitive optimised by this protocol.

2. Protocol mechanic — the full loop

V2 has no public ETH sale. Distribution is airdrop-only; the LP is dev-seeded; trading is enabled by THODLV2.launch(pair) once the pair exists and is funded.

           ┌─────────────────────────────────────────────────────────────┐
           │                     THE $THODL V2 LOOP                      │
           └─────────────────────────────────────────────────────────────┘

   ┌──────────────────┐
   │ Off-protocol     │  ~0.45 ETH from 6529 TDHODL Meme card mint
   │ Meme card mint   │ ─────────────────────────────────────────────┐
   └──────────────────┘                                               │
                                                                      ▼
                              ┌───────────────────────────────────────────────┐
                              │ Dev seeds initial LP                           │
                              │   factory.createPair(THODLV2, WETH)            │
                              │   Safe.launch(pair)                            │
                              │   Safe.setFeeExempt(seeder, true)              │
                              │   router.addLiquidityETH(..., to=DEAD)         │
                              └───────────────────────────────────────────────┘
                                                                      │
                                                                      ▼
   ┌──────────┐        10% fee on AMM        ┌────────────────┐
   │  Trader  │ ──────────────────────────▶  │  $THODL token  │
   └──────────┘                               └────────────────┘
         │                                            │
         │                                   9% ─┐    │   ┌─ 1% dev wallet
         ▼                                        │    ▼
   user buys/sells $THODL                         ▼
                                            ┌───────────────────────┐
                                            │   BuyerContractV2     │
                                            │  (immutable treasury) │
                                            └───────────────────────┘
                                                │             │
                                  convertFeesToETH         NFTs held forever
                                  (own Uniswap sell,       (no withdraw function
                                   fee-exempt path)         exists in the code)
                                                │
                                                ▼
                                ┌─────────────────────────────────┐
                                │  Off-chain oracle               │
                                │    - scans OpenSea listings     │
                                │    - computes PPTDH per card    │
                                │    - signs lowest-PPTDH with    │
                                │      EIP-712 BestListing        │
                                └─────────────────────────────────┘
                                                │
                                                ▼
                                          triggerBuy()
                                       (permissionless,
                                        15-block cooldown,
                                        gas refunded from treasury)
                                                │
                                                ▼
                                  ┌───────────────────────────────┐
                                  │ Seaport.fulfillAdvancedOrder  │
                                  │ recipient = BuyerContractV2   │
                                  └───────────────────────────────┘
                                                │
                                                ▼
                           NFT lives inside BuyerContractV2 forever.
                           TDH accrues to the contract's address.
                           Via 6529 DelegationRegistry, it is
                           consolidated to a governance wallet
                           controlled by $THODL holders.

Step-by-step walkthrough

1. Dev seeds LP off-protocol. Using revenue from the 6529 TDHODL Meme card mint (~0.45 ETH expected), the dev pairs a proportional amount of $THODL from the deployer surplus with that ETH and deposits it into a fresh Uniswap V2 pool. The LP tokens are sent to 0x000…dEaD. No buyer ETH is ever used for this; no fixed minimum is enforced on-chain.
2. Trading is enabled. The Safe calls THODLV2.launch(pair) once, registering the canonical AMM pair and flipping the launched flag. From this block on, the 10% FOT applies to any transfer where the pair is from or to.
3. Airdrop opens. Once the merkle root (V1 migrants + Meme card minters) is committed via setRoot → lockRoot → startAirdrop, eligible wallets can claim 111,968 $THODL per entry by submitting their merkle proof. The airdrop is open indefinitely.
4. Trader swaps $THODL on the Uniswap V2 ETH/$THODL pool. The token's _update function intercepts the transfer, takes 10% in $THODL, splits it 9% / 1% to BuyerContractV2 / dev wallet.
5. BuyerContractV2 accrues $THODL passively. An authorised keeper (typically the oracle signer EOA, registered by Safe via setKeeper) periodically calls convertFeesToETH(amountIn, minEthOut), which sells accumulated $THODL for ETH on the same Uniswap pool. Restricting the call to keepers + owner prevents permissionless callers from sandwiching the swap with minEthOut = 0. Because BuyerContractV2 is fee-exempt on the token, its own sell pays no fee — no recursion.
6. Oracle scans OpenSea listings of the 6529 Memes collection every 30 s. It computes PPTDH = price_wei / tdh_rate_1e9 for each active card (mint-window cards < 299 supply are excluded) and picks the lowest.
7. Oracle signs an EIP-712 BestListing(tokenId, priceWei, validForBlocks, nonce, deadline) message off-chain.
8. Anyone submits the signed payload to GaslessOracleV2.submitBestListing(...), which verifies the signature and forwards updateBestListing(tokenId, priceWei, validForBlocks) to BuyerContractV2. The submitter's gas is reimbursed from the treasury ETH balance (capped at 100 gwei effective, 0.01 ETH per call).
9. After a 15-block cooldown (~3 min), anyone can call triggerBuy(tokenId, seaportOrderData). The contract validates: tokenId matches the oracle signal, the Seaport order targets the 6529 Memes contract, all consideration items are NATIVE ETH, total ETH ≤ maxNftPrice (5 ETH default), on-chain IERC1155.totalSupply(tokenId) ≥ minCardSupply (299 default).
10. Purchase executes atomically via ISeaport.fulfillAdvancedOrder, with recipient = address(this). The NFT lands directly inside BuyerContractV2. A balance-of check after the call guarantees the NFT was received.
11. NFT lives forever inside the contract. There is no function in the code that moves it out. It can never be sold, transferred, or listed. Its TDH flows to the contract's address and is consolidated to the governance wallet via callDelegationRegistry() (owner-only).

2.1 Optional secondary path — start4xSale

After the airdrop has been open for as long as the dev judges sufficient, the Safe picks exactly one terminal action:

• burnRemainingAirdrop() — burns all unclaimed THODL forever. Terminal.
• start4xSale(deadline) with deadline ≤ now + 62 days — opens a public secondary sale where anyone can buy a slot at 0.25 ETH and receive 111,968 $THODL. This is exactly 4× the typical 6529 Meme card mint price (0.0625 ETH), hence the name. When the deadline passes, anyone can call finalize4xSale():
  • 100% of ETH proceeds → BuyerContractV2 treasury
  • 100% of unsold THODL → burned via token.burn
  • No auto-LP (intentional — eliminates spot-reserve sandwich risk).

The state machine is strictly one-way: Configured → AirdropOpen → (Sale4xOpen → Finalized) OR (Finalized via burn). No reopens, no second chance.

3. Investor thesis

3.1 First on-chain treasury for TDH — perpetual, liquid 6529 exposure

$THODL is the first protocol that turns the 6529 ecosystem into a single liquid ERC20. Owning a well-rounded 6529 Memes position historically required buying dozens of individual cards over months or years, monitoring listings, managing gas, and navigating the PPTDH curve by hand. $THODL packages that entire activity into one token, perpetually:

• Hold $THODL once — you own fractional exposure to every card the treasury acquires, priced by the market.
• The protocol's oracle does the PPTDH math 24/7 — every cycle it ranks every active OpenSea listing across all 487 6529 Memes by PPTDH and signals the most TDH-efficient card on the market. The treasury buys it. Forever.
• Exit anytime on Uniswap V2 (bearing the 10% FOT fee, which goes back into the protocol you just exited — fueling more buys).

Unlike a vault where NAV is recomputed by a curator, here the exposure is a running claim on a permanently-growing stack of high-conviction cards selected purely on a transparent, on-chain-verifiable metric (PPTDH with the 6529 formula). There is no manager, no rebalance committee, no discretion: the protocol's behaviour is fully encoded in immutable contracts.

3.2 Supply reduction — deflationary pressure on the Memes floor

The Memes collection has a finite maximum supply per card (mint ends after ~6 days and supply freezes). Every NFT the treasury purchases is permanently locked — there is no transfer-out function in the buyer contract. Over time, as trading volume on $THODL funds more buys:

• Cards held by the protocol leave the float forever, never to sell back.
• Effective circulating supply of the collection shrinks with every trigger.
• At constant or growing demand, this creates monotonic upward pressure on floor prices and on the community's weighted PPTDH baseline.

This is structural, not promotional: it follows mechanically from the absence of a sell path in the smart contract code.

3.3 Governance weight — THODL holders vote on 6529 via the vault's TDH

As the treasury accumulates NFTs, it accumulates TDH. Through the 6529 Delegation Registry's consolidation mechanism, the contract's TDH is attributed to a designated consolidation wallet that participates in 6529 governance on behalf of the protocol. That wallet's voting stance — on 6529.io proposals, community direction, meme card curation, boycotts, ecosystem partnerships — is decided off-chain by $THODL holders via a snapshot-based vote (1 $THODL = 1 vote). The Safe multisig that controls the consolidation wallet executes the outcome.

Concretely:

• Per-card TDH contribution grows as the protocol buys more cards and as time passes (each day = +1 × (3941/edition_size) per copy held).
• Per-$THODL voting power grows monotonically alongside, minus any $THODL burned via buybackAndBurn.
• The marginal $THODL holder inherits a fractional claim on a governance position inside 6529 that would be infeasible to assemble individually.

Over time, this turns $THODL into the most efficient per-dollar way to express conviction about 6529 community direction.

Activation milestone — 100,000 TDH. $THODL holders' direct use of the vault's TDH (governance routing, gated 6529 access, community features) activates as soon as the treasury reaches 100,000 accumulated TDH. Until then the consolidation wallet is registered and accruing in the background; from that threshold onward the protocol opens shared TDH usage (see §6.4).

3.4 Minter advantage — 4× cheaper than 4xSale

V2 has no fixed-rate public sale, so the V1 framing of "minter advantage vs sale" no longer applies directly. The structural advantage now lives in the comparison between:

• 6529 Meme card mint at ~0.0625 ETH → claim 111,968 $THODL via the airdrop, plus you keep the underlying NFT.
• buy4x() at 0.25 ETH (only available if the Safe opens the 4xSale) → 111,968 $THODL, no NFT.

Per ETH spent, a Meme card minter ends up with roughly 4× the $THODL of a 4xSale buyer, and they also keep the card. The 4xSale, if opened, exists to monetise unclaimed allocations: it is not a primary distribution channel.

After launch, $THODL is also obtainable directly on Uniswap V2 (subject to the 10% FOT). The pool price discovers freely; the airdrop floor (per-card cost amortised at ~0.0625 ETH for 111,968 $THODL) and the buy4x ceiling (0.25 ETH for 111,968 $THODL) frame the launch price discovery zone.

3.5 Zero dev pre-allocation, yield stream from usage

The developer has no pre-mined liquid token allocation tied to a vesting cliff. The deployer surplus left over after funding the airdrop bucket (22,393,440 $THODL ≈ 32.26% of supply) is disposed of post-deploy by the Safe — used for the LP seed, distributed back to community, or burned (see §5). Developer income on an ongoing basis is exclusively the 1% of every trade fee, paid in $THODL. This aligns incentives: the dev earns only when the protocol is used, and only at the same rate per-trade as the treasury (the protocol earning 9× more than the dev on every swap).

The dev's ability to influence protocol parameters (through the Safe multisig) is bounded by the immutable logic: the dev cannot mint new tokens, cannot move NFTs out of the vault, cannot withdraw the LP, cannot override trade fees, cannot rewrite the oracle. The only live knobs are safety caps (maxNftPrice, minCardSupply, minEthForTrigger) and governance primitives (oracle authorisation, consolidation registration, buyback-and-burn discretion).

4. Safety — why funds, LP, and NFTs are provably safe

The trust model of $THODL rests on what the smart contract code cannot do, by construction. Every class of risk that investors typically worry about in DeFi is eliminated at the code level rather than by policy.

4.1 NFTs cannot leave the treasury

BuyerContractV2 inherits OpenZeppelin's ERC1155Holder and accepts ERC1155 transfers (needed to receive Seaport purchases). It has zero functions that transfer NFTs out:

• There is no sendNFT, withdrawNFT, listOnSeaport, transferToSafe, or any equivalent.
• The only place the contract calls Seaport is triggerBuy, which is fulfillAdvancedOrder (a buy).
• emergencyWithdrawToken explicitly operates on IERC20 only, not IERC1155. It cannot move NFTs.
• The callDelegationRegistry function calls into the 6529 registry contract only, on a hardcoded immutable address, to register consolidations/delegations — not to transfer ownership of anything. Selector allowlist of 6 known 6529 NFTDelegation methods is enforced in-contract.

BuyerContractV2 is byte-identical to V1's audited BuyerContract (only the name differs). Even the Safe multisig owner, with full admin rights, cannot sell or transfer a single NFT out of the treasury. It is a one-way sink.

4.2 Liquidity pool is permanently locked

The LP is dev-seeded off-protocol from Meme card mint revenue and the LP tokens are sent to 0x000000000000000000000000000000000000dEaD — the canonical burn address. Nobody, including the deployer, holds the keys to that address.

Concrete launch flow:

1. factory.createPair(THODLV2, WETH)     // anyone — produces canonical pair address
2. Safe.launch(pair)                     // registers the pair on the token, flips `launched`
3. Safe.setFeeExempt(seeder, true)       // seeder skips FOT on the addLiquidity transferFrom
4. seeder.router.addLiquidityETH(
       THODLV2,
       thodlAmount,
       minThodl,
       minEth,
       0x000…dEaD,                       // LP recipient = burn
       deadline
   )

Consequences:

• The liquidity can never be withdrawn.
• No rug-pull is possible: removeLiquidity from 0x…dEaD would fail.
• The pool reserves can only change through ordinary swaps and through future top-ups (which, if any, follow the same to=DEAD discipline or use the permissionless LpHelperV2).

4.2a No fixed ETH precondition (V1 failure mode eliminated)

V1's GenesisSale.finalize() required exactly 8.097 ETH to seed the LP and reverted otherwise. With a sale that raised 0.376 ETH, the function became permanently unreachable. V2 has no such precondition: there is no on-chain finalize step that the LP depends on, no minimum-raise gate, no LpEthShortfall revert path. The dev simply pairs whatever ETH is available with a proportional amount of $THODL and calls addLiquidityETH directly. The token's launched flag is the only gate, and it is owner-flipped (Safe.launch(pair)).

4.2b LP scaling roadmap

Initial LP depth at launch is intentionally small (~0.45 ETH and the proportional $THODL). As trading volume scales, depth must scale with it to avoid extreme slippage on large trades. The protocol has a layered, progressively-enabled approach:

1. Tier 1 — BuyerContractV2.buybackAndBurn(ethAmount, minThodlOut) (live from day 1). The Safe can use treasury ETH to buy THODL from the LP and burn it. Net effect: pool's ETH side grows, THODL side shrinks → spot price rises and float reduces. Does NOT increase absolute depth, but improves price stability under selling pressure.

2. Tier 2 — Owner-led LP injection (always available; trust-mid). The Safe can THODLV2.setFeeExempt(self, true) and then call UniswapV2Router.addLiquidityETH with treasury THODL + ETH it has accumulated. New LP tokens go to the Safe (NOT burned) unless explicitly sent to 0x…dEaD. Suitable for periodic, announced top-ups.

3. Tier 3 — LpHelperV2 permissionless helper (already deployed at 0x2E79…189C7). An immutable, fee-exempt helper that lets ANY user deposit THODL + ETH and receive LP tokens directly to their wallet. The Safe makes a single THODLV2.setFeeExempt(LpHelperV2, true) call to enable; from that moment on, any community member can become an LP-provider without losing 10% to FOT fees.

Each tier is opt-in by Safe and cumulative — none requires a contract redeploy.

4.3 Proceeds flow is deterministic

V2 has no V1-style GenesisSale.finalize to route sale proceeds. The two distinct ETH-receiving paths are:

• AirdropManagerV2.buy4x (only when Sale4xOpen): buyer ETH is held in the airdrop manager. At finalize4xSale, 100% of accumulated ETH is forwarded to BuyerContractV2 and 100% of unsold THODL is burned. The forward is unconditional in the code; there is no path for the ETH to reach the deployer, the dev wallet, or any third party.
• Treasury fee flow (perpetual, post-launch): 9% of every swap goes to BuyerContractV2, 1% to the dev wallet. Hardcoded bps, no setters.

Direct ETH transfers to AirdropManagerV2 outside buy4x() are rejected: the receive() function reverts with UnsolicitedEth(). This prevents accidental loss and ensures the only ETH that enters the contract is intentional sale revenue.

4.4 Emergency powers are one-shot self-destructing

During the brief pre-launch window, emergencyWithdrawETH and emergencyWithdrawToken are available on BuyerContractV2 to the owner so that mistakes in setup (wrong env var, misrouted tokens) can be recovered. Once operational confidence is reached, the Safe multisig calls disableEmergency() exactly once:

function disableEmergency() external onlyOwner {
    if (!emergencyEnabled) revert EmergencyAlreadyDisabled();
    emergencyEnabled = false;
    emit EmergencyDisabled();
}

After this, both emergency functions revert. The flag is non-reversible — there is no enableEmergency(). From that moment on, even the owner cannot extract ETH or ERC20 from the treasury by any means. (Again, NFTs were never extractable even during the emergency window.)

4.5 Ownership can be renounced

THODLV2, BuyerContractV2, AirdropManagerV2, and GaslessOracleV2 all inherit OpenZeppelin's Ownable2Step. At the community's discretion, the Safe can call renounceOwnership() on any or all of them, setting the owner to address(0) and eliminating even the last privileged operations. Candidate post-launch renouncements:

• THODLV2 — after launch(pair) and the AMM pair registry settles, the remaining owner powers (setAmmPair, setFeeExempt) are low-risk; renouncement makes the token fully immutable.
• AirdropManagerV2 — once the airdrop reaches its terminal state (Finalized), ownership becomes ceremonial; can be renounced.
• BuyerContractV2 and GaslessOracleV2 — more tactical: oracle signers may need to be rotated if a key is compromised, TDH filters may need occasional tuning. Community governance decides whether to keep the Safe or renounce.

4.6 V2 launch flow — what the dev does, transparently

The end-to-end launch is fully on-chain-observable; the Safe transactions are public. In order:

1. factory.createPair(THODLV2, WETH) (anyone — produces canonical pair address).
2. Safe.launch(pair) (flips launched = true, registers the pair).
3. Safe.setFeeExempt(seederWallet, true) (so the seeder's addLiquidity transferFrom skips the FOT).
4. Seeder calls router.addLiquidityETH(THODLV2, …, to=DEAD, deadline) — LP locked.
5. After the Meme card mint window closes, off-chain snapshot script generates merkle leaves (V1 migrants + minters), produces a combined root.
6. Safe.setRoot(root) → Safe.lockRoot() → Safe.startAirdrop().
7. Eligible wallets claim at /claim indefinitely.
8. When ready: Safe.burnRemainingAirdrop() OR Safe.start4xSale(deadline).
9. (Optional) After 4xSale deadline: anyone calls AirdropManagerV2.finalize4xSale() — permissionless.
10. Safe.disableEmergency() on BuyerContractV2 once production confidence is reached.

Steps 1–4 happen first because the airdrop has no fixed timing — the dev wants trading to exist before users start claiming.

4.7 Fair launch, no hidden allocation

• No founder pre-mint with vesting. 100% of the 69.42M supply is minted at deploy and split into two visible buckets at the deploy script: the airdrop bucket (67.74%, transferred to AirdropManagerV2) and the deployer surplus (32.26%, held by the Safe). The Safe disposes of the surplus transparently — earmarks to LP seed, treasury injection, or burn — with each transfer on-chain.
• No public ETH sale / VC allocation. There is no primary sale to enter. The 4xSale (if opened) is a secondary path for unclaimed slots, capped at 420 entries total across the entire airdrop bucket.
• Fully on-chain verifiable. Token, buyer, airdrop manager, LP helper, and oracle contracts are verified on Etherscan at deploy time.

5. Tokenomics

5.1 Total supply

69,420,000 $THODL, 18 decimals. The number encodes the memetic constant 69420. The supply is minted in full at deploy time. Supply can only ever decrease through burns, never increase (no mint() function is exposed).

5.2 Distribution

Within the airdrop bucket:

The TDHODL Meme card is being submitted to the 6529 Memes collection via the official Submission Window. Wallets that mint the TDHODL Meme card during that window receive an airdrop entry; one mint = one allocation, mint N times = N allocations (the airdrop scales linearly with cards held at snapshot, up to the per-wallet allocation in the snapshot script).

Deployer surplus disposition (pending Safe decision):

The actual allocation is published as Safe transactions on Etherscan once decided.

5.3 Airdrop parameters

5.4 Fee mechanic (post-launch, perpetual)

Every transfer where either from or to is a registered AMM pair triggers the fee:

P2P transfers between EOAs — wallet-to-wallet — pay no fee. The token is self-describing about this via isFeeExempt and isAmmPair public mappings.

The 900/100 bps and the destinations are hardcoded constants — they cannot be changed by anyone, ever.

6. Governance — $THODL as a lever on 6529

6.1 The consolidation mechanism

Every 6529 Meme NFT held by any wallet accrues TDH to that wallet. Normally, if you own NFTs across multiple wallets, each wallet has its own TDH score. The 6529 NFTDelegation contract (0x2202CB9c00487e7e8EF21e6d8E914B32e709f43d) introduces a registerDelegationAddress function with a "consolidation" use case: wallet A consolidates to wallet B, and B inherits A's TDH for governance purposes. (Note: 0x00000000000076A84feF008CDAbe6409d2FE638B is the standard delegate.cash registry, NOT the 6529-specific consolidation contract; v3 of this protocol uses the latter.)

For $THODL:

• Wallet A = BuyerContractV2 (holds the growing NFT collection).
• Wallet B = the consolidation target — a Safe multisig controlled by the protocol, whose signers execute $THODL holders' governance decisions.
• Every meme-card purchase by BuyerContractV2 mechanically increases B's voting weight on 6529.io.

The callDelegationRegistry(bytes) function on BuyerContractV2 lets the Safe owner register / revoke consolidations via calldata, restricted in two layers: (a) the registry address is immutable (set in constructor, no setter exists), and (b) the function only accepts the 6 hardcoded 4-byte selectors of known 6529 NFTDelegation methods (register/revoke/update/batch + sub-delegation variants). This prevents any future code path that could be weaponised to drain assets.

6.2 How $THODL holders direct the vote

Off-chain governance (Snapshot.org-style) where 1 $THODL = 1 vote:

1. A proposal is opened in the $THODL snapshot space (e.g., "How should we vote on 6529 Proposal #N?").
2. $THODL holders vote with their balances at the snapshot block.
3. The outcome is published.
4. The Safe signers execute the decision by casting the corresponding vote from the consolidation wallet on 6529.io or the relevant 6529 governance endpoint.

Over time, the Safe can be replaced by an on-chain voting module that automates step 4, removing the last trust assumption. The contract architecture already accommodates this: callDelegationRegistry accepts arbitrary calldata, and there is no requirement that the owner be a human-controlled multisig.

6.3 Why this matters

For a 6529 community member who wants voice without spending hundreds of ETH on individual cards, $THODL is the most capital-efficient path to leverage. Holding $THODL:

• Immediately gives a proportional claim on whatever TDH the contract holds today.
• Gives a proportional claim on all future TDH accrual as the treasury buys more cards.
• Scales with the entire community's trading activity, not just the holder's own.
• Requires no operational overhead (no card selection, no listing management, no consolidation calls).

6.4 Shared TDH usage — activation at 100,000 TDH

The treasury accrues TDH from the moment its first NFT is purchased and registers consolidation. To avoid premature, low-signal governance participation while the vault is still small, the protocol gates shared TDH usage behind a measurable on-chain milestone.

Trigger: when the BuyerContractV2 treasury reaches 100,000 accumulated TDH (verifiable from the 6529 NFTDelegation registry + BuyerContractV2 NFT inventory at any moment), the protocol activates the shared-TDH layer.

What "shared TDH usage" means:

• $THODL holders can collectively direct the consolidation wallet's TDH on 6529 governance votes (via Snapshot-style off-chain process, 1 $THODL = 1 vote, executed by the Safe).
• TDH-gated 6529 ecosystem features (community access, drops, boycotts, partnerships) become available pro-rata to $THODL balance.
• The protocol publishes a public TDH dashboard reflecting (a) total vault TDH, (b) per-$THODL TDH share, (c) live governance action queue.

Why 100,000 TDH: this is the threshold below which the vault's vote is too small to be meaningful in 6529 governance and above which the per-$THODL share becomes practically usable. At 100k TDH and a fully diluted 69.42M $THODL, the per-token entitlement is 100,000 / 69,420,000 ≈ 0.00144 TDH/token. A holder of 1M $THODL controls ~1,440 TDH worth of governance weight, which is meaningful in mid-sized 6529 votes.

Pre-100k state: the consolidation wallet is registered, the TDH is accruing, and it is passively visible on 6529.io. The Safe does not direct it, $THODL holders do not vote on it; it simply earns reputation in the background. This avoids governance theatre while the protocol is still warming up.

Post-100k state: the protocol publishes the activation transaction and from that block onward the shared-TDH governance pipeline is open. The threshold is one-shot — once crossed, shared usage stays on permanently.

6.5 Long-term vision — on-chain oracle migration

The current architecture is deliberately conservative: it ships what is provably safe today on Ethereum L1, while leaving room to upgrade the trust assumptions as the surrounding ecosystem matures.

The price oracle that selects the next 6529 Meme to buy is currently an off-chain service (see §2 step 6). It signs BestListing messages off-chain and the on-chain BuyerContractV2 enforces freshness, signer authorization and price bounds before honoring the trigger. This is the right design today because there is no general-purpose, low-cost on-chain way to read live OpenSea listings from an Ethereum L1 contract.

When the 6529 chain launches, an on-chain oracle becomes architecturally feasible: native access to the 6529 NFT layer, lower per-call cost, and a settlement environment where listing data and trigger logic can co-exist without introducing trust shortcuts. The protocol commits to migrating the price-discovery path on-chain as soon as that infrastructure is live and audited:

• The off-chain signer becomes redundant — the buyer (or its 6529-chain twin) reads listings directly from the chain and computes the best-PPTDH candidate in a view function.
• The GaslessOracleV2 relay degenerates to a thin adapter or is retired entirely.
• The trigger becomes fully trustless: no key, no off-chain process, no signer to compromise.

Until 6529 chain is live, the off-chain oracle remains the operationally correct choice — but it is explicitly an interim design.

7. Protocol parameters and adjustability

Most values are set at deploy and cannot change. The small set that can change is controlled by the Safe multisig and publicly observable on Etherscan.

The pattern is "conservative defaults, minimal adjustability, maximum immutability". The Safe can tune a few operational knobs but cannot change the core economic rules.

8. Deployed addresses (mainnet)

8.1 V2 — current protocol (deployed 2026-05-13, block ~25085626)

All contracts verified on Etherscan.

8.2 V1 — deprecated (record only)

The V1 sale is permanently bricked (see Appendix A). These contracts remain on-chain but are no longer part of the protocol. V1 buyers are honored via V2 migration airdrop entries — there is no V1 claim path to use.

9. External dependencies

All four external protocols are blue-chip, widely audited, and have been in production on mainnet for years with billions of dollars in cumulative throughput.

10. Links

• Domain: tdhodl.xyz
• On-site whitepaper: tdhodl.xyz/whitepaper
• FAQ: tdhodl.xyz/faq
• Claim page: tdhodl.xyz/claim
• 6529 Submission link: to be published when the TDHODL Meme card submission goes live
• Repository: github.com/6529STR/tdhodl
• Inspiration: punkstrategy.fun (PNKSTR mechanic for CryptoPunks)
• 6529 TDH formula: 6529.io/network/tdh
• 6529 Memes prices & valuations: 6529nfts.io/memes/prices-and-valuations
• 6529 Delegation Center: 6529.io/delegation/delegation-center
• OpenSea collection: opensea.io/collection/thememes6529

11. Glossary

• TDH — Total Days Held. 6529's on-chain holder reputation score. Per-copy-per-day rate = 3941 / edition_size.
• PPTDH — Price Per TDH. price_wei / tdh_rate. Lower is better.
• FOT — Fee-on-Transfer. An ERC20 that takes a fee on certain transfers (here: AMM-pair transfers only).
• Consolidation — 6529's mechanism to combine the TDH of multiple wallets under one primary wallet for governance purposes.
• LP — Liquidity Provider / Liquidity Pool. In this context, the Uniswap V2 WETH/THODLV2 pool.
• Seaport — OpenSea's open-source NFT exchange protocol. Used here for on-chain NFT fulfilment.
• EIP-712 — Ethereum standard for typed structured data signing. Used by the oracle to sign BestListing payloads without spending gas.
• Safe (Gnosis Safe) — Smart-contract multisig wallet. Here, the owner of all $THODL contracts.
• Dead address — 0x000000000000000000000000000000000000dEaD. A canonical address with no known private key; sending tokens to it effectively burns them.
• AirdropManagerV2 — the V2 contract that holds the airdrop bucket, accepts merkle-proof claims, and runs the optional 4xSale terminal path.
• buy4x — function on AirdropManagerV2 (only callable in state Sale4xOpen) that lets anyone buy one unclaimed slot at 0.25 ETH for 111,968 $THODL.
• finalize4xSale — permissionless function (only callable after sale4xDeadline) that forwards 100% of accumulated 4xSale ETH to BuyerContractV2 and burns 100% of unsold THODL.
• V1 / V2 — the original (bricked) and current deployments. See Appendix A.

This document describes the protocol as implemented in the open-source code at github.com/6529STR/tdhodl. Where this document and the code disagree, the code is authoritative.

Appendix A — V1 → V2 history

V1 launched on 2026-04-27 with five contracts: THODL, BuyerContract, GenesisSale, MerkleAirdrop, GaslessOracle. The Genesis Sale was the single ETH on-ramp. It was designed so that, at finalize(), the contract would pair the 5% LP reserve (3.47M $THODL) with a fixed 8.097 ETH from sale proceeds and deposit the result into Uniswap V2.

The sale raised 0.376 ETH across 2 buyers — well below the 8.097 ETH precondition. As a result finalize() reverts with LpEthShortfall on every call and is permanently bricked:

• The 0.376 ETH is stuck inside GenesisSale (no extract path).
• The V1 buyers' 161k $THODL allocation is stuck (only released by finalize).
• The 5% LP reserve cannot be seeded.
• The token's launched flag stays false; trading is blocked.

V2 removes this failure mode entirely by eliminating the public ETH-collecting sale. The dev seeds initial LP off-protocol from Meme card mint revenue, then opens a merkle airdrop with no fixed-amount preconditions. V1 buyers are honored via a +100% bonus airdrop entry in the V2 merkle tree:

The V1 contracts remain on mainnet as a public record (see §8 for addresses); they are no longer part of the protocol.