Merge pull request #576 from CosmWasm/460-range-to-range_raw

`range` to `range raw`

contracts/cw1-subkeys/src/contract.rs

@@ -409,7 +409,7 @@ pub fn query_all_allowances(
  // we use raw addresses here....
  let start = start_after.map(Bound::exclusive);
 
- let res: StdResult<Vec<AllowanceInfo>> = ALLOWANCES
+ let allowances = ALLOWANCES
  .range(deps.storage, start, None, Order::Ascending)
  .filter(|item| {
  if let Ok((_, allow)) = item {
@@ -420,16 +420,14 @@ pub fn query_all_allowances(
  })
  .take(limit)
  .map(|item| {
- item.and_then(|(k, allow)| {
- Ok(AllowanceInfo {
- spender: String::from_utf8(k)?,
- balance: allow.balance,
- expires: allow.expires,
- })
+ item.map(|(addr, allow)| AllowanceInfo {
+ spender: addr.into(),
+ balance: allow.balance,
+ expires: allow.expires,
  })
  })
- .collect();
- Ok(AllAllowancesResponse { allowances: res? })
+ .collect::<StdResult<Vec<_>>>()?;
+ Ok(AllAllowancesResponse { allowances })
 }
 
 // return a list of all permissions here
@@ -441,19 +439,17 @@ pub fn query_all_permissions(
  let limit = calc_limit(limit);
  let start = start_after.map(Bound::exclusive);
 
- let res: StdResult<Vec<PermissionsInfo>> = PERMISSIONS
+ let permissions = PERMISSIONS
  .range(deps.storage, start, None, Order::Ascending)
  .take(limit)
  .map(|item| {
- item.and_then(|(k, perm)| {
- Ok(PermissionsInfo {
- spender: String::from_utf8(k)?,
- permissions: perm,
- })
+ item.map(|(addr, perm)| PermissionsInfo {
+ spender: addr.into(),
+ permissions: perm,
  })
  })
- .collect();
- Ok(AllPermissionsResponse { permissions: res? })
+ .collect::<StdResult<Vec<_>>>()?;
+ Ok(AllPermissionsResponse { permissions })
 }
 
 // Migrate contract if version is lower than current version

contracts/cw1155-base/src/contract.rs

@@ -1,7 +1,7 @@
 use cosmwasm_std::entry_point;
 use cosmwasm_std::{
- to_binary, Addr, Binary, Deps, DepsMut, Env, MessageInfo, Order, Record, Response, StdResult,
- SubMsg, Uint128,
+ to_binary, Addr, Binary, Deps, DepsMut, Env, MessageInfo, Order, Response, StdResult, SubMsg,
+ Uint128,
 };
 use cw_storage_plus::Bound;
 
@@ -478,10 +478,10 @@ pub fn query(deps: Deps, env: Env, msg: Cw1155QueryMsg) -> StdResult<Binary> {
  }
 }
 
-fn parse_approval(item: StdResult<Record<Expiration>>) -> StdResult<cw1155::Approval> {
- item.and_then(|(k, expires)| {
- let spender = String::from_utf8(k)?;
- Ok(cw1155::Approval { spender, expires })
+fn build_approval(item: StdResult<(Addr, Expiration)>) -> StdResult<cw1155::Approval> {
+ item.map(|(addr, expires)| cw1155::Approval {
+ spender: addr.into(),
+ expires,
  })
 }
 
@@ -501,7 +501,7 @@ fn query_all_approvals(
  .range(deps.storage, start, None, Order::Ascending)
  .filter(|r| include_expired || r.is_err() || !r.as_ref().unwrap().1.is_expired(&env.block))
  .take(limit)
- .map(parse_approval)
+ .map(build_approval)
  .collect::<StdResult<_>>()?;
  Ok(ApprovedForAllResponse { operators })
 }
@@ -517,9 +517,8 @@ fn query_tokens(
 
  let tokens = BALANCES
  .prefix(&owner)
- .range(deps.storage, start, None, Order::Ascending)
+ .keys(deps.storage, start, None, Order::Ascending)
  .take(limit)
- .map(|item| item.map(|(k, _)| String::from_utf8(k).unwrap()))
  .collect::<StdResult<_>>()?;
  Ok(TokensResponse { tokens })
 }
@@ -532,9 +531,8 @@ fn query_all_tokens(
  let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
  let start = start_after.map(Bound::exclusive);
  let tokens = TOKENS
- .range(deps.storage, start, None, Order::Ascending)
+ .keys(deps.storage, start, None, Order::Ascending)
  .take(limit)
- .map(|item| item.map(|(k, _)| String::from_utf8(k).unwrap()))
  .collect::<StdResult<_>>()?;
  Ok(TokensResponse { tokens })
 }

contracts/cw20-atomic-swap/src/state.rs

@@ -1,7 +1,7 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::{Addr, Binary, BlockInfo, Order, StdError, StdResult, Storage};
+use cosmwasm_std::{Addr, Binary, BlockInfo, Order, StdResult, Storage};
 use cw_storage_plus::{Bound, Map};
 
 use cw20::{Balance, Expiration};
@@ -34,7 +34,6 @@ pub fn all_swap_ids(
  SWAPS
  .keys(storage, start, None, Order::Ascending)
  .take(limit)
- .map(|k| String::from_utf8(k).map_err(|_| StdError::invalid_utf8("Parsing swap id")))
  .collect()
 }
 

contracts/cw20-base/src/enumerable.rs

@@ -18,22 +18,19 @@ pub fn query_all_allowances(
  let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
  let start = start_after.map(Bound::exclusive);
 
- let allowances: StdResult<Vec<AllowanceInfo>> = ALLOWANCES
+ let allowances = ALLOWANCES
  .prefix(&owner_addr)
  .range(deps.storage, start, None, Order::Ascending)
  .take(limit)
  .map(|item| {
- let (k, v) = item?;
- Ok(AllowanceInfo {
- spender: String::from_utf8(k)?,
- allowance: v.allowance,
- expires: v.expires,
+ item.map(|(addr, allow)| AllowanceInfo {
+ spender: addr.into(),
+ allowance: allow.allowance,
+ expires: allow.expires,
  })
  })
- .collect();
- Ok(AllAllowancesResponse {
- allowances: allowances?,
- })
+ .collect::<StdResult<_>>()?;
+ Ok(AllAllowancesResponse { allowances })
 }
 
 pub fn query_all_accounts(
@@ -44,15 +41,13 @@ pub fn query_all_accounts(
  let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
  let start = start_after.map(Bound::exclusive);
 
- let accounts: Result<Vec<_>, _> = BALANCES
+ let accounts = BALANCES
  .keys(deps.storage, start, None, Order::Ascending)
- .map(String::from_utf8)
  .take(limit)
- .collect();
+ .map(|item| item.map(Into::into))
+ .collect::<StdResult<_>>()?;
 
- Ok(AllAccountsResponse {
- accounts: accounts?,
- })
+ Ok(AllAccountsResponse { accounts })
 }
 
 #[cfg(test)]

contracts/cw20-escrow/src/state.rs

@@ -1,7 +1,7 @@
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::{Addr, Coin, Env, Order, StdError, StdResult, Storage, Timestamp};
+use cosmwasm_std::{Addr, Coin, Env, Order, StdResult, Storage, Timestamp};
 use cw_storage_plus::Map;
 
 use cw20::{Balance, Cw20CoinVerified};
@@ -96,7 +96,6 @@ pub const ESCROWS: Map<&str, Escrow> = Map::new("escrow");
 pub fn all_escrow_ids(storage: &dyn Storage) -> StdResult<Vec<String>> {
  ESCROWS
  .keys(storage, None, None, Order::Ascending)
- .map(|k| String::from_utf8(k).map_err(|_| StdError::invalid_utf8("parsing escrow key")))
  .collect()
 }
 

contracts/cw20-ics20/src/contract.rs

@@ -151,32 +151,30 @@ fn query_port(deps: Deps) -> StdResult<PortResponse> {
 }
 
 fn query_list(deps: Deps) -> StdResult<ListChannelsResponse> {
- let channels: StdResult<Vec<_>> = CHANNEL_INFO
- .range(deps.storage, None, None, Order::Ascending)
+ let channels = CHANNEL_INFO
+ .range_raw(deps.storage, None, None, Order::Ascending)
  .map(|r| r.map(|(_, v)| v))
- .collect();
- Ok(ListChannelsResponse {
- channels: channels?,
- })
+ .collect::<StdResult<_>>()?;
+ Ok(ListChannelsResponse { channels })
 }
 
 // make public for ibc tests
 pub fn query_channel(deps: Deps, id: String) -> StdResult<ChannelResponse> {
  let info = CHANNEL_INFO.load(deps.storage, &id)?;
  // this returns Vec<(outstanding, total)>
- let state: StdResult<Vec<_>> = CHANNEL_STATE
+ let state = CHANNEL_STATE
  .prefix(&id)
  .range(deps.storage, None, None, Order::Ascending)
  .map(|r| {
- let (k, v) = r?;
- let denom = String::from_utf8(k)?;
- let outstanding = Amount::from_parts(denom.clone(), v.outstanding);
- let total = Amount::from_parts(denom, v.total_sent);
- Ok((outstanding, total))
+ r.map(|(denom, v)| {
+  let outstanding = Amount::from_parts(denom.clone(), v.outstanding);
+  let total = Amount::from_parts(denom, v.total_sent);
+  (outstanding, total)
+ })
  })
- .collect();
+ .collect::<StdResult<Vec<_>>>()?;
  // we want (Vec<outstanding>, Vec<total>)
- let (balances, total_sent) = state?.into_iter().unzip();
+ let (balances, total_sent) = state.into_iter().unzip();
 
  Ok(ChannelResponse {
  info,

contracts/cw3-fixed-multisig/src/contract.rs

@@ -17,9 +17,7 @@ use utils::Expiration;
 
 use crate::error::ContractError;
 use crate::msg::{ExecuteMsg, InstantiateMsg, QueryMsg};
-use crate::state::{
- next_id, parse_id, Ballot, Config, Proposal, BALLOTS, CONFIG, PROPOSALS, VOTERS,
-};
+use crate::state::{next_id, Ballot, Config, Proposal, BALLOTS, CONFIG, PROPOSALS, VOTERS};
 
 // version info for migration info
 const CONTRACT_NAME: &str = "crates.io:cw3-fixed-multisig";
@@ -315,13 +313,13 @@ fn list_proposals(
 
  let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
  let start = start_after.map(Bound::exclusive_int);
- let props: StdResult<Vec<_>> = PROPOSALS
+ let proposals = PROPOSALS
  .range(deps.storage, start, None, Order::Ascending)
  .take(limit)
  .map(|p| map_proposal(&env.block, &threshold, p))
- .collect();
+ .collect::<StdResult<_>>()?;
 
- Ok(ProposalListResponse { proposals: props? })
+ Ok(ProposalListResponse { proposals })
 }
 
 fn reverse_proposals(
@@ -338,30 +336,31 @@ fn reverse_proposals(
 
  let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
  let end = start_before.map(Bound::exclusive_int);
- let props: StdResult<Vec<_>> = PROPOSALS
+ let proposals = PROPOSALS
  .range(deps.storage, None, end, Order::Descending)
  .take(limit)
  .map(|p| map_proposal(&env.block, &threshold, p))
- .collect();
+ .collect::<StdResult<_>>()?;
 
- Ok(ProposalListResponse { proposals: props? })
+ Ok(ProposalListResponse { proposals })
 }
 
 fn map_proposal(
  block: &BlockInfo,
  threshold: &ThresholdResponse,
- item: StdResult<(Vec<u8>, Proposal)>,
+ item: StdResult<(u64, Proposal)>,
 ) -> StdResult<ProposalResponse> {
- let (key, prop) = item?;
- let status = prop.current_status(block);
- Ok(ProposalResponse {
- id: parse_id(&key)?,
- title: prop.title,
- description: prop.description,
- msgs: prop.msgs,
- status,
- expires: prop.expires,
- threshold: threshold.clone(),
+ item.map(|(id, prop)| {
+ let status = prop.current_status(block);
+ ProposalResponse {
+ id,
+ title: prop.title,
+ description: prop.description,
+ msgs: prop.msgs,
+ status,
+ expires: prop.expires,
+ threshold: threshold.clone(),
+ }
  })
 }
 
@@ -385,21 +384,20 @@ fn list_votes(
  let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
  let start = start_after.map(Bound::exclusive);
 
- let votes: StdResult<Vec<_>> = BALLOTS
+ let votes = BALLOTS
  .prefix(proposal_id)
  .range(deps.storage, start, None, Order::Ascending)
  .take(limit)
  .map(|item| {
- let (key, ballot) = item?;
- Ok(VoteInfo {
- voter: String::from_utf8(key)?,
+ item.map(|(addr, ballot)| VoteInfo {
+ voter: addr.into(),
  vote: ballot.vote,
  weight: ballot.weight,
  })
  })
- .collect();
+ .collect::<StdResult<_>>()?;
 
- Ok(VoteListResponse { votes: votes? })
+ Ok(VoteListResponse { votes })
 }
 
 fn query_voter(deps: Deps, voter: String) -> StdResult<VoterResponse> {
@@ -416,19 +414,18 @@ fn list_voters(
  let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
  let start = start_after.map(Bound::exclusive);
 
- let voters: StdResult<Vec<_>> = VOTERS
+ let voters = VOTERS
  .range(deps.storage, start, None, Order::Ascending)
  .take(limit)
  .map(|item| {
- let (key, weight) = item?;
- Ok(VoterDetail {
- addr: String::from_utf8(key)?,
+ item.map(|(addr, weight)| VoterDetail {
+ addr: addr.into(),
  weight,
  })
  })
- .collect();
+ .collect::<StdResult<_>>()?;
 
- Ok(VoterListResponse { voters: voters? })
+ Ok(VoterListResponse { voters })
 }
 
 #[cfg(test)]