Tweak interface to have separate files for different bytearray hash sizes

Author: MicroProofs

lib/aiken/crypto/bitwise.ak

@@ -0,0 +1,135 @@
+use aiken/builtin
+
+pub opaque type State<t> {
+  inner: Int,
+}
+
+pub const zero_intermediary = State { inner: 0 }
+
+pub const one_intermediary = State { inner: 1 }
+
+pub fn add_bits(scalar: Int, big_endian: Bool) {
+  fn(intermediate: State<t>, bytes: ByteArray) -> State<t> {
+    builtin.bytearray_to_integer(big_endian, bytes)
+      |> builtin.add_integer(intermediate.inner)
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn add_int(scalar: Int) {
+  fn(intermediate: State<t>, int: Int) -> State<t> {
+    intermediate.inner + int
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn add_intermediary(scalar: Int) {
+  fn(intermediate: State<t>, other: State<t>) -> State<t> {
+    intermediate.inner + other.inner
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn sub_bits(scalar: Int, big_endian: Bool) {
+  fn(intermediate: State<t>, bytes: ByteArray) -> State<t> {
+    builtin.bytearray_to_integer(big_endian, bytes)
+      |> builtin.subtract_integer(intermediate.inner)
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn sub_int(scalar: Int) {
+  fn(intermediate: State<t>, int: Int) -> State<t> {
+    intermediate.inner - int
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn sub_intermediary(scalar: Int) {
+  fn(intermediate: State<t>, other: State<t>) -> State<t> {
+    intermediate.inner - other.inner
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn mul_bits(scalar: Int, big_endian: Bool) {
+  fn(intermediate: State<t>, bytes: ByteArray) -> State<t> {
+    builtin.bytearray_to_integer(big_endian, bytes)
+      |> builtin.multiply_integer(intermediate.inner)
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn mul_int(scalar: Int) {
+  fn(intermediate: State<t>, int: Int) -> State<t> {
+    intermediate.inner * int
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn mul_intermediary(scalar: Int) {
+  fn(intermediate: State<t>, other: State<t>) -> State<t> {
+    intermediate.inner * other.inner
+      |> builtin.mod_integer(scalar)
+      |> State
+  }
+}
+
+pub fn scale(self: State<t>, e: Int, scalar: Int) -> State<t> {
+  if e < 0 {
+    zero_intermediary
+  } else if e == 0 {
+    one_intermediary
+  } else if e % 2 == 0 {
+    scale(mul_intermediary(scalar)(self, self), e / 2, scalar)
+  } else {
+    mul_intermediary(scalar)(
+      self,
+      scale(mul_intermediary(scalar)(self, self), ( e - 1 ) / 2, scalar),
+    )
+  }
+}
+
+/// A faster version of `scale` for the case where the exponent is a power of two.
+/// That is, the exponent `e = 2^k` for some non-negative integer `k`. Which is used alot in zk-SNARKs.
+pub fn scale2(scalar: Int) {
+  fn(self: State<t>, k: Int) -> State<t> {
+    if k == 0 {
+      self
+    } else {
+      do_scale2(mul_intermediary(scalar)(self, self), k - 1, scalar)
+    }
+  }
+}
+
+fn do_scale2(self: State<t>, k: Int, scalar) -> State<t> {
+  if k == 0 {
+    self
+  } else {
+    do_scale2(mul_intermediary(scalar)(self, self), k - 1, scalar)
+  }
+}
+
+pub fn neg(scalar: Int) {
+  fn(intermediate: State<t>) -> State<t> {
+    scalar - intermediate.inner
+      |> State
+  }
+}
+
+pub fn to_int(intermediate: State<t>) -> Int {
+  intermediate.inner
+}
+
+pub fn from_int(int: Int, field: Int) -> State<t> {
+  int % field
+    |> State
+}

lib/aiken/crypto/int224.ak

@@ -0,0 +1,89 @@
+use aiken/builtin
+use aiken/crypto/bitwise.{
+  State, add_bits as addbit, add_int as addint, mul_bits as mulbit,
+  mul_int as mulint, neg as negbit, sub_bits as subbit, sub_int as subint,
+}
+
+pub type Hash224 =
+  ByteArray
+
+pub const hash224_field =
+  builtin.replicate_byte(28, 0)
+    |> builtin.cons_bytearray(1, _)
+    |> builtin.bytearray_to_integer(True, _)
+
+pub fn to_bytes(intermediate: State<Hash224>) -> ByteArray {
+  bitwise.to_int(intermediate)
+    |> builtin.integer_to_bytearray(True, 28, _)
+}
+
+pub fn to_int(intermediate: State<Hash224>) -> Int {
+  bitwise.to_int(intermediate)
+}
+
+pub fn from_bytes(bytes: Hash224) -> State<Hash224> {
+  bytes
+    |> builtin.bytearray_to_integer(True, _)
+    |> bitwise.from_int(hash224_field)
+}
+
+pub fn from_int(int: Int) -> State<Hash224> {
+  bitwise.from_int(int, hash224_field)
+}
+
+type Bitwise224Bytes =
+  fn(State<Hash224>, ByteArray) -> State<Hash224>
+
+type Bitwise224Int =
+  fn(State<Hash224>, Int) -> State<Hash224>
+
+const add_bit224: Bitwise224Bytes = addbit(hash224_field, True)
+
+pub fn add_bytes(
+  intermediate: State<Hash224>,
+  bytes: ByteArray,
+) -> State<Hash224> {
+  add_bit224(intermediate, bytes)
+}
+
+const add_i224: Bitwise224Int = addint(hash224_field)
+
+pub fn add_int(intermediate: State<Hash224>, int: Int) -> State<Hash224> {
+  add_i224(intermediate, int)
+}
+
+const sub_i224: Bitwise224Int = subint(hash224_field)
+
+pub fn sub_int(intermediate: State<Hash224>, int: Int) -> State<Hash224> {
+  sub_i224(intermediate, int)
+}
+
+const sub_bit224: Bitwise224Bytes = subbit(hash224_field, True)
+
+pub fn sub_bytes(
+  intermediate: State<Hash224>,
+  bytes: ByteArray,
+) -> State<Hash224> {
+  sub_bit224(intermediate, bytes)
+}
+
+const mul_bit224: Bitwise224Bytes = mulbit(hash224_field, True)
+
+pub fn mul_bytes(
+  intermediate: State<Hash224>,
+  bytes: ByteArray,
+) -> State<Hash224> {
+  mul_bit224(intermediate, bytes)
+}
+
+const mul_i224: Bitwise224Int = mulint(hash224_field)
+
+pub fn mul_int(intermediate: State<Hash224>, int: Int) -> State<Hash224> {
+  mul_i224(intermediate, int)
+}
+
+const neg224: fn(State<Hash224>) -> State<Hash224> = negbit(hash224_field)
+
+pub fn neg(intermediate: State<Hash224>) -> State<Hash224> {
+  neg224(intermediate)
+}

lib/aiken/crypto/int256.ak

@@ -0,0 +1,89 @@
+use aiken/builtin
+use aiken/crypto/bitwise.{
+  State, add_bits as addbit, add_int as addint, mul_bits as mulbit,
+  mul_int as mulint, neg as negbit, sub_bits as subbit, sub_int as subint,
+}
+
+pub type Hash256 =
+  ByteArray
+
+pub const hash256_field =
+  builtin.replicate_byte(32, 0)
+    |> builtin.cons_bytearray(1, _)
+    |> builtin.bytearray_to_integer(True, _)
+
+pub fn to_bytes(intermediate: State<Hash256>) -> ByteArray {
+  bitwise.to_int(intermediate)
+    |> builtin.integer_to_bytearray(True, 32, _)
+}
+
+pub fn to_int(intermediate: State<Hash256>) -> Int {
+  bitwise.to_int(intermediate)
+}
+
+pub fn from_bytes(bytes: Hash256) -> State<Hash256> {
+  bytes
+    |> builtin.bytearray_to_integer(True, _)
+    |> bitwise.from_int(hash256_field)
+}
+
+pub fn from_int(int: Int) -> State<Hash256> {
+  bitwise.from_int(int, hash256_field)
+}
+
+type Bitwise256Bytes =
+  fn(State<Hash256>, ByteArray) -> State<Hash256>
+
+type Bitwise256Int =
+  fn(State<Hash256>, Int) -> State<Hash256>
+
+const add_bit256: Bitwise256Bytes = addbit(hash256_field, True)
+
+pub fn add_bytes(
+  intermediate: State<Hash256>,
+  bytes: ByteArray,
+) -> State<Hash256> {
+  add_bit256(intermediate, bytes)
+}
+
+const add_i256: Bitwise256Int = addint(hash256_field)
+
+pub fn add_int(intermediate: State<Hash256>, int: Int) -> State<Hash256> {
+  add_i256(intermediate, int)
+}
+
+const sub_i256: Bitwise256Int = subint(hash256_field)
+
+pub fn sub_int(intermediate: State<Hash256>, int: Int) -> State<Hash256> {
+  sub_i256(intermediate, int)
+}
+
+const sub_bit256: Bitwise256Bytes = subbit(hash256_field, True)
+
+pub fn sub_bytes(
+  intermediate: State<Hash256>,
+  bytes: ByteArray,
+) -> State<Hash256> {
+  sub_bit256(intermediate, bytes)
+}
+
+const mul_bit256: Bitwise256Bytes = mulbit(hash256_field, True)
+
+pub fn mul_bytes(
+  intermediate: State<Hash256>,
+  bytes: ByteArray,
+) -> State<Hash256> {
+  mul_bit256(intermediate, bytes)
+}
+
+const mul_i256: Bitwise256Int = mulint(hash256_field)
+
+pub fn mul_int(intermediate: State<Hash256>, int: Int) -> State<Hash256> {
+  mul_i256(intermediate, int)
+}
+
+const neg256: fn(State<Hash256>) -> State<Hash256> = negbit(hash256_field)
+
+pub fn neg(intermediate: State<Hash256>) -> State<Hash256> {
+  neg256(intermediate)
+}

lib/aiken/math/bitwise.tests.ak renamed to lib/aiken/crypto/int256.tests.ak

@@ -1,14 +1,14 @@
-use aiken/math/bitwise.{add_bits256, bits256_to_intermediary, to_bits256}
+use aiken/crypto/int256.{add_bytes, from_bytes, to_bytes}
 
 test equal_pad_for_addition() {
   let a: ByteArray = #"acab"
   let b: ByteArray = #"cafe"
 
   let x =
     a
-      |> bits256_to_intermediary
-      |> add_bits256(b)
-      |> to_bits256
+      |> from_bytes
+      |> add_bytes(b)
+      |> to_bytes
 
   x == #"00000000000000000000000000000000000000000000000000000000000177a9"
 }
@@ -19,9 +19,9 @@ test unequal_pad_for_addition() {
 
   let x =
     a
-      |> bits256_to_intermediary
-      |> add_bits256(b)
-      |> to_bits256
+      |> from_bytes
+      |> add_bytes(b)
+      |> to_bytes
 
   x == #"0000000000000000000000000000000000000000000000000000acabbef0c5cc"
 }