Merge pull request #10 from pragma-org/jshy/builtins

Author: rvcas

Cargo.lock

@@ -14,7 +14,8 @@ publish = true
 blst = "0.3.13"
 bumpalo = { version = "3.16.0", features = ["collections"] }
 chumsky = { version = "=1.0.0-alpha.7", features = ["pratt"] }
-cryptoxide = "0.4.4"
+cryptoxide = { version = "0.4.4", features = ["ripemd160"] }
+hamming = "0.1.3"
 minicbor = { version = "0.25.1", features = ["std"] }
 num = "0.4.3"
 num-bigint = "0.4"

crates/uplc/Cargo.toml

@@ -98,6 +98,19 @@ pub enum DefaultFunction {
     // Bitwise
     IntegerToByteString = 73,
     ByteStringToInteger = 74,
+
+    AndByteString = 75,
+    OrByteString = 76,
+    XorByteString = 77,
+    ComplementByteString = 78,
+    ReadBit = 79,
+    WriteBits = 80,
+    ReplicateByte = 81,
+    ShiftByteString = 82,
+    RotateByteString = 83,
+    CountSetBits = 84,
+    FindFirstSetBit = 85,
+    Ripemd_160 = 86,
 }
 
 impl DefaultFunction {
@@ -178,6 +191,18 @@ impl DefaultFunction {
             DefaultFunction::Bls12_381_FinalVerify => 0,
             DefaultFunction::IntegerToByteString => 0,
             DefaultFunction::ByteStringToInteger => 0,
+            DefaultFunction::AndByteString => 0,
+            DefaultFunction::OrByteString => 0,
+            DefaultFunction::XorByteString => 0,
+            DefaultFunction::ComplementByteString => 0,
+            DefaultFunction::ReadBit => 0,
+            DefaultFunction::WriteBits => 0,
+            DefaultFunction::ReplicateByte => 0,
+            DefaultFunction::ShiftByteString => 0,
+            DefaultFunction::RotateByteString => 0,
+            DefaultFunction::CountSetBits => 0,
+            DefaultFunction::FindFirstSetBit => 0,
+            DefaultFunction::Ripemd_160 => 0,
         }
     }
 
@@ -258,6 +283,18 @@ impl DefaultFunction {
             DefaultFunction::Bls12_381_FinalVerify => 2,
             DefaultFunction::IntegerToByteString => 3,
             DefaultFunction::ByteStringToInteger => 2,
+            DefaultFunction::AndByteString => 3,
+            DefaultFunction::OrByteString => 3,
+            DefaultFunction::XorByteString => 3,
+            DefaultFunction::ComplementByteString => 1,
+            DefaultFunction::ReadBit => 2,
+            DefaultFunction::WriteBits => 3,
+            DefaultFunction::ReplicateByte => 2,
+            DefaultFunction::ShiftByteString => 2,
+            DefaultFunction::RotateByteString => 2,
+            DefaultFunction::CountSetBits => 1,
+            DefaultFunction::FindFirstSetBit => 1,
+            DefaultFunction::Ripemd_160 => 1,
         }
     }
 }

crates/uplc/src/builtin/default_function.rs

@@ -53,8 +53,7 @@ impl<'a, 'b> minicbor::decode::Decode<'b, Ctx<'a>> for &'a PlutusData<'a> {
                         }
                         _ => {
                             let e = minicbor::decode::Error::message(format!(
-                                "unknown tag for plutus data tag: {}",
-                                tag
+                                "unknown tag for plutus data tag: {tag}",
                             ));
 
                             Err(e)
@@ -76,7 +75,7 @@ impl<'a, 'b> minicbor::decode::Decode<'b, Ctx<'a>> for &'a PlutusData<'a> {
                             if x == IanaTag::PosBignum {
                                 num_bigint::Sign::Plus
                             } else {
-                                num_bigint::Sign::Plus
+                                num_bigint::Sign::Minus
                             },
                             &bytes,
                         ));

crates/uplc/src/flat/data.rs

@@ -93,6 +93,18 @@ pub struct BuiltinCosts {
     // bitwise
     integer_to_byte_string: ThreeArgumentsCosting,
     byte_string_to_integer: TwoArgumentsCosting,
+    and_byte_string: ThreeArgumentsCosting,
+    or_byte_string: ThreeArgumentsCosting,
+    xor_byte_string: ThreeArgumentsCosting,
+    complement_byte_string: OneArgumentCosting,
+    read_bit: TwoArgumentsCosting,
+    write_bits: ThreeArgumentsCosting,
+    replicate_byte: TwoArgumentsCosting,
+    shift_byte_string: TwoArgumentsCosting,
+    rotate_byte_string: TwoArgumentsCosting,
+    count_set_bits: OneArgumentCosting,
+    find_first_set_bit: OneArgumentCosting,
+    ripemd_160: OneArgumentCosting,
 }
 
 impl Default for BuiltinCosts {
@@ -568,6 +580,87 @@ impl BuiltinCosts {
         )
     }
 
+    pub fn and_byte_string(&self, args: [i64; 3]) -> ExBudget {
+        ExBudget::new(
+            self.and_byte_string.mem.cost(args),
+            self.and_byte_string.cpu.cost(args),
+        )
+    }
+
+    pub fn or_byte_string(&self, args: [i64; 3]) -> ExBudget {
+        ExBudget::new(
+            self.or_byte_string.mem.cost(args),
+            self.or_byte_string.cpu.cost(args),
+        )
+    }
+
+    pub fn xor_byte_string(&self, args: [i64; 3]) -> ExBudget {
+        ExBudget::new(
+            self.xor_byte_string.mem.cost(args),
+            self.xor_byte_string.cpu.cost(args),
+        )
+    }
+
+    pub fn complement_byte_string(&self, args: [i64; 1]) -> ExBudget {
+        ExBudget::new(
+            self.complement_byte_string.mem.cost(args),
+            self.complement_byte_string.cpu.cost(args),
+        )
+    }
+
+    pub fn read_bit(&self, args: [i64; 2]) -> ExBudget {
+        ExBudget::new(self.read_bit.mem.cost(args), self.read_bit.cpu.cost(args))
+    }
+
+    pub fn write_bits(&self, args: [i64; 3]) -> ExBudget {
+        ExBudget::new(
+            self.write_bits.mem.cost(args),
+            self.write_bits.cpu.cost(args),
+        )
+    }
+
+    pub fn replicate_byte(&self, args: [i64; 2]) -> ExBudget {
+        ExBudget::new(
+            self.replicate_byte.mem.cost(args),
+            self.replicate_byte.cpu.cost(args),
+        )
+    }
+
+    pub fn shift_byte_string(&self, args: [i64; 2]) -> ExBudget {
+        ExBudget::new(
+            self.shift_byte_string.mem.cost(args),
+            self.shift_byte_string.cpu.cost(args),
+        )
+    }
+
+    pub fn rotate_byte_string(&self, args: [i64; 2]) -> ExBudget {
+        ExBudget::new(
+            self.rotate_byte_string.mem.cost(args),
+            self.rotate_byte_string.cpu.cost(args),
+        )
+    }
+
+    pub fn count_set_bits(&self, args: [i64; 1]) -> ExBudget {
+        ExBudget::new(
+            self.count_set_bits.mem.cost(args),
+            self.count_set_bits.cpu.cost(args),
+        )
+    }
+
+    pub fn find_first_set_bit(&self, args: [i64; 1]) -> ExBudget {
+        ExBudget::new(
+            self.find_first_set_bit.mem.cost(args),
+            self.find_first_set_bit.cpu.cost(args),
+        )
+    }
+
+    pub fn ripemd_160(&self, args: [i64; 1]) -> ExBudget {
+        ExBudget::new(
+            self.ripemd_160.mem.cost(args),
+            self.ripemd_160.cpu.cost(args),
+        )
+    }
+
     pub fn v3() -> Self {
         Self {
             add_integer: TwoArgumentsCosting::new(
@@ -880,6 +973,54 @@ impl BuiltinCosts {
                 TwoArgumentsCosting::linear_in_y(0, 1),
                 TwoArgumentsCosting::quadratic_in_y(1006041, 43623, 251),
             ),
+            and_byte_string: ThreeArgumentsCosting::new(
+                ThreeArgumentsCosting::linear_in_max_y_z(0, 1),
+                ThreeArgumentsCosting::linear_in_y_and_z(100181, 726, 719),
+            ),
+            or_byte_string: ThreeArgumentsCosting::new(
+                ThreeArgumentsCosting::linear_in_max_y_z(0, 1),
+                ThreeArgumentsCosting::linear_in_y_and_z(100181, 726, 719),
+            ),
+            xor_byte_string: ThreeArgumentsCosting::new(
+                ThreeArgumentsCosting::linear_in_max_y_z(0, 1),
+                ThreeArgumentsCosting::linear_in_y_and_z(100181, 726, 719),
+            ),
+            complement_byte_string: OneArgumentCosting::new(
+                OneArgumentCosting::linear_cost(0, 1),
+                OneArgumentCosting::linear_cost(107878, 680),
+            ),
+            read_bit: TwoArgumentsCosting::new(
+                TwoArgumentsCosting::constant_cost(1),
+                TwoArgumentsCosting::constant_cost(95336),
+            ),
+            write_bits: ThreeArgumentsCosting::new(
+                ThreeArgumentsCosting::linear_in_x(0, 1),
+                ThreeArgumentsCosting::linear_in_y(281145, 18848),
+            ),
+            replicate_byte: TwoArgumentsCosting::new(
+                TwoArgumentsCosting::linear_in_x(1, 1),
+                TwoArgumentsCosting::linear_in_x(180194, 159),
+            ),
+            shift_byte_string: TwoArgumentsCosting::new(
+                TwoArgumentsCosting::linear_in_x(0, 1),
+                TwoArgumentsCosting::linear_in_x(158519, 8942),
+            ),
+            rotate_byte_string: TwoArgumentsCosting::new(
+                TwoArgumentsCosting::linear_in_x(0, 1),
+                TwoArgumentsCosting::linear_in_x(159378, 8813),
+            ),
+            count_set_bits: OneArgumentCosting::new(
+                OneArgumentCosting::constant_cost(1),
+                OneArgumentCosting::linear_cost(107490, 3298),
+            ),
+            find_first_set_bit: OneArgumentCosting::new(
+                OneArgumentCosting::constant_cost(1),
+                OneArgumentCosting::linear_cost(106057, 655),
+            ),
+            ripemd_160: OneArgumentCosting::new(
+                OneArgumentCosting::constant_cost(3),
+                OneArgumentCosting::linear_cost(1964219, 24520),
+            ),
         }
     }
 }

crates/uplc/src/machine/cost_model/builtin_costs.rs

@@ -204,11 +204,13 @@ impl Cost<2> for TwoArguments {
 pub enum ThreeArguments {
     ConstantCost(i64),
     // AddedSizes(AddedSizes),
-    // LinearInX(LinearSize),
+    LinearInX(LinearSize),
     LinearInY(LinearSize),
     LinearInZ(LinearSize),
     QuadraticInZ(QuadraticFunction),
     LiteralInYorLinearInZ(LinearSize),
+    LinearInYAndZ(TwoVariableLinearSize),
+    LinearInMaxYZ(LinearSize),
 }
 
 pub type ThreeArgumentsCosting = Costing<3, ThreeArguments>;
@@ -237,18 +239,34 @@ impl ThreeArgumentsCosting {
             coeff_2,
         })
     }
+
+    pub fn linear_in_y_and_z(intercept: i64, slope1: i64, slope2: i64) -> ThreeArguments {
+        ThreeArguments::LinearInYAndZ(TwoVariableLinearSize {
+            intercept,
+            slope1,
+            slope2,
+        })
+    }
+
+    pub fn linear_in_max_y_z(intercept: i64, slope: i64) -> ThreeArguments {
+        ThreeArguments::LinearInMaxYZ(LinearSize { intercept, slope })
+    }
+
+    pub fn linear_in_x(intercept: i64, slope: i64) -> ThreeArguments {
+        ThreeArguments::LinearInX(LinearSize { intercept, slope })
+    }
 }
 
 impl Cost<3> for ThreeArguments {
     fn cost(&self, args: [i64; 3]) -> i64 {
-        // let x = args[0];
+        let x = args[0];
         let y = args[1];
         let z = args[2];
 
         match self {
             ThreeArguments::ConstantCost(c) => *c,
             // ThreeArguments::AddedSizes(s) => (x + y + z) * s.slope + s.intercept,
-            // ThreeArguments::LinearInX(l) => x * l.slope + l.intercept,
+            ThreeArguments::LinearInX(l) => x * l.slope + l.intercept,
             ThreeArguments::LinearInY(l) => y * l.slope + l.intercept,
             ThreeArguments::LinearInZ(l) => z * l.slope + l.intercept,
             ThreeArguments::QuadraticInZ(q) => q.coeff_0 + (q.coeff_1 * z) + (q.coeff_2 * z * z),
@@ -259,6 +277,8 @@ impl Cost<3> for ThreeArguments {
                     y
                 }
             }
+            ThreeArguments::LinearInYAndZ(l) => y * l.slope1 + z * l.slope2 + l.intercept,
+            ThreeArguments::LinearInMaxYZ(l) => y.max(z) * l.slope + l.intercept,
         }
     }
 }
@@ -290,6 +310,13 @@ pub struct LinearSize {
     pub slope: i64,
 }
 
+#[derive(Debug, PartialEq)]
+pub struct TwoVariableLinearSize {
+    pub intercept: i64,
+    pub slope1: i64,
+    pub slope2: i64,
+}
+
 #[derive(Debug, PartialEq)]
 pub struct AddedSizes {
     pub intercept: i64,