Format (#215)

guibescos · web-flow · commit f31a788ef9ae · 2022-07-29T12:37:00.000-05:00
* Format * CI * Fixed * Add comment to README * Format config * Fix build * Log time and ema (#212) * Log time and ema * Fix ema deserialize * Revert format * Add expo * Fix comments * Unused import * Revert "Log time and ema (#212)" (#216) This reverts commit f0bb36c. Co-authored-by: Guillermo Bescos <guibescos>
diff --git a/.github/workflows/check-fomatting.yml b/.github/workflows/check-fomatting.yml
@@ -0,0 +1,19 @@
+name: Check Formatting
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-python@v2
+    - uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: nightly
+        components: rustfmt
+    - uses: pre-commit/action@v2.0.3
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -0,0 +1,16 @@
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v3.2.0
+  hooks:
+  - id: trailing-whitespace
+    files : program/
+  - id: end-of-file-fixer
+    files : program/
+  - id: check-added-large-files
+- repo: local
+  hooks:
+    - id: cargo-fmt-nightly
+      name: Cargo Fmt Nightly
+      language: "rust"
+      entry: cargo +nightly fmt
+      pass_filenames: false
diff --git a/Cargo.toml b/Cargo.toml
@@ -0,0 +1,4 @@
+[workspace]
+members = [
+  "program/rust"
+]
diff --git a/README.md b/README.md
@@ -107,3 +107,9 @@ root@pyth-dev# usermod -u 1002 -g 1004 -s /bin/bash pyth
 Finally, in docker extension inside VS Code click right and choose "Attach VS Code". If you're using a remote host in VS Code make sure to let this connection be open.
 
 To get best experience from C++ IntelliSense, open entire `/home/pyth` in VS Code to include `solana` directory in home for lookup directories.
+
+### pre-commit hooks
+pre-commit is a tool that checks and fixes simple issues (formatting, ...) before each commit. You can install it by following [their website](https://pre-commit.com/). In order to enable checks for this repo run `pre-commit install` from command-line in the root of this repo.
+
+The checks are also performed in the CI to ensure the code follows consistent formatting. Formatting is only currently enforced in the `program/` directory.
+You might also need to install the nightly toolchain to run the formatting by running `rustup toolchain install nightly`.
diff --git a/program/c/src/oracle/model/clean b/program/c/src/oracle/model/clean
@@ -1,3 +1,2 @@
 #!/bin/sh
 rm -rfv bin
-
diff --git a/program/c/src/oracle/model/price_model.c b/program/c/src/oracle/model/price_model.c
@@ -17,14 +17,14 @@ price_model_core( uint64_t  cnt,
      optimized mergesort (merge with an unrolled insertion sorting
      network small n base cases).  The best case is ~0.5 n lg n compares
      and the average and worst cases are ~n lg n compares.
-     
+
      While not completely data oblivious, this has quite low variance in
      operation count practically and this is _better_ than quicksort's
      average case and quicksort's worst case is a computational
      denial-of-service and timing attack vulnerable O(n^2).  Unlike
      quicksort, this is also stable (but this stability does not
      currently matter ... it might be a factor in future models).
-     
+
      A data oblivious sorting network approach might be viable here with
      and would have a completely deterministic operations count.  It
      currently isn't used as the best known practical approaches for
@@ -101,7 +101,7 @@ price_model_core( uint64_t  cnt,
 
     *_p50 = avg_2_int64( vl, vr );
   }
-  
+
   /* Extract the p75 (this is the mirror image of the p25 case) */
 
   uint64_t p75_idx = cnt - ((uint64_t)1) - p25_idx;
@@ -110,4 +110,3 @@ price_model_core( uint64_t  cnt,
 
   return sort_quote;
 }
-
diff --git a/program/c/src/oracle/model/run_tests b/program/c/src/oracle/model/run_tests
@@ -15,4 +15,3 @@ $CC test_price_model.c price_model.c -o bin/test_price_model || exit 1
 bin/test_price_model || exit 1
 
 echo all tests passed
-
diff --git a/program/c/src/oracle/model/test_price_model.c b/program/c/src/oracle/model/test_price_model.c
@@ -66,4 +66,3 @@ main( int     argc,
   printf( "pass\n" );
   return 0;
 }
-
diff --git a/program/c/src/oracle/oracle.c b/program/c/src/oracle/oracle.c
@@ -563,4 +563,3 @@ extern uint64_t c_entrypoint(const uint8_t *input)
   }
   return dispatch( prm, ka );
 }
-
diff --git a/program/c/src/oracle/oracle.h b/program/c/src/oracle/oracle.h
@@ -13,7 +13,7 @@ extern "C" {
 // defines to u32 (even with ULL suffix)
 const uint64_t SUCCESSFULLY_UPDATED_AGGREGATE = 1000ULL;
 
-// The size of the "time machine" account defined in the 
+// The size of the "time machine" account defined in the
 // Rust portion of the codebase.
 const uint64_t TIME_MACHINE_STRUCT_SIZE = 1864ULL;
 
diff --git a/program/c/src/oracle/pd.h b/program/c/src/oracle/pd.h
@@ -188,4 +188,3 @@ static inline void pd_sqrt( pd_t *r, pd_t *val, const int64_t *f )
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/program/c/src/oracle/sort/clean b/program/c/src/oracle/sort/clean
@@ -1,3 +1,2 @@
 #!/bin/sh
 rm -rfv bin
-
diff --git a/program/c/src/oracle/sort/run_tests b/program/c/src/oracle/sort/run_tests
@@ -15,4 +15,3 @@ $CC test_sort_stable.c -o bin/test_sort_stable || exit 1
 bin/test_sort_stable || exit 1
 
 echo all tests passed
-
diff --git a/program/c/src/oracle/sort/sort_stable_base_gen.c b/program/c/src/oracle/sort/sort_stable_base_gen.c
@@ -92,4 +92,3 @@ main( int     argc,
   sort_gen( n );
   return 0;
 }
-
diff --git a/program/c/src/oracle/sort/test_sort_stable.c b/program/c/src/oracle/sort/test_sort_stable.c
@@ -49,11 +49,11 @@ main( int     argc,
   prng_t _prng[1];
   prng_t * prng = prng_join( prng_new( _prng, (uint32_t)0, (uint64_t)0 ) );
 
-  int ctr = 0;                                                                                                                      
+  int ctr = 0;
   for( int iter=0; iter<10000000; iter++ ) {
     if( !ctr ) { printf( "Randomized: Completed %i iterations\n", iter ); ctr = 100000; }
     ctr--;
-    
+
     int n = (int)(prng_uint32( prng ) % (uint32_t)(N+1)); /* In [0,N], approx uniform IID */
     for( int i=0; i<n; i++ ) x[i] = (int)((prng_uint32( prng ) & UINT32_C( 0x00ff0000 )) | (uint32_t)i);
     for( int i=0; i<n; i++ ) w[i] = x[i];
@@ -74,10 +74,9 @@ main( int     argc,
   }
 
   prng_delete( prng_leave( prng ) );
- 
+
   printf( "pass\n" );
   return 0;
 }
 
 #undef BEFORE
-
diff --git a/program/c/src/oracle/sort/tmpl/sort_stable.c b/program/c/src/oracle/sort/tmpl/sort_stable.c
@@ -145,12 +145,12 @@ SORT_IMPL(stable_node)( SORT_KEY_T * x,
   SORT_KEY_T * tr = t + nl;
   SORT_IDX_T   nr = n - nl;
   SORT_KEY_T * yr = SORT_IMPL(stable_node)( xr,nr, tr );
-  
+
   /* If left subsort result ended up in orig array, merge into temp
      array.  Otherwise, merge into orig array. */
 
   if( yl==xl ) x = t;
- 
+
   /* At this point, note that yl does not overlap with the location for
      merge output at this point.  yr might overlap (with the right half)
      with the location for merge output but this will still work in that
@@ -193,4 +193,3 @@ SORT_IMPL(stable)( SORT_KEY_T * key,
 #undef SORT_IDX_T
 #undef SORT_KEY_T
 #undef SORT_NAME
-
diff --git a/program/c/src/oracle/upd_aggregate.h b/program/c/src/oracle/upd_aggregate.h
@@ -237,4 +237,3 @@ static inline bool upd_aggregate( pc_price_t *ptr, uint64_t slot, int64_t timest
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/program/c/src/oracle/util/avg.h b/program/c/src/oracle/util/avg.h
@@ -66,8 +66,8 @@ avg_2_int64( int64_t x,
   /* Similar considerations as above */
 
 # if 1 /* Fewer ops but less parallel issue */
-  /* x+y = x+2^63 + y+2^63 - 2^64 ... exact ops 
-         = ux     + uy     - 2^64 ... exact ops where ux and uy are exactly representable as a 64-bit uint 
+  /* x+y = x+2^63 + y+2^63 - 2^64 ... exact ops
+         = ux     + uy     - 2^64 ... exact ops where ux and uy are exactly representable as a 64-bit uint
          = uz     + 2^64 c - 2^64 ... exact ops where uz is a 64-bit uint and c is in [0,1].
      Thus, as before
        uz = ux+uy   ... c ops
@@ -86,7 +86,7 @@ avg_2_int64( int64_t x,
      using the signed and unsigned adds are the same operation binary
      in we have:
        x+2^63              ... exact ops
-       ==x+/-2^63 mod 2^64 ... exact ops 
+       ==x+/-2^63 mod 2^64 ... exact ops
        ==x+/-2^63          ... c ops  */
    uint64_t t = (uint64_t)x;
    uint64_t z = t + (uint64_t)y;
@@ -165,4 +165,3 @@ PYTH_ORACLE_UTIL_AVG_DECL( avg_int32, int32_t )
 #endif
 
 #endif /* _pyth_oracle_util_avg_h_ */
-
diff --git a/program/c/src/oracle/util/clean b/program/c/src/oracle/util/clean
@@ -1,3 +1,2 @@
 #!/bin/sh
 rm -rfv bin
-
diff --git a/program/c/src/oracle/util/hash.h b/program/c/src/oracle/util/hash.h
@@ -71,4 +71,3 @@ hash_inverse_uint64( uint64_t x ) {
 #endif
 
 #endif /* _pyth_oracle_util_hash_h_ */
-
diff --git a/program/c/src/oracle/util/prng.h b/program/c/src/oracle/util/prng.h
@@ -5,7 +5,7 @@
    generator.  Supports parallel generation, interprocess shared memory
    usage, checkpointing, random access, reversible, atomic, etc.  Passes
    extremely strict tests of randomness.
-   
+
    Assumes hash.h provides a high quality 64<>64-bit integer hash
    functions (i.e. full avalanche) with the property hash_uint64(0)==0
    and hash_uint64(i) for i in [0,2^64) yields a permutation of [0,2^64)
@@ -88,7 +88,7 @@ prng_private_contract( uint64_t seq ) {
    state of a _prng and returns ownership of the underlying memory
    region to the caller.  There should be no joins in the system on the
    prng.  Returns a pointer to the underlying memory region.
-   
+
    FIXME: CONSIDER FLATTENING ALIGN? */
 
 static inline uint64_t prng_footprint( void ) { return (uint64_t)sizeof ( prng_t ); }
@@ -143,7 +143,7 @@ prng_idx_set( prng_t * prng,
    possible values of of a signed int uniform IID can be obtained by
    casting the output of the unsigned generator of the same, assuming
    typical twos complement arithmetic platform.)
-   
+
    The theory for this that hash_uint64(i) for i in [0,2^64) specifies a
    random looking permutation of the integers in [0,2^64).  Returning
    the low order bits of this random permutation then yields a high
@@ -207,7 +207,7 @@ static inline int64_t prng_int64( prng_t * prng ) { return (int64_t)( prng_uint6
    goes from [i/N,(i+1)/N) where i is in [0,N).  For single (double)
    precision, "float" ("double"), the largest N for which the range of
    each interval is _exactly_ representable is N = 2^24 (2^53).
-   
+
    Given then a uniform IID uint32_t random input, the
    prng_uint32_to_float_c0 converter output is as though an continuous
    IID uniform random in [0,1) was generated and then rounded down to
@@ -246,7 +246,7 @@ static inline int64_t prng_int64( prng_t * prng ) { return (int64_t)( prng_uint6
    Note that it is possible to make converters that will handle exactly
    rounding toward all possible floating point representations in [0,1]
    but this are significantly more expensive.
-   
+
    Assumes IEEE-754 style float and doubles.
 
    FIXME: ADD UNIT TEST COVERAGE */
diff --git a/program/c/src/oracle/util/run_tests b/program/c/src/oracle/util/run_tests
@@ -52,4 +52,3 @@ bin/test_avg   || exit 1
 #bin/test_prng_battery 4 0 0 || exit 1 # BigCrush: Takes >~3 hours (seq 0, idx 0)
 
 echo all tests passed
-
diff --git a/program/c/src/oracle/util/sar.h b/program/c/src/oracle/util/sar.h
@@ -71,4 +71,3 @@ sar_int64( int64_t x,
 #endif
 
 #endif /* _pyth_oracle_util_sar_h_ */
-
diff --git a/program/c/src/oracle/util/test_align.c b/program/c/src/oracle/util/test_align.c
@@ -17,7 +17,7 @@ main( int     argc,
   prng_t _prng[1];
   prng_t * prng = prng_join( prng_new( _prng, (uint32_t)0, (uint64_t)0 ) );
 
-  int ctr = 0;                                                                                                                      
+  int ctr = 0;
   for( int i=0; i<1000000000; i++ ) {
     if( !ctr ) { printf( "Completed %i iterations\n", i ); ctr = 10000000; }
     ctr--;
@@ -74,4 +74,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_avg.c b/program/c/src/oracle/util/test_avg.c
@@ -10,12 +10,12 @@ main( int     argc,
   prng_t * prng = prng_join( prng_new( _prng, (uint32_t)0, (uint64_t)0 ) );
 
   int ctr;
-  
-  ctr = 0;                                                                                                                      
+
+  ctr = 0;
   for( int i=0; i<1000000000; i++ ) {
     if( !ctr ) { printf( "reg: Completed %i iterations\n", i ); ctr = 10000000; }
     ctr--;
-     
+
 #   define TEST(w) do {                                                                      \
       uint##w##_t x = prng_uint##w( prng );                                                  \
       uint##w##_t y = prng_uint##w( prng );                                                  \
@@ -140,4 +140,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_hash.c b/program/c/src/oracle/util/test_hash.c
@@ -56,4 +56,3 @@ main( int     argc,
   printf( "pass\n" );
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_prng.c b/program/c/src/oracle/util/test_prng.c
@@ -174,4 +174,3 @@ main( int     argc,
   printf( "pass\n" );
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_prng_battery.c b/program/c/src/oracle/util/test_prng_battery.c
@@ -89,4 +89,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_round.c b/program/c/src/oracle/util/test_round.c
@@ -28,4 +28,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_sar.c b/program/c/src/oracle/util/test_sar.c
@@ -12,7 +12,7 @@ main( int     argc,
   /* FIXME: EXPLICT COVERAGE OF EDGE CASES (PROBABLY STATICALLY FULLY
      SAMPLED ALREADY THOUGH FOR 8 AND 16 BIT TYPES) */
 
-  int ctr = 0;                                                                                                                      
+  int ctr = 0;
   for( int i=0; i<1000000000; i++ ) {
     if( !ctr ) { printf( "Completed %i iterations\n", i ); ctr = 10000000; }
     ctr--;
@@ -46,4 +46,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/util.h b/program/c/src/oracle/util/util.h
@@ -8,4 +8,3 @@
 #include "prng.h"   /* includes stdalign.h and hash.h */
 
 #endif /* _pyth_oracle_util_util_h_ */
-
diff --git a/program/rust/.gitignore b/program/rust/.gitignore
@@ -0,0 +1 @@
+bindings.rs
diff --git a/program/rust/build.rs b/program/rust/build.rs
@@ -2,7 +2,7 @@ mod build_utils;
 use bindgen::Builder;
 
 fn main() {
-    println!("cargo:rustc-link-search=../c/target");
+    println!("cargo:rustc-link-search=./program/c/target");
 
     let borsh_derives = ["BorshSerialize".to_string(), "BorshDeserialize".to_string()];
 
diff --git a/program/rust/build_utils.rs b/program/rust/build_utils.rs
@@ -24,7 +24,8 @@ impl<'a> DeriveAdderParserCallback<'a> {
 }
 
 //this is required to implement the callback trait
-impl UnwindSafe for DeriveAdderParserCallback<'_> {}
+impl UnwindSafe for DeriveAdderParserCallback<'_> {
+}
 
 impl ParseCallbacks for DeriveAdderParserCallback<'_> {
     fn add_derives(&self, _name: &str) -> Vec<String> {
diff --git a/program/rust/src/c_oracle_header.rs b/program/rust/src/c_oracle_header.rs
@@ -5,7 +5,10 @@
 #![allow(unused_variables)]
 #![allow(dead_code)]
 //All the custom trait imports should go here
-use borsh::{BorshDeserialize, BorshSerialize};
+use borsh::{
+    BorshDeserialize,
+    BorshSerialize,
+};
 //bindings.rs is generated by build.rs to include
 //things defined in bindings.h
 include!("../bindings.rs");
diff --git a/program/rust/src/error.rs b/program/rust/src/error.rs
@@ -10,13 +10,13 @@ pub type OracleResult = Result<u64, ProgramError>;
 pub enum OracleError {
     /// Generic catch all error
     #[error("Generic")]
-    Generic = 600,
+    Generic             = 600,
     /// integer casting error
     #[error("IntegerCastingError")]
     IntegerCastingError = 601,
     /// c_entrypoint returned an unexpected value
     #[error("UnknownCError")]
-    UnknownCError = 602,
+    UnknownCError       = 602,
 }
 
 impl From<OracleError> for ProgramError {
diff --git a/program/rust/src/lib.rs b/program/rust/src/lib.rs
diff --git a/program/rust/src/price_t_offsets.h b/program/rust/src/price_t_offsets.h
diff --git a/program/rust/src/processor.rs b/program/rust/src/processor.rs
diff --git a/program/rust/src/rust_oracle.rs b/program/rust/src/rust_oracle.rs
diff --git a/rustfmt.toml b/rustfmt.toml
diff --git a/scripts/build-bpf.sh b/scripts/build-bpf.sh

Original file line number	Diff line number	Diff line change
`@@ -15,4 +15,3 @@ $CC test_price_model.c price_model.c -o bin/test_price_model \|\| exit 1`
`15`	`15`	`bin/test_price_model \|\| exit 1`
`16`	`16`
`17`	`17`	`echo all tests passed`
`18`		`-`
Original file line number	Diff line number	Diff line change
`@@ -66,4 +66,3 @@ main( int argc,`
`66`	`66`	`printf( "pass\n" );`
`67`	`67`	`return 0;`
`68`	`68`	`}`
`69`		`-`
Original file line number	Diff line number	Diff line change
`@@ -563,4 +563,3 @@ extern uint64_t c_entrypoint(const uint8_t *input)`
`563`	`563`	`}`
`564`	`564`	`return dispatch( prm, ka );`
`565`	`565`	`}`
`566`		`-`