add generic digest opcode

Author: msinkec

src/compiler/expr.rs

@@ -190,6 +190,11 @@ pub(crate) fn emit_expression_asm(expr: &Expression, asm: &mut Vec<String>) {
             emit_expression_asm(hash_type, asm);
             asm.push(OP_SIGHASH.to_string());
         }
+        Expression::Digest { data, hash_type } => {
+            emit_expression_asm(data, asm);
+            emit_expression_asm(hash_type, asm);
+            asm.push(OP_DIGEST.to_string());
+        }
         // Byte-string concatenation: bytes-like + value → OP_CAT
         Expression::Concat {
             left,

src/compiler/loops.rs

@@ -283,6 +283,14 @@ pub(crate) fn substitute_expression(
                 hash_type, index_var, value_var, k, array_name,
             )),
         },
+        Expression::Digest { data, hash_type } => Expression::Digest {
+            data: Box::new(substitute_expression(
+                data, index_var, value_var, k, array_name,
+            )),
+            hash_type: Box::new(substitute_expression(
+                hash_type, index_var, value_var, k, array_name,
+            )),
+        },
         Expression::ModExp {
             base,
             exponent,

src/compiler/mod.rs

@@ -4,7 +4,7 @@ use crate::models::{
 };
 use crate::opcodes::{
     OP_0, OP_1, OP_8, OP_ADD, OP_BIN2NUM, OP_BOOLAND, OP_CAT, OP_CHECKLOCKTIMEVERIFY, OP_CHECKSIG,
-    OP_CHECKSIGADD, OP_CHECKSIGFROMSTACK, OP_DIV, OP_DROP, OP_ECADD, OP_ECMUL,
+    OP_CHECKSIGADD, OP_CHECKSIGFROMSTACK, OP_DIGEST, OP_DIV, OP_DROP, OP_ECADD, OP_ECMUL,
     OP_ECMULSCALARVERIFY, OP_ECPAIRING, OP_ELSE, OP_ENDIF, OP_EQUAL, OP_EQUALVERIFY,
     OP_FINDASSETGROUPBYASSETID, OP_GREATERTHAN, OP_GREATERTHANOREQUAL, OP_IF, OP_INSPECTASSETGROUP,
     OP_INSPECTASSETGROUPASSETID, OP_INSPECTASSETGROUPCTRL, OP_INSPECTASSETGROUPMETADATAHASH,

src/models/mod.rs

@@ -483,6 +483,11 @@ pub enum Expression {
     },
     /// Signature hash for the current input under the selected hash type.
     Sighash { hash_type: Box<Expression> },
+    /// Digest selected at runtime. The result is 20 or 32 bytes depending on the hash type.
+    Digest {
+        data: Box<Expression>,
+        hash_type: Box<Expression>,
+    },
     // ─── Arithmetic ────────────────────────────────────────────────────
     /// Negate a BigNum value: negate(value)
     Negate { value: Box<Expression> },

src/opcodes/mod.rs

@@ -45,6 +45,7 @@ pub const OP_SHA256FINALIZE: &str = "OP_SHA256FINALIZE";
 pub const OP_HASH160: &str = "OP_HASH160";
 pub const OP_HASH256: &str = "OP_HASH256";
 pub const OP_RIPEMD160: &str = "OP_RIPEMD160";
+pub const OP_DIGEST: &str = "OP_DIGEST";
 
 // Byte-string manipulation
 pub const OP_CAT: &str = "OP_CAT";

src/parser/crypto.rs

@@ -66,6 +66,16 @@ pub(crate) fn parse_sighash(pair: Pair<Rule>) -> Result<Expression, String> {
     })
 }
 
+pub(crate) fn parse_digest(pair: Pair<Rule>) -> Result<Expression, String> {
+    let mut inner = pair.into_inner();
+    let data = parse_additive_expr(inner.next().ok_or("Missing data in digest")?)?;
+    let hash_type = parse_atom_pair(inner.next().ok_or("Missing hash type in digest")?);
+    Ok(Expression::Digest {
+        data: Box::new(data),
+        hash_type: Box::new(hash_type),
+    })
+}
+
 // ─── Arithmetic Parsing ────────────────────────────────────────────────
 
 /// Parse negate(value) → Expression::Negate

src/parser/expr.rs

@@ -147,6 +147,7 @@ pub(crate) fn reserved_function_signature(name: &str) -> Option<&'static str> {
         "sha256Initialize" => Some("sha256Initialize(data)"),
         "sha256Update" => Some("sha256Update(ctx, chunk)"),
         "sha256Finalize" => Some("sha256Finalize(ctx, lastChunk)"),
+        "digest" => Some("digest(data, hashType)"),
         "sighash" => Some("sighash(hashType)"),
         "negate" => Some("negate(value)"),
         "modExp" => Some("modExp(base, exponent, modulus)"),
@@ -214,6 +215,7 @@ pub(crate) fn parse_primary_expr(pair: Pair<Rule>) -> Result<Expression, String>
         Rule::sha256_initialize => parse_sha256_initialize(pair),
         Rule::sha256_update => parse_sha256_update(pair),
         Rule::sha256_finalize => parse_sha256_finalize(pair),
+        Rule::digest_func => parse_digest(pair),
         Rule::sighash_func => parse_sighash(pair),
         // Arithmetic
         Rule::negate_func => parse_negate(pair),

src/parser/grammar.pest

@@ -136,6 +136,7 @@ primary_expr = {
     sha256_update |
     sha256_finalize |
     sha256_func |
+    digest_func |
     sighash_func |
     negate_func |
     mod_exp_func |
@@ -196,6 +197,7 @@ complex_expression = _{
     sha256_initialize |
     sha256_update |
     sha256_finalize |
+    digest_func |
     sighash_func |
     negate_func |
     mod_exp_func |
@@ -512,6 +514,10 @@ sighash_func = {
     "sighash" ~ "(" ~ (identifier | number_literal) ~ ")"
 }
 
+digest_func = {
+    "digest" ~ "(" ~ additive_expr ~ "," ~ (identifier | number_literal) ~ ")"
+}
+
 // ─── Arithmetic ────────────────────────────────────────────────────────
 
 // Negate a BigNum value: negate(value) → OP_NEGATE

src/typechecker/mod.rs

@@ -546,7 +546,7 @@ pub fn infer_type(expr: &Expression, scope: &Scope) -> ArkType {
         | Expression::Sighash { .. } => ArkType::Bytes32,
 
         // Byte-string ops
-        Expression::Concat { .. } => ArkType::Bytes,
+        Expression::Concat { .. } | Expression::Digest { .. } => ArkType::Bytes,
 
         // Arithmetic
         Expression::Negate { .. } | Expression::ModExp { .. } => ArkType::Int,

src/validator/mod.rs

@@ -399,6 +399,7 @@ fn child_exprs(expr: &Expression) -> Vec<&Expression> {
             last_chunk,
         } => vec![context, last_chunk],
         Expression::Sighash { hash_type } => vec![hash_type],
+        Expression::Digest { data, hash_type } => vec![data, hash_type],
         Expression::Negate { value } => vec![value],
         Expression::ModExp {
             base,