feat: update zkasm modules to latest versions (#827)

Author: DavePearce

exp/exp.zkasm

@@ -25,7 +25,7 @@ pub fn exp(INST=0xEE0A u16, ARG u256, CDS u6, EBS u6) -> (RES=0 u128)
 {
    var s, b u1
    var tmp u5
-   var log_word, zero, shift u8
+   var shift u8
    var shifted_word, filled_word u256
    ;;
    if INST == EXP_INST_EXPLOG goto explog
@@ -43,8 +43,7 @@ explog2:
    return
 modexplog:
    ;; fill as necessary
-   zero = 0
-   filled_word = fill_bytes_between(ARG, CDS, EBS, zero)
+   filled_word = fill_bytes_between(ARG, CDS, EBS, 0)
    ;; determine shift amount (in bits)
    s, b, shift = (32 - EBS) * 8
    ;; check precondition
@@ -53,9 +52,7 @@ modexplog:
    ;; shift right
    shifted_word = bit_shr256(filled_word,shift)
    ;; compute log
-   log_word = log2(shifted_word)
-   ;; cast
-   RES = log_word
+   RES = log2(shifted_word)
    ;;
    return
 failed_pre:

util/bit_shift.zkasm

@@ -2,7 +2,6 @@
 ;; implementation performs a decomposition on the shift, starting with
 ;; the most significant bit.
 fn bit_shl256(word u256, n u8) -> (res u256) {
-  var nword u256
   var lsw u128
   var msw u128
   var b u1
@@ -15,13 +14,11 @@ fn bit_shl256(word u256, n u8) -> (res u256) {
   return
 apply:
   msw, lsw = word
-  nword = lsw * 2^128
-  res = bit_shl256_u7(nword,m)
+  res = bit_shl256_u7(lsw * 2^128, m)
   return
 }
 
 fn bit_shl256_u7(word u256, n u7) -> (res u256) {
-  var nword u256
   var lsw u192
   var msw u64
   var b u1
@@ -34,13 +31,11 @@ fn bit_shl256_u7(word u256, n u7) -> (res u256) {
   return
 apply:
   msw, lsw = word
-  nword = lsw * 2^64
-  res = bit_shl256_u6(nword,m)
+  res = bit_shl256_u6(lsw * 2^64, m)
   return
 }
 
 fn bit_shl256_u6(word u256, n u6) -> (res u256) {
-  var nword u256
   var lsw u224
   var msw u32
   var b u1
@@ -53,13 +48,11 @@ fn bit_shl256_u6(word u256, n u6) -> (res u256) {
   return
 apply:
   msw, lsw = word
-  nword = lsw * 2^32
-  res = bit_shl256_u5(nword,m)
+  res = bit_shl256_u5(lsw * 2^32, m)
   return
 }
 
 fn bit_shl256_u5(word u256, n u5) -> (res u256) {
-  var nword u256
   var lsw u240
   var msw u16
   var b u1
@@ -72,13 +65,11 @@ fn bit_shl256_u5(word u256, n u5) -> (res u256) {
   return
 apply:
   msw, lsw = word
-  nword = lsw * 2^16
-  res = bit_shl256_u4(nword,m)
+  res = bit_shl256_u4(lsw * 2^16, m)
   return
 }
 
 fn bit_shl256_u4(word u256, n u4) -> (res u256) {
-  var nword u256
   var lsw u248
   var msw u8
   var b u1
@@ -91,13 +82,11 @@ fn bit_shl256_u4(word u256, n u4) -> (res u256) {
   return
 apply:
   msw, lsw = word
-  nword = lsw * 2^8
-  res = bit_shl256_u3(nword,m)
+  res = bit_shl256_u3(lsw * 2^8, m)
   return
 }
 
 fn bit_shl256_u3(word u256, n u3) -> (res u256) {
-  var nword u256
   var lsw u252
   var msw u4
   var b u1
@@ -110,13 +99,11 @@ fn bit_shl256_u3(word u256, n u3) -> (res u256) {
   return
 apply:
   msw, lsw = word
-  nword = lsw * 2^4
-  res = bit_shl256_u2(nword,m)
+  res = bit_shl256_u2(lsw * 2^4, m)
   return
 }
 
 fn bit_shl256_u2(word u256, n u2) -> (res u256) {
-  var nword u256
   var lsw u254
   var msw u2
   var b u1
@@ -129,8 +116,7 @@ fn bit_shl256_u2(word u256, n u2) -> (res u256) {
   return
 apply:
   msw, lsw = word
-  nword = lsw * 2^2
-  res = bit_shl256_u1(nword,m)
+  res = bit_shl256_u1(lsw * 2^2, m)
   return
 }
 

util/bit_shl.zkasm

@@ -1,6 +1,8 @@
-;; Bit_xoan is doing intermediate functions calls to split a u256 down to u1
+;; Bit_xoan is doing intermediate functions calls to split a u256 down
+;; to u1.
+;;
 ;; bit_xoan_u2 has the logic to discriminate between the instructions
-;; Used for Xor, Or, And, Not
+;; XOR, OR, AND, NOT
 
 const BIT_XOR = 0
 const BIT_OR  = 1

util/bit_xoan.zkasm

@@ -18,7 +18,6 @@ include "set_byte.zkasm"
 ;; end.  The key is that all other bytes remain unchanged.
 fn fill_bytes_between(word u256, start u6, end u6, value u8) -> (res u256) {
    var nword u256
-   var noffset u6
    var offset u5
    var s u1
    ;; check termination
@@ -29,10 +28,8 @@ fn fill_bytes_between(word u256, start u6, end u6, value u8) -> (res u256) {
    if s == 1 goto exit
    ;; set given byte
    nword = set_byte256(word, offset, value)
-   ;; increment offset
-   noffset = offset + 1
    ;; recurse
-   res = fill_bytes_between(nword, noffset, end, value)
+   res = fill_bytes_between(nword, offset+1, end, value)
    ;; done
    return
 exit:

util/fill_bytes.zkasm

@@ -2,15 +2,20 @@
 ;;
 ;; n = ( 31 - size )
 ;; Extend the sign of the nth byte on the range [0:n[ with n excluded
-;; if size == 0, sign of the 31th byte is extended from byte 0 to 30
+;; if size == 0, sign of the 31st byte is extended from byte 0 to 30
 ;; if size == 31, word stays unchanged
 ;;
 ;; Examples :
-;; size = 0, word = 0x80FF, res = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff (byte 30 is overridden)
-;; size = 1, word = 0x80FF, res = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80ff
-;; size = 2, word = 0x80FF, res = 0x80FF
-;;
-;; note : this function does not handle the case where size > 31, as it's handled at the module level
+;; (1)
+;; size = 0, word = 0x80FF
+;; res = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
+;; note : (byte 30 is overridden)
+;; (2)
+;; size = 1, word = 0x80FF
+;; res = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff80ff
+;; (3)
+;; size = 2, word = 0x80FF
+;; res = 0x80FF
 
 include "byte.zkasm"
 include "fill_bytes.zkasm"