expose zero

Author: 0xgleb

crates/float/src/js_api.rs

@@ -378,6 +378,29 @@ impl Float {
         Self::min_negative_value()
     }
 
+    /// Returns the zero value of a `Float` in its maximized representation.
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Float)` - The zero value.
+    /// * `Err(FloatError)` - If the EVM call fails.
+    ///
+    /// # Example
+    ///
+    /// ```typescript
+    /// const zeroResult = Float.zero();
+    /// if (zeroResult.error) {
+    ///    console.error(zeroResult.error);
+    /// }
+    /// const zero = zeroResult.value;
+    /// assert(zero.isZero().value);
+    /// assert(zero.format().value === "0");
+    /// ```
+    #[wasm_export(js_name = "zero", preserve_js_class)]
+    pub fn zero_js() -> Result<Float, FloatError> {
+        Self::zero()
+    }
+
     /// Formats the float as a decimal string.
     ///
     /// # Returns

crates/float/src/lib.rs

@@ -465,6 +465,37 @@ impl Float {
         })
     }
 
+    /// Returns the zero value of a `Float` in its maximized representation.
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Float)` - The zero value.
+    /// * `Err(FloatError)` - If the EVM call fails.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rain_math_float::Float;
+    ///
+    /// let zero = Float::zero()?;
+    /// assert!(zero.is_zero()?);
+    /// assert_eq!(zero.format()?, "0");
+    ///
+    /// // Should be equal to parsed zero
+    /// let parsed_zero = Float::parse("0".to_string())?;
+    /// assert!(zero.eq(parsed_zero)?);
+    ///
+    /// anyhow::Ok(())
+    /// ```
+    pub fn zero() -> Result<Self, FloatError> {
+        let calldata = DecimalFloat::zeroCall {}.abi_encode();
+
+        execute_call(Bytes::from(calldata), |output| {
+            let decoded = DecimalFloat::zeroCall::abi_decode_returns(output.as_ref())?;
+            Ok(Float(decoded))
+        })
+    }
+
     /// Formats the float as a decimal string with a default significant figures limit of 18.
     ///
     /// # Returns
@@ -1099,6 +1130,20 @@ mod tests {
         assert!(zero.eq(Float::default()).unwrap());
     }
 
+    #[test]
+    fn test_zero() {
+        let zero = Float::zero().unwrap();
+        assert!(zero.is_zero().unwrap());
+        assert_eq!(zero.format().unwrap(), "0");
+
+        // Test that zero equals parsed zero
+        let parsed_zero = Float::parse("0".to_string()).unwrap();
+        assert!(zero.eq(parsed_zero).unwrap());
+
+        // Test that zero equals default
+        assert!(zero.eq(Float::default()).unwrap());
+    }
+
     prop_compose! {
         fn arb_float()(
             coefficient in any::<I224>(),

test_js/float.test.ts

@@ -110,6 +110,26 @@ describe('Test Float Bindings', () => {
 			expect(a.add(b)?.value!.format()?.value!).toBe('0');
 		});
 
+		it('should test zero constant', () => {
+			// Test the zero function
+			const zeroResult = Float.zero();
+			expect(zeroResult.error).toBeUndefined();
+
+			const zero = zeroResult.value!;
+
+			// Test that zero is actually zero
+			expect(zero.isZero()?.value!).toBe(true);
+			expect(zero.format()?.value!).toBe('0');
+
+			// Test that zero equals parsed zero
+			const parsedZero = Float.parse('0')?.value!;
+			expect(zero.eq(parsedZero)?.value!).toBe(true);
+
+			// Test that zero equals bigint zero
+			const bigintZero = Float.fromBigint(0n);
+			expect(zero.eq(bigintZero)?.value!).toBe(true);
+		});
+
 		it('should test float constants', () => {
 			// Test that all constant methods return valid floats
 			const maxPosResult = Float.maxPositiveValue();