chore: format all files

Author: jmagan

mock-ledger/backend/ledger/src/chain.rs

@@ -1,13 +1,13 @@
-use std::{collections::HashMap};
-use std::sync::Arc;
 use anyhow::{Context, anyhow};
+use std::collections::HashMap;
+use std::sync::Arc;
 
-use wasmtime::*;
-use wasmtime::component::{Component, Linker};
 use p3_field::PrimeField64;
+use wasmtime::component::{Component, Linker};
+use wasmtime::*;
 
-use crate::utxo::{UtxoId, UtxoInstance, UtxoRegistry};
 use crate::utils::hash::poseidon2_hash_bytes;
+use crate::utxo::{UtxoId, UtxoInstance, UtxoRegistry};
 
 pub struct Chain {
     utxos: UtxoRegistry,
@@ -17,76 +17,86 @@ pub struct Chain {
 pub type WasmComponent = Vec<u8>;
 
 impl Chain {
-  pub fn new(genesis_block: &Vec<WasmComponent>) -> anyhow::Result<Self> {
-      let mut utxos = HashMap::new();
+    pub fn new(genesis_block: &Vec<WasmComponent>) -> anyhow::Result<Self> {
+        let mut utxos = HashMap::new();
+
+        let mut config = wasmtime::Config::default();
+        config.async_support(true);
+        let engine = Engine::new(&config)?;
 
-      let mut config = wasmtime::Config::default();
-      config.async_support(true);
-      let engine = Engine::new(&config)?;
+        // load genesis block
+        {
+            for component_bytes in genesis_block {
+                let component = Component::new(&engine, component_bytes)
+                    .context("failed to parse component")?;
 
-      // load genesis block
-      {
-        for component_bytes in genesis_block {
-          let component = Component::new(&engine, component_bytes)
-              .context("failed to parse component")?;
+                // TODO: inject context imports into linker: inject_context_imports
+                let linker = Linker::new(&engine);
+                let instance_pre = linker.instantiate_pre(&component)?;
 
-          // TODO: inject context imports into linker: inject_context_imports
-          let linker = Linker::new(&engine);
-          let instance_pre = linker.instantiate_pre(&component)?;
-          
-          let digest = poseidon2_hash_bytes(component_bytes);
-          let contract_hash = format!("0x{:016X}{:016X}{:016X}{:016X}", digest[0].as_canonical_u64(), digest[1].as_canonical_u64(), digest[2].as_canonical_u64(), digest[3].as_canonical_u64());
+                let digest = poseidon2_hash_bytes(component_bytes);
+                let contract_hash = format!(
+                    "0x{:016X}{:016X}{:016X}{:016X}",
+                    digest[0].as_canonical_u64(),
+                    digest[1].as_canonical_u64(),
+                    digest[2].as_canonical_u64(),
+                    digest[3].as_canonical_u64()
+                );
 
-          // Register the utxo
-          utxos.insert(
-              UtxoId::new(contract_hash, 0),
-              UtxoInstance {
-                  wasm_instance: Arc::new(instance_pre),
-                  datum: vec![] // TODO: maybe some genesis UTXOs require storage initialization
-              },
-          );
+                // Register the utxo
+                utxos.insert(
+                    UtxoId::new(contract_hash, 0),
+                    UtxoInstance {
+                        wasm_instance: Arc::new(instance_pre),
+                        datum: vec![], // TODO: maybe some genesis UTXOs require storage initialization
+                    },
+                );
+            }
         }
-      }
 
-      Ok(Self {
-        engine: Arc::new(engine),
-        utxos: tokio::sync::RwLock::new(utxos),
-    })
-  }
+        Ok(Self {
+            engine: Arc::new(engine),
+            utxos: tokio::sync::RwLock::new(utxos),
+        })
+    }
 
-  pub fn engine(&self) -> Arc<Engine> {
-    self.engine.clone()
-  }
+    pub fn engine(&self) -> Arc<Engine> {
+        self.engine.clone()
+    }
 
-  pub async fn get_utxo(&self, contract_hash: String, serial: u64) -> anyhow::Result<UtxoInstance> {
-    self.get_utxo_by_id(&UtxoId::new(contract_hash, serial)).await
-  }
+    pub async fn get_utxo(
+        &self,
+        contract_hash: String,
+        serial: u64,
+    ) -> anyhow::Result<UtxoInstance> {
+        self.get_utxo_by_id(&UtxoId::new(contract_hash, serial))
+            .await
+    }
 
-  pub async fn get_utxo_by_id(&self, id: &UtxoId) -> anyhow::Result<UtxoInstance> {
-    let utxos = self.utxos.read().await;
-    let utxo = utxos
-        .get(id)
-        .cloned()
-        .ok_or_else(|| anyhow!("UTXO not found"))?;
-    Ok(utxo)
-  }
+    pub async fn get_utxo_by_id(&self, id: &UtxoId) -> anyhow::Result<UtxoInstance> {
+        let utxos = self.utxos.read().await;
+        let utxo = utxos
+            .get(id)
+            .cloned()
+            .ok_or_else(|| anyhow!("UTXO not found"))?;
+        Ok(utxo)
+    }
 }
 
-
 /// Host any context that can be fetched from Starstream contracts through an effect handler
 ///
 /// Think of this similar to a React Context: Starstream programs can raise an effect to receive context from the runtime
 /// This is represented as an interface (in the WIT definition of the word) that the host provides when it calls into the UTXO
 /// (pseudocode as the Starstream syntax isn't decided yet): `raise Ctx.Caller()`
-/// 
+///
 /// Here, the ledger is the "host" in the WASM sense
 /// and it exposes this data to guests via host functions added to the Linker
-/// 
+///
 /// Note: blockchain execution doesn't involve stateful handles like file descriptors or network connections
 ///       so it can be an interface, and not a "resource"
 fn inject_context_imports() {
-  // TODO: Add ledger context fields as needed:
-  // pub block_range: (u64, u64), // validity interval of tx
-  // pub timestamp_range: (u64, u64), // validity interval of tx
-  // pub caller_address: String
-}
+    // TODO: Add ledger context fields as needed:
+    // pub block_range: (u64, u64), // validity interval of tx
+    // pub timestamp_range: (u64, u64), // validity interval of tx
+    // pub caller_address: String
+}

mock-ledger/backend/ledger/src/encode.rs

@@ -1,9 +1,9 @@
+use core::time::Duration;
 use tokio::io::{DuplexStream, ReadHalf, WriteHalf};
 use wasmtime::component::ResourceTable;
 use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiCtxView, WasiView};
 use wrpc_runtime_wasmtime::{SharedResourceTable, WrpcCtxView, WrpcView};
 use wrpc_transport::Invoke;
-use core::time::Duration;
 use wrpc_transport::frame::Oneshot;
 
 pub type InMemoryTransport = Oneshot<ReadHalf<DuplexStream>, WriteHalf<DuplexStream>>;
@@ -81,4 +81,4 @@ pub fn gen_ctx<C: Invoke>(wrpc: C, cx: C::Context) -> Ctx<C> {
             timeout: Duration::from_secs(10),
         },
     }
-}
+}

mock-ledger/backend/ledger/src/lib.rs

@@ -1,5 +1,5 @@
 pub mod chain;
-pub mod utxo;
-pub mod utils;
 pub mod encode;
+pub mod utils;
+pub mod utxo;
 pub use chain::*;

mock-ledger/backend/ledger/src/utils/hash.rs

@@ -1,20 +1,20 @@
+use once_cell::sync::Lazy;
+use p3_field::PrimeCharacteristicRing;
 use p3_goldilocks::{Goldilocks, Poseidon2Goldilocks};
-use p3_field::{PrimeCharacteristicRing};
-use p3_symmetric::PaddingFreeSponge;
 use p3_symmetric::CryptographicHasher;
-use rand::{rngs::StdRng, SeedableRng};
-use once_cell::sync::Lazy;
+use p3_symmetric::PaddingFreeSponge;
+use rand::{SeedableRng, rngs::StdRng};
 
 // capacity = WIDTH - RATE = 4 bytes = 256 bytes of pre-image security = 128 bits of collision resistance
 const WIDTH: usize = 8; // recommended parameter
-const RATE: usize = 4;  // Run permutation on 4 elements at a time (~256 bits). Must be < WIDTH
-const OUT: usize = 4;   // 4*64= ~256 bit output (slightly lower as goldilocks is not quite 64-bits)
+const RATE: usize = 4; // Run permutation on 4 elements at a time (~256 bits). Must be < WIDTH
+const OUT: usize = 4; // 4*64= ~256 bit output (slightly lower as goldilocks is not quite 64-bits)
 
 static HASHER: Lazy<Hash> = Lazy::new(|| {
-  // constant seed so contract hashes are deterministic
-  let mut rng = StdRng::seed_from_u64(0);
-  let perm = Perm::new_from_rng_128(&mut rng);
-  Hash::new(perm)
+    // constant seed so contract hashes are deterministic
+    let mut rng = StdRng::seed_from_u64(0);
+    let perm = Perm::new_from_rng_128(&mut rng);
+    Hash::new(perm)
 });
 
 type Perm = Poseidon2Goldilocks<WIDTH>;
@@ -24,7 +24,7 @@ type Hash = PaddingFreeSponge<Perm, WIDTH, RATE, OUT>;
  * Outputs a 256-bit hash from input bytes.
  */
 pub fn poseidon2_hash_bytes(bytes: &[u8]) -> [Goldilocks; OUT] {
-  let field_iter = bytes
+    let field_iter = bytes
         // Goldilocks field modulus: p = 2^64 - 2^32 + 1
         // therefore 8 bytes may not fit, so we use 7 instead
         .chunks(7)
@@ -38,5 +38,5 @@ pub fn poseidon2_hash_bytes(bytes: &[u8]) -> [Goldilocks; OUT] {
             Goldilocks::from_u64(word)
         });
 
-  HASHER.hash_iter(field_iter)
+    HASHER.hash_iter(field_iter)
 }

mock-ledger/backend/ledger/src/utils/mod.rs

@@ -1,2 +1 @@
 pub mod hash;
-

mock-ledger/backend/ledger/src/utxo.rs

@@ -1,35 +1,38 @@
-use std::sync::Arc;
 use std::collections::HashMap;
-use wasmtime::component::{InstancePre};
+use std::sync::Arc;
+use wasmtime::component::InstancePre;
 
-use crate::encode::{InMemoryTransport, Ctx};
+use crate::encode::{Ctx, InMemoryTransport};
 
 #[derive(Clone)]
 pub struct UtxoInstance {
-  /// Cached setup for hydrating a UTXO. Combine it with the datum to initialize
-  /// InstancePre is immutable and cloneable, so Arc is sufficient for shared ownership
-  pub wasm_instance: Arc<InstancePre<Ctx<InMemoryTransport>>>,
-  /// UTXO datum encoded using the WASM Component value encoding
-  pub datum: Vec<u8>
+    /// Cached setup for hydrating a UTXO. Combine it with the datum to initialize
+    /// InstancePre is immutable and cloneable, so Arc is sufficient for shared ownership
+    pub wasm_instance: Arc<InstancePre<Ctx<InMemoryTransport>>>,
+    /// UTXO datum encoded using the WASM Component value encoding
+    pub datum: Vec<u8>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct UtxoId {
-  /// The contract hash
-  contract_hash: String,
-  /// nth occurrence of the contract_hash on chain
-  serial: u64,
+    /// The contract hash
+    contract_hash: String,
+    /// nth occurrence of the contract_hash on chain
+    serial: u64,
 }
 impl UtxoId {
-  pub fn new(contract_hash: String, serial: u64) -> Self {
-    Self { contract_hash, serial }
-  }
-  pub fn contract_hash(&self) -> &String {
-    &self.contract_hash
-  }
-  pub fn serial(&self) -> u64 {
-    self.serial
-  }
+    pub fn new(contract_hash: String, serial: u64) -> Self {
+        Self {
+            contract_hash,
+            serial,
+        }
+    }
+    pub fn contract_hash(&self) -> &String {
+        &self.contract_hash
+    }
+    pub fn serial(&self) -> u64 {
+        self.serial
+    }
 }
 
 /// Mapping from UtxoId -> WASM Component

mock-ledger/backend/node-client/src/args_record.rs

@@ -1,15 +1,14 @@
+use crate::rpc;
 use anyhow::Context as _;
 use bytes::BytesMut;
 use wrpc_pack::{pack, unpack};
-use crate::rpc;
 
 pub mod args_record_bindings {
     wit_bindgen_wrpc::generate!({
         path: "../node-server/genesis/wit/args-record/wit"
     });
 }
 
-
 pub async fn explicit_call(
     addr: String,
     contract_hash: String,
@@ -38,4 +37,4 @@ pub async fn explicit_call(
     // you can do better if you have access to the WIT
     let result: i64 = unpack(&mut result.into())?;
     Ok(result)
-}
+}

mock-ledger/backend/node-client/src/args_simple.rs

@@ -1,7 +1,7 @@
+use crate::rpc;
 use anyhow::Context as _;
 use bytes::BytesMut;
 use wrpc_pack::{pack, unpack};
-use crate::rpc;
 
 pub async fn explicit_call(
     addr: String,
@@ -28,4 +28,4 @@ pub async fn explicit_call(
     // you can do better if you have access to the WIT
     let result: i64 = unpack(&mut result.into())?;
     Ok(result)
-}
+}