Add new() function to StorageKey

sway-lib-core/src/storage.sw

@@ -15,6 +15,6 @@ pub struct StorageKey<T> {
     slot: b256,
     /// The assigned offset based on the data structure `T`.
     offset: u64,
-    /// A unqiue identifier.
+    /// A unique identifier.
     field_id: b256,
 }

sway-lib-std/src/storage/storage_key.sw

@@ -97,4 +97,43 @@ impl<T> StorageKey<T> {
     pub fn write(self, value: T) {
         write(self.slot, self.offset, value);
     }
+
+    /// Create a new `StorageKey`.
+    ///
+    /// # Arguments
+    ///
+    /// * `slot`: [b256] - The assigned location in storage for the new `StorageKey`.
+    /// * `offset`: [u64] - The assigned offset based on the data structure `T` for the new `StorageKey`.
+    /// * `field_id`: [b256] - A unique identifier for the new `StorageKey`.
+    ///
+    /// # Returns
+    ///
+    /// * [StorageKey] - The newly create `StorageKey`.
+    ///
+    /// # Examples
+    ///
+    /// ```sway
+    /// use std::{constants::ZERO_B256, hash::sha256};
+    ///
+    /// fn foo() {
+    ///     let my_key = StorageKey::<u64>::new(ZERO_B256, 0, sha256(ZERO_B256));
+    ///     assert(my_key.slot == ZERO_B256);
+    /// }
+    /// ```
+    pub fn new(slot: b256, offset: u64, field_id: b256) -> Self {
+        Self {
+            slot, offset, field_id
+        }
+    }
+}
+
+#[test]
+fn test_storage_key_new() {
+    use ::constants::ZERO_B256;
+    use ::assert::assert;
+
+    let key = StorageKey::<u64>::new(ZERO_B256, 0, ZERO_B256);
+    assert(key.slot == ZERO_B256);
+    assert(key.offset == 0);
+    assert(key.field_id == ZERO_B256);
 }

sway-lib-std/src/storage/storage_map.sw

@@ -68,11 +68,11 @@ impl<K, V> StorageKey<StorageMap<K, V>> where K: Hash {
     /// }
     /// ```
     pub fn get(self, key: K) -> StorageKey<V> where K: Hash {
-        StorageKey {
-            slot: sha256((key, self.field_id)),
-            offset: 0,
-            field_id: sha256((key, self.field_id)),
-        }
+        StorageKey::<V>::new(
+            sha256((key, self.field_id)), 
+            0, 
+            sha256((key, self.field_id))
+        )
     }
 
     /// Clears a value previously stored using a key

sway-lib-std/src/storage/storage_vec.sw

@@ -134,11 +134,11 @@ impl<V> StorageKey<StorageVec<V>> {
             return None;
         }
 
-        Some(StorageKey {
-            slot: sha256((index, self.field_id)),
-            offset: 0,
-            field_id: sha256((index, self.field_id)),
-        })
+        Some(StorageKey::<V>::new(
+            sha256((index, self.field_id)), 
+            0, 
+            sha256((index, self.field_id))
+        ))
     }
 
     /// Removes the element in the given index and moves all the elements in the following indexes
@@ -575,11 +575,11 @@ impl<V> StorageKey<StorageVec<V>> {
     pub fn first(self) -> Option<StorageKey<V>> {
         match read::<u64>(self.field_id, 0).unwrap_or(0) {
             0 => None,
-            _ => Some(StorageKey {
-                slot: sha256((0, self.field_id)),
-                offset: 0,
-                field_id: sha256((0, self.field_id)),
-            }),
+            _ => Some(StorageKey::<V>::new(
+                sha256((0, self.field_id)), 
+                0, 
+                sha256((0, self.field_id))
+            )),
         }
     }
 
@@ -614,11 +614,11 @@ impl<V> StorageKey<StorageVec<V>> {
     pub fn last(self) -> Option<StorageKey<V>> {
         match read::<u64>(self.field_id, 0).unwrap_or(0) {
             0 => None,
-            len => Some(StorageKey {
-                slot: sha256((len - 1, self.field_id)),
-                offset: 0,
-                field_id: sha256((0, self.field_id)),
-            }),
+            len => Some(StorageKey::<V>::new(
+                sha256((len - 1, self.field_id)), 
+                0, 
+                sha256((0, self.field_id))
+            )),
         }
     }