Use Uint256 for Coin amount

chipshort · chipshort · commit b394ad62a8c3 · 2025-04-25T14:38:40.000+02:00
diff --git a/packages/std/src/coin.rs b/packages/std/src/coin.rs
@@ -4,16 +4,16 @@ use serde::{Deserialize, Serialize};
 
 use crate::prelude::*;
 use crate::CoinFromStrError;
-use crate::Uint128;
+use crate::Uint256;
 
 #[derive(Serialize, Deserialize, Clone, Default, PartialEq, Eq, JsonSchema)]
 pub struct Coin {
     pub denom: String,
-    pub amount: Uint128,
+    pub amount: Uint256,
 }
 
 impl Coin {
-    pub fn new(amount: impl Into<Uint128>, denom: impl Into<String>) -> Self {
+    pub fn new(amount: impl Into<Uint256>, denom: impl Into<String>) -> Self {
         Coin {
             amount: amount.into(),
             denom: denom.into(),
@@ -116,7 +116,7 @@ mod tests {
     #[test]
     fn coin_implements_display() {
         let a = Coin {
-            amount: Uint128::new(123),
+            amount: Uint256::new(123),
             denom: "ucosm".to_string(),
         };
 
@@ -131,7 +131,7 @@ mod tests {
         assert_eq!(
             a,
             Coin {
-                amount: Uint128::new(123),
+                amount: Uint256::new(123),
                 denom: "ucosm".to_string()
             }
         );
@@ -140,7 +140,7 @@ mod tests {
         assert_eq!(
             zero,
             Coin {
-                amount: Uint128::new(0),
+                amount: Uint256::new(0),
                 denom: "ucosm".to_string()
             }
         );
@@ -149,7 +149,7 @@ mod tests {
         assert_eq!(
             string_denom,
             Coin {
-                amount: Uint128::new(42),
+                amount: Uint256::new(42),
                 denom: "ucosm".to_string()
             }
         );
@@ -161,7 +161,7 @@ mod tests {
         assert_eq!(
             a,
             vec![Coin {
-                amount: Uint128::new(123),
+                amount: Uint256::new(123),
                 denom: "ucosm".to_string()
             }]
         );
@@ -170,7 +170,7 @@ mod tests {
         assert_eq!(
             zero,
             vec![Coin {
-                amount: Uint128::new(0),
+                amount: Uint256::new(0),
                 denom: "ucosm".to_string()
             }]
         );
@@ -179,7 +179,7 @@ mod tests {
         assert_eq!(
             string_denom,
             vec![Coin {
-                amount: Uint128::new(42),
+                amount: Uint256::new(42),
                 denom: "ucosm".to_string()
             }]
         );
diff --git a/packages/std/src/coins.rs b/packages/std/src/coins.rs
@@ -3,7 +3,7 @@ use core::fmt;
 use core::str::FromStr;
 
 use crate::prelude::*;
-use crate::{Coin, CoinsError, OverflowError, OverflowOperation, StdError, StdResult, Uint128};
+use crate::{Coin, CoinsError, OverflowError, OverflowOperation, StdError, StdResult, Uint256};
 
 /// A collection of coins, similar to Cosmos SDK's `sdk.Coins` struct.
 ///
@@ -133,11 +133,11 @@ impl Coins {
     }
 
     /// Returns the amount of the given denom or zero if the denom is not present.
-    pub fn amount_of(&self, denom: &str) -> Uint128 {
+    pub fn amount_of(&self, denom: &str) -> Uint256 {
         self.0
             .get(denom)
             .map(|c| c.amount)
-            .unwrap_or_else(Uint128::zero)
+            .unwrap_or_else(Uint256::zero)
     }
 
     /// Returns the amount of the given denom if and only if this collection contains only
@@ -159,7 +159,7 @@ impl Coins {
     /// let coins: Coins = [coin(100, "uatom"), coin(200, "uusd")].try_into().unwrap();
     /// assert_eq!(coins.contains_only("uatom"), None);
     /// ```
-    pub fn contains_only(&self, denom: &str) -> Option<Uint128> {
+    pub fn contains_only(&self, denom: &str) -> Option<Uint256> {
         if self.len() == 1 {
             self.0.get(denom).map(|c| c.amount)
         } else {
@@ -222,11 +222,11 @@ impl Coins {
     ///
     /// let uatom = iterator.next().unwrap();
     /// assert_eq!(uatom.denom, "uatom");
-    /// assert_eq!(uatom.amount.u128(), 1000);
+    /// assert_eq!(uatom.amount, Uint256::new(1000));
     ///
     /// let uluna = iterator.next().unwrap();
     /// assert_eq!(uluna.denom, "uluna");
-    /// assert_eq!(uluna.amount.u128(), 500);
+    /// assert_eq!(uluna.amount, Uint256::new(500));
     ///
     /// assert_eq!(iterator.next(), None);
     /// ```
@@ -398,14 +398,14 @@ mod tests {
     fn handling_zero_amount() {
         // create a Vec<Coin> that contains zero amounts
         let mut vec = mock_vec();
-        vec[0].amount = Uint128::zero();
+        vec[0].amount = Uint256::zero();
 
         let coins = Coins::try_from(vec).unwrap();
         assert_eq!(coins.len(), 2);
-        assert_ne!(coins.amount_of("ibc/1234ABCD"), Uint128::zero());
+        assert_ne!(coins.amount_of("ibc/1234ABCD"), Uint256::zero());
         assert_ne!(
             coins.amount_of("factory/osmo1234abcd/subdenom"),
-            Uint128::zero()
+            Uint256::zero()
         );
 
         // adding a coin with zero amount should not be added
@@ -432,15 +432,15 @@ mod tests {
         // existing denom
         coins.add(coin(12345, "uatom")).unwrap();
         assert_eq!(coins.len(), 3);
-        assert_eq!(coins.amount_of("uatom").u128(), 24690);
+        assert_eq!(coins.amount_of("uatom"), Uint256::new(24690));
 
         // new denom
         coins.add(coin(123, "uusd")).unwrap();
         assert_eq!(coins.len(), 4);
 
         // zero amount
         coins.add(coin(0, "uusd")).unwrap();
-        assert_eq!(coins.amount_of("uusd").u128(), 123);
+        assert_eq!(coins.amount_of("uusd"), Uint256::new(123));
 
         // zero amount, new denom
         coins.add(coin(0, "utest")).unwrap();
@@ -462,7 +462,7 @@ mod tests {
         // partial sub
         coins.sub(coin(1, "uatom")).unwrap();
         assert_eq!(coins.len(), 1);
-        assert_eq!(coins.amount_of("uatom").u128(), 12344);
+        assert_eq!(coins.amount_of("uatom"), Uint256::new(12344));
 
         // full sub
         coins.sub(coin(12344, "uatom")).unwrap();
@@ -476,7 +476,7 @@ mod tests {
         // sub zero, non-existent denom
         coins.sub(coin(0, "uatom")).unwrap();
         assert_eq!(coins.len(), 1);
-        assert_eq!(coins.amount_of("uatom").u128(), 12345);
+        assert_eq!(coins.amount_of("uatom"), Uint256::new(12345));
     }
 
     #[test]
@@ -488,7 +488,7 @@ mod tests {
         // happy path
         let coins = Coins::from(coin(12345, "uatom"));
         assert_eq!(coins.len(), 1);
-        assert_eq!(coins.amount_of("uatom").u128(), 12345);
+        assert_eq!(coins.amount_of("uatom"), Uint256::new(12345));
     }
 
     #[test]
@@ -524,6 +524,6 @@ mod tests {
             .eq(coins.to_vec().iter().map(|c| &c.denom)));
 
         // can still use the coins afterwards
-        assert_eq!(coins.amount_of("uatom").u128(), 12345);
+        assert_eq!(coins.amount_of("uatom"), Uint256::new(12345));
     }
 }
diff --git a/packages/std/src/testing/message_info.rs b/packages/std/src/testing/message_info.rs
@@ -49,7 +49,7 @@ pub fn message_info(sender: &Addr, funds: &[Coin]) -> MessageInfo {
 
 #[cfg(test)]
 mod tests {
-    use crate::{coins, Uint128};
+    use crate::{coins, Uint256};
 
     use super::*;
 
@@ -72,7 +72,7 @@ mod tests {
             MessageInfo {
                 sender: addr.clone(),
                 funds: vec![Coin {
-                    amount: Uint128::new(123),
+                    amount: Uint256::new(123),
                     denom: "foo".to_string(),
                 }],
             }
diff --git a/packages/std/src/testing/mock.rs b/packages/std/src/testing/mock.rs
@@ -38,7 +38,7 @@ use crate::query::{DelegatorWithdrawAddressResponse, DistributionQuery};
 use crate::results::{ContractResult, Empty, SystemResult};
 use crate::traits::{Api, Querier, QuerierResult};
 use crate::types::{BlockInfo, ContractInfo, Env, TransactionInfo};
-use crate::{from_json, to_json_binary, Binary, Uint128};
+use crate::{from_json, to_json_binary, Binary, Uint256};
 #[cfg(feature = "cosmwasm_1_3")]
 use crate::{
     query::{AllDenomMetadataResponse, DecCoin, DenomMetadataResponse},
@@ -743,7 +743,7 @@ impl Default for WasmQuerier {
 pub struct BankQuerier {
     #[allow(dead_code)]
     /// BTreeMap<denom, amount>
-    supplies: BTreeMap<String, Uint128>,
+    supplies: BTreeMap<String, Uint256>,
     /// A map from address to balance. The address is the String conversion of `Addr`,
     /// i.e. the bech32 encoded address.
     balances: BTreeMap<String, Vec<Coin>>,
@@ -784,15 +784,15 @@ impl BankQuerier {
             .collect();
     }
 
-    fn calculate_supplies(balances: &BTreeMap<String, Vec<Coin>>) -> BTreeMap<String, Uint128> {
+    fn calculate_supplies(balances: &BTreeMap<String, Vec<Coin>>) -> BTreeMap<String, Uint256> {
         let mut supplies = BTreeMap::new();
 
         let all_coins = balances.iter().flat_map(|(_, coins)| coins);
 
         for coin in all_coins {
             *supplies
                 .entry(coin.denom.clone())
-                .or_insert_with(Uint128::zero) += coin.amount;
+                .or_insert_with(Uint256::zero) += coin.amount;
         }
 
         supplies
@@ -806,7 +806,7 @@ impl BankQuerier {
                     .supplies
                     .get(denom)
                     .cloned()
-                    .unwrap_or_else(Uint128::zero);
+                    .unwrap_or_else(Uint256::zero);
                 let bank_res = SupplyResponse {
                     amount: Coin {
                         amount,
diff --git a/packages/std/src/traits.rs b/packages/std/src/traits.rs
@@ -651,7 +651,7 @@ mod tests {
 
     use super::*;
     use crate::testing::MockQuerier;
-    use crate::{coins, Uint128};
+    use crate::{coins, Uint256};
 
     // this is a simple demo helper to prove we can use it
     fn demo_helper(_querier: &dyn Querier) -> u64 {
@@ -688,7 +688,7 @@ mod tests {
             .unwrap()
             .unwrap();
         let balance: BalanceResponse = from_json(raw).unwrap();
-        assert_eq!(balance.amount.amount, Uint128::new(5));
+        assert_eq!(balance.amount.amount, Uint256::new(5));
     }
 
     #[cfg(feature = "cosmwasm_1_1")]
diff --git a/packages/vm/src/instance.rs b/packages/vm/src/instance.rs
@@ -541,7 +541,9 @@ mod tests {
         mock_instance_with_balances, mock_instance_with_failing_api, mock_instance_with_gas_limit,
         mock_instance_with_options, MockInstanceOptions,
     };
-    use cosmwasm_std::{coin, coins, from_json, BalanceResponse, BankQuery, Empty, QueryRequest};
+    use cosmwasm_std::{
+        coin, coins, from_json, BalanceResponse, BankQuery, Empty, QueryRequest, Uint256,
+    };
     use wasmer::FunctionEnvMut;
 
     const KIB: usize = 1024;
@@ -1005,7 +1007,7 @@ mod tests {
                     .unwrap()
                     .unwrap();
                 let BalanceResponse { amount, .. } = from_json(response).unwrap();
-                assert_eq!(amount.amount.u128(), 8000);
+                assert_eq!(amount.amount, Uint256::new(8000));
                 assert_eq!(amount.denom, "silver");
                 Ok(())
             })
@@ -1036,7 +1038,7 @@ mod tests {
                     .unwrap()
                     .unwrap();
                 let BalanceResponse { amount, .. } = from_json(response).unwrap();
-                assert_eq!(amount.amount.u128(), 500);
+                assert_eq!(amount.amount, Uint256::new(500));
                 Ok(())
             })
             .unwrap();
@@ -1065,7 +1067,7 @@ mod tests {
                     .unwrap()
                     .unwrap();
                 let BalanceResponse { amount, .. } = from_json(response).unwrap();
-                assert_eq!(amount.amount.u128(), 8000);
+                assert_eq!(amount.amount, Uint256::new(8000));
                 Ok(())
             })
             .unwrap();
