scripts

crates/cvm-runtime/src/outpost/query.rs

@@ -113,6 +113,6 @@ pub struct GetConfigResponse {
     pub network_assets: Vec<NetworkAssetItem>,
 }
 
-// impl GetConfigResponse {
-//     pub fn 
-// }
+impl GetConfigResponse {
+    pub fn get_network_for_asset() 
+}

crates/cvm-runtime/src/shared.rs

@@ -18,6 +18,16 @@ pub type CvmProgram = crate::Program<Vec<CvmInstruction>>;
 
 pub type CvmSpawnRef<'a> = (&'a CvmProgram, &'a CvmFundsFilter);
 
+
+impl Default for CvmProgram {
+    fn default() -> Self {
+        Self {
+            tag: vec![0],
+            instructions: vec![],
+        }
+    }
+}
+
 impl CvmProgram {
     pub fn new(instructions: Vec<CvmInstruction>) -> Self {
         Self {

crates/cvm/Cargo.toml

@@ -10,6 +10,7 @@ cosmwasm-schema = { workspace = true, optional = true }
 cosmwasm-std = { workspace = true, no-default-features = true, optional = true}
 cw-storage-plus = { workspace = true, optional = true}
 
+# num = { workspace = true, optional = false}
 parity-scale-codec = { workspace = true, optional = true }
 prost = { workspace = true, features = ["prost-derive"] }
 scale-info = { workspace = true, features = ["derive"], optional = true }

crates/cvm/src/asset.rs

@@ -26,6 +26,14 @@ pub struct AssetId(
     pub Displayed<u128>,
 );
 
+impl FromStr for AssetId {
+    type Err = <u128 as FromStr>::Err;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(AssetId(Displayed(u128::from_str(s)?)))
+    }
+}
+
 impl core::fmt::Display for AssetId {
     fn fmt(&self, fmtr: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.0 .0.fmt(fmtr)
@@ -94,6 +102,25 @@ pub struct Amount {
     pub slope: Displayed<u64>,
 }
 
+impl TryFrom<i64> for Amount {
+    type Error = ArithmeticError;
+
+    fn try_from(value: i64) -> Result<Self, Self::Error> {
+        if value < 0 {
+            return Err(ArithmeticError::Underflow);
+        }
+        Ok(Amount::absolute(value as u64 as u128))
+    }
+}
+
+impl FromStr for Amount {
+    type Err = <u128 as FromStr>::Err;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        u128::from_str(s).map(Amount::absolute)
+    }
+}
+
 /// analog of `Coin`s in IBC/CW, but with CVM numeric id and amount
 /// requires registry to map id back and forth as needed
 #[cfg_attr(
@@ -132,8 +159,24 @@ impl From<(u64, u64)> for Amount {
 }
 
 impl Amount {
+
+
     pub const MAX_PARTS: u64 = 1_000_000_000_000_000_000;
 
+    pub fn one() -> Self{
+        Self::absolute(1)
+    }
+
+    pub fn try_floor_f64(value: f64) -> Result<Self, ArithmeticError> {
+        if value < 0.0 || value.is_nan() {
+            Err(ArithmeticError::Underflow)
+        } else if value > u128::MAX as f64 {
+            Err(ArithmeticError::Underflow)
+        } else {
+            Ok((value as u128).into())
+        }
+    }
+
     pub const fn new(intercept: u128, slope: u64) -> Self {
         Self {
             intercept: Displayed(intercept),

flake.nix

@@ -484,8 +484,7 @@
             cosmwasm-json-schema-ts
             mantis-blackbox
             pyscipopt-latest
-            maturin-latest
-
+            maturin-latest          
             ;
           all =
             pkgs.linkFarmFromDrvs "all"