11: Let governance control hub proposal metadata

Author: djb15

solana/app/deploy/12_create_airlock.ts solana/app/deploy/2_create_airlock.ts

@@ -1,6 +1,6 @@
 import * as anchor from "@coral-xyz/anchor";
 import { AnchorProvider, Program, Wallet } from "@coral-xyz/anchor";
-import { Connection } from "@solana/web3.js";
+import { Connection, PublicKey, SystemProgram } from "@solana/web3.js";
 import { hubProposalMetadataUint8Array } from "../constants";
 import { DEPLOYER_AUTHORITY_KEYPAIR, RPC_NODE } from "./devnet";
 import { Staking } from "../../target/types/staking";
@@ -22,9 +22,14 @@ async function main() {
       provider,
     );
 
+    const airlockPDA: PublicKey = PublicKey.findProgramAddressSync(
+      [Buffer.from("airlock")],
+      program.programId,
+    )[0];
+
     await program.methods
       .updateHubProposalMetadata(Array.from(hubProposalMetadataUint8Array))
-      .accounts({ governanceAuthority: DEPLOYER_AUTHORITY_KEYPAIR.publicKey })
+      .accounts({ payer: DEPLOYER_AUTHORITY_KEYPAIR.publicKey, airlock: airlockPDA })
       .rpc();
   } catch (err) {
     console.error("Error:", err);

solana/app/deploy/3_update_HubProposalMetadata.ts

@@ -211,6 +211,28 @@ pub struct InitializeSpokeMetadataCollector<'info> {
 
 #[derive(Accounts)]
 pub struct UpdateHubProposalMetadata<'info> {
+    #[account(mut)]
+    pub payer: Signer<'info>,
+
+    #[account(
+        seeds = [AIRLOCK_SEED.as_bytes()],
+        bump = airlock.bump,
+    )]
+    pub airlock: Account<'info, SpokeAirlock>,
+
+    #[account(
+        mut,
+        seeds = [SPOKE_METADATA_COLLECTOR_SEED.as_bytes()],
+        bump = spoke_metadata_collector.bump
+    )]
+    pub spoke_metadata_collector: Account<'info, SpokeMetadataCollector>,
+
+    #[account(seeds = [CONFIG_SEED.as_bytes()], bump = config.bump)]
+    pub config: Box<Account<'info, global_config::GlobalConfig>>,
+}
+
+#[derive(Accounts)]
+pub struct RelinquishAdminControlOverHubProposalMetadata<'info> {
     #[account(mut, address = config.governance_authority)]
     pub governance_authority: Signer<'info>,
 

solana/programs/staking/src/context.rs

@@ -53,6 +53,10 @@ pub enum ErrorCode {
     InvalidCheckpointAccountLimit,
     #[msg("Zero withdrawals not permitted")]
     ZeroWithdrawal,
+    #[msg("Not governance authority")]
+    NotGovernanceAuthority,
+    #[msg("Airlock is not a signer")]
+    AirlockNotSigner,
     #[msg("Other")]
     Other,
 }

solana/programs/staking/src/error.rs

@@ -790,11 +790,28 @@ pub mod staking {
         new_hub_proposal_metadata: [u8; 20],
     ) -> Result<()> {
         let spoke_metadata_collector = &mut ctx.accounts.spoke_metadata_collector;
+
+        if spoke_metadata_collector.updates_controlled_by_governance {
+            require!(ctx.accounts.payer.key() == ctx.accounts.config.governance_authority, ErrorCode::NotGovernanceAuthority);
+        }
+        else {
+            require!(ctx.accounts.airlock.to_account_info().is_signer, ErrorCode::AirlockNotSigner);
+        }
+
         let _ = spoke_metadata_collector.update_hub_proposal_metadata(new_hub_proposal_metadata);
 
         Ok(())
     }
 
+    pub fn relinquish_admin_control_over_hub_proposal_metadata(
+        ctx: Context<RelinquishAdminControlOverHubProposalMetadata>
+    ) -> Result<()> {
+        let spoke_metadata_collector = &mut ctx.accounts.spoke_metadata_collector;
+        spoke_metadata_collector.updates_controlled_by_governance = false;
+
+        Ok(())
+    }
+
     pub fn initialize_vote_weight_window_lengths(
         ctx: Context<InitializeVoteWeightWindowLengths>,
         initial_window_length: u64,

solana/programs/staking/src/lib.rs

@@ -22,6 +22,8 @@ pub struct SpokeMetadataCollector {
     pub hub_proposal_metadata: [u8; 20],
     // Wormhole contract handling messages
     pub wormhole_core: Pubkey,
+    // Updates to hub_proposal_metadata are governance controlled
+    pub updates_controlled_by_governance: bool
 }
 
 impl SpokeMetadataCollector {
@@ -39,6 +41,7 @@ impl SpokeMetadataCollector {
         self.hub_chain_id = hub_chain_id;
         self.hub_proposal_metadata = hub_proposal_metadata;
         self.wormhole_core = wormhole_core;
+        self.updates_controlled_by_governance = true;
 
         Ok(())
     }

solana/programs/staking/src/state/spoke_metadata_collector.rs

@@ -174,6 +174,7 @@ reexport_seed_const!(CONFIG_SEED);
 reexport_seed_const!(PROPOSAL_SEED);
 reexport_seed_const!(VESTING_CONFIG_SEED);
 reexport_seed_const!(VESTING_BALANCE_SEED);
+reexport_seed_const!(AIRLOCK_SEED);
 reexport_seed_const!(VEST_SEED);
 reexport_seed_const!(SPOKE_METADATA_COLLECTOR_SEED);
 reexport_seed_const!(VOTE_WEIGHT_WINDOW_LENGTHS_SEED);

solana/programs/staking/src/wasm.rs

@@ -55,6 +55,7 @@ describe("config", async () => {
 
   let program;
   let controller;
+  let airlockAddress
 
   let configAccount: PublicKey;
   let bump: number;
@@ -84,6 +85,27 @@ describe("config", async () => {
       }),
     ];
     await program.provider.sendAndConfirm(tx, [program.provider.wallet.payer]);
+
+    airlockAddress =
+      PublicKey.findProgramAddressSync(
+        [
+          utils.bytes.utf8.encode(
+            wasm.Constants.AIRLOCK_SEED(),
+          ),
+        ],
+        program.programId,
+      )[0];
+
+      // Initialize the airlock account
+      await program.methods
+      .initializeSpokeAirlock()
+      .accounts({
+        payer: program.provider.wallet.payer,
+        airlock: airlockAddress,
+        systemProgram: SystemProgram.programId,
+      })
+      .signers([program.provider.wallet.payer])
+      .rpc();
   });
 
   it("initializes config", async () => {
@@ -278,20 +300,20 @@ describe("config", async () => {
     try {
       await program.methods
         .updateHubProposalMetadata(hubProposalMetadataUint8Array)
-        .accounts({ governanceAuthority: randomUser.publicKey })
+        .accounts({ payer: randomUser.publicKey, airlock: airlockAddress})
         .signers([randomUser])
         .rpc();
 
       assert.fail("Expected error was not thrown");
     } catch (e) {
-      assert((e as AnchorError).error?.errorCode?.code === "ConstraintAddress");
+      assert((e as AnchorError).error?.errorCode?.code === "NotGovernanceAuthority");
     }
   });
 
   it("should successfully update HubProposalMetadata", async () => {
     await program.methods
       .updateHubProposalMetadata(hubProposalMetadataUint8Array)
-      .accounts({ governanceAuthority: program.provider.wallet.publicKey })
+      .accounts({ payer: program.provider.wallet.publicKey, airlock: airlockAddress })
       .rpc({ skipPreflight: true });
 
     const [spokeMetadataCollectorAccount, spokeMetadataCollectorBump] =
@@ -324,6 +346,45 @@ describe("config", async () => {
     );
   });
 
+  it("should revoke admin rights for updating HubProposalMetadata", async () => {
+    await program.methods
+      .relinquishAdminControlOverHubProposalMetadata()
+      .accounts({ governanceAuthority: program.provider.wallet.publicKey })
+      .rpc({ skipPreflight: true });
+
+    const [spokeMetadataCollectorAccount, spokeMetadataCollectorBump] =
+      PublicKey.findProgramAddressSync(
+        [
+          utils.bytes.utf8.encode(
+            wasm.Constants.SPOKE_METADATA_COLLECTOR_SEED(),
+          ),
+        ],
+        program.programId,
+      );
+
+    const spokeMetadataCollectorAccountData =
+      await program.account.spokeMetadataCollector.fetch(
+        spokeMetadataCollectorAccount,
+      );
+
+    assert.equal(
+      spokeMetadataCollectorAccountData.updatesControlledByGovernance,
+      false,
+    );
+
+    try {
+      await program.methods
+        .updateHubProposalMetadata(hubProposalMetadataUint8Array)
+        .accounts({ payer: randomUser.publicKey, airlock: airlockAddress})
+        .signers([randomUser])
+        .rpc();
+
+      assert.fail("Expected error was not thrown");
+    } catch (e) {
+      assert((e as AnchorError).error?.errorCode?.code === "AirlockNotSigner");
+    }
+  });
+
   it("create account", async () => {
     const configAccountData =
       await program.account.globalConfig.fetch(configAccount);