Wadoozie DAO — Smart Contracts

Fully on-chain governance system for the Wadoozie ecosystem. Token holders vote on proposals that control the DAO treasury and can modify governance parameters. No single entity retains admin privileges after deployment.

Table of Contents

• Contracts
• Token Specification
• Governance Parameters
• Proposal Guardian
• Governance Lifecycle
• Timelock Roles
• Tech Stack
• Requirements
• Installation
• Compile
• Testing
• Deployment
• Deployment Checklist
• Contract Verification
• Security
• License

Contracts

WadoozieFeeRouter

Thin, non-upgradeable wrapper around the canonical Uniswap V2 Router. On every swap it takes feeBps (default 50 = 0.5%, hard-capped at 100 = 1%) from the input token, sends the fee to feeRecipient (the DAO treasury multisig in production), and routes the remainder through Uniswap with the user as the direct recipient. The router holds nothing between transactions.

Three swap shapes, mirroring the buy-wadz UI's spend-token picker:

The non-ETH paths require an approve(WadoozieFeeRouter, ≥ amountIn) on the input token before the call (V2-standard UX, identical to what Uniswap's own interface requires).

Admin surface (Ownable, owner = DAO multisig post-deploy):

feeRecipient is deliberately not in this table. It is set once in the constructor and stored in an immutable slot — there is no setter, and a compromised owner key cannot redirect the fee stream. If the recipient ever needs to change, deploy a new WadoozieFeeRouter and have the frontend repoint.

Safety invariants (all enforced at the contract level, not by convention):

• WADZ, WETH, and feeRecipient are immutable and pinned at deploy — no admin action can repurpose the contract for a different token or redirect the fee stream.
• Fee is hard-capped at 100 bps. A malicious / compromised owner cannot raise it above 1%.
• ReentrancyGuard on every swap function.
• whenNotPaused on every swap function.
• Fees forward atomically — the router never holds user funds between calls.
• WADZ-as-input and WETH-as-input rejected on buyWadzWithToken to prevent path tricks.

Token Specification

Extensions:

Genesis Distribution

The constructor takes six wallet addresses and distributes the supply atomically — there are no admin functions, so this is the only allocation event the contract will ever see.

totalSupply() permanently equals 2,000,000,000: the burn is implemented as a transfer to 0x…dEaD, not an OpenZeppelin _burn, so supply does not decrease. The 999,999,999 burned tokens sit in 0x…dEaD forever (no key controls that address). All five allocation addresses are exposed as immutable public getters (LP_WALLET, TREASURY, PUBLISHER_REWARDS, SIGNAL_FRAGMENTS, TEAM_VESTING).

After the constructor finishes, the deployer holds zero tokens and has no role. There is nothing to renounce.

Immutability guarantees:

• No mint function — supply is fixed at deployment
• No burn function — tokens cannot be destroyed post-genesis
• No pause function — transfers cannot be halted
• No owner / Ownable — no admin key exists

Auto-Delegation (WAD-04)

To avoid governance stalling on un-delegated supply, Wadoozie auto self-delegates recipients the first time they receive tokens via a transfer — voting power activates on arrival without requiring a separate delegate() call. Because the genesis distribution flows through _transfer, all five allocation wallets are auto-self-delegated at deployment, with voting power equal to their allocation. The 0x…dEaD burn address is also self-delegated; its 999,999,999 voting power is permanently inert because no key controls the address. Any delegation a holder has already set — to self or someone else — is never overridden by a later transfer.

Governance Parameters

Production (ignition/modules/WadoozieDAO.ts)

Testnet (ignition/modules/WadoozieDAO_Test.ts)

All governance parameters are modifiable through governance proposals via GovernorSettings (setVotingDelay, setVotingPeriod, setProposalThreshold, updateQuorumNumerator).

Proposal Guardian

Headquarters includes the GovernorProposalGuardian extension — an emergency address that can cancel any non-executed proposal.

Deadlock risk: If the guardian is compromised, it can cancel the proposal attempting to replace it. Mitigation: always use a multisig wallet as guardian, never a single EOA.

Governance Lifecycle

Propose  ──>  Voting Delay  ──>  Active Voting  ──>  Succeeded  ──>  Queue  ──>  Timelock Delay  ──>  Execute
                                                         │
                                                     Defeated
                                                     (quorum not met or majority Against)

Timelock Roles

After deployment and role configuration, the Timelock access control is:

The Timelock holds all DAO funds and is the contract that executes on-chain actions.

Tech Stack

Requirements

• Node.js >= 18
• npm >= 9
• A .env file based on .env.example:

DEPLOYER_PRIVATE_KEY=your_private_key_here
ETHEREUM_RPC_URL=https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY
ETHERSCAN_API_KEY=your_etherscan_api_key

Installation

git clone https://github.com/wadoozie/SmartContracts.git
cd SmartContracts
npm install

Compile

npm run compile

Artifacts are written to artifacts/ (gitignored).

Testing

npm test

79 tests across three suites:

Deployment

Deployment Order

Contracts must be deployed in this order due to constructor dependencies:

1. Wadoozie Token
2. WadoozieTreasury
3. Headquarters (requires token + timelock addresses)
4. Grant PROPOSER_ROLE to Headquarters on Timelock
5. Grant CANCELLER_ROLE to Headquarters on Timelock
6. Renounce DEFAULT_ADMIN_ROLE on Timelock

The Ignition modules handle all six steps automatically.

Ethereum Mainnet

npm run deploy:mainnet

Deploys all three contracts with production parameters, grants roles, and renounces admin — fully automated via Hardhat Ignition.

Local Network

# Terminal 1 — start a local Hardhat node
npx hardhat node

# Terminal 2 — deploy with production parameters
npm run deploy:local

Sepolia Testnet

# Production parameters
npm run deploy:sepolia

# Fast test parameters
npm run deploy:sepolia:test

Available npm Scripts

Deployment Checklist

Before deploying to Ethereum mainnet:

1. Run all tests and confirm 79/79 pass:

   npm test

2. Configure .env with mainnet RPC URL, deployer private key, and Etherscan API key.

3. Set the six wallet addresses for the genesis distribution. Each must be the final holder of its allocation — there is no admin to change them later. Use multisigs for everything except the LP wallet (which will pair with ETH on Uniswap immediately post-deploy).

   Constructor parameter	Allocation	Recommended type
   deployer_	0 (drains during constructor)	The signer running the deploy tx
   lpWallet_	750,000,001 WADZ	EOA or multisig that will pair LP on Uniswap
   treasury_	100,000,000 WADZ	DAO treasury multisig
   publisherRewards_	70,000,000 WADZ	Publisher payouts multisig
   signalFragments_	50,000,000 WADZ	Signal Fragments prize-pool multisig
   teamVesting_	30,000,000 WADZ	Team vesting timelock contract

4. Deploy:

   npm run deploy:mainnet

5. Verify contracts on Etherscan (see below).

6. Confirm roles on Etherscan:

   • Timelock hasRole(PROPOSER_ROLE, governorAddress) returns true
   • Timelock hasRole(CANCELLER_ROLE, governorAddress) returns true
   • Timelock hasRole(DEFAULT_ADMIN_ROLE, deployerAddress) returns false

7. Delegation — all five genesis allocation wallets are auto-self-delegated by the constructor (their voting power is live the moment the deploy tx confirms). No manual delegate() calls are required to activate quorum. Downstream recipients (anyone who later receives WADZ via transfer) are also auto-self-delegated on first receipt; see the Auto-Delegation (WAD-04) section for details.

Contract Verification

After deployment, verify source code on Etherscan:

# Token
npx hardhat verify --network mainnet <TOKEN_ADDRESS> \
  "<DEPLOYER_ADDRESS>" \
  "<LP_WALLET_ADDRESS>" \
  "<TREASURY_ADDRESS>" \
  "<PUBLISHER_REWARDS_ADDRESS>" \
  "<SIGNAL_FRAGMENTS_ADDRESS>" \
  "<TEAM_VESTING_ADDRESS>"

# Timelock
npx hardhat verify --network mainnet <TIMELOCK_ADDRESS> \
  86400 "[]" '["0x0000000000000000000000000000000000000000"]' "<DEPLOYER_ADDRESS>"

# Governor
npx hardhat verify --network mainnet <GOVERNOR_ADDRESS> \
  "<TOKEN_ADDRESS>" "<TIMELOCK_ADDRESS>" 7200 50400 "1000000000000000000000" 4 "<GUARDIAN_ADDRESS>"

Or use the convenience script (requires ETHERSCAN_API_KEY in environment):

export ETHERSCAN_API_KEY=your_key_here
bash scripts/verify-etherscan.sh

Security

Design Principles

• Immutable token — no mint, burn, pause, or admin functions
• No admin keys — DEFAULT_ADMIN_ROLE is renounced after setup
• Timelock protection — mandatory delay before any governance action executes
• Proposal guardian — emergency cancellation via multisig
• Battle-tested dependencies — built entirely on OpenZeppelin's audited contract library
• No upgradeability — contracts cannot be changed after deployment

Inheritance

Wadoozie
├── ERC20
├── ERC20Permit
└── ERC20Votes

Headquarters
├── Governor
├── GovernorSettings
├── GovernorCountingSimple
├── GovernorVotes
├── GovernorVotesQuorumFraction
├── GovernorTimelockControl
└── GovernorProposalGuardian

WadoozieTreasury
└── TimelockController

Known Considerations

License

MIT