Minor improvments for util & rlp (#57)

* minor improvments

* fixes & format

* refactor

* more

* cleanups

* update & fixes

* more refactoring

* use copy instead loop for u8ArrToUintArr

* simplify hash

Author: MaxGraey

assembly/rlp.ts

@@ -29,8 +29,8 @@ export function decodeAccount(buf: Uint8Array): Array<Uint8Array> {
   } else if (nonceLen <= 0x7f) {
     nonce = buf.subarray(2, 3)
   } else {
-    nonce = buf.subarray(3, 3 + nonceLen - 0x80)
     offset = 3 + nonceLen - 0x80
+    nonce = buf.subarray(3, offset)
   }
 
   let balance: Uint8Array
@@ -39,12 +39,14 @@ export function decodeAccount(buf: Uint8Array): Array<Uint8Array> {
     balance = new Uint8Array(0)
     offset++
   } else if (balanceFirstByte <= 0x7f) {
-    balance = buf.subarray(offset, offset + 1)
-    offset++
+    let end = offset + 1
+    balance = buf.subarray(offset, end)
+    offset = end
   } else {
     offset++
-    balance = buf.subarray(offset, offset + balanceFirstByte - 0x80)
-    offset = offset + balanceFirstByte - 0x80
+    let end = offset + balanceFirstByte - 0x80
+    balance = buf.subarray(offset, end)
+    offset = end
   }
 
   // stateRoot and codeHash are 32 byte hashes
@@ -194,7 +196,7 @@ export function hashBranch(children: Array<Uint8Array | null>): Uint8Array {
   }
 
   // How many bytes do we need to encode length?
-  let lenOfLen = dataLen > 255 ? 2 : 1
+  let lenOfLen = 1 + i32(dataLen > 255)
   let totalLen = 1 + lenOfLen + dataLen
   let buf = new Uint8Array(totalLen)
   let offset = 0
@@ -265,13 +267,14 @@ export function hashBranchNode(branchNodeChildren: Array<usize>): usize {
   // bytes for hashes = len(0xa0 + hash) = 33*branch_num_children
   // bytes for empty nodes (0x80) = (17 - branch_num_children)
 
-  let child_indexes = Array.create<u8>(17)
-  let child_hash_ptrs = Array.create<usize>(17)
+  let child_indexes = new Array<u8>()
+  let child_hash_ptrs = new Array<usize>()
   for (let i = 0; i < 17; i++) {
     // read child index
-    if (branchNodeChildren[i] > 0) {
+    let branchNodeChild = branchNodeChildren[i]
+    if (branchNodeChild > 0) {
       child_indexes.push(i as u8)
-      child_hash_ptrs.push(branchNodeChildren[i])
+      child_hash_ptrs.push(branchNodeChild)
     }
   }
 
@@ -396,10 +399,11 @@ export class Decoded {
  * @param base The base to parse the integer into
  */
 function safeParseInt(v: string, base: u32): u32 {
-  if (v.slice(0, 2) == '00') {
+  // v.slice(0, 2) == '00'
+  if (v.charCodeAt(0) == 0x30 && v.charCodeAt(1) == 0x30) {
     throw new Error('invalid RLP: extra zeros')
   }
-  return I32.parseInt(v, base) as u32
+  return <u32>I32.parseInt(v, base)
 }
 
 /** Transform an integer into its hexadecimal value */
@@ -412,16 +416,16 @@ function intToHex(integer: u32): string {
     res.push(hexAlphabet[r])
   } while (integer)
   let hex = res.reverse().join('')
-  return hex.length % 2 ? '0' + hex : hex
+  return hex.length & 1 ? '0' + hex : hex
 }
 
 function bytesToHex(bytes: Uint8Array): string {
   let len = bytes.length
   let res = new Uint8Array(len * 2)
   for (let i = 0; i < len; i++) {
     let hex = intToHex(bytes[i])
-    res[i * 2 + 0] = hex.charCodeAt(0)
-    res[i * 2 + 1] = hex.charCodeAt(1)
+    unchecked((res[i * 2 + 0] = hex.charCodeAt(0)))
+    unchecked((res[i * 2 + 1] = hex.charCodeAt(1)))
   }
   return String.UTF8.decodeUnsafe(res.dataStart as usize, res.byteLength)
 }
@@ -434,16 +438,18 @@ function hexToBytes(hex: string): Uint8Array {
   let byteLength = hex.length / 2
   let res = new Uint8Array(byteLength)
   for (let i = 0; i < byteLength; i++) {
-    res[i] = I32.parseInt(hex.substring(i * 2, 2), 16) as u8
+    res[i] = U8.parseInt(hex.substring(i * 2, 2), 16)
   }
   return res
 }
 
 function concatUint8Array(arr1: Uint8Array, arr2: Uint8Array): Uint8Array {
-  let len = arr1.byteLength + arr2.byteLength
-  let res = new Uint8Array(len)
-  memory.copy(res.dataStart as usize, arr1.dataStart as usize, arr1.byteLength)
-  memory.copy((res.dataStart as usize) + arr1.byteLength, arr2.dataStart as usize, arr2.byteLength)
+  let len1 = arr1.byteLength
+  let len2 = arr2.byteLength
+  let res = new Uint8Array(len1 + len2)
+  let dst = res.dataStart as usize
+  memory.copy(dst, arr1.dataStart as usize, len1)
+  memory.copy(dst + len1, arr2.dataStart as usize, len2)
   return res
 }
 
@@ -468,11 +474,11 @@ function concatUint8Arrays(arrays: Array<Uint8Array>): Uint8Array {
  **/
 export function encode(input: RLPData): Uint8Array {
   let children = input.children
-  if (children.length) {
-    let output = new Array<Uint8Array>()
-    output.push(new Uint8Array(0))
+  let len = children.length
+  if (len) {
+    let output = [new Uint8Array(0)]
     let totalLen = 0
-    for (let i = 0, len = children.length; i < len; i++) {
+    for (let i = 0; i < len; i++) {
       let e = encode(children[i])
       output.push(e)
       totalLen += output[i + 1].byteLength
@@ -482,12 +488,13 @@ export function encode(input: RLPData): Uint8Array {
   } else {
     //debug_mem((input.buffer.buffer as usize) + input.buffer.byteOffset, input.buffer.byteLength);
     let inputBuffer = input.buffer
-    if (inputBuffer.length == 1 && inputBuffer[0] < 128) {
+    len = inputBuffer.length
+    if (len == 1 && inputBuffer[0] < 128) {
       return inputBuffer
     }
-    let len_encoded = encodeLength(inputBuffer.length, 128)
-    //debug_mem(len_encoded.dataStart, len_encoded.byteLength);
-    return concatUint8Array(len_encoded, inputBuffer)
+    let encodedLen = encodeLength(len, 128)
+    //debug_mem(len_encoded.dataStart, encodedLen.byteLength);
+    return concatUint8Array(encodedLen, inputBuffer)
   }
 }
 
@@ -505,12 +512,12 @@ function encodeLength(len: u32, offset: u32): Uint8Array {
       let int_as_bytes = new Uint8Array(2)
       //let int_view = DataView.wrap(int_as_bytes.buffer, 0, 2);
       let int_view = new DataView(int_as_bytes.buffer, 0, 2)
-      int_view.setUint16(0, int as u16, false)
+      int_view.setUint16(0, int as u16)
       return int_as_bytes
     }
     throw new Error('longer lengths unsupported')
-    //return hexToBytes(intToHex(len + offset));
-    return hexToBytes(intToHex(len + offset))
+    // return hexToBytes(intToHex(len + offset));
+    // return hexToBytes(intToHex(len + offset))
   } else {
     /*
         let hexLength = intToHex(len);
@@ -529,7 +536,7 @@ function encodeLength(len: u32, offset: u32): Uint8Array {
       lLength = 2
       len_as_bytes = new Uint8Array(2)
       let len_view = new DataView(len_as_bytes.buffer, 0, 2)
-      len_view.setUint16(0, len as u16, false)
+      len_view.setUint16(0, len as u16)
     } else {
       throw new Error('longer lengths unsupported')
     }
@@ -545,7 +552,7 @@ function encodeLength(len: u32, offset: u32): Uint8Array {
       firstByte_as_bytes = new Uint8Array(2)
       //let int_view = DataView.wrap(int_as_bytes.buffer, 0, 2);
       let int_view = new DataView(firstByte_as_bytes.buffer, 0, 2)
-      int_view.setUint16(0, firstByte as u16, false)
+      int_view.setUint16(0, firstByte as u16)
       //return int_as_bytes;
     } else {
       throw new Error('longer lengths unsupported')

assembly/token.ts

@@ -337,7 +337,7 @@ function verifyMultiproofAndUpdate(
   }
 
   // Verify given keys match computed paths
-  for (let i = 0; i < paths.length; i++) {
+  for (let i = 0, len = paths.length; i < len; i++) {
     let path = nibbleArrToUintArr(paths[i])
     if (cmpBuf(path, keys[i]) != 0) {
       throw new Error('invalid key')
@@ -369,9 +369,7 @@ function insertNewLeafNewBranch(
   // current_node.bodyrlp
 
   // pathStack could be smaller than 40
-  let pathStack = Array.create<usize>(40)
-  pathStack.push(prestate_root_hash_ptr)
-
+  let pathStack = [prestate_root_hash_ptr]
   for (let k_i = 0; k_i < 40; k_i++) {
     let branch_index_i = new_leaf_key_nibbles[k_i]
 
@@ -386,7 +384,7 @@ function insertNewLeafNewBranch(
       return
     } else if (currentNode.type == NodeType.Branch) {
       if (currentNode.branchBody.dirty == null) {
-        currentNode.branchBody.dirty = Array.create<u8>(16)
+        currentNode.branchBody.dirty = new Array<u8>()
 
         // setting the dirty flag to an empty array indicates that no children are dity but the branch node itself needs to be rehashed
         // explanation:
@@ -460,10 +458,10 @@ function createNewBranchWhereLeafExists(
     addHexPrefix(new_key_for_existing_leaf_nibbles, true),
   )
 
-  let new_node_for_existing_leaf_rlp_children = Array.create<RLPData>(2)
-
-  new_node_for_existing_leaf_rlp_children.push(new RLPData(null, Array.create<RLPData>(0)))
-  new_node_for_existing_leaf_rlp_children.push(new RLPData(null, Array.create<RLPData>(0)))
+  let new_node_for_existing_leaf_rlp_children = [
+    new RLPData(null, new Array<RLPData>()),
+    new RLPData(null, new Array<RLPData>()),
+  ]
   new_node_for_existing_leaf_rlp_children[0].buffer = new_key_for_existing_leaf
   new_node_for_existing_leaf_rlp_children[1].buffer = existing_leaf_value
   let new_node_for_existing_leaf_rlp = new RLPData(null, new_node_for_existing_leaf_rlp_children)
@@ -487,10 +485,10 @@ function createNewBranchWhereLeafExists(
   let branch_index_for_new_leaf = new_key_nibbles[k_i]
   let key_for_new_leaf = nibbleArrToUintArr(addHexPrefix(new_key_nibbles.slice(k_i + 1), true))
 
-  let node_for_new_leaf_rlp_children = Array.create<RLPData>(2)
-
-  node_for_new_leaf_rlp_children.push(new RLPData(null, Array.create<RLPData>(0)))
-  node_for_new_leaf_rlp_children.push(new RLPData(null, Array.create<RLPData>(0)))
+  let node_for_new_leaf_rlp_children = [
+    new RLPData(null, new Array<RLPData>()),
+    new RLPData(null, new Array<RLPData>()),
+  ]
   node_for_new_leaf_rlp_children[0].buffer = key_for_new_leaf
   node_for_new_leaf_rlp_children[1].buffer = new_leaf_account_rlp
   let node_for_new_leaf_rlp = new RLPData(null, node_for_new_leaf_rlp_children)
@@ -554,7 +552,7 @@ function rehashNode(staleHashPtr: usize): usize {
       throw new Error('ERROR: called rehash on a branch node that has no dirty flag')
     }
 
-    for (let i = 0; i < dirty_indexes.length; i++) {
+    for (let i = 0, len = dirty_indexes.length; i < len; i++) {
       let dirty_i = dirty_indexes[i]
       let stale_hash_for_dirty_child_ptr = node_with_stale_hash.branchBody.children[dirty_i]
       let new_hash_for_dirty_child_ptr = rehashNode(stale_hash_for_dirty_child_ptr)

assembly/util.ts

@@ -9,10 +9,7 @@ export function parseU8(buf: Uint8Array): u8 {
 export function bufEq(buf: Uint8Array, other: Uint8Array): boolean {
   let bufLen = buf.length
   if (bufLen != other.length) return false
-  for (let i = 0; i < bufLen; i++) {
-    if (unchecked(buf[i]) != unchecked(other[i])) return false
-  }
-  return true
+  return memory.compare(buf.dataStart as usize, other.dataStart as usize, bufLen) == 0
 }
 
 export function padBuf(buf: Uint8Array, length: usize): Uint8Array {
@@ -45,7 +42,7 @@ export function cmpBuf(buf: Uint8Array, other: Uint8Array): i32 {
 
 export function stripBuf(buf: Uint8Array): Uint8Array {
   let start = buf.length
-  for (let i = 0, len = buf.length; i < len; i++) {
+  for (let i = 0, len = start; i < len; i++) {
     if (unchecked(buf[i]) != 0) {
       start = i
       break
@@ -56,19 +53,16 @@ export function stripBuf(buf: Uint8Array): Uint8Array {
 
 @inline
 export function hash(buf: Uint8Array): Uint8Array {
-  let hashBuf = new ArrayBuffer(32)
+  let res = new Uint8Array(32)
   // @ts-ignore
-  ethash_keccak256(hashBuf as usize, buf.dataStart as usize, buf.byteLength)
-  return Uint8Array.wrap(hashBuf)
+  ethash_keccak256(res.dataStart as usize, buf.dataStart as usize, buf.byteLength)
+  return res
 }
 
+@inline
 export function removeHexPrefix(nib_arr: Array<u8>): Array<u8> {
   // the hex prefix is merkle-patricia-trie encoding, not RLP
-  if (nib_arr[0] & 1) {
-    return nib_arr.slice(1)
-  } else {
-    return nib_arr.slice(2)
-  }
+  return nib_arr.slice(1 + i32((nib_arr[0] & 1) == 0))
 }
 
 export function addHexPrefix(key_nib_arr: Array<u8>, terminator: bool): Array<u8> {
@@ -82,7 +76,7 @@ export function addHexPrefix(key_nib_arr: Array<u8>, terminator: bool): Array<u8
   }
 
   if (terminator) {
-    key_nib_arr[0] = key_nib_arr[0] + 2
+    key_nib_arr[0] += 2
   }
 
   return key_nib_arr
@@ -93,47 +87,38 @@ export function u8ArrToNibbleArr(u8_arr: Array<u8>): Array<u8> {
 
   let nib_arr = new Array<u8>(len * 2) // length is num of hex chars for address_hash
   // TODO: we might not need to convert the whole thing to nibbles, just enough chars to follow the path to the proof
-
-  let q = 0
   for (let i = 0; i < len; i++) {
-    q = i * 2
-    nib_arr[q] = u8_arr[i] >> 4
-    q = q + 1
-    nib_arr[q] = u8_arr[i] & 15
+    let byte = u8_arr[i]
+    nib_arr[(i << 1) + 0] = byte >> 4
+    nib_arr[(i << 1) + 1] = byte & 15
   }
-
   return nib_arr
 }
 
 export function uintArrToNibbleArr(uint_arr: Uint8Array): Array<u8> {
   let len = uint_arr.length
   let nib_arr = new Array<u8>(len * 2) // length is num of hex chars for address_hash
   // TODO: we might not need to convert the whole thing to nibbles, just enough chars to follow the path to the proof
-
-  let q = 0
   for (let i = 0; i < len; i++) {
-    q = i << 1
-    nib_arr[q] = uint_arr[i] >> 4
-    q = q + 1
-    nib_arr[q] = uint_arr[i] & 15
+    let byte = uint_arr[i]
+    nib_arr[(i << 1) + 0] = byte >> 4
+    nib_arr[(i << 1) + 1] = byte & 15
   }
-
   return nib_arr
 }
 
 export function nibbleArrToUintArr(arr: Array<u8>): Uint8Array {
-  let buf = new Uint8Array(arr.length / 2)
-  for (let i = 0, len = buf.length; i < len; i++) {
-    let q = i << 1
-    unchecked((buf[i] = (arr[q] << 4) + arr[++q]))
+  let len = arr.length / 2
+  let buf = new Uint8Array(len)
+  for (let i = 0; i < len; i++) {
+    unchecked((buf[i] = (arr[i << 1] << 4) + arr[(i << 1) + 1]))
   }
   return buf
 }
 
 export function u8ArrToUintArr(arr: Array<u8>): Uint8Array {
-  let buf = new Uint8Array(arr.length)
-  for (let i = 0, len = arr.length; i < len; i++) {
-    unchecked((buf[i] = arr[i]))
-  }
+  let len = arr.length
+  let buf = new Uint8Array(len)
+  memory.copy(buf.dataStart as usize, arr.dataStart as usize, len)
   return buf
 }