Add pre commit

Author: danimhr

.pre-commit-config.yaml

@@ -0,0 +1,25 @@
+repos:
+  - repo: local
+    hooks:
+      # Hooks for workspace
+      - id: cargo-fmt-workspace
+        name: Cargo format for workspace
+        language: "rust"
+        entry: cargo +nightly-2024-12-03 fmt --manifest-path ./Cargo.toml --all -- --config-path rustfmt.toml
+        pass_filenames: false
+        types_or: ["rust", "cargo", "cargo-lock"]
+        files: .
+      - id: cargo-clippy-workspace
+        name: Cargo clippy for workspace
+        language: "rust"
+        entry: cargo +1.87.0 clippy --manifest-path ./Cargo.toml --tests -- -D warnings
+        pass_filenames: false
+        types_or: ["rust", "cargo", "cargo-lock"]
+        files: .
+      - id: cargo-test-workspace
+        name: Cargo test for workspace
+        language: "rust"
+        entry: cargo +1.87.0 test --manifest-path ./Cargo.toml
+        pass_filenames: false
+        types_or: ["rust", "cargo", "cargo-lock"]
+        files: .

rustfmt.toml

@@ -0,0 +1,19 @@
+edition = "2021"
+
+# Merge all imports into a clean vertical list of module imports.
+imports_granularity = "One"
+group_imports = "One"
+imports_layout = "Vertical"
+
+# Better grep-ability.
+empty_item_single_line = false
+
+# Consistent pipe layout.
+match_arm_leading_pipes = "Preserve"
+
+# Align Fields
+enum_discrim_align_threshold = 80
+struct_field_align_threshold = 80
+
+# Allow up to two blank lines for visual grouping.
+blank_lines_upper_bound = 2

src/.github/workflows/ci-pre-commit.yml

@@ -0,0 +1,50 @@
+name: Pre-commit checks
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          # Need to grab the history of the PR
+          fetch-depth: 0
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: "package.json"
+          registry-url: "https://registry.npmjs.org"
+      - uses: ./.github/actions/python-poetry
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: 1.85.1
+          components: clippy
+      - uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: nightly-2024-12-03
+          components: rustfmt
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          version: "28.x"
+      - uses: pnpm/action-setup@v4
+        name: Install pnpm
+        with:
+          run_install: true
+      - name: Install Anchor CLI
+        run: |
+          cargo install --git https://github.com/coral-xyz/anchor avm
+          avm install 0.31.0
+          avm use 0.31.0
+      - uses: pre-commit/[email protected]
+        if: ${{ github.event_name == 'pull_request' }}
+        with:
+          # Run only on files changed in the PR
+          extra_args: --from-ref ${{ github.event.pull_request.base.sha }} --to-ref ${{ github.event.pull_request.head.sha }}
+      - uses: pre-commit/[email protected]
+        if: ${{ github.event_name != 'pull_request' }}

src/config.rs

@@ -1,20 +1,25 @@
-use std::path::PathBuf;
-
 use clap::Parser;
 
-
 #[derive(Parser, Clone, Debug)]
 pub struct RunOptions {
     /// The API key to use for auction server authentication.
     #[arg(long = "pythnet-url", env = "PYTHNET_URL")]
-    pub pythnet_url: String,
+    pub pythnet_url:         String,
     /// Path to the file containing the secret key.
     #[arg(long = "secret-key", env = "SECRET_KEY")]
-    pub secret_key_path: String,
+    pub secret_key_path:     String,
     /// The Wormhole program ID.
-    #[arg(long = "wormhole-pid", env = "WORMHOLE_PID", default_value = "H3fxXJ86ADW2PNuDDmZJg6mzTtPxkYCpNuQUTgmJ7AjU")]
-    pub wormhole_pid: String,
+    #[arg(
+        long = "wormhole-pid",
+        env = "WORMHOLE_PID",
+        default_value = "H3fxXJ86ADW2PNuDDmZJg6mzTtPxkYCpNuQUTgmJ7AjU"
+    )]
+    pub wormhole_pid:        String,
     /// The address of the accumulator contract.
-    #[arg(long = "accumulator-address", env = "ACCUMULATOR_ADDRESS", default_value = "G9LV2mp9ua1znRAfYwZz5cPiJMAbo1T6mbjdQsDZuMJg")]
+    #[arg(
+        long = "accumulator-address",
+        env = "ACCUMULATOR_ADDRESS",
+        default_value = "G9LV2mp9ua1znRAfYwZz5cPiJMAbo1T6mbjdQsDZuMJg"
+    )]
     pub accumulator_address: String,
 }

src/main.rs

@@ -1,72 +1,88 @@
-use borsh::BorshDeserialize;
-use observation::{Body, SignedBody};
-use posted_message::PostedMessageUnreliableData;
-use secp256k1::SecretKey;
-use solana_account_decoder::UiAccountEncoding;
-use solana_client::{
-    nonblocking::pubsub_client::PubsubClient, pubsub_client::PubsubClientError, rpc_config::{RpcAccountInfoConfig, RpcProgramAccountsConfig}
+use {
+    borsh::BorshDeserialize,
+    clap::Parser,
+    core::panic,
+    observation::{
+        Body,
+        SignedBody,
+    },
+    posted_message::PostedMessageUnreliableData,
+    secp256k1::SecretKey,
+    solana_account_decoder::UiAccountEncoding,
+    solana_client::{
+        nonblocking::pubsub_client::PubsubClient,
+        pubsub_client::PubsubClientError,
+        rpc_config::{
+            RpcAccountInfoConfig,
+            RpcProgramAccountsConfig,
+        },
+    },
+    solana_sdk::pubkey::Pubkey,
+    std::{
+        fs,
+        str::FromStr,
+        time::Duration,
+    },
+    tokio::time::sleep,
+    tokio_stream::StreamExt,
 };
-use solana_sdk::pubkey::Pubkey;
-use tokio::time::sleep;
-use core::panic;
-use std::{fs, path::PathBuf, str::FromStr, time::Duration};
-use tokio_stream::StreamExt;
-use clap::Parser;
 
-mod posted_message;
+mod config;
 mod observation;
+mod posted_message;
 mod serde_array;
-mod config;
 
 const PYTHNET_CHAIN_ID: u16 = 26;
 
 struct ListenerConfig {
-    ws_url: String,
-    secret_key: SecretKey,
-    wormhole_pid: Pubkey,
+    ws_url:              String,
+    secret_key:          SecretKey,
+    wormhole_pid:        Pubkey,
     accumulator_address: Pubkey,
 }
 
-fn find_message_pda(
-    wormhole_pid: &Pubkey,
-    ring_index: u32,
-) -> Pubkey {
+fn find_message_pda(wormhole_pid: &Pubkey, ring_index: u32) -> Pubkey {
     Pubkey::find_program_address(
         &[b"AccumulatorMessage", &ring_index.to_be_bytes()],
         wormhole_pid,
-    ).0
+    )
+    .0
 }
 
 async fn run_listener(config: ListenerConfig) -> Result<(), PubsubClientError> {
     let client = PubsubClient::new(config.ws_url.as_str()).await?;
-    let (mut stream, unsubscribe) = client.program_subscribe(
-        &config.wormhole_pid,
-        Some(RpcProgramAccountsConfig { 
-            filters: None,
-            account_config: RpcAccountInfoConfig {
-                encoding: Some(UiAccountEncoding::Base64),
-                data_slice: None,
-                commitment: Some(solana_sdk::commitment_config::CommitmentConfig::confirmed()),
-                min_context_slot: None,
-            }, 
-            with_context: None, 
-            sort_results: None
-        }),
-    )
-    .await?;
+    let (mut stream, unsubscribe) = client
+        .program_subscribe(
+            &config.wormhole_pid,
+            Some(RpcProgramAccountsConfig {
+                filters:        None,
+                account_config: RpcAccountInfoConfig {
+                    encoding:         Some(UiAccountEncoding::Base64),
+                    data_slice:       None,
+                    commitment:       Some(
+                        solana_sdk::commitment_config::CommitmentConfig::confirmed(),
+                    ),
+                    min_context_slot: None,
+                },
+                with_context:   None,
+                sort_results:   None,
+            }),
+        )
+        .await?;
 
     while let Some(update) = stream.next().await {
-        let message_pda = find_message_pda(
-            &config.wormhole_pid, 
-            (update.context.slot % 10_000) as u32
-        );
+        let message_pda =
+            find_message_pda(&config.wormhole_pid, (update.context.slot % 10_000) as u32);
         if message_pda.to_string() != update.value.pubkey {
             continue; // Skip updates that are not for the expected PDA
         }
 
-        let unreliable_data: Option<PostedMessageUnreliableData> = update.value.account.data.decode().map(|data| {
-            BorshDeserialize::deserialize(&mut data.as_slice()).ok()
-        }).flatten();
+        let unreliable_data: Option<PostedMessageUnreliableData> = update
+            .value
+            .account
+            .data
+            .decode()
+            .and_then(|data| BorshDeserialize::deserialize(&mut data.as_slice()).ok());
 
         if let Some(unreliable_data) = unreliable_data {
             if PYTHNET_CHAIN_ID != unreliable_data.emitter_chain {
@@ -77,13 +93,13 @@ async fn run_listener(config: ListenerConfig) -> Result<(), PubsubClientError> {
             }
 
             let body = Body {
-                timestamp: unreliable_data.submission_time,
-                nonce: unreliable_data.nonce,
-                emitter_chain: unreliable_data.emitter_chain,
-                emitter_address: unreliable_data.emitter_address,
-                sequence: unreliable_data.sequence,
+                timestamp:         unreliable_data.submission_time,
+                nonce:             unreliable_data.nonce,
+                emitter_chain:     unreliable_data.emitter_chain,
+                emitter_address:   unreliable_data.emitter_address,
+                sequence:          unreliable_data.sequence,
                 consistency_level: unreliable_data.consistency_level,
-                payload: unreliable_data.payload.clone(),
+                payload:           unreliable_data.payload.clone(),
             };
 
             match body.sign(config.secret_key.secret_bytes()) {
@@ -105,7 +121,9 @@ async fn run_listener(config: ListenerConfig) -> Result<(), PubsubClientError> {
         unsubscribe().await
     });
 
-    Err(PubsubClientError::ConnectionClosed("Stream ended".to_string()))
+    Err(PubsubClientError::ConnectionClosed(
+        "Stream ended".to_string(),
+    ))
 }
 
 fn load_secret_key(path: String) -> SecretKey {
@@ -115,7 +133,10 @@ fn load_secret_key(path: String) -> SecretKey {
         return SecretKey::from_byte_array(byte_array).expect("Invalid secret key length");
     }
 
-    let content = fs::read_to_string(path).expect("Invalid secret key file").trim().to_string();
+    let content = fs::read_to_string(path)
+        .expect("Invalid secret key file")
+        .trim()
+        .to_string();
     if let Ok(secret_key) = SecretKey::from_str(&content) {
         return secret_key;
     }
@@ -127,18 +148,24 @@ fn load_secret_key(path: String) -> SecretKey {
 async fn main() {
     let run_options = config::RunOptions::parse();
     let secret_key = load_secret_key(run_options.secret_key_path);
-    let client = PubsubClient::new(&run_options.pythnet_url).await.expect("Invalid WebSocket URL");
+    let client = PubsubClient::new(&run_options.pythnet_url)
+        .await
+        .expect("Invalid WebSocket URL");
     drop(client); // Drop the client to avoid holding the connection open
-    let accumulator_address = Pubkey::from_str(&run_options.accumulator_address).expect("Invalid accumulator address");
-    let wormhole_pid = Pubkey::from_str(&run_options.wormhole_pid).expect("Invalid Wormhole program ID");
+    let accumulator_address =
+        Pubkey::from_str(&run_options.accumulator_address).expect("Invalid accumulator address");
+    let wormhole_pid =
+        Pubkey::from_str(&run_options.wormhole_pid).expect("Invalid Wormhole program ID");
 
     loop {
-        if let Err(e) = run_listener(ListenerConfig { 
+        if let Err(e) = run_listener(ListenerConfig {
             ws_url: run_options.pythnet_url.clone(),
-            secret_key, 
-            wormhole_pid, 
+            secret_key,
+            wormhole_pid,
             accumulator_address,
-        }).await {
+        })
+        .await
+        {
             tracing::error!(error = ?e, "Error listening to messages");
             sleep(Duration::from_millis(200)).await; // Wait before retrying
         }