feat(solana): governance proposal execution

Signed-off-by: Guilherme Felipe da Silva <[email protected]>

Author: frenzox

solana/cli/Cargo.lock

@@ -18,6 +18,8 @@ axelar-solana-its = { git = "https://github.com/eigerco/solana-axelar.git", rev
 ] }
 axelar-solana-encoding = { git = "https://github.com/eigerco/solana-axelar.git", rev = "1c97f24" }
 axelar-executable = { git = "https://github.com/eigerco/solana-axelar.git", rev = "1c97f24" }
+governance-gmp = { git = "https://github.com/eigerco/solana-axelar.git", rev = "1c97f24" }
+program-utils = { git = "https://github.com/eigerco/solana-axelar.git", rev = "1c97f24" }
 
 axelar-wasm-std = { git = "https://github.com/eigerco/axelar-amplifier.git", rev = "3f036ec" }
 voting-verifier = { git = "https://github.com/eigerco/axelar-amplifier.git", rev = "3f036ec", features = [
@@ -27,8 +29,10 @@ multisig-prover = { git = "https://github.com/eigerco/axelar-amplifier.git", rev
     "library",
 ] }
 
+alloy-sol-types = "0.7.6"
 anyhow = "1.0.98"
 bincode = { version = "2.0.1", features = ["serde"] }
+borsh = "1.5.1"
 bs58 = "0.5.1"
 clap = { version = "3.2", features = ["derive", "env"] }
 cosmrs = { version = "0.16", features = ["cosmwasm", "rpc", "grpc"] }
@@ -54,3 +58,4 @@ walkdir = "2.5.0"
 spl-token = { version = "8.0.0", features = ["no-entrypoint"] }
 spl-token-2022 = { version = "8.0.1", features = ["no-entrypoint"] }
 spl-associated-token-account = { version = "6.0.0", features = ["no-entrypoint"] }
+base64 = "0.22.1"

solana/cli/Cargo.toml

@@ -1,23 +1,32 @@
-use clap::{Parser, Subcommand};
-use solana_sdk::{instruction::Instruction, pubkey::Pubkey};
+use axelar_solana_governance::instructions::builder::IxBuilder;
+use base64::Engine;
+use clap::{Args, Subcommand};
+use solana_sdk::{instruction::AccountMeta, instruction::Instruction, pubkey::Pubkey};
 
 use crate::{
     config::Config,
     types::ChainNameOnAxelar,
     utils::{
-        read_json_file_from_path, write_json_to_file_path, ADDRESS_KEY, CHAINS_KEY,
-        CONFIG_ACCOUNT_KEY, CONTRACTS_KEY, GOVERNANCE_ADDRESS_KEY, GOVERNANCE_CHAIN_KEY,
-        GOVERNANCE_KEY, UPGRADE_AUTHORITY_KEY,
+        parse_account_meta_string, read_json_file_from_path, write_json_to_file_path, ADDRESS_KEY,
+        CHAINS_KEY, CONFIG_ACCOUNT_KEY, CONTRACTS_KEY, GOVERNANCE_ADDRESS_KEY,
+        GOVERNANCE_CHAIN_KEY, GOVERNANCE_KEY, MINIMUM_PROPOSAL_ETA_DELAY_KEY,
+        UPGRADE_AUTHORITY_KEY,
     },
 };
 
 #[derive(Subcommand, Debug)]
 pub(crate) enum Commands {
-    #[clap(long_about = "Initialize the Gateway program")]
+    #[clap(long_about = "Initialize the Governance program")]
     Init(InitArgs),
+
+    #[clap(long_about = "Execute a scheduled proposal after its ETA")]
+    ExecuteProposal(ExecuteProposalArgs),
+
+    #[clap(long_about = "Execute an operator-approved proposal (bypasses ETA)")]
+    ExecuteOperatorProposal(ExecuteOperatorProposalArgs),
 }
 
-#[derive(Parser, Debug)]
+#[derive(Args, Debug)]
 pub(crate) struct InitArgs {
     #[clap(short, long)]
     governance_chain: String,
@@ -32,24 +41,86 @@ pub(crate) struct InitArgs {
     operator: Pubkey,
 }
 
+// Common arguments for proposal execution
+#[derive(Args, Debug, Clone)]
+struct ProposalExecutionBaseArgs {
+    #[clap(long, help = "Target program ID for the proposal's instruction")]
+    target: Pubkey,
+
+    #[clap(
+        long,
+        help = "Amount of native value (lamports) to transfer with the proposal"
+    )]
+    native_value: u64,
+
+    #[clap(
+        long,
+        help = "Base64 encoded call data for the target program instruction"
+    )]
+    calldata: String,
+
+    #[clap(
+        long,
+        help = "Account metas required by the target program instruction. Format: 'pubkey:is_signer:is_writable'",
+        value_parser = parse_account_meta_string,
+    )]
+    target_accounts: Vec<AccountMeta>,
+
+    #[clap(long, help = "Optional account to receive the native value transfer")]
+    native_value_receiver: Option<Pubkey>,
+}
+
+#[derive(Args, Debug)]
+pub(crate) struct ExecuteProposalArgs {
+    #[clap(flatten)]
+    base: ProposalExecutionBaseArgs,
+}
+
+#[derive(Args, Debug)]
+pub(crate) struct ExecuteOperatorProposalArgs {
+    #[clap(flatten)]
+    base: ProposalExecutionBaseArgs,
+
+    #[clap(long, help = "Operator pubkey (must be a signer of the transaction)")]
+    operator: Pubkey,
+}
+
+#[derive(Args, Debug)]
+pub(crate) struct TransferOperatorshipArgs {
+    #[clap(long, help = "Pubkey of the new operator")]
+    new_operator: Pubkey,
+
+    #[clap(
+        long,
+        help = "Pubkey of the current operator (must be a signer of the transaction)"
+    )]
+    operator: Pubkey,
+}
+
 pub(crate) async fn build_instruction(
     fee_payer: &Pubkey,
     command: Commands,
     config: &Config,
 ) -> eyre::Result<Instruction> {
+    let (config_pda, _) = axelar_solana_governance::state::GovernanceConfig::pda();
+
     match command {
-        Commands::Init(init_args) => init(fee_payer, init_args, config).await,
+        Commands::Init(init_args) => init(fee_payer, init_args, config, &config_pda).await,
+        Commands::ExecuteProposal(args) => execute_proposal(fee_payer, args, &config_pda).await,
+        Commands::ExecuteOperatorProposal(args) => {
+            execute_operator_proposal(fee_payer, args, &config_pda).await
+        }
     }
 }
 
 async fn init(
     fee_payer: &Pubkey,
     init_args: InitArgs,
     config: &Config,
+    config_pda: &Pubkey,
 ) -> eyre::Result<Instruction> {
     let chain_hash = solana_sdk::keccak::hashv(&[init_args.governance_chain.as_bytes()]).0;
     let address_hash = solana_sdk::keccak::hashv(&[init_args.governance_address.as_bytes()]).0;
-    let (config_pda, _bump) = axelar_solana_governance::state::GovernanceConfig::pda();
 
     let governance_config = axelar_solana_governance::state::GovernanceConfig::new(
         chain_hash,
@@ -66,13 +137,65 @@ async fn init(
         UPGRADE_AUTHORITY_KEY: fee_payer.to_string(),
         GOVERNANCE_ADDRESS_KEY: init_args.governance_address,
         GOVERNANCE_CHAIN_KEY: init_args.governance_chain,
+        MINIMUM_PROPOSAL_ETA_DELAY_KEY: init_args.minimum_proposal_eta_delay,
     });
 
     write_json_to_file_path(&chains_info, &config.chains_info_file)?;
 
-    Ok(
-        axelar_solana_governance::instructions::builder::IxBuilder::new()
-            .initialize_config(fee_payer, &config_pda, governance_config)
-            .build(),
-    )
+    Ok(IxBuilder::new()
+        .initialize_config(fee_payer, config_pda, governance_config)
+        .build())
+}
+
+async fn execute_proposal(
+    fee_payer: &Pubkey,
+    args: ExecuteProposalArgs,
+    config_pda: &Pubkey,
+) -> eyre::Result<Instruction> {
+    let calldata_bytes = base64::engine::general_purpose::STANDARD.decode(args.base.calldata)?;
+    let native_value_receiver_account = args
+        .base
+        .native_value_receiver
+        .map(|pk| AccountMeta::new(pk, false));
+
+    // Note: ETA is part of the proposal data stored on-chain, not provided here.
+    // The builder calculates the proposal hash based on target, calldata, native_value.
+    // The ETA value used in `with_proposal_data` is only relevant for *scheduling*,
+    // not execution, but the builder requires some value. We use 0 here.
+    let builder = IxBuilder::new().with_proposal_data(
+        args.base.target,
+        args.base.native_value,
+        0,
+        native_value_receiver_account,
+        &args.base.target_accounts,
+        calldata_bytes,
+    );
+
+    Ok(builder.execute_proposal(fee_payer, config_pda).build())
+}
+
+async fn execute_operator_proposal(
+    fee_payer: &Pubkey,
+    args: ExecuteOperatorProposalArgs,
+    config_pda: &Pubkey,
+) -> eyre::Result<Instruction> {
+    let calldata_bytes = base64::engine::general_purpose::STANDARD.decode(args.base.calldata)?;
+    let native_value_receiver_account = args
+        .base
+        .native_value_receiver
+        .map(|pk| AccountMeta::new(pk, false));
+
+    // ETA is irrelevant for operator execution. Use 0.
+    let builder = IxBuilder::new().with_proposal_data(
+        args.base.target,
+        args.base.native_value,
+        0,
+        native_value_receiver_account,
+        &args.base.target_accounts,
+        calldata_bytes,
+    );
+
+    Ok(builder
+        .execute_operator_proposal(fee_payer, config_pda, &args.operator)
+        .build())
 }

solana/cli/src/governance.rs

@@ -212,6 +212,7 @@ async fn run() -> eyre::Result<()> {
 
     let config = Config::new(cli.url, cli.output_dir, cli.chains_info_dir)?;
 
+    // Proceed with building and potentially sending/signing/broadcasting a Solana transaction
     match cli.command {
         Command::Send(args) => {
             let send_args = SendArgs {
@@ -276,8 +277,8 @@ async fn build_instruction(
         InstructionSubcommand::Its(command) => {
             its::build_instruction(fee_payer, command, config).await?
         }
-        InstructionSubcommand::Governance(commands) => {
-            governance::build_instruction(fee_payer, commands, config).await?
+        InstructionSubcommand::Governance(command) => {
+            governance::build_instruction(fee_payer, command, config).await?
         }
     };
 

solana/cli/src/main.rs

@@ -11,6 +11,7 @@ use crate::error::{AppError, Result};
 use crate::types::{
     NetworkType, PartialSignature, SignedSolanaTransaction, UnsignedSolanaTransaction,
 };
+pub(crate) use solana_sdk::instruction::AccountMeta;
 
 pub(crate) const ADDRESS_KEY: &str = "address";
 pub(crate) const AXELAR_KEY: &str = "axelar";
@@ -148,6 +149,38 @@ pub(crate) fn encode_its_destination(
     }
 }
 
+/// Parses a string representation of an AccountMeta.
+/// Format: "pubkey:is_signer:is_writable" (e.g., "SomePubkey...:false:true")
+pub fn parse_account_meta_string(s: &str) -> Result<AccountMeta> {
+    let parts: Vec<&str> = s.split(':').collect();
+    if parts.len() != 3 {
+        return Err(AppError::InvalidInput(format!(
+            "Invalid AccountMeta format: '{}'. Expected 'pubkey:is_signer:is_writable'",
+            s
+        )));
+    }
+
+    let pubkey = Pubkey::from_str(parts[0])?;
+    let is_signer = bool::from_str(parts[1]).map_err(|_| {
+        AppError::InvalidInput(format!(
+            "Invalid is_signer value: '{}'. Expected 'true' or 'false'",
+            parts[1]
+        ))
+    })?;
+    let is_writable = bool::from_str(parts[2]).map_err(|_| {
+        AppError::InvalidInput(format!(
+            "Invalid is_writable value: '{}'. Expected 'true' or 'false'",
+            parts[2]
+        ))
+    })?;
+
+    Ok(if is_writable {
+        AccountMeta::new(pubkey, is_signer)
+    } else {
+        AccountMeta::new_readonly(pubkey, is_signer)
+    })
+}
+
 pub(crate) fn print_transaction_result(config: &Config, result: Result<Signature>) -> Result<()> {
     match result {
         Ok(tx_signature) => {