[sui 11/x] - pyth merkle accumulator (#910)

* merkle tree impl

* - take leftmost 20 bytes in hash
- don't assign output of cursor::take_rest to _, instead just drop it

* push PREFIXes (MERKLE_LEAF_PREFIX, MERKLE_NODE_PREFIX) to front instead of back

* delete testXOR

* test construct merkle tree depth exceeded error

* invalid merkle proof test cases

* comments

* rename failure tests

* simplification for initializing a vector

* fix leafHash bug, add tests for hashLeaf and hashNode

* pyth accumulator start, extract_price_info_from_merkle_proof, parse_price_feed_message

* parse_price_feed_message, parse_and_verify_accumulator_updates

* implementation + debugging for merkle pyth accumulator

* edit merkle tree

* testNodehash

* test hash

* delete prints

* test case for parse and verify TEST_ACCUMULATOR_3_MSGS

* hot potato vector -> authenticated price infos

* refactor - move tests from pyth_accumulator to pyth to avoid dependency cycle

* remove _ from deserializing unused vaa

* add sui-contract.yml for github actions

* AuthenticatedPriceInfos -> AuthenticatedVector

* charge base update fee per call to update_single_price_feed

* add back multiple tests, including test_create_and_update_price_feeds_insufficient_fee, update cache, update cache old update

* test multiple price feed creation and update accumulator

* authenticated_price_infos.move -> authenticated_vector.move

* 5 * single_update_fee

* delete some comments, add accumulator test info

* don't make TEST_VAAS test_only in pyth.move

* remove #[test_only]s

* assert price info object contains correct price feed info

* factor out some constants from accumulator test cases to reduce duplicate code

* add sui-contract.yml file for github actions CI

* more refactor and clean-up

* assert price_info_object_1 is correct in test_create_and_update_price_feeds_with_batch_attestation_success

* removed the parse_and_verify_accumulator_message_with_worm_state entirely, and instead added the helper parse_vaa_bytes_from_accumulator_message

* edit comment

* update comment

* edit sui github ci

* fix for sui-contract.yml

* MINIMUM_SUPPORTED_MINOR_VERSION and MAJOR_VERSION

* remove test_get_price_feed_updates_from_accumulator and  parse_vaa_bytes_from_accumulator_message from pyth_accumulator.move

* test_parse_and_verify_accumulator_updates_with_extra_bytes_at_end_of_message

* sui contract yml update

* use rev to cargo install sui in github actions ci

* cargo install --locked for github CI

Author: optke3

.github/workflows/sui-contract.yml

@@ -0,0 +1,30 @@
+on:
+  pull_request:
+    paths:
+      - target_chains/sui/contracts/**
+  push:
+    branches:
+      - main
+    paths:
+      - target_chains/sui/contracts/**
+
+name: Sui Contracts
+
+jobs:
+  sui-tests:
+    name: Sui tests
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: target_chains/sui/contracts/
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Update rust
+        run: rustup update stable
+
+      - name: Install Sui CLI
+        run: cargo install --locked --git https://github.com/MystenLabs/sui.git --rev 09b2081498366df936abae26eea4b2d5cafb2788 sui
+
+      - name: Run tests
+        run: sui move test

target_chains/sui/contracts/sources/authenticated_vector.move

@@ -0,0 +1,65 @@
+/// This class represents a collection of objects wrapped inside of a struct
+/// called AuthenticatedVector. Its constructor is non-public and can only be called
+/// by friend modules, making the creation of new AuthenticatedVector protected.
+module pyth::authenticated_vector {
+    use std::vector;
+
+    friend pyth::pyth;
+
+    // A vector of elements
+    struct AuthenticatedVector<T: copy + drop> has drop {
+        contents: vector<T>
+    }
+
+    // A public destroy function.
+    public fun destroy<T: copy + drop>(vec: AuthenticatedVector<T>){
+        let AuthenticatedVector {contents: _} = vec;
+    }
+
+    // Only certain on-chain functions are allowed to create a new hot potato vector.
+    public(friend) fun new<T: copy + drop>(vec: vector<T>): AuthenticatedVector<T>{
+        AuthenticatedVector {
+            contents: vec
+        }
+    }
+
+    public fun length<T: copy + drop>(vec: &AuthenticatedVector<T>): u64 {
+        vector::length(&vec.contents)
+    }
+
+    public fun is_empty<T: copy + drop>(vec: &AuthenticatedVector<T>): bool {
+        vector::is_empty(&vec.contents)
+    }
+
+    public fun borrow<T: copy + drop>(vec: &AuthenticatedVector<T>, i: u64): &T {
+        vector::borrow<T>(&vec.contents, i)
+    }
+
+    public(friend) fun pop_back<T: copy + drop>(vec: AuthenticatedVector<T>): (T, AuthenticatedVector<T>){
+        let elem = vector::pop_back<T>(&mut vec.contents);
+        return (elem, vec)
+    }
+
+    #[test_only]
+    struct A has copy, drop {
+        a : u64
+    }
+
+    #[test]
+    fun test_authenticated_vector(){
+        let vec_of_a = vector::empty<A>();
+        vector::push_back(&mut vec_of_a, A{a:5});
+        vector::push_back(&mut vec_of_a, A{a:11});
+        vector::push_back(&mut vec_of_a, A{a:23});
+
+        let vec = new<A>(vec_of_a);
+        let (b, vec) = pop_back<A>(vec);
+        assert!(b.a==23, 0);
+        (b, vec) = pop_back<A>(vec);
+        assert!(b.a==11, 0);
+        let (b, vec) = pop_back<A>(vec);
+        assert!(b.a==5, 0);
+
+        destroy<A>(vec);
+    }
+}

target_chains/sui/contracts/sources/hot_potato_vector.move

@@ -80,16 +80,14 @@ module pyth::merkle_tree {
     }
 
     // isProofValid returns whether a merkle proof is valid
-    fun isProofValid(
+    public fun isProofValid(
         encodedProof: &mut Cursor<u8>,
         root: Bytes20,
         leafData: vector<u8>,
     ): bool {
-
         let currentDigest: Bytes20 = leafHash(&leafData);
         let proofSize: u8 = deserialize::deserialize_u8(encodedProof);
-        let i: u8 = 0;
-        while (i < proofSize){
+        while (proofSize > 0){
             let siblingDigest: Bytes20 = bytes20::new(
                 deserialize::deserialize_vector(encodedProof, 20)
             );
@@ -98,14 +96,14 @@ module pyth::merkle_tree {
                 currentDigest,
                 siblingDigest
             );
-            i = i + 1;
+            proofSize = proofSize - 1;
         };
         bytes20::data(&currentDigest) == bytes20::data(&root)
     }
 
     // constructProofs constructs a merkle tree and returns the root of the tree as
     // a Bytes20 as well as the vector of encoded proofs
-    fun constructProofs(
+    public fun constructProofs(
         messages: &vector<vector<u8>>,
         depth: u8
     ) : (Bytes20, vector<u8>) {

target_chains/sui/contracts/sources/merkle_tree.move

@@ -13,7 +13,7 @@ module pyth::price_status {
     }
 
     public fun from_u64(status: u64): PriceStatus {
-        assert!(status <= TRADING, 0); // error::invalid_price_status()
+        assert!(status <= TRADING, 0);
         PriceStatus {
             status: status
         }