[WIP] Finalize SUI contracts and make it backward compatible (#935)

* move test accumulator message details to above the definition

* camel case to snake case

* deserialize and check header inside of parse_and_verify_accumulator_message

* factor out cleanup / destruction function for worm / pyth states and clock

* take_wormhole_and_pyth_states to simplify 9 tests

* get_balance for price_info_object

* Store fees as dynamic fields

* Rename functions and modules back to the published version to remain bacward compatible

* Remove withdrawal functionality for now

This functionality can always be added via contract upgrades

---------

Co-authored-by: optke3 <[email protected]>
Co-authored-by: optke3 <[email protected]>

Author: m30m

target_chains/sui/contracts/sources/authenticated_vector.move

@@ -0,0 +1,66 @@
+/// This class represents a vector of objects wrapped
+/// inside of a hot potato struct.
+module pyth::hot_potato_vector {
+    use std::vector;
+
+    const E_EMPTY_HOT_POTATO: u64 = 0;
+
+    friend pyth::pyth;
+
+    // A hot potato containing a vector of elements
+    struct HotPotatoVector<T: copy + drop> {
+        contents: vector<T>
+    }
+
+    // A public destroy function.
+    public fun destroy<T: copy + drop>(hot_potato_vector: HotPotatoVector<T>) {
+        let HotPotatoVector { contents: _ } = hot_potato_vector;
+    }
+
+    // Only certain on-chain functions are allowed to create a new hot potato vector.
+    public(friend) fun new<T: copy + drop>(vec: vector<T>): HotPotatoVector<T> {
+        HotPotatoVector {
+            contents: vec
+        }
+    }
+
+    public fun length<T: copy + drop>(potato: &HotPotatoVector<T>): u64 {
+        vector::length(&potato.contents)
+    }
+
+    public fun is_empty<T: copy + drop>(potato: &HotPotatoVector<T>): bool {
+        vector::is_empty(&potato.contents)
+    }
+
+    public fun borrow<T: copy + drop>(potato: &HotPotatoVector<T>, i: u64): &T {
+        vector::borrow<T>(&potato.contents, i)
+    }
+
+    public(friend) fun pop_back<T: copy + drop>(hot_potato_vector: HotPotatoVector<T>): (T, HotPotatoVector<T>) {
+        let elem = vector::pop_back<T>(&mut hot_potato_vector.contents);
+        return (elem, hot_potato_vector)
+    }
+
+    #[test_only]
+    struct A has copy, drop {
+        a: u64
+    }
+
+    #[test]
+    fun test_hot_potato_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 hot_potato = new<A>(vec_of_a);
+        let (b, hot_potato) = pop_back<A>(hot_potato);
+        assert!(b.a == 23, 0);
+        (b, hot_potato) = pop_back<A>(hot_potato);
+        assert!(b.a == 11, 0);
+        let (b, hot_potato) = pop_back<A>(hot_potato);
+        assert!(b.a == 5, 0);
+
+        destroy<A>(hot_potato);
+    }
+}

target_chains/sui/contracts/sources/hot_potato_vector.move

@@ -3,11 +3,14 @@ module pyth::price_info {
     use sui::tx_context::{TxContext};
     use sui::dynamic_object_field::{Self};
     use sui::table::{Self};
+    use sui::coin::{Self, Coin};
+    use sui::sui::SUI;
 
     use pyth::price_feed::{Self, PriceFeed};
     use pyth::price_identifier::{PriceIdentifier};
 
     const KEY: vector<u8> = b"price_info";
+    const FEE_STORAGE_KEY: vector<u8> = b"fee_storage";
     const E_PRICE_INFO_REGISTRY_ALREADY_EXISTS: u64 = 0;
     const E_PRICE_IDENTIFIER_ALREADY_REGISTERED: u64 = 1;
     const E_PRICE_IDENTIFIER_NOT_REGISTERED: u64 = 2;
@@ -91,6 +94,27 @@ module pyth::price_info {
         table::contains<PriceIdentifier, ID>(ref, price_identifier)
     }
 
+    public fun get_balance(price_info_object: &PriceInfoObject): u64 {
+        if (!dynamic_object_field::exists_with_type<vector<u8>, Coin<SUI>>(&price_info_object.id, FEE_STORAGE_KEY)) {
+            return 0
+        };
+        let fee = dynamic_object_field::borrow<vector<u8>, Coin<SUI>>(&price_info_object.id, FEE_STORAGE_KEY);
+        coin::value(fee)
+    }
+
+    public fun deposit_fee_coins(price_info_object: &mut PriceInfoObject, fee_coins: Coin<SUI>) {
+        if (!dynamic_object_field::exists_with_type<vector<u8>, Coin<SUI>>(&price_info_object.id, FEE_STORAGE_KEY)) {
+            dynamic_object_field::add(&mut price_info_object.id, FEE_STORAGE_KEY, fee_coins);
+        }
+        else {
+            let current_fee = dynamic_object_field::borrow_mut<vector<u8>, Coin<SUI>>(
+                &mut price_info_object.id,
+                FEE_STORAGE_KEY
+            );
+            coin::join(current_fee, fee_coins);
+        };
+    }
+
     public(friend) fun new_price_info_object(
         price_info: PriceInfo,
         ctx: &mut TxContext
@@ -143,7 +167,7 @@ module pyth::price_info {
     }
 
     #[test_only]
-    public fun destroy(price_info: PriceInfoObject){
+    public fun destroy(price_info: PriceInfoObject) {
         let PriceInfoObject {
             id,
             price_info: _,