proposalHelpers.ts

import { VoteType, type Wallet } from 'test/config/types';
import {
  type WalletClient,
  encodeFunctionData,
  keccak256,
  toBytes,
} from 'viem';
import { HubEvmSpokeAggregateProposerAbi, HubGovernorAbi } from '../../../abis';
import { ContractAddresses } from '../../config/addresses';
import { createClients } from '../../config/clients';
import { mineToTimestamp } from '../time/timeHelpers';
import {
  getMaxQueryTimestampOffset,
  getWormholeGetVotesQueryResponse,
} from '../wormhole/wormholeHelpers';
import type { ProposalData } from './types';
import {
  getVoteEnd,
  getVoteStart,
  getVotingPower,
  voteOnProposal,
} from './votingHelpers';

export function createProposalData({
  targets,
  values,
  calldatas,
  description,
}: ProposalData) {
  return {
    targets,
    values,
    calldatas,
    description,
  };
}

export const createProposalViaAggregateProposer = async ({
  proposalData,
}: {
  proposalData: ProposalData;
}) => {
  const { ethClient, eth2Client, ethWallet, account } = createClients();

  // Get current block timestamps
  const hubBlock = await ethClient.getBlock();
  const spokeBlock = await eth2Client.getBlock();
  const maxQueryTimestampOffset = await getMaxQueryTimestampOffset();

  // Use timestamp from 5 minutes ago for query server compatibility
  const FIVE_MINUTES = 300n;
  const timestamp = hubBlock.timestamp - FIVE_MINUTES;

  // Verify we're still within maxQueryTimestampOffset
  if (hubBlock.timestamp - timestamp > BigInt(maxQueryTimestampOffset)) {
    throw new Error('Timestamp too old for maxQueryTimestampOffset');
  }

  console.log('Timestamps after sync:', {
    hubBlock: Number(hubBlock.timestamp),
    spokeBlock: Number(spokeBlock.timestamp),
    queryTimestamp: Number(timestamp),
    maxOffset: maxQueryTimestampOffset,
    offsetFromCurrent: Number(hubBlock.timestamp - timestamp),
  });

  // Debug: Check voting power using block timestamp
  const hubVotingPower = await getVotingPower({
    account: account.address,
    isHub: true,
    timestamp,
  });
  const spokeVotingPower = await getVotingPower({
    account: account.address,
    isHub: false,
    timestamp,
  });
  console.log(`Hub voting power: ${hubVotingPower}`);
  console.log(`Spoke voting power: ${spokeVotingPower}`);

  // Pass block timestamp - the Wormhole query will handle microsecond conversion
  const { queryResponseBytes, queryResponseSignatures } =
    await getWormholeGetVotesQueryResponse({
      account: account.address,
      timestampSpoke: timestamp,
    });

  console.log('Query response bytes:', queryResponseBytes);
  console.log('Query response signatures:', queryResponseSignatures);
  console.log('🦄 ~ account:', account.address);

  try {
    const { result: proposalId } = await ethClient.simulateContract({
      address: ContractAddresses.HUB_EVM_SPOKE_AGGREGATE_PROPOSER,
      abi: HubEvmSpokeAggregateProposerAbi,
      functionName: 'checkAndProposeIfEligible',
      args: [
        proposalData.targets,
        proposalData.values,
        proposalData.calldatas,
        proposalData.description,
        queryResponseBytes,
        queryResponseSignatures,
      ],
      account,
    });

    const hash = await ethWallet.writeContract({
      address: ContractAddresses.HUB_EVM_SPOKE_AGGREGATE_PROPOSER,
      abi: HubEvmSpokeAggregateProposerAbi,
      functionName: 'checkAndProposeIfEligible',
      args: [
        proposalData.targets,
        proposalData.values,
        proposalData.calldatas,
        proposalData.description,
        queryResponseBytes,
        queryResponseSignatures,
      ],
      account,
      chain: ethWallet.chain,
    });

    console.log(`Created proposal. Transaction hash: ${hash}`);
    return proposalId;
  } catch (error) {
    console.error('Error creating proposal:', error);
    throw error;
  }
};

export const executeProposal = async ({
  wallet,
  proposalId,
  proposalData,
}: {
  wallet: Wallet;
  proposalId: bigint;
  proposalData: ProposalData;
}) => {
  const descriptionHash = keccak256(toBytes(proposalData.description));

  await wallet.simulateContract({
    address: ContractAddresses.HUB_GOVERNOR,
    abi: HubGovernorAbi,
    functionName: 'execute',
    args: [
      proposalData.targets,
      proposalData.values,
      proposalData.calldatas,
      descriptionHash,
    ],
  });

  const hash = await wallet.writeContract({
    address: ContractAddresses.HUB_GOVERNOR,
    abi: HubGovernorAbi,
    functionName: 'execute',
    args: [
      proposalData.targets,
      proposalData.values,
      proposalData.calldatas,
      descriptionHash,
    ],
    account: handleNoAccount(wallet),
    chain: wallet.chain,
  });

  console.log(`Executed proposal ${proposalId}. Transaction hash: ${hash}`);
  return proposalId;
};

export const createArbitraryProposalData = async () => {
  const { ethClient } = createClients();

  const timestamp = (await ethClient.getBlock()).timestamp;
  const quorum = await ethClient.readContract({
    address: ContractAddresses.HUB_GOVERNOR,
    abi: HubGovernorAbi,
    functionName: 'quorum',
    args: [timestamp],
  });
  const newQuorum = quorum - 1n;

  return {
    targets: [ContractAddresses.HUB_GOVERNOR],
    values: [0n],
    calldatas: [
      encodeFunctionData({
        abi: HubGovernorAbi,
        functionName: 'setQuorum',
        args: [newQuorum],
      }),
    ],
    description: `Arbitrary proposal to set quorum to ${newQuorum}`,
  };
};

const handleNoAccount = (wallet: WalletClient) => {
  if (!wallet.account) {
    throw new Error('Wallet account is undefined');
  }
  return wallet.account;
};

// Creates and executes a proposal via the HubGovernor directly
export async function createAndExecuteProposal(proposalData: ProposalData) {
  const { ethWallet } = createClients();

  const proposalId = await createProposalViaHubGovernor({
    targets: proposalData.targets,
    values: proposalData.values,
    calldatas: proposalData.calldatas,
    description: proposalData.description,
  });

  await passProposal({
    proposalId,
  });

  await executeProposal({
    wallet: ethWallet,
    proposalId,
    proposalData,
  });

  return proposalId;
}

export const createProposalViaHubGovernor = async ({
  targets,
  values,
  calldatas,
  description,
}: ProposalData) => {
  const { ethClient, ethWallet } = createClients();

  const { result: proposalId } = await ethClient.simulateContract({
    address: ContractAddresses.HUB_GOVERNOR,
    abi: HubGovernorAbi,
    functionName: 'propose',
    args: [targets, values, calldatas, description],
  });

  const hash = await ethWallet.writeContract({
    address: ContractAddresses.HUB_GOVERNOR,
    abi: HubGovernorAbi,
    functionName: 'propose',
    args: [targets, values, calldatas, description],
    account: handleNoAccount(ethWallet),
    chain: ethWallet.chain,
  });

  console.log(`Created proposal ${proposalId}. Transaction hash: ${hash}`);

  return proposalId;
};

// Go through the proposal state flow to make it pass
export const passProposal = async ({ proposalId }: { proposalId: bigint }) => {
  const { ethClient } = createClients();

  const voteStart = await getVoteStart({ proposalId });

  await mineToTimestamp({ client: ethClient, timestamp: voteStart });
  await voteOnProposal({ proposalId, isHub: true, voteType: VoteType.FOR });

  const voteEnd = await getVoteEnd({ proposalId });
  await mineToTimestamp({ client: ethClient, timestamp: voteEnd + 1n });
};