Governance

1. Create Proposal (100K PRIV required)
         |
         v
2. Voting Delay (1 day)
         |
         v
3. Voting Period (7 days) - For/Against/Abstain
         |
         v
4. Queue in Timelock (if passed + quorum)
         |
         v
5. Timelock Delay (2 days)
         |
         v
6. Execute Proposal

function propose(
    address[] memory targets,
    uint256[] memory values,
    bytes[] memory calldatas,
    string memory description
) public override returns (uint256)

function castVote(uint256 proposalId, uint8 support) external returns (uint256)
function castVoteWithReason(uint256 proposalId, uint8 support, string calldata reason) external returns (uint256)

function queue(
    address[] memory targets,
    uint256[] memory values,
    bytes[] memory calldatas,
    bytes32 descriptionHash
) public returns (uint256)

function execute(
    address[] memory targets,
    uint256[] memory values,
    bytes[] memory calldatas,
    bytes32 descriptionHash
) public payable returns (uint256)

function cancel(
    address[] memory targets,
    uint256[] memory values,
    bytes[] memory calldatas,
    bytes32 descriptionHash
) public returns (uint256)

function cleanupProposal(uint256 proposalId) external

function canPropose(address account) external view returns (bool)

function proposalCooldownRemaining(address account) external view returns (uint256)

function proposalProposer(uint256 proposalId) public view returns (address)

function state(uint256 proposalId) public view returns (ProposalState)

function proposalThreshold() public view returns (uint256)

function quorum(uint256 blockNumber) public view returns (uint256)

function schedule(
    address target,
    uint256 value,
    bytes calldata data,
    bytes32 predecessor,
    bytes32 salt,
    uint256 delay
) public onlyRole(PROPOSER_ROLE)

function execute(
    address target,
    uint256 value,
    bytes calldata data,
    bytes32 predecessor,
    bytes32 salt
) public payable onlyRoleOrOpenRole(EXECUTOR_ROLE)

function cancel(bytes32 id) public onlyRole(CANCELLER_ROLE)

function getMinDelay() public view returns (uint256)

/// @notice Emitted when a proposal is created
event ProposalCreated(
    uint256 proposalId,
    address proposer,
    address[] targets,
    uint256[] values,
    string[] signatures,
    bytes[] calldatas,
    uint256 voteStart,
    uint256 voteEnd,
    string description
);

/// @notice Emitted when a vote is cast
event VoteCast(
    address indexed voter,
    uint256 proposalId,
    uint8 support,
    uint256 weight,
    string reason
);

/// @notice Emitted when a proposal is executed
event ProposalExecuted(uint256 proposalId);

/// @notice Emitted when a proposal is canceled
event ProposalCanceled(uint256 proposalId);

/// @notice Emitted when an operation is scheduled
event CallScheduled(
    bytes32 indexed id,
    uint256 indexed index,
    address target,
    uint256 value,
    bytes data,
    bytes32 predecessor,
    uint256 delay
);

/// @notice Emitted when an operation is executed
event CallExecuted(
    bytes32 indexed id,
    uint256 indexed index,
    address target,
    uint256 value,
    bytes data
);

/// @notice Emitted when an operation is cancelled
event Cancelled(bytes32 indexed id);

/// @notice Thrown when proposer is still in cooldown period
error ProposalCooldownActive(uint256 remainingTime);

/// @notice Thrown when proposer has too many active proposals
error TooManyActiveProposals(uint256 current, uint256 max);

/// @notice Thrown when trying to cleanup a non-finalized proposal
error ProposalNotFinalized(uint256 proposalId);

/// @notice Thrown when proposal has already been cleaned up
error ProposalAlreadyCleaned(uint256 proposalId);

import { useWriteContract } from 'wagmi'

// Delegate to yourself
async function delegateToSelf() {
  await writeContract({
    address: PRIV_TOKEN_ADDRESS,
    abi: privTokenAbi,
    functionName: 'delegate',
    args: [myAddress],
  })
}

// Delegate to someone else
async function delegateTo(delegatee: string) {
  await writeContract({
    address: PRIV_TOKEN_ADDRESS,
    abi: privTokenAbi,
    functionName: 'delegate',
    args: [delegatee],
  })
}

import { encodeFunctionData, keccak256, toBytes } from 'viem'

async function createProposal() {
  // Example: Proposal to update protocol fee to 3%
  const calldata = encodeFunctionData({
    abi: dataXchangeAbi,
    functionName: 'setProtocolFee',
    args: [300n], // 3% = 300 basis points
  })

  const description = `# Update Protocol Fee to 3%

## Summary
Increase the DataXchange protocol fee from 2.5% to 3% to fund development.

## Rationale
- Increased development costs
- Need for additional security audits
- Community fund expansion
`

  await writeContract({
    address: GOVERNOR_ADDRESS,
    abi: governorAbi,
    functionName: 'propose',
    args: [
      [DATAXCHANGE_ADDRESS],  // targets
      [0n],                    // values (no ETH)
      [calldata],              // calldatas
      description,             // description
    ],
  })
}

async function voteFor(proposalId: bigint) {
  await writeContract({
    address: GOVERNOR_ADDRESS,
    abi: governorAbi,
    functionName: 'castVoteWithReason',
    args: [proposalId, 1, 'I support this proposal because...'],
  })
}

async function voteAgainst(proposalId: bigint) {
  await writeContract({
    address: GOVERNOR_ADDRESS,
    abi: governorAbi,
    functionName: 'castVoteWithReason',
    args: [proposalId, 0, 'I oppose this proposal because...'],
  })
}

import { keccak256, toBytes } from 'viem'

async function queueProposal(
  targets: string[],
  values: bigint[],
  calldatas: `0x${string}`[],
  description: string
) {
  const descriptionHash = keccak256(toBytes(description))

  await writeContract({
    address: GOVERNOR_ADDRESS,
    abi: governorAbi,
    functionName: 'queue',
    args: [targets, values, calldatas, descriptionHash],
  })
}

async function executeProposal(
  targets: string[],
  values: bigint[],
  calldatas: `0x${string}`[],
  description: string
) {
  const descriptionHash = keccak256(toBytes(description))

  await writeContract({
    address: GOVERNOR_ADDRESS,
    abi: governorAbi,
    functionName: 'execute',
    args: [targets, values, calldatas, descriptionHash],
  })
}

function useProposalState(proposalId: bigint) {
  return useReadContract({
    address: GOVERNOR_ADDRESS,
    abi: governorAbi,
    functionName: 'state',
    args: [proposalId],
  })
}

// State values:
// 0 = Pending
// 1 = Active
// 2 = Canceled
// 3 = Defeated
// 4 = Succeeded
// 5 = Queued
// 6 = Expired
// 7 = Executed

timelock.grantRole(timelock.PROPOSER_ROLE(), address(governor));

timelock.grantRole(timelock.CANCELLER_ROLE(), address(governor));

timelock.grantRole(timelock.EXECUTOR_ROLE(), address(0));

timelock.renounceRole(timelock.DEFAULT_ADMIN_ROLE(), deployer);

// For each protocol contract:
dataXchange.transferOwnership(address(timelock));
adNetwork.transferOwnership(address(timelock));
// etc.