HOODL

[
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "initialOwner",
        "type": "address"
      },
      {
        "internalType": "address",
        "name": "initialTeamWallet",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "initialSupply",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "constructor"
  },
  {
    "inputs": [],
    "name": "ApprovalToZeroAddress",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "BalanceTooLow",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "GameNotSet",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "InvalidSupply",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "OnlyOwner",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "TransferFromZeroAddress",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "TransferToZeroAddress",
    "type": "error"
  },
  {
    "inputs": [],
    "name": "ZeroAddress",
    "type": "error"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "owner",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "spender",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "Approval",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "oldGame",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "newGame",
        "type": "address"
      }
    ],
    "name": "GameSet",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "oldOwner",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "newOwner",
        "type": "address"
      }
    ],
    "name": "OwnershipTransferred",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "oldHook",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "newHook",
        "type": "address"
      }
    ],
    "name": "SwapTaxHookSet",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "oldTeamWallet",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "newTeamWallet",
        "type": "address"
      }
    ],
    "name": "TeamWalletSet",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "from",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "indexed": false,
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "Transfer",
    "type": "event"
  },
  {
    "anonymous": false,
    "inputs": [
      {
        "indexed": true,
        "internalType": "address",
        "name": "oldWantedPosters",
        "type": "address"
      },
      {
        "indexed": true,
        "internalType": "address",
        "name": "newWantedPosters",
        "type": "address"
      }
    ],
    "name": "WantedPostersSet",
    "type": "event"
  },
  {
    "inputs": [],
    "name": "BURN_ADDRESS",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "activateHoodler",
    "outputs": [
      {
        "internalType": "bool",
        "name": "activated",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "activateHoodler",
    "outputs": [
      {
        "internalType": "bool",
        "name": "activated",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "activationCursor",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "activeBalanceOf",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "activeHoodlerBalance",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "activeHoodlerCount",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "owner_",
        "type": "address"
      },
      {
        "internalType": "address",
        "name": "spender",
        "type": "address"
      }
    ],
    "name": "allowance",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "spender",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "approve",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "attemptSteal",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "entropyBlock",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "balanceForMaxPower",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "balanceOf",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "balance",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "claimRewards",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "recipient",
        "type": "address"
      }
    ],
    "name": "claimRewardsTo",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "claimSellTaxRefund",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "recipient",
        "type": "address"
      }
    ],
    "name": "claimSellTaxRefundTo",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "recipient",
        "type": "address"
      }
    ],
    "name": "claimTeamTaxTo",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "claimableRewards",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "claimableSellTaxRefund",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "claimableTeamTax",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "currentSellTaxBps",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "decimals",
    "outputs": [
      {
        "internalType": "uint8",
        "name": "",
        "type": "uint8"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "emergencyShutdown",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "recipient",
        "type": "address"
      }
    ],
    "name": "emergencyShutdownAndWithdrawAllNative",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "thief",
        "type": "address"
      }
    ],
    "name": "finalizeSteal",
    "outputs": [
      {
        "internalType": "bool",
        "name": "success",
        "type": "bool"
      },
      {
        "internalType": "uint256",
        "name": "distributed",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "count",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "totalEligibleBalance",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "firstStealDelay",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "fullPowerAge",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "hoodlGame",
    "outputs": [
      {
        "internalType": "contract IHoodlGame",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "hoodlerScore",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "hoodlerSince",
    "outputs": [
      {
        "internalType": "uint64",
        "name": "",
        "type": "uint64"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "isActiveHoodler",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "router",
        "type": "address"
      }
    ],
    "name": "isFifoSafeRouter",
    "outputs": [
      {
        "internalType": "bool",
        "name": "allowed",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "isHoodler",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "isHoodlerExcluded",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "isTaxExempt",
    "outputs": [
      {
        "internalType": "bool",
        "name": "exempt",
        "type": "bool"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "maxMatureHoodlersPerSteal",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "maxStealChanceBps",
    "outputs": [
      {
        "internalType": "uint16",
        "name": "",
        "type": "uint16"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "maxSupply",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "targetGame",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "migrateSheriffPot",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "minHoodlerAge",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "minHoodlerBalance",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "name",
    "outputs": [
      {
        "internalType": "string",
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "nextStealAt",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "owner",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "pendingReward",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "limit",
        "type": "uint256"
      }
    ],
    "name": "processMatureHoodlers",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "processed",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "activated",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "limit",
        "type": "uint256"
      }
    ],
    "name": "processPendingSteals",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "processed",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "finalized",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "rewardDebt",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "rewardPerActiveToken",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "scheduleFirstStealUnlock",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "unlockAt",
        "type": "uint256"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "sellTaxDecayPeriod",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "router",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "allowed",
        "type": "bool"
      }
    ],
    "name": "setFifoSafeRouter",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newDelay",
        "type": "uint256"
      }
    ],
    "name": "setFirstStealDelay",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newGame",
        "type": "address"
      }
    ],
    "name": "setHoodlGame",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "excluded",
        "type": "bool"
      }
    ],
    "name": "setHoodlerExcluded",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newPoolManager",
        "type": "address"
      }
    ],
    "name": "setMarketPoolManager",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "relay",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "allowed",
        "type": "bool"
      }
    ],
    "name": "setMarketRelay",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newLimit",
        "type": "uint256"
      }
    ],
    "name": "setMaxMatureHoodlersPerSteal",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newMinAge",
        "type": "uint256"
      }
    ],
    "name": "setMinHoodlerAge",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newMinBalance",
        "type": "uint256"
      }
    ],
    "name": "setMinHoodlerBalance",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newPeriod",
        "type": "uint256"
      }
    ],
    "name": "setSellTaxDecayPeriod",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newFullPowerAge",
        "type": "uint256"
      },
      {
        "internalType": "uint256",
        "name": "newBalanceForMaxPower",
        "type": "uint256"
      },
      {
        "internalType": "uint16",
        "name": "newMaxBps",
        "type": "uint16"
      }
    ],
    "name": "setStealChanceConfig",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newCooldown",
        "type": "uint256"
      }
    ],
    "name": "setStealCooldown",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "newUnlockAt",
        "type": "uint256"
      }
    ],
    "name": "setStealsUnlockAt",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newHook",
        "type": "address"
      }
    ],
    "name": "setSwapTaxHook",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      },
      {
        "internalType": "bool",
        "name": "exempt",
        "type": "bool"
      }
    ],
    "name": "setTaxExempt",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newTaxManager",
        "type": "address"
      }
    ],
    "name": "setTaxManager",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newTeamWallet",
        "type": "address"
      }
    ],
    "name": "setTeamWallet",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newWantedPosters",
        "type": "address"
      }
    ],
    "name": "setWantedPosters",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "sheriffPot",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "stealAttempts",
    "outputs": [
      {
        "internalType": "uint64",
        "name": "startedBlock",
        "type": "uint64"
      },
      {
        "internalType": "uint64",
        "name": "entropyBlock",
        "type": "uint64"
      },
      {
        "internalType": "uint256",
        "name": "nonce",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "account",
        "type": "address"
      }
    ],
    "name": "stealChanceBps",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "stealCooldown",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "stealNonce",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "stealsUnlockAt",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "swapTaxHook",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "symbol",
    "outputs": [
      {
        "internalType": "string",
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "taxManager",
    "outputs": [
      {
        "internalType": "address",
        "name": "manager",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "teamWallet",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "totalSupply",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "uint256",
        "name": "index",
        "type": "uint256"
      }
    ],
    "name": "trackedHolderAt",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "trackedHolderCount",
    "outputs": [
      {
        "internalType": "uint256",
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "transfer",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "from",
        "type": "address"
      },
      {
        "internalType": "address",
        "name": "to",
        "type": "address"
      },
      {
        "internalType": "uint256",
        "name": "amount",
        "type": "uint256"
      }
    ],
    "name": "transferFrom",
    "outputs": [
      {
        "internalType": "bool",
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [
      {
        "internalType": "address",
        "name": "newOwner",
        "type": "address"
      }
    ],
    "name": "transferOwnership",
    "outputs": [],
    "stateMutability": "nonpayable",
    "type": "function"
  },
  {
    "inputs": [],
    "name": "wantedPosters",
    "outputs": [
      {
        "internalType": "address",
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view",
    "type": "function"
  }
]

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import { IHoodlGame } from "./IHoodlGame.sol";

/// @title HOODL
/// @notice ERC20 with hook-owned swap taxes and delegated Nottingham game state.
contract HOODL {
    // forge-lint: disable-next-line(screaming-snake-case-const)
    string public constant name = "HOODL";
    // forge-lint: disable-next-line(screaming-snake-case-const)
    string public constant symbol = "HOODL";
    // forge-lint: disable-next-line(screaming-snake-case-const)
    uint8 public constant decimals = 18;

    address public constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD;

    uint256 public totalSupply;
    // forge-lint: disable-next-line(screaming-snake-case-immutable)
    uint256 public immutable maxSupply;
    address public owner;
    address public teamWallet;
    address public swapTaxHook;
    address public wantedPosters;
    IHoodlGame public hoodlGame;

    mapping(address account => uint256 balance) public balanceOf;
    mapping(address owner_ => mapping(address spender => uint256 amount)) public allowance;
    mapping(address account => bool exempt) public isTaxExempt;

    error ApprovalToZeroAddress();
    error BalanceTooLow();
    error GameNotSet();
    error InvalidSupply();
    error OnlyOwner();
    error TransferFromZeroAddress();
    error TransferToZeroAddress();
    error ZeroAddress();

    event Approval(address indexed owner, address indexed spender, uint256 amount);
    event GameSet(address indexed oldGame, address indexed newGame);
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);
    event SwapTaxHookSet(address indexed oldHook, address indexed newHook);
    event TeamWalletSet(address indexed oldTeamWallet, address indexed newTeamWallet);
    event Transfer(address indexed from, address indexed to, uint256 amount);
    event WantedPostersSet(address indexed oldWantedPosters, address indexed newWantedPosters);

    modifier onlyOwner() {
        _onlyOwner();
        _;
    }

    function _onlyOwner() internal view {
        if (msg.sender != owner) revert OnlyOwner();
    }

    // `initialOwner` is explicit (not msg.sender) so the token can be deployed via a
    // CREATE2 factory for a vanity address without the factory becoming owner or
    // receiving the minted supply.
    constructor(address initialOwner, address initialTeamWallet, uint256 initialSupply) {
        if (initialOwner == address(0) || initialTeamWallet == address(0)) revert ZeroAddress();
        if (initialSupply == 0) revert InvalidSupply();

        owner = initialOwner;
        teamWallet = initialTeamWallet;
        maxSupply = initialSupply;

        isTaxExempt[initialOwner] = true;
        isTaxExempt[address(this)] = true;
        isTaxExempt[initialTeamWallet] = true;
        isTaxExempt[BURN_ADDRESS] = true;

        _mint(initialOwner, initialSupply);
        emit OwnershipTransferred(address(0), initialOwner);
        emit TeamWalletSet(address(0), initialTeamWallet);
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        if (spender == address(0)) revert ApprovalToZeroAddress();
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        _transfer(msg.sender, msg.sender, to, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        uint256 allowed = allowance[from][msg.sender];
        if (allowed != type(uint256).max) {
            if (allowed < amount) revert BalanceTooLow();
            allowance[from][msg.sender] = allowed - amount;
            emit Approval(from, msg.sender, allowance[from][msg.sender]);
        }

        _transfer(msg.sender, from, to, amount);
        return true;
    }

    function setHoodlGame(address newGame) external onlyOwner {
        if (newGame == address(0)) revert ZeroAddress();

        address oldGame = address(hoodlGame);
        hoodlGame = IHoodlGame(newGame);
        isTaxExempt[newGame] = true;
        _clearTaxExemptIfNotCore(oldGame);

        _syncCoreGameExclusions();
        emit GameSet(oldGame, newGame);
    }

    function setSwapTaxHook(address newHook) external onlyOwner {
        if (newHook == address(0)) revert ZeroAddress();

        address oldHook = swapTaxHook;
        swapTaxHook = newHook;
        isTaxExempt[newHook] = true;
        _clearTaxExemptIfNotCore(oldHook);
        _setGameExcludedIfConfigured(newHook, true);
        _clearGameExcludedIfNotCore(oldHook);

        emit SwapTaxHookSet(oldHook, newHook);
    }

    function setWantedPosters(address newWantedPosters) external onlyOwner {
        address oldWantedPosters = wantedPosters;
        wantedPosters = newWantedPosters;
        _game().setWantedPosters(newWantedPosters);
        emit WantedPostersSet(oldWantedPosters, newWantedPosters);
    }

    function setTaxExempt(address account, bool exempt) external onlyOwner {
        if (account == address(0)) revert ZeroAddress();
        isTaxExempt[account] = exempt;
    }

    function setHoodlerExcluded(address account, bool excluded) external onlyOwner {
        _game().setHoodlerExcluded(account, excluded);
    }

    function setMarketPoolManager(address newPoolManager) external onlyOwner {
        _game().setMarketPoolManager(newPoolManager);
    }

    function setMarketRelay(address relay, bool allowed) external onlyOwner {
        _game().setMarketRelay(relay, allowed);
    }

    function setFifoSafeRouter(address router, bool allowed) external onlyOwner {
        _game().setFifoSafeRouter(router, allowed);
    }

    function setTaxManager(address newTaxManager) external onlyOwner {
        _game().setTaxManager(newTaxManager);
    }

    function setTeamWallet(address newTeamWallet) external onlyOwner {
        if (newTeamWallet == address(0)) revert ZeroAddress();

        address oldTeamWallet = teamWallet;
        teamWallet = newTeamWallet;
        isTaxExempt[newTeamWallet] = true;
        _clearTaxExemptIfNotCore(oldTeamWallet);
        _setGameExcludedIfConfigured(newTeamWallet, true);
        _clearGameExcludedIfNotCore(oldTeamWallet);

        emit TeamWalletSet(oldTeamWallet, newTeamWallet);
    }

    function setSellTaxDecayPeriod(uint256 newPeriod) external onlyOwner {
        _game().setSellTaxDecayPeriod(newPeriod);
    }

    function setMinHoodlerAge(uint256 newMinAge) external onlyOwner {
        _game().setMinHoodlerAge(newMinAge);
    }

    function setMinHoodlerBalance(uint256 newMinBalance) external onlyOwner {
        _game().setMinHoodlerBalance(newMinBalance);
    }

    function setStealCooldown(uint256 newCooldown) external onlyOwner {
        _game().setStealCooldown(newCooldown);
    }

    function setFirstStealDelay(uint256 newDelay) external onlyOwner {
        _game().setFirstStealDelay(newDelay);
    }

    function setStealsUnlockAt(uint256 newUnlockAt) external onlyOwner {
        _game().setStealsUnlockAt(newUnlockAt);
    }

    function scheduleFirstStealUnlock() external onlyOwner returns (uint256 unlockAt) {
        return _game().scheduleFirstStealUnlock();
    }

    function setStealChanceConfig(
        uint256 newFullPowerAge,
        uint256 newBalanceForMaxPower,
        uint16 newMaxBps
    ) external onlyOwner {
        _game().setStealChanceConfig(newFullPowerAge, newBalanceForMaxPower, newMaxBps);
    }

    function setMaxMatureHoodlersPerSteal(uint256 newLimit) external onlyOwner {
        _game().setMaxMatureHoodlersPerSteal(newLimit);
    }

    function migrateSheriffPot(address targetGame, uint256 amount) external onlyOwner {
        _game().migrateSheriffPot(targetGame, amount);
    }

    function emergencyShutdownAndWithdrawAllNative(address recipient)
        external
        onlyOwner
        returns (uint256 amount)
    {
        return _game().emergencyShutdownAndWithdrawAllNative(recipient);
    }

    function transferOwnership(address newOwner) external onlyOwner {
        if (newOwner == address(0)) revert ZeroAddress();
        address oldOwner = owner;
        owner = newOwner;
        isTaxExempt[newOwner] = true;
        _clearTaxExemptIfNotCore(oldOwner);
        _setGameExcludedIfConfigured(newOwner, true);
        _clearGameExcludedIfNotCore(oldOwner);
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    function currentSellTaxBps(address account) public view returns (uint256) {
        IHoodlGame game = hoodlGame;
        if (address(game) == address(0)) {
            return 0;
        }
        return game.currentSellTaxBps(account);
    }

    function isHoodler(address account) public view returns (bool) {
        return address(hoodlGame) != address(0) && hoodlGame.isHoodler(account);
    }

    function hoodlerScore(address account) public view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.hoodlerScore(account);
    }

    function stealChanceBps(address account) public view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.stealChanceBps(account);
    }

    function isHoodlerExcluded(address account) public view returns (bool) {
        return address(hoodlGame) != address(0) && hoodlGame.isHoodlerExcluded(account);
    }

    function taxManager() public view returns (address manager) {
        return address(hoodlGame) == address(0) ? address(0) : hoodlGame.taxManager();
    }

    function isFifoSafeRouter(address router) public view returns (bool allowed) {
        return address(hoodlGame) != address(0) && hoodlGame.isFifoSafeRouter(router);
    }

    function hoodlerSince(address account) public view returns (uint64) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.hoodlerSince(account);
    }

    function nextStealAt(address account) public view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.nextStealAt(account);
    }

    function stealAttempts(address account)
        public
        view
        returns (uint64 startedBlock, uint64 entropyBlock, uint256 nonce)
    {
        if (address(hoodlGame) == address(0)) {
            return (0, 0, 0);
        }
        return hoodlGame.stealAttempts(account);
    }

    function isActiveHoodler(address account) public view returns (bool) {
        return address(hoodlGame) != address(0) && hoodlGame.isActiveHoodler(account);
    }

    function activeBalanceOf(address account) public view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.activeBalanceOf(account);
    }

    function rewardDebt(address account) public view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.rewardDebt(account);
    }

    function claimableRewards(address account) public view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.claimableRewards(account);
    }

    function sellTaxDecayPeriod() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.sellTaxDecayPeriod();
    }

    function minHoodlerAge() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.minHoodlerAge();
    }

    function minHoodlerBalance() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.minHoodlerBalance();
    }

    function stealCooldown() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.stealCooldown();
    }

    function fullPowerAge() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.fullPowerAge();
    }

    function balanceForMaxPower() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.balanceForMaxPower();
    }

    function firstStealDelay() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.firstStealDelay();
    }

    function stealsUnlockAt() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.stealsUnlockAt();
    }

    function maxStealChanceBps() external view returns (uint16) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.maxStealChanceBps();
    }

    function sheriffPot() public view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.sheriffPot();
    }

    function stealNonce() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.stealNonce();
    }

    function maxMatureHoodlersPerSteal() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.maxMatureHoodlersPerSteal();
    }

    function activeHoodlerBalance() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.activeHoodlerBalance();
    }

    function activeHoodlerCount() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.activeHoodlerCount();
    }

    function activationCursor() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.activationCursor();
    }

    function rewardPerActiveToken() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.rewardPerActiveToken();
    }

    function trackedHolderCount() external view returns (uint256) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.trackedHolderCount();
    }

    function trackedHolderAt(uint256 index) external view returns (address) {
        return address(hoodlGame) == address(0) ? address(0) : hoodlGame.trackedHolderAt(index);
    }

    function activateHoodler() external returns (bool activated) {
        return _game().activateHoodlerFor(msg.sender);
    }

    function activateHoodler(address account) external returns (bool activated) {
        return _game().activateHoodlerFor(account);
    }

    function processMatureHoodlers(uint256 limit)
        external
        returns (uint256 processed, uint256 activated)
    {
        return _game().processMatureHoodlers(limit);
    }

    function processPendingSteals(uint256 limit)
        external
        returns (uint256 processed, uint256 finalized)
    {
        return _game().processPendingSteals(limit);
    }

    function pendingReward(address account) public view returns (uint256 amount) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.pendingReward(account);
    }

    function claimRewards() external returns (uint256 amount) {
        return _game().claimRewardsFor(msg.sender);
    }

    function claimRewardsTo(address recipient) external returns (uint256 amount) {
        return _game().claimRewardsForTo(msg.sender, recipient);
    }

    function claimableSellTaxRefund(address account) public view returns (uint256 amount) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.claimableSellTaxRefunds(account);
    }

    function claimSellTaxRefund() external returns (uint256 amount) {
        return _game().claimSellTaxRefundFor(msg.sender);
    }

    function claimSellTaxRefundTo(address recipient) external returns (uint256 amount) {
        return _game().claimSellTaxRefundForTo(msg.sender, recipient);
    }

    function claimableTeamTax(address account) public view returns (uint256 amount) {
        return address(hoodlGame) == address(0) ? 0 : hoodlGame.claimableTeamTax(account);
    }

    function emergencyShutdown() public view returns (bool) {
        return address(hoodlGame) != address(0) && hoodlGame.emergencyShutdown();
    }

    function claimTeamTaxTo(address recipient) external returns (uint256 amount) {
        return _game().claimTeamTaxForTo(msg.sender, recipient);
    }

    function attemptSteal() external returns (uint256 entropyBlock) {
        return _game().attemptStealFor(msg.sender);
    }

    function finalizeSteal(address thief)
        external
        returns (bool success, uint256 distributed, uint256 count, uint256 totalEligibleBalance)
    {
        return _game().finalizeStealFor(thief);
    }

    function _transfer(address operator, address from, address to, uint256 amount) internal {
        if (from == address(0)) revert TransferFromZeroAddress();
        if (to == address(0)) revert TransferToZeroAddress();

        _move(from, to, amount);
        _notifyTransfer(operator, from, to, amount);
    }

    function _move(address from, address to, uint256 amount) internal {
        if (balanceOf[from] < amount) revert BalanceTooLow();

        if (amount > 0) {
            unchecked {
                balanceOf[from] -= amount;
                balanceOf[to] += amount;
            }
        }

        emit Transfer(from, to, amount);
    }

    function _mint(address to, uint256 amount) internal {
        if (to == address(0)) revert TransferToZeroAddress();
        totalSupply += amount;
        balanceOf[to] += amount;
        emit Transfer(address(0), to, amount);
        _notifyTransfer(address(0), address(0), to, amount);
    }

    function _notifyTransfer(address operator, address from, address to, uint256 amount) internal {
        IHoodlGame game = hoodlGame;
        if (address(game) != address(0)) {
            game.onTokenTransfer(operator, from, to, amount);
        }
    }

    function _syncCoreGameExclusions() internal {
        IHoodlGame game = _game();
        game.setHoodlerExcluded(address(this), true);
        game.setHoodlerExcluded(owner, true);
        game.setHoodlerExcluded(teamWallet, true);
        game.setHoodlerExcluded(BURN_ADDRESS, true);
        if (swapTaxHook != address(0)) {
            game.setHoodlerExcluded(swapTaxHook, true);
        }
    }

    function _setGameExcludedIfConfigured(address account, bool excluded) internal {
        IHoodlGame game = hoodlGame;
        if (address(game) != address(0)) {
            game.setHoodlerExcluded(account, excluded);
        }
    }

    function _clearTaxExemptIfNotCore(address account) internal {
        if (account == address(0) || _isCoreTaxExempt(account)) {
            return;
        }
        isTaxExempt[account] = false;
    }

    function _clearGameExcludedIfNotCore(address account) internal {
        if (account == address(0) || _isCoreGameExcluded(account)) {
            return;
        }
        _setGameExcludedIfConfigured(account, false);
    }

    function _isCoreTaxExempt(address account) internal view returns (bool) {
        return account == owner || account == address(this) || account == teamWallet
            || account == swapTaxHook || account == address(hoodlGame) || account == BURN_ADDRESS;
    }

    function _isCoreGameExcluded(address account) internal view returns (bool) {
        return account == owner || account == address(this) || account == teamWallet
            || account == swapTaxHook || account == BURN_ADDRESS;
    }

    function _game() internal view returns (IHoodlGame game) {
        game = hoodlGame;
        if (address(game) == address(0)) revert GameNotSet();
    }
}