Use tuple as RawRangeEntry

Author: chipshort

packages/go-gen/tests/cosmwasm_std__RawRangeResponse.go

@@ -1,10 +1,6 @@
 type RawRangeResponse struct {
 	// The key-value pairs
-	Data Array[RawRangeEntry] `json:"data"`
+	Data Array[Array[[]byte]] `json:"data"`
 	// `None` if there are no more key-value pairs within the given key range.
 	NextKey []byte `json:"next_key"`
-}
-type RawRangeEntry struct {
-	K []byte `json:"k"`
-	V []byte `json:"v"`
 }

packages/std/src/query/wasm.rs

@@ -161,23 +161,7 @@ impl_hidden_constructor!(
     next_key: Option<Binary>
 );
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
-pub struct RawRangeEntry {
-    // keys renamed to reduce JSON size overhead
-    #[serde(rename = "k")]
-    pub key: Binary,
-    #[serde(rename = "v")]
-    pub value: Binary,
-}
-
-impl RawRangeEntry {
-    pub fn new(key: impl Into<Binary>, value: impl Into<Binary>) -> Self {
-        RawRangeEntry {
-            key: key.into(),
-            value: value.into(),
-        }
-    }
-}
+pub type RawRangeEntry = (Binary, Binary);
 
 #[cfg(test)]
 mod tests {
@@ -284,15 +268,15 @@ mod tests {
     fn raw_range_response_serialization() {
         let response = RawRangeResponse {
             data: vec![
-                RawRangeEntry::new(b"key", b"value"),
-                RawRangeEntry::new(b"foo", b"bar"),
+                (Binary::from(b"key"), Binary::from(b"value")),
+                (Binary::from(b"foo"), Binary::from(b"bar")),
             ],
             next_key: Some(Binary::from(b"next")),
         };
         let json = to_json_binary(&response).unwrap();
         assert_eq!(
             String::from_utf8_lossy(&json),
-            r#"{"data":[{"k":"a2V5","v":"dmFsdWU="},{"k":"Zm9v","v":"YmFy"}],"next_key":"bmV4dA=="}"#,
+            r#"{"data":[["a2V5","dmFsdWU="],["Zm9v","YmFy"]],"next_key":"bmV4dA=="}"#,
         );
     }
 }

packages/std/src/testing/mock.rs

@@ -2846,8 +2846,6 @@ mod tests {
                     limit,
                     order,
                 } => {
-                    use crate::RawRangeEntry;
-
                     let Ok(addr) = api.addr_validate(contract_addr) else {
                         return SystemResult::Err(SystemError::NoSuchContract {
                             addr: contract_addr.clone(),
@@ -2861,12 +2859,12 @@ mod tests {
                                 *order,
                             )
                             .take(*limit as usize + 1) // take one more entry than limit
-                            .map(|(key, value)| RawRangeEntry::new(key, value))
+                            .map(|(key, value)| (Binary::new(key), Binary::new(value)))
                             .collect();
 
                         // if we have more than limit, there are more entries to fetch
                         let next_key = if data.len() > *limit as usize {
-                            data.pop().map(|RawRangeEntry { key, .. }| key)
+                            data.pop().map(|(key, _)| key)
                         } else {
                             None
                         };
@@ -2966,7 +2964,7 @@ mod tests {
             match result {
                 SystemResult::Ok(ContractResult::Ok(value)) => assert_eq!(
                     value.as_slice(),
-                    br#"{"data":[{"k":"dGhlIGtleQ==","v":"dGhlIHZhbHVl"}],"next_key":null}"#
+                    br#"{"data":[["dGhlIGtleQ==","dGhlIHZhbHVl"]],"next_key":null}"#
                 ),
                 res => panic!("Unexpected result: {res:?}"),
             }