feat: flesh out proposal helpers

integration-tests/test/config/addresses.ts

@@ -1,46 +1,51 @@
-import { join } from "path";
-import { readFileSync } from "fs";
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import type { Address } from 'viem';
 
 // Chain IDs for the different networks
 const CHAIN_IDS = {
-  HUB: 1337,    // EthDevnet1 (Hub)
-  SPOKE: 1397,  // EthDevnet2 (Spoke)
+  HUB: 1337, // EthDevnet1 (Hub)
+  SPOKE: 1397, // EthDevnet2 (Spoke)
 } as const;
 
-function getDeploymentAddresses(deploymentFile: string, chainId: number = CHAIN_IDS.HUB) {
+function getDeploymentAddresses(
+  deploymentFile: string,
+  chainId: number = CHAIN_IDS.HUB,
+) {
   const projectRoot = join(__dirname, '..', '..', '..', '..');
-  
+
   const artifactPath = join(
     projectRoot,
     'example-cross-chain-governance',
     'evm',
     'broadcast',
     deploymentFile,
     chainId.toString(),
-    "run-latest.json"
+    'run-latest.json',
   );
-  
+
   try {
     console.log('Attempting to read deployment from:', artifactPath);
-    const deployment = JSON.parse(
-      readFileSync(artifactPath, "utf-8")
-    );
+    const deployment = JSON.parse(readFileSync(artifactPath, 'utf-8'));
 
     const addresses: Record<string, Address> = {};
-
-    deployment.transactions
-      .filter((tx: any) => tx.contractAddress)
-      .forEach((tx: any) => {
+
+    for (const tx of deployment.transactions) {
+      if (tx.contractAddress) {
         addresses[tx.contractName] = tx.contractAddress as Address;
-      });
+      }
+    }
 
     return addresses;
   } catch (error) {
     if ((error as any).code === 'ENOENT') {
       console.error(`Deployment file not found: ${artifactPath}`);
-      console.error('Make sure you have run the deployments for both hub and spoke chains');
-      console.error(`Expected chainIds: Hub=${CHAIN_IDS.HUB}, Spoke=${CHAIN_IDS.SPOKE}`);
+      console.error(
+        'Make sure you have run the deployments for both hub and spoke chains',
+      );
+      console.error(
+        `Expected chainIds: Hub=${CHAIN_IDS.HUB}, Spoke=${CHAIN_IDS.SPOKE}`,
+      );
       console.error(`Current directory: ${__dirname}`);
       console.error(`Project root: ${projectRoot}`);
     }
@@ -49,9 +54,15 @@ function getDeploymentAddresses(deploymentFile: string, chainId: number = CHAIN_
 }
 
 // Get Hub contract addresses from EthDevnet1 deployment
-const hubAddresses = getDeploymentAddresses("DeployHubContractsEthDevnet1.sol", CHAIN_IDS.HUB);
+const hubAddresses = getDeploymentAddresses(
+  'DeployHubContractsEthDevnet1.sol',
+  CHAIN_IDS.HUB,
+);
 // Get Spoke contract addresses from EthDevnet2 deployment
-const spokeAddresses = getDeploymentAddresses("DeploySpokeContractsEthDevnet2.sol", CHAIN_IDS.SPOKE);
+const spokeAddresses = getDeploymentAddresses(
+  'DeploySpokeContractsEthDevnet2.sol',
+  CHAIN_IDS.SPOKE,
+);
 
 const ContractAddressesEnum = {
   // Hub contracts (deployed on EthDevnet1)
@@ -65,7 +76,7 @@ const ContractAddressesEnum = {
   HUB_PROPOSAL_EXTENDER: hubAddresses.HubProposalExtender,
   HUB_SOLANA_MESSAGE_DISPATCHER: hubAddresses.HubSolanaMessageDispatcher,
   HUB_SOLANA_SPOKE_VOTE_DECODER: hubAddresses.HubSolanaSpokeVoteDecoder,
-  
+
   // Spoke contracts (deployed on EthDevnet2)
   SPOKE_VOTE_AGGREGATOR: spokeAddresses.SpokeVoteAggregator,
   SPOKE_MESSAGE_EXECUTOR: spokeAddresses.SpokeMessageExecutor,
@@ -80,10 +91,10 @@ export type Addresses = {
 };
 
 // Validate all addresses are defined
-Object.entries(ContractAddressesEnum).forEach(([key, value]) => {
+for (const [key, value] of Object.entries(ContractAddressesEnum)) {
   if (!value) {
     throw new Error(`Missing address for ${key}`);
   }
-});
+}
 
 export { ContractAddressesEnum as ContractAddresses };

integration-tests/test/config/clients.ts

@@ -29,13 +29,13 @@ export const createClients = () => {
     account,
     chain: ethDevnet,
     transport: http(ETH_DEVNET_NODE_URL),
-  });
+  }).extend(publicActions);
 
   const eth2Wallet = createWalletClient({
     account,
     chain: eth2Devnet,
     transport: http(ETH2_DEVNET_NODE_URL),
-  });
+  }).extend(publicActions);
 
   return { ethClient, eth2Client, ethWallet, eth2Wallet, account };
 };

integration-tests/test/config/types.ts

@@ -1,4 +1,13 @@
+import type { createClients } from './clients';
+
 export enum VoteType {
   FOR = 1,
   AGAINST = 0,
 }
+
+export type Client =
+  | ReturnType<typeof createClients>['ethClient']
+  | ReturnType<typeof createClients>['eth2Client'];
+export type Wallet =
+  | ReturnType<typeof createClients>['ethWallet']
+  | ReturnType<typeof createClients>['eth2Wallet'];

integration-tests/test/createProposalFromHub/helpers.ts

@@ -1,10 +1,12 @@
-import { createArbitraryProposalData, createProposal } from 'test/helpers';
+import {
+  createArbitraryProposalData,
+  createProposalViaAggregateProposer,
+} from 'test/helpers';
 
 export const createProposalFromHub = async () => {
   const proposalData = await createArbitraryProposalData();
-  const proposalId = await createProposal({
+  const proposalId = await createProposalViaAggregateProposer({
     proposalData,
   });
   return proposalId;
-  // TODO: Add the rest of the logic to create a proposal from hub
 };

integration-tests/test/createProposalFromHub/index.ts

@@ -1,10 +1,17 @@
 import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { ContractAddresses } from 'test/config/addresses';
+import { getWhitelistedProposer } from 'test/helpers/governance/registrationHelpers';
 import { setupTestEnvironment, teardownTestEnvironment } from '../setup';
 import { createProposalFromHub } from './helpers';
 
 describe('Create proposal from hub', () => {
   beforeAll(async () => {
     await setupTestEnvironment();
+    // check to make sure hubevmspokeaggregate proposer is whitelisted
+    const isWhitelisted = await getWhitelistedProposer();
+    expect(isWhitelisted).toBe(
+      ContractAddresses.HUB_EVM_SPOKE_AGGREGATE_PROPOSER,
+    );
   });
 
   afterAll(async () => {

integration-tests/test/helpers/governance/proposalHelpers.ts

@@ -1,5 +1,5 @@
+import { VoteType, type Wallet } from 'test/config/types';
 import {
-  type Address,
   type WalletClient,
   encodeFunctionData,
   keccak256,
@@ -8,20 +8,25 @@ import {
 import { HubEvmSpokeAggregateProposerAbi, HubGovernorAbi } from '../../../abis';
 import { ContractAddresses } from '../../config/addresses';
 import { createClients } from '../../config/clients';
-import { getWormholeGetVotesQueryResponse } from '../wormhole/wormholeHelpers';
-import { getVotingPower } from './votingHelpers';
+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,
-}: {
-  targets: Address[];
-  values: bigint[];
-  calldatas: `0x${string}`[];
-  description: string;
-}) {
+}: ProposalData) {
   return {
     targets,
     values,
@@ -30,41 +35,59 @@ export function createProposalData({
   };
 }
 
-export const createProposal = async ({
+export const createProposalViaAggregateProposer = async ({
   proposalData,
 }: {
-  proposalData: ReturnType<typeof createProposalData>;
+  proposalData: ProposalData;
 }) => {
   const { ethClient, eth2Client, ethWallet, account } = createClients();
 
-  // Use a past timestamp to account for limitations in the query server
-  // Use 5 minutes ago
-  const timestampHub = (await ethClient.getBlock()).timestamp - 300n;
-  const timestampSpoke = (await eth2Client.getBlock()).timestamp - 300n;
+  // 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;
 
-  // Debug: Check voting power
+  // 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: timestampHub,
+    timestamp,
   });
   const spokeVotingPower = await getVotingPower({
     account: account.address,
     isHub: false,
-    timestamp: timestampSpoke,
+    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,
+      timestampSpoke: timestamp,
     });
 
-  // Debug: Log query response
   console.log('Query response bytes:', queryResponseBytes);
   console.log('Query response signatures:', queryResponseSignatures);
+  console.log('🦄 ~ account:', account.address);
 
   try {
     const { result: proposalId } = await ethClient.simulateContract({
@@ -111,11 +134,24 @@ export const executeProposal = async ({
   proposalId,
   proposalData,
 }: {
-  wallet: WalletClient;
+  wallet: Wallet;
   proposalId: bigint;
-  proposalData: ReturnType<typeof createProposalData>;
+  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,
@@ -129,8 +165,9 @@ export const executeProposal = async ({
     account: handleNoAccount(wallet),
     chain: wallet.chain,
   });
+
   console.log(`Executed proposal ${proposalId}. Transaction hash: ${hash}`);
-  return hash;
+  return proposalId;
 };
 
 export const createArbitraryProposalData = async () => {
@@ -165,3 +202,69 @@ const handleNoAccount = (wallet: WalletClient) => {
   }
   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 });
+};

integration-tests/test/helpers/governance/registrationHelpers.ts

@@ -1,23 +1,15 @@
-import {
-  type Account,
-  type Address,
-  encodeFunctionData,
-  zeroAddress,
-} from 'viem';
+import { type Address, encodeFunctionData, zeroAddress } from 'viem';
 import {
   HubEvmSpokeAggregateProposerAbi,
   HubGovernorAbi,
   HubVotePoolAbi,
 } from '../../../abis';
 import { ContractAddresses } from '../../config/addresses';
 import { createClients } from '../../config/clients';
-import { VoteType } from '../../config/types';
 import {
-  createProposal,
+  createAndExecuteProposal,
   createProposalData,
-  executeProposal,
 } from './proposalHelpers';
-import { voteOnProposal } from './votingHelpers';
 
 export const getWhitelistedProposer = async () => {
   const { ethClient } = createClients();
@@ -135,7 +127,6 @@ export const registerSpokeOnHubVotePool = async ({
   chainId: number;
   spokeAddress: Address;
 }) => {
-  const { ethClient, ethWallet } = createClients();
   const registerSpokeCalldata = encodeFunctionData({
     abi: HubVotePoolAbi,
     functionName: 'registerSpoke',
@@ -149,89 +140,35 @@ export const registerSpokeOnHubVotePool = async ({
     description: `Register spoke for chain ${chainId} at address ${spokeAddress}`,
   });
 
-  const proposalId = await createProposal({
-    proposalData,
-  });
+  const proposalId = await createAndExecuteProposal(proposalData);
 
   console.log(
-    `Created proposal to register spoke for chain ${chainId} at address ${spokeAddress}. Proposal ID: ${proposalId}`,
+    `Registered spoke for chain ${chainId} at address ${spokeAddress}. Proposal ID: ${proposalId}`,
   );
-
-  // Fast forward to the vote start
-  const voteStart = await getVoteStart({ proposalId });
-  await ethClient.setNextBlockTimestamp({ timestamp: voteStart });
-
-  // Vote on the proposal to make it pass
-  await voteOnProposal({
-    isHub: true,
-    proposalId,
-    voteType: VoteType.FOR,
-  });
-
-  // Fast forward to the end of voting period
-  const voteEnd = await getVoteEnd({ proposalId });
-  await ethClient.setNextBlockTimestamp({ timestamp: voteEnd + 1n });
-  await ethClient.mine({ blocks: 1 });
-
-  // Execute the proposal
-  const hash = await executeProposal({
-    wallet: ethWallet,
-    proposalId,
-    proposalData,
-  });
-
-  return hash;
+  return proposalId;
 };
 
-export const registerWhitelistedProposer = async ({
+export async function registerWhitelistedProposer({
   proposerAddress,
 }: {
   proposerAddress: Address;
-  account: Account;
-}) => {
-  const { ethClient, ethWallet } = createClients();
-
-  // Impersonate the HubGovernor
-  await ethClient.impersonateAccount({
-    address: ContractAddresses.HUB_GOVERNOR,
-  });
-
-  const hash = await ethWallet.writeContract({
-    address: ContractAddresses.HUB_GOVERNOR,
-    abi: HubGovernorAbi,
-    functionName: 'setWhitelistedProposer',
-    args: [proposerAddress],
-    account: ContractAddresses.HUB_GOVERNOR,
-    chain: ethWallet.chain,
+}) {
+  const proposalData = createProposalData({
+    targets: [ContractAddresses.HUB_GOVERNOR],
+    values: [0n],
+    calldatas: [
+      encodeFunctionData({
+        abi: HubGovernorAbi,
+        functionName: 'setWhitelistedProposer',
+        args: [proposerAddress],
+      }),
+    ],
+    description: `Set whitelisted proposer to ${proposerAddress}`,
   });
 
-  await ethClient.stopImpersonatingAccount({
-    address: ContractAddresses.HUB_GOVERNOR,
-  });
+  const proposalId = await createAndExecuteProposal(proposalData);
 
   console.log(
-    `Registered whitelisted proposer at address ${proposerAddress}. Transaction hash: ${hash}`,
+    `Set whitelisted proposer to ${proposerAddress}. Proposal ID: ${proposalId}`,
   );
-  return hash;
-};
-
-const getVoteStart = async ({ proposalId }: { proposalId: bigint }) => {
-  const { ethClient } = createClients();
-
-  return await ethClient.readContract({
-    address: ContractAddresses.HUB_GOVERNOR,
-    abi: HubGovernorAbi,
-    functionName: 'proposalSnapshot',
-    args: [proposalId],
-  });
-};
-
-const getVoteEnd = async ({ proposalId }: { proposalId: bigint }) => {
-  const { ethClient } = createClients();
-  return await ethClient.readContract({
-    address: ContractAddresses.HUB_GOVERNOR,
-    abi: HubGovernorAbi,
-    functionName: 'proposalDeadline',
-    args: [proposalId],
-  });
-};
+}

integration-tests/test/helpers/governance/types.ts

@@ -0,0 +1,8 @@
+import type { Address } from 'viem';
+
+export type ProposalData = {
+  targets: Address[];
+  values: bigint[];
+  calldatas: `0x${string}`[];
+  description: string;
+};

integration-tests/test/helpers/governance/votingHelpers.ts

@@ -139,3 +139,24 @@ export const getProposalVotes = async ({
     abstainVotes: votes[3],
   };
 };
+
+export const getVoteStart = async ({ proposalId }: { proposalId: bigint }) => {
+  const { ethClient } = createClients();
+
+  return await ethClient.readContract({
+    address: ContractAddresses.HUB_GOVERNOR,
+    abi: HubGovernorAbi,
+    functionName: 'proposalSnapshot',
+    args: [proposalId],
+  });
+};
+
+export const getVoteEnd = async ({ proposalId }: { proposalId: bigint }) => {
+  const { ethClient } = createClients();
+  return await ethClient.readContract({
+    address: ContractAddresses.HUB_GOVERNOR,
+    abi: HubGovernorAbi,
+    functionName: 'proposalDeadline',
+    args: [proposalId],
+  });
+};

integration-tests/test/helpers/index.ts

@@ -1,24 +1,3 @@
-import type { Address } from 'viem';
-
-export function createProposalData({
-  targets,
-  values,
-  calldatas,
-  description,
-}: {
-  targets: Address[];
-  values: bigint[];
-  calldatas: `0x${string}`[];
-  description: string;
-}) {
-  return {
-    targets,
-    values,
-    calldatas,
-    description,
-  };
-}
-
 // Export all helpers from their respective files
 export * from './governance/proposalHelpers';
 export * from './governance/votingHelpers';

integration-tests/test/helpers/time/timeHelpers.ts

@@ -1,3 +1,4 @@
+import type { Client } from 'test/config/types';
 import { createClients } from '../../config/clients';
 
 export const syncTime = async () => {
@@ -13,3 +14,12 @@ export const syncTime = async () => {
   await ethClient.mine({ blocks: 1 });
   await eth2Client.mine({ blocks: 1 });
 };
+
+export const mineToTimestamp = async ({
+  client,
+  timestamp,
+}: { client: Client; timestamp: bigint }) => {
+  await client.setNextBlockTimestamp({ timestamp });
+  await client.mine({ blocks: 1 });
+  await syncTime();
+};

integration-tests/test/setup.ts

@@ -1,6 +1,7 @@
 import { ContractAddresses } from './config/addresses';
 import { ETH2_DEVNET_WORMHOLE_CHAIN_ID } from './config/chains';
 import { createClients } from './config/clients';
+import { syncTime } from './helpers';
 import {
   handleRegisterSpokeOnAggProposer,
   handleRegisterSpokeOnHubVotePool,
@@ -48,9 +49,9 @@ export async function setupTestEnvironment() {
   // 5. Register whitelisted proposer (HubEvmSpokeAggregateProposer)
   await registerWhitelistedProposer({
     proposerAddress: ContractAddresses.HUB_EVM_SPOKE_AGGREGATE_PROPOSER,
-    account,
   });
 
+  await syncTime();
   console.log('Test environment setup completed');
 }