StorageVec

sway-lib-std/src/storage.sw

@@ -1,6 +1,9 @@
 library r#storage;
 
+use ::assert::assert;
 use ::hash::sha256;
+use ::option::Option;
+use ::result::Result;
 use ::context::registers::stack_ptr;
 
 /// Store a stack variable in storage.
@@ -106,3 +109,189 @@ impl<K, V> StorageMap<K, V> {
         get::<V>(key)
     }
 }
+
+/// A persistant vector struct
+pub struct StorageVec<V> {}
+
+impl<V> StorageVec<V> {
+    /// Appends the value to the end of the vector
+    /// 
+    /// # Arguments
+    /// 
+    /// * `value` - The item being added to the end of the vector
+    #[storage(read, write)]
+    pub fn push(self, value: V) {
+        // The length of the vec is stored in the __get_storage_key() slot
+        let len = get::<u64>(__get_storage_key());
+
+        // Storing the value at the current length index (if this is the first item, starts off at 0)
+        let key = sha256((len, __get_storage_key()));
+        store::<V>(key, value);
+
+        // Incrementing the length
+        store(__get_storage_key(), len + 1);
+    }
+
+    /// Removes the last element of the vector and returns it, None if empty
+    #[storage(read, write)]
+    pub fn pop(self) -> Option<V> {
+        let len = get::<u64>(__get_storage_key());
+        // if the length is 0, there is no item to pop from the vec
+        if len == 0 {
+            return Option::None;
+        }
+
+        // reduces len by 1, effectively removing the last item in the vec
+        store(__get_storage_key(), len - 1);
+
+        let key = sha256((len - 1, __get_storage_key()));
+        Option::Some::<V>(get::<V>(key))
+    }
+
+    /// Gets the value in the given index, None if index is out of bounds
+    /// 
+    /// # Arguments
+    /// 
+    /// * `index` - The index of the vec to retrieve the item from
+    #[storage(read)]
+    pub fn get(self, index: u64) -> Option<V> {
+        let len = get::<u64>(__get_storage_key());
+        // if the index is larger or equal to len, there is no item to return
+        if len <= index {
+            return Option::None;
+        }
+
+        let key = sha256((index, __get_storage_key()));
+        Option::Some::<V>(get::<V>(key))
+    }
+
+    /// Removes the element in the given index and moves all the element in the following indexes
+    /// Down one index. Also returns the element
+    ///
+    /// # WARNING 
+    ///
+    /// Expensive for larger vecs
+    ///
+    /// # Arguments
+    /// 
+    /// * `index` - The index of the vec to remove the item from
+    ///
+    /// # Reverts
+    /// 
+    /// Reverts if index is larger or equal to length of the vec
+    #[storage(read, write)]
+    pub fn remove(self, index: u64) -> V {
+        let len = get::<u64>(__get_storage_key());
+        // if the index is larger or equal to len, there is no item to remove
+        assert(index < len);
+
+        // gets the element before removing it, so it can be returned
+        let removed_element = get::<V>(sha256((index, __get_storage_key())));
+
+        // for every element in the vec with an index greater than the input index,
+        // shifts the index for that element down one
+        let mut count = index + 1;
+        while count < len {
+            // gets the storage location for the previous index
+            let key = sha256((count - 1, __get_storage_key()));
+            // moves the element of the current index into the previous index
+            store::<V>(key, get::<V>(sha256((count, __get_storage_key()))));
+
+            count += 1;
+        }
+
+        // decrements len by 1
+        store(__get_storage_key(), len - 1);
+
+        removed_element
+    }
+
+    /// Removes the element at the specified index and fills it with the last element
+    /// Does not preserve ordering. Also returns the element
+    ///
+    /// # Arguments
+    /// 
+    /// * `index` - The index of the vec to remove the item from
+    ///
+    /// # Reverts
+    /// 
+    /// Reverts if index is larger or equal to length of the vec
+    #[storage(read, write)]
+    pub fn swap_remove(self, index: u64) -> V {
+        let len = get::<u64>(__get_storage_key());
+        // if the index is larger or equal to len, there is no item to remove
+        assert(index < len);
+
+        let hash_of_to_be_removed = sha256((index, __get_storage_key()));
+        // gets the element before removing it, so it can be returned
+        let element_to_be_removed = get::<V>(hash_of_to_be_removed);
+
+        let last_element = get::<V>(sha256((len - 1, __get_storage_key())));
+        store::<V>(hash_of_to_be_removed, last_element);
+
+        // decrements len by 1
+        store(__get_storage_key(), len - 1);
+
+        element_to_be_removed
+    }
+
+    /// Inserts the value at the given index, moving the current index's value aswell as the following's
+    /// Up one index
+    ///
+    /// # WARNING 
+    ///
+    /// Expensive for larger vecs
+    ///
+    /// # Arguments
+    /// 
+    /// * `index` - The index of the vec to insert the item into
+    /// * `value` - The value to insert into the vec
+    ///
+    /// # Reverts
+    /// 
+    /// Reverts if index is larger than length of the vec
+    #[storage(read, write)]
+    pub fn insert(self, index: u64, value: V) {
+        let len = get::<u64>(__get_storage_key());
+        // if the index is larger than len, there is no space to insert
+        assert(index <= len);
+
+        // for every element in the vec with an index larger than the input index,
+        // move the element up one index.
+        // performed in reverse to prevent data overwriting
+        let mut count = len-1;
+        while count >= index {
+            let key = sha256((count + 1, __get_storage_key()));
+            // shifts all the values up one index
+            store::<V>(key, get::<V>(sha256((count, __get_storage_key()))));
+
+            count -= 1
+        }
+
+        // inserts the value into the now unused index
+        let key = sha256((index, __get_storage_key()));
+        store::<V>(key, value);
+
+        // increments len by 1
+        store(__get_storage_key(), len + 1);
+    }
+
+    /// Returns the length of the vector
+    #[storage(read)]
+    pub fn len(self) -> u64 {
+        get::<u64>(__get_storage_key())
+    }
+
+    /// Checks whether the len is 0 or not
+    #[storage(read)]
+    pub fn is_empty(self) -> bool {
+        let len = get::<u64>(__get_storage_key());
+        len == 0
+    }
+
+    /// Sets the len to 0
+    #[storage(write)]
+    pub fn clear(self) {
+        store(__get_storage_key(), 0);
+    }
+}

test/src/sdk-harness/build.sh

@@ -27,7 +27,7 @@ while true; do
   fi
 done
 
-test_dirs="${base_dir}/test_artifacts/* ${base_dir}/test_projects/*"
+test_dirs="${base_dir}/test_artifacts/* ${base_dir}/test_projects/* ${base_dir}/test_artifacts/*/*"
 
 for test_dir in $test_dirs; do
   if [[ -f "${test_dir}/Forc.toml" ]]; then

test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/.gitignore

@@ -0,0 +1,2 @@
+out
+target

test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.lock

@@ -0,0 +1,14 @@
+[[package]]
+name = 'core'
+source = 'path+from-root-0A9A4F1E1D370290'
+dependencies = []
+
+[[package]]
+name = 'std'
+source = 'path+from-root-0A9A4F1E1D370290'
+dependencies = ['core']
+
+[[package]]
+name = 'svec_u8'
+source = 'root'
+dependencies = ['std']

test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/Forc.toml

@@ -0,0 +1,8 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "svec_u8"
+
+[dependencies]
+std = { path = "../../../../../../sway-lib-std" }

test/src/sdk-harness/test_artifacts/storage_vec/svec_u8/src/main.sw

@@ -0,0 +1,67 @@
+contract;
+
+use std::{option::Option, result::Result, storage::StorageVec};
+
+abi MyContract {
+    #[storage(read, write)]
+    fn u8_push(value: u8);
+    #[storage(read)]
+    fn u8_get(index: u64) -> u8;
+    #[storage(read, write)]
+    fn u8_pop() -> u8;
+    #[storage(read, write)]
+    fn u8_remove(index: u64) -> u8;
+    #[storage(read, write)]
+    fn u8_swap_remove(index: u64) -> u8;
+    #[storage(read, write)]
+    fn u8_insert(index: u64, value: u8);
+    #[storage(read)]
+    fn u8_len() -> u64;
+    #[storage(read)]
+    fn u8_is_empty() -> bool;
+    #[storage(write)]
+    fn u8_clear();
+}
+
+storage {
+    my_vec: StorageVec<u8> = StorageVec {},
+}
+
+impl MyContract for Contract {
+    #[storage(read, write)]
+    fn u8_push(value: u8) {
+        storage.my_vec.push(value);
+    }
+    #[storage(read)]
+    fn u8_get(index: u64) -> u8 {
+        storage.my_vec.get(index).unwrap()
+    }
+    #[storage(read, write)]
+    fn u8_pop() -> u8 {
+        storage.my_vec.pop().unwrap()
+    }
+    #[storage(read, write)]
+    fn u8_remove(index: u64) -> u8 {
+        storage.my_vec.remove(index)
+    }
+    #[storage(read, write)]
+    fn u8_swap_remove(index: u64) -> u8 {
+        storage.my_vec.swap_remove(index)
+    }
+    #[storage(read, write)]
+    fn u8_insert(index: u64, value: u8) {
+        storage.my_vec.insert(index, value);
+    }
+    #[storage(read)]
+    fn u8_len() -> u64 {
+        storage.my_vec.len()
+    }
+    #[storage(read)]
+    fn u8_is_empty() -> bool {
+        storage.my_vec.is_empty()
+    }
+    #[storage(write)]
+    fn u8_clear() {
+        storage.my_vec.clear();
+    }
+}

test/src/sdk-harness/test_projects/harness.rs

@@ -15,5 +15,6 @@ mod registers;
 mod script_data;
 mod storage;
 mod storage_map;
+mod storage_vec;
 mod token_ops;
 mod tx_fields;

test/src/sdk-harness/test_projects/storage_vec/mod.rs

@@ -0,0 +1 @@
+mod u8;