Add powHit method

sethdusek · sethdusek · commit 9664d68f27da · 2025-04-01T20:39:22.000+05:00
diff --git a/ergo-chain-types/src/autolykos_pow_scheme.rs b/ergo-chain-types/src/autolykos_pow_scheme.rs
@@ -101,10 +101,10 @@ pub struct AutolykosPowScheme {
 
 impl AutolykosPowScheme {
     /// Create a new `AutolykosPowScheme`. Returns None if k is not >= 2 && <= 32 or big_n is not >= 16
-    pub fn new(k: u64, big_n: u32) -> Option<Self> {
-        let k = BoundedU64::new(k)?;
-        let big_n = BoundedU32::new(big_n)?;
-        Some(Self {
+    pub fn new(k: u64, big_n: u32) -> Result<Self, AutolykosPowSchemeError> {
+        let k = BoundedU64::new(k).ok_or(AutolykosPowSchemeError::OutOfBounds)?;
+        let big_n = BoundedU32::new(big_n).ok_or(AutolykosPowSchemeError::OutOfBounds)?;
+        Ok(Self {
             k,
             big_n_base: big_n,
         })
@@ -116,7 +116,7 @@ impl AutolykosPowScheme {
         msg: &[u8],
         nonce: &[u8],
         h: &[u8],
-        big_n: usize,
+        big_n: u32,
     ) -> Result<BigUint, AutolykosPowSchemeError> {
         let seed_hash = self.calc_seed_v2(big_n, msg, nonce, h)?;
         let indexes = self.gen_indexes(&seed_hash, big_n);
@@ -171,7 +171,7 @@ impl AutolykosPowScheme {
     /// in ErgoPow paper.
     pub fn calc_seed_v2(
         &self,
-        big_n: usize,
+        big_n: u32,
         msg: &[u8],
         nonce: &[u8],
         header_height_bytes: &[u8],
@@ -201,7 +201,7 @@ impl AutolykosPowScheme {
     }
 
     /// Returns a list of size `k` with numbers in [0,`N`)
-    pub fn gen_indexes(&self, seed_hash: &[u8; 32], big_n: usize) -> Vec<u32> {
+    pub fn gen_indexes(&self, seed_hash: &[u8; 32], big_n: u32) -> Vec<u32> {
         let mut res = vec![];
         let mut extended_hash: Vec<u8> = seed_hash.to_vec();
         extended_hash.extend(&seed_hash[..3]);
@@ -218,9 +218,9 @@ impl AutolykosPowScheme {
     }
 
     /// Calculates table size (N value) for a given height (moment of time)
-    pub fn calc_big_n(&self, header_version: u8, header_height: u32) -> usize {
+    pub fn calc_big_n(&self, header_version: u8, header_height: u32) -> u32 {
         // Number of elements in a table to find k-sum problem solution on top of
-        let n_base = self.big_n_base.get() as usize;
+        let n_base = self.big_n_base.get();
         if header_version == 1 {
             n_base
         } else {
@@ -288,6 +288,9 @@ pub enum AutolykosPowSchemeError {
     /// Checking proof-of-work for AutolykosV1 is not supported
     #[error("Header.check_pow is not supported for Autolykos1")]
     Unsupported,
+    /// k or N are out of bounds, see [`AutolykosPowScheme::new`]
+    #[error("Arguments to AutolykosPowScheme::new were out of bounds")]
+    OutOfBounds,
 }
 
 /// The following tests are taken from <https://github.com/ergoplatform/ergo/blob/f7b91c0be00531c6d042c10a8855149ca6924373/src/test/scala/org/ergoplatform/mining/AutolykosPowSchemeSpec.scala#L43-L130>
@@ -302,7 +305,7 @@ mod tests {
     #[test]
     fn test_calc_big_n() {
         let pow = AutolykosPowScheme::default();
-        let n_base = pow.big_n_base.get() as usize;
+        let n_base = pow.big_n_base.get();
 
         // autolykos v1
         assert_eq!(pow.calc_big_n(1, 700000), n_base);
diff --git a/ergotree-interpreter/src/eval.rs b/ergotree-interpreter/src/eval.rs
@@ -361,6 +361,7 @@ fn smethod_eval_fn(method: &SMethod) -> Result<EvalFn, EvalError> {
             sglobal::SERIALIZE_METHOD_ID => self::sglobal::SERIALIZE_EVAL_FN,
             sglobal::SOME_METHOD_ID => self::sglobal::SGLOBAL_SOME_EVAL_FN,
             sglobal::NONE_METHOD_ID => self::sglobal::SGLOBAL_NONE_EVAL_FN,
+            sglobal::POW_HIT_METHOD_ID => self::sglobal::POW_HIT_EVAL_FN,
             method_id => {
                 return Err(EvalError::NotFound(format!(
                     "Eval fn: method {:?} with method id {:?} not found in SGlobal",
diff --git a/ergotree-interpreter/src/eval/sglobal.rs b/ergotree-interpreter/src/eval/sglobal.rs
@@ -3,6 +3,7 @@ use alloc::boxed::Box;
 use alloc::{string::ToString, sync::Arc};
 
 use ergotree_ir::serialization::sigma_byte_writer::SigmaByteWrite;
+use ergotree_ir::unsignedbigint256::UnsignedBigInt;
 use ergotree_ir::{
     mir::{
         constant::{Constant, TryExtractInto},
@@ -17,7 +18,7 @@ use ergotree_ir::{
 
 use super::EvalFn;
 use crate::eval::Vec;
-use ergo_chain_types::ec_point::generator;
+use ergo_chain_types::{autolykos_pow_scheme::AutolykosPowScheme, ec_point::generator};
 use ergotree_ir::bigint256::BigInt256;
 use ergotree_ir::types::stype::SType;
 
@@ -219,6 +220,42 @@ pub(crate) static SGLOBAL_NONE_EVAL_FN: EvalFn = |_mc, _env, _ctx, obj, _args| {
     Ok(Value::Opt(None))
 };
 
+pub(crate) static POW_HIT_EVAL_FN: EvalFn = |_mc, _env, _ctx, _obj, mut args| {
+    // Pop arguments to avoid cloning
+    let big_n: u32 = args
+        .pop()
+        .ok_or_else(|| EvalError::NotFound("powHit: missing N".into()))?
+        .try_extract_into::<i32>()?
+        .try_into()
+        .map_err(|_| EvalError::Misc("N out of bounds".into()))?;
+    let h = args
+        .pop()
+        .ok_or_else(|| EvalError::NotFound("powHit: missing h".into()))?
+        .try_extract_into::<Vec<u8>>()?;
+    let nonce = args
+        .pop()
+        .ok_or_else(|| EvalError::NotFound("powHit: missing nonce".into()))?
+        .try_extract_into::<Vec<u8>>()?;
+    let msg = args
+        .pop()
+        .ok_or_else(|| EvalError::NotFound("powHit: missing msg".into()))?
+        .try_extract_into::<Vec<u8>>()?;
+    let k = args
+        .pop()
+        .ok_or_else(|| EvalError::NotFound("powHit: missing msg".into()))?
+        .try_extract_into::<i32>()?;
+    Ok(UnsignedBigInt::try_from(
+        AutolykosPowScheme::new(
+            k.try_into()
+                .map_err(|_| EvalError::Misc("k out of bounds".into()))?,
+            big_n,
+        )?
+        .pow_hit_message_v2(&msg, &nonce, &h, big_n)?,
+    )
+    .map_err(EvalError::Misc)?
+    .into())
+};
+
 #[allow(clippy::unwrap_used)]
 #[cfg(test)]
 #[cfg(feature = "arbitrary")]
@@ -238,11 +275,12 @@ mod tests {
     use ergotree_ir::types::sgroup_elem::GET_ENCODED_METHOD;
     use ergotree_ir::types::stype_param::STypeVar;
     use ergotree_ir::unsignedbigint256::UnsignedBigInt;
+    use num_traits::Num;
     use proptest::proptest;
 
     use crate::eval::tests::{eval_out, eval_out_wo_ctx, try_eval_out_with_version};
     use ergotree_ir::chain::context::Context;
-    use ergotree_ir::types::sglobal::{self, DESERIALIZE_METHOD, SERIALIZE_METHOD};
+    use ergotree_ir::types::sglobal::{self, DESERIALIZE_METHOD, POW_HIT_METHOD, SERIALIZE_METHOD};
     use ergotree_ir::types::stype::SType;
     use sigma_test_util::force_any_val;
 
@@ -315,6 +353,30 @@ mod tests {
         }
     }
 
+    fn pow_hit(k: u32, msg: &[u8], nonce: &[u8], h: &[u8], big_n: u32) -> UnsignedBigInt {
+        let expr: Expr = MethodCall::new(
+            Expr::Global,
+            POW_HIT_METHOD.clone(),
+            vec![
+                Constant::from(k as i32).into(),
+                Constant::from(msg.to_owned()).into(),
+                Constant::from(nonce.to_owned()).into(),
+                Constant::from(h.to_owned()).into(),
+                Constant::from(big_n as i32).into(),
+            ],
+        )
+        .unwrap()
+        .into();
+        let ctx = force_any_val::<Context>();
+        assert!(
+            (0..ErgoTreeVersion::V3.into()).all(|version| try_eval_out_with_version::<
+                UnsignedBigInt,
+            >(&expr, &ctx, version, 3)
+            .is_err())
+        );
+        try_eval_out_with_version(&expr, &ctx, ErgoTreeVersion::V3.into(), 3).unwrap()
+    }
+
     #[test]
     fn eval_group_generator() {
         let expr: Expr = PropertyCall::new(Expr::Global, sglobal::GROUP_GENERATOR_METHOD.clone())
@@ -558,6 +620,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn powhit_eval() {
+        let msg = base16::decode("0a101b8c6a4f2e").unwrap();
+        let nonce = base16::decode("000000000000002c").unwrap();
+        let hbs = base16::decode("00000000").unwrap();
+        assert_eq!(
+            pow_hit(32, &msg, &nonce, &hbs, 1024 * 1024),
+            UnsignedBigInt::from_str_radix(
+                "326674862673836209462483453386286740270338859283019276168539876024851191344",
+                10
+            )
+            .unwrap()
+        );
+    }
+
     proptest! {
         #[test]
         fn serialize_sigmaprop_eq_prop_bytes(sigma_prop: SigmaProp) {
diff --git a/ergotree-ir/src/types/sglobal.rs b/ergotree-ir/src/types/sglobal.rs
@@ -28,6 +28,8 @@ pub const SERIALIZE_METHOD_ID: MethodId = MethodId(3);
 pub const DESERIALIZE_METHOD_ID: MethodId = MethodId(4);
 /// "fromBigEndianBytes" predefined function
 pub const FROM_BIGENDIAN_BYTES_METHOD_ID: MethodId = MethodId(5);
+/// Global.powHit function
+pub const POW_HIT_METHOD_ID: MethodId = MethodId(8);
 /// "some" property
 pub const SOME_METHOD_ID: MethodId = MethodId(9);
 /// "none" property
@@ -36,7 +38,7 @@ pub const NONE_METHOD_ID: MethodId = MethodId(10);
 lazy_static! {
     /// Global method descriptors
     pub(crate) static ref METHOD_DESC: Vec<SMethodDesc> =
-        vec![GROUP_GENERATOR_METHOD_DESC.clone(), XOR_METHOD_DESC.clone(), SERIALIZE_METHOD_DESC.clone(), DESERIALIZE_METHOD_DESC.clone(), FROM_BIGENDIAN_BYTES_METHOD_DESC.clone(), NONE_METHOD_DESC.clone(), SOME_METHOD_DESC.clone()];
+        vec![GROUP_GENERATOR_METHOD_DESC.clone(), XOR_METHOD_DESC.clone(), SERIALIZE_METHOD_DESC.clone(), DESERIALIZE_METHOD_DESC.clone(), FROM_BIGENDIAN_BYTES_METHOD_DESC.clone(), NONE_METHOD_DESC.clone(), SOME_METHOD_DESC.clone(), POW_HIT_METHOD_DESC.clone()];
 }
 
 lazy_static! {
@@ -125,6 +127,27 @@ lazy_static! {
     };
     /// GLOBAL.serialize
     pub static ref SERIALIZE_METHOD: SMethod = SMethod::new(STypeCompanion::Global, SERIALIZE_METHOD_DESC.clone(),);
+
+    static ref POW_HIT_METHOD_DESC: SMethodDesc = SMethodDesc {
+        method_id: POW_HIT_METHOD_ID,
+        name: "powHit",
+        tpe: SFunc {
+            t_dom: vec![
+                SType::SGlobal,
+                SType::SInt,
+                SType::SColl(SType::SByte.into()),
+                SType::SColl(SType::SByte.into()),
+                SType::SColl(SType::SByte.into()),
+                SType::SInt,
+            ],
+            t_range: SType::SBoolean.into(),
+            tpe_params: vec![],
+        },
+        explicit_type_args: vec![],
+        min_version: ErgoTreeVersion::V3
+    };
+    /// Global.powHit
+    pub static ref POW_HIT_METHOD: SMethod = SMethod::new(STypeCompanion::Global, POW_HIT_METHOD_DESC.clone());
 }
 
 lazy_static! {
diff --git a/ergotree-ir/src/unsignedbigint256.rs b/ergotree-ir/src/unsignedbigint256.rs
@@ -1,6 +1,8 @@
 //! 256-bit unsigned big integer type
+use alloc::string::String;
 use alloc::vec::Vec;
 use core::ops::{Div, Mul, Rem};
+use num_bigint::BigUint;
 
 use bnum::{
     cast::{As, CastFrom},
@@ -169,6 +171,15 @@ impl UnsignedBigInt {
     }
 }
 
+impl TryFrom<BigUint> for UnsignedBigInt {
+    type Error = String;
+
+    fn try_from(value: BigUint) -> Result<Self, Self::Error> {
+        let bytes = value.to_bytes_be();
+        Self::from_be_slice(&bytes).ok_or_else(|| "BigInt256 value: {value} out of bounds".into())
+    }
+}
+
 impl From<u32> for UnsignedBigInt {
     fn from(value: u32) -> Self {
         Self(U256::from(value))
