Add RawRangeEntry type

Author: chipshort

packages/go-gen/tests/cosmwasm_std__RawRangeResponse.go

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

packages/std/src/lib.rs

@@ -98,8 +98,8 @@ pub use crate::query::{
     CustomQuery, DecCoin, Delegation, DelegationResponse, DelegationRewardsResponse,
     DelegationTotalRewardsResponse, DelegatorReward, DelegatorValidatorsResponse,
     DelegatorWithdrawAddressResponse, DenomMetadataResponse, DistributionQuery, FullDelegation,
-    GrpcQuery, IbcQuery, PortIdResponse, QueryRequest, RawRangeResponse, StakingQuery,
-    SupplyResponse, Validator, ValidatorResponse, WasmQuery,
+    GrpcQuery, IbcQuery, PortIdResponse, QueryRequest, RawRangeEntry, RawRangeResponse,
+    StakingQuery, SupplyResponse, Validator, ValidatorResponse, WasmQuery,
 };
 
 #[cfg(all(feature = "stargate", feature = "cosmwasm_1_2"))]

packages/std/src/query/wasm.rs

@@ -150,17 +150,35 @@ impl QueryResponseType for CodeInfoResponse {}
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 pub struct RawRangeResponse {
     /// The key-value pairs
-    pub data: Vec<(Binary, Binary)>,
+    pub data: Vec<RawRangeEntry>,
     /// `None` if there are no more key-value pairs within the given key range.
     pub next_key: Option<Binary>,
 }
 
 impl_hidden_constructor!(
     RawRangeResponse,
-    data: Vec<(Binary, Binary)>,
+    data: Vec<RawRangeEntry>,
     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(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -266,15 +284,15 @@ mod tests {
     fn raw_range_response_serialization() {
         let response = RawRangeResponse {
             data: vec![
-                (Binary::from(b"key"), Binary::from(b"value")),
-                (Binary::from(b"foo"), Binary::from(b"bar")),
+                RawRangeEntry::new(b"key", b"value"),
+                RawRangeEntry::new(b"foo", 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":[["a2V5","dmFsdWU="],["Zm9v","YmFy"]],"next_key":"bmV4dA=="}"#,
+            r#"{"data":[{"k":"a2V5","v":"dmFsdWU="},{"k":"Zm9v","v":"YmFy"}],"next_key":"bmV4dA=="}"#,
         );
     }
 }

packages/std/src/testing/mock.rs

@@ -2828,6 +2828,8 @@ 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(),
@@ -2841,12 +2843,12 @@ mod tests {
                                 *order,
                             )
                             .take(*limit as usize + 1) // take one more entry than limit
-                            .map(|(key, value)| (Binary::new(key), Binary::new(value)))
+                            .map(|(key, value)| RawRangeEntry::new(key, 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(|(k, _)| k)
+                            data.pop().map(|RawRangeEntry { key, .. }| key)
                         } else {
                             None
                         };
@@ -2946,7 +2948,7 @@ mod tests {
             match result {
                 SystemResult::Ok(ContractResult::Ok(value)) => assert_eq!(
                     value.as_slice(),
-                    br#"{"data":[["dGhlIGtleQ==","dGhlIHZhbHVl"]],"next_key":null}"#
+                    br#"{"data":[{"k":"dGhlIGtleQ==","v":"dGhlIHZhbHVl"}],"next_key":null}"#
                 ),
                 res => panic!("Unexpected result: {res:?}"),
             }