Softfork infrastructure and coinid operator

src/allocator.rs

@@ -121,6 +121,13 @@ impl Allocator {
     }
 
     pub fn restore_checkpoint(&mut self, cp: &Checkpoint) {
+        // if any of these asserts fire, it means we're trying to restore to
+        // a state that has already been "long-jumped" passed (via another
+        // restore to an earler state). You can only restore backwards in time,
+        // not forwards.
+        assert!(self.u8_vec.len() >= cp.u8s);
+        assert!(self.pair_vec.len() >= cp.pairs);
+        assert!(self.atom_vec.len() >= cp.atoms);
         self.u8_vec.truncate(cp.u8s);
         self.pair_vec.truncate(cp.pairs);
         self.atom_vec.truncate(cp.atoms);

src/chia_dialect.rs

@@ -1,12 +1,12 @@
 use crate::allocator::{Allocator, NodePtr};
 use crate::core_ops::{op_cons, op_eq, op_first, op_if, op_listp, op_raise, op_rest};
 use crate::cost::Cost;
-use crate::dialect::Dialect;
+use crate::dialect::{Dialect, Operators};
 use crate::err_utils::err;
 use crate::more_ops::{
-    op_add, op_all, op_any, op_ash, op_concat, op_div, op_divmod, op_gr, op_gr_bytes, op_logand,
-    op_logior, op_lognot, op_logxor, op_lsh, op_multiply, op_not, op_point_add, op_pubkey_for_exp,
-    op_sha256, op_softfork, op_strlen, op_substr, op_subtract, op_unknown,
+    op_add, op_all, op_any, op_ash, op_coinid, op_concat, op_div, op_divmod, op_gr, op_gr_bytes,
+    op_logand, op_logior, op_lognot, op_logxor, op_lsh, op_multiply, op_not, op_point_add,
+    op_pubkey_for_exp, op_sha256, op_strlen, op_substr, op_subtract, op_unknown,
 };
 use crate::reduction::Response;
 
@@ -21,6 +21,10 @@ pub const LIMIT_HEAP: u32 = 0x0004;
 // When set, enforce a stack size limit for CLVM programs
 pub const LIMIT_STACK: u32 = 0x0008;
 
+// When set, we allow softfork with extension 0 (which includes coinid and the
+// BLS operators). This remains disabled until the soft-fork activates
+pub const ENABLE_BLS_OPS: u32 = 0x0010;
+
 // The default mode when running grnerators in mempool-mode (i.e. the stricter
 // mode)
 pub const MEMPOOL_MODE: u32 = NO_UNKNOWN_OPS | LIMIT_HEAP | LIMIT_STACK;
@@ -56,12 +60,15 @@ impl Dialect for ChiaDialect {
         o: NodePtr,
         argument_list: NodePtr,
         max_cost: Cost,
+        extension: Operators,
     ) -> Response {
         let b = &allocator.atom(o);
         if b.len() != 1 {
             return unknown_operator(allocator, o, argument_list, self.flags, max_cost);
         }
         let f = match b[0] {
+            // 1 = quote
+            // 2 = apply
             3 => op_if,
             4 => op_cons,
             5 => op_first,
@@ -95,16 +102,19 @@ impl Dialect for ChiaDialect {
             33 => op_any,
             34 => op_all,
             // 35 ---
-            36 => {
-                if (self.flags & NO_UNKNOWN_OPS) != 0 {
-                    return err(o, "no softfork implemented");
-                } else {
-                    op_softfork
+            // 36 = softfork
+            _ => match extension {
+                Operators::BLS => match b[0] {
+                    48 => op_coinid,
+                    // TODO: add BLS operators here
+                    _ => {
+                        return unknown_operator(allocator, o, argument_list, self.flags, max_cost);
+                    }
+                },
+                _ => {
+                    return unknown_operator(allocator, o, argument_list, self.flags, max_cost);
                 }
-            }
-            _ => {
-                return unknown_operator(allocator, o, argument_list, self.flags, max_cost);
-            }
+            },
         };
         f(allocator, argument_list, max_cost)
     }
@@ -117,11 +127,38 @@ impl Dialect for ChiaDialect {
         &[2]
     }
 
+    fn softfork_kw(&self) -> &[u8] {
+        &[36]
+    }
+
+    // interpret the extension argument passed to the softfork operator, and
+    // return the Operators it enables (or None) if we don't know what it means
+    // We have to pretend that we don't know about the BLS extensions until
+    // after the soft-fork activation, which is controlled by the ENABLE_BLS_OPS
+    // flag
+    fn softfork_extension(&self, ext: u32) -> Operators {
+        match ext {
+            0 => {
+                if (self.flags & ENABLE_BLS_OPS) == 0 {
+                    Operators::None
+                } else {
+                    Operators::BLS
+                }
+            }
+            // new extensions go here
+            _ => Operators::None,
+        }
+    }
+
     fn stack_limit(&self) -> usize {
         if (self.flags & LIMIT_STACK) != 0 {
             20000000
         } else {
             usize::MAX
         }
     }
+
+    fn allow_unknown_ops(&self) -> bool {
+        (self.flags & NO_UNKNOWN_OPS) == 0
+    }
 }

src/dialect.rs

@@ -2,10 +2,26 @@ use crate::allocator::{Allocator, NodePtr};
 use crate::cost::Cost;
 use crate::reduction::Response;
 
+#[repr(u32)]
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub enum Operators {
+    None,
+    BLS,
+}
+
 pub trait Dialect {
     fn quote_kw(&self) -> &[u8];
     fn apply_kw(&self) -> &[u8];
-    fn op(&self, allocator: &mut Allocator, op: NodePtr, args: NodePtr, max_cost: Cost)
-        -> Response;
+    fn softfork_kw(&self) -> &[u8];
+    fn softfork_extension(&self, ext: u32) -> Operators;
+    fn op(
+        &self,
+        allocator: &mut Allocator,
+        op: NodePtr,
+        args: NodePtr,
+        max_cost: Cost,
+        extensions: Operators,
+    ) -> Response;
     fn stack_limit(&self) -> usize;
+    fn allow_unknown_ops(&self) -> bool;
 }

src/f_table.rs

@@ -6,7 +6,7 @@ use crate::cost::Cost;
 use crate::more_ops::{
     op_add, op_all, op_any, op_ash, op_concat, op_div, op_divmod, op_gr, op_gr_bytes, op_logand,
     op_logior, op_lognot, op_logxor, op_lsh, op_multiply, op_not, op_point_add, op_pubkey_for_exp,
-    op_sha256, op_softfork, op_strlen, op_substr, op_subtract,
+    op_sha256, op_strlen, op_substr, op_subtract,
 };
 use crate::reduction::Response;
 
@@ -15,7 +15,7 @@ type OpFn = fn(&mut Allocator, NodePtr, Cost) -> Response;
 pub type FLookup = [Option<OpFn>; 256];
 
 pub fn opcode_by_name(name: &str) -> Option<OpFn> {
-    let opcode_lookup: [(OpFn, &str); 30] = [
+    let opcode_lookup: [(OpFn, &str); 29] = [
         (op_if, "op_if"),
         (op_cons, "op_cons"),
         (op_first, "op_first"),
@@ -44,7 +44,6 @@ pub fn opcode_by_name(name: &str) -> Option<OpFn> {
         (op_not, "op_not"),
         (op_any, "op_any"),
         (op_all, "op_all"),
-        (op_softfork, "op_softfork"),
         (op_div, "op_div"),
     ];
     let name: &[u8] = name.as_ref();

src/more_ops.rs

@@ -13,7 +13,7 @@ use crate::err_utils::err;
 use crate::node::Node;
 use crate::number::{number_from_u8, ptr_from_number, Number};
 use crate::op_utils::{
-    arg_count, atom, check_arg_count, i32_atom, int_atom, two_ints, u32_from_u8, uint_atom,
+    arg_count, atom, check_arg_count, i32_atom, int_atom, two_ints, u32_from_u8,
 };
 use crate::reduction::{Reduction, Response};
 use crate::sha2::{Digest, Sha256};
@@ -85,6 +85,10 @@ const PUBKEY_BASE_COST: Cost = 1325730;
 // increased from 12 to closer model Raspberry PI
 const PUBKEY_COST_PER_BYTE: Cost = 38;
 
+// the new coinid operator
+const COINID_COST: Cost =
+    SHA256_BASE_COST + SHA256_COST_PER_ARG * 3 + SHA256_COST_PER_BYTE * (32 + 32 + 8);
+
 fn limbs_for_int(v: &Number) -> usize {
     ((v.bits() + 7) / 8) as usize
 }
@@ -786,23 +790,6 @@ pub fn op_all(a: &mut Allocator, input: NodePtr, max_cost: Cost) -> Response {
     Ok(Reduction(cost, total.node))
 }
 
-pub fn op_softfork(a: &mut Allocator, input: NodePtr, max_cost: Cost) -> Response {
-    let args = Node::new(a, input);
-    match args.pair() {
-        Some((p1, _)) => {
-            let cost = uint_atom::<8>(&p1, "softfork")?;
-            if cost > max_cost {
-                return args.err("cost exceeded");
-            }
-            if cost == 0 {
-                return args.err("cost must be > 0");
-            }
-            Ok(Reduction(cost, args.null().node))
-        }
-        _ => args.err("softfork takes at least 1 argument"),
-    }
-}
-
 lazy_static! {
     static ref GROUP_ORDER: Number = {
         let order_as_bytes = &[
@@ -877,3 +864,45 @@ pub fn op_point_add(a: &mut Allocator, input: NodePtr, max_cost: Cost) -> Respon
     let total: G1Affine = total.into();
     new_atom_and_cost(a, cost, &total.to_compressed())
 }
+
+pub fn op_coinid(a: &mut Allocator, input: NodePtr, _max_cost: Cost) -> Response {
+    let args = Node::new(a, input);
+    check_arg_count(&args, 3, "coinid")?;
+
+    let parent_coin = atom(args.first()?, "coinid")?;
+    if parent_coin.len() != 32 {
+        return args.err("coinid: invalid parent coin id (must be 32 bytes)");
+    }
+    let args = args.rest()?;
+    let puzzle_hash = atom(args.first()?, "coinid")?;
+    if puzzle_hash.len() != 32 {
+        return args.err("coinid: invalid puzzle hash (must be 32 bytes)");
+    }
+    let args = args.rest()?;
+    let amount = atom(args.first()?, "coinid")?;
+    if !amount.is_empty() {
+        if (amount[0] & 0x80) != 0 {
+            return args.err("coinid: invalid amount (may not be negative");
+        }
+        if amount == [0_u8] || (amount.len() > 1 && amount[0] == 0 && (amount[1] & 0x80) == 0) {
+            return args.err("coinid: invalid amount (may not have redundant leading zero)");
+        }
+        // the only valid coin value that's 9 bytes is when a leading zero is
+        // required to not have the value interpreted as negative
+        if amount.len() > 9 || (amount.len() == 9 && amount[0] != 0) {
+            return args.err("coinid: invalid amount (may not exceed max coin amount)");
+        }
+    }
+
+    let mut hasher = Sha256::new();
+    hasher.update(parent_coin);
+    hasher.update(puzzle_hash);
+    hasher.update(amount);
+    let ret: [u8; 32] = hasher
+        .finalize()
+        .as_slice()
+        .try_into()
+        .expect("sha256 hash is not 32 bytes");
+    let ret = a.new_atom(&ret)?;
+    Ok(Reduction(COINID_COST, ret))
+}