deploy: 29d69b98cbbb3a8071c5f3ad7ef1a3cf7aa36f1e

.update.timestamp

@@ -1 +1 @@
-1616486691
+1616606816

tests/v2/test_waku_rln_relay.nim

@@ -180,8 +180,15 @@ procSuite "Waku rln relay":
       ethAccountAddress = accounts[9]
     await web3.close()
 
+    # create an RLN instance
+    var 
+      ctx = RLN[Bn256]()
+      ctxPtr = addr(ctx)
+      ctxPtrPtr = addr(ctxPtr)
+    doAssert(createRLNInstance(32, ctxPtrPtr))
+
     # generate the membership keys
-    let membershipKeyPair = membershipKeyGen()
+    let membershipKeyPair = membershipKeyGen(ctxPtrPtr[])
     
     check:
       membershipKeyPair.isSome
@@ -219,8 +226,9 @@ procSuite "Waku rln relay":
 
     await node.stop()
 
+
 suite "Waku rln relay":
-  test "Keygen Nim Wrappers":
+  test "key_gen Nim Wrappers":
     var 
       merkleDepth: csize_t = 32
       # parameters.key contains the parameters related to the Poseidon hasher
@@ -231,25 +239,27 @@ suite "Waku rln relay":
       parameters = readFile("waku/v2/protocol/waku_rln_relay/parameters.key")
       pbytes = parameters.toBytes()
       len : csize_t = uint(pbytes.len)
-      parametersBuffer = Buffer(`ptr`: unsafeAddr(pbytes[0]), len: len)
+      parametersBuffer = Buffer(`ptr`: addr(pbytes[0]), len: len)
     check:
       # check the parameters.key is not empty
       pbytes.len != 0
 
     # ctx holds the information that is going to be used for  the key generation
     var 
-      obj = RLNBn256()
+      obj = RLN[Bn256]()
-      objPtr = unsafeAddr(obj)
+      objPtr = addr(obj)
-      ctx = objPtr
+      objptrptr = addr(objPtr)
-    let res = newCircuitFromParams(merkleDepth, unsafeAddr parametersBuffer, ctx)
+      ctx = objptrptr
+    let res = new_circuit_from_params(merkleDepth, addr parametersBuffer, ctx)
     check:
       # check whether the circuit parameters are generated successfully
       res == true
 
     # keysBufferPtr will hold the generated key pairs i.e., secret and public keys 
     var 
-      keysBufferPtr : Buffer
+      keysBuffer : Buffer
-      done = keyGen(ctx, keysBufferPtr) 
+      keysBufferPtr = addr(keysBuffer)
+      done = key_gen(ctx[], keysBufferPtr) 
     check:
       # check whether the keys are generated successfully
       done == true
@@ -262,7 +272,14 @@ suite "Waku rln relay":
       debug "generated keys: ", generatedKeys 
       
   test "membership Key Gen":
-    var key = membershipKeyGen()
+    # create an RLN instance
+    var 
+      ctx = RLN[Bn256]()
+      ctxPtr = addr(ctx)
+      ctxPtrPtr = addr(ctxPtr)
+    doAssert(createRLNInstance(32, ctxPtrPtr))
+
+    var key = membershipKeyGen(ctxPtrPtr[])
     var empty : array[32,byte]
     check:
       key.isSome
@@ -272,3 +289,134 @@ suite "Waku rln relay":
       key.get().publicKey != empty
     
     debug "the generated membership key pair: ", key 
+  
+  test "get_root Nim binding":
+    # create an RLN instance which also includes an empty Merkle tree
+    var 
+      ctx = RLN[Bn256]()
+      ctxPtr = addr(ctx)
+      ctxPtrPtr = addr(ctxPtr)
+    doAssert(createRLNInstance(32, ctxPtrPtr))
+
+    # read the Merkle Tree root
+    var 
+      root1 {.noinit.} : Buffer = Buffer()
+      rootPtr1 = addr(root1)
+      get_root_successful1 = get_root(ctxPtrPtr[], rootPtr1)
+    doAssert(get_root_successful1)
+    doAssert(root1.len == 32)
+
+    # read the Merkle Tree root
+    var 
+      root2 {.noinit.} : Buffer = Buffer()
+      rootPtr2 = addr(root2)
+      get_root_successful2 = get_root(ctxPtrPtr[], rootPtr2)
+    doAssert(get_root_successful2)
+    doAssert(root2.len == 32)
+
+    var rootValue1 = cast[ptr array[32,byte]] (root1.`ptr`)
+    let rootHex1 = rootValue1[].toHex
+
+    var rootValue2 = cast[ptr array[32,byte]] (root2.`ptr`)
+    let rootHex2 = rootValue2[].toHex
+
+    # the two roots must be identical
+    doAssert(rootHex1 == rootHex2)
+
+  test "update_next_member Nim Wrapper":
+    # create an RLN instance which also includes an empty Merkle tree
+    var 
+      ctx = RLN[Bn256]()
+      ctxPtr = addr(ctx)
+      ctxPtrPtr = addr(ctxPtr)
+    doAssert(createRLNInstance(32, ctxPtrPtr))
+
+    # generate a key pair
+    var keypair = membershipKeyGen(ctxPtrPtr[])
+    doAssert(keypair.isSome())
+    var pkBuffer = Buffer(`ptr`: addr(keypair.get().publicKey[0]), len: 32)
+    let pkBufferPtr = addr pkBuffer
+
+    # add the member to the tree
+    var member_is_added = update_next_member(ctxPtrPtr[], pkBufferPtr)
+    check:
+      member_is_added == true
+      
+  test "delete_member Nim wrapper":
+    # create an RLN instance which also includes an empty Merkle tree
+    var 
+      ctx = RLN[Bn256]()
+      ctxPtr = addr(ctx)
+      ctxPtrPtr = addr(ctxPtr)
+    doAssert(createRLNInstance(32, ctxPtrPtr))
+
+    # delete the first member 
+    var deleted_member_index = uint(0)
+    let deletion_success = delete_member(ctxPtrPtr[], deleted_member_index)
+    doAssert(deletion_success)
+  
+  test "Merkle tree consistency check between deletion and insertion":
+    # create an RLN instance
+    var 
+      ctx = RLN[Bn256]()
+      ctxPtr = addr(ctx)
+      ctxPtrPtr = addr(ctxPtr)
+    doAssert(createRLNInstance(32, ctxPtrPtr))
+
+    # read the Merkle Tree root
+    var 
+      root1 {.noinit.} : Buffer = Buffer()
+      rootPtr1 = addr(root1)
+      get_root_successful1 = get_root(ctxPtrPtr[], rootPtr1)
+    doAssert(get_root_successful1)
+    doAssert(root1.len == 32)
+    
+    # generate a key pair
+    var keypair = membershipKeyGen(ctxPtrPtr[])
+    doAssert(keypair.isSome())
+    var pkBuffer = Buffer(`ptr`: addr(keypair.get().publicKey[0]), len: 32)
+    let pkBufferPtr = addr pkBuffer
+
+    # add the member to the tree
+    var member_is_added = update_next_member(ctxPtrPtr[], pkBufferPtr)
+    doAssert(member_is_added)
+
+    # read the Merkle Tree root after insertion
+    var 
+      root2 {.noinit.} : Buffer = Buffer()
+      rootPtr2 = addr(root2)
+      get_root_successful2 = get_root(ctxPtrPtr[], rootPtr2)
+    doAssert(get_root_successful2)
+    doAssert(root2.len == 32)
+
+    # delete the first member 
+    var deleted_member_index = uint(0)
+    let deletion_success = delete_member(ctxPtrPtr[], deleted_member_index)
+    doAssert(deletion_success)
+
+    # read the Merkle Tree root after the deletion
+    var 
+      root3 {.noinit.} : Buffer = Buffer()
+      rootPtr3 = addr(root3)
+      get_root_successful3 = get_root(ctxPtrPtr[], rootPtr3)
+    doAssert(get_root_successful3)
+    doAssert(root3.len == 32)
+
+    var rootValue1 = cast[ptr array[32,byte]] (root1.`ptr`)
+    let rootHex1 = rootValue1[].toHex
+    debug "The initial root", rootHex1
+
+    var rootValue2 = cast[ptr array[32,byte]] (root2.`ptr`)
+    let rootHex2 = rootValue2[].toHex
+    debug "The root after insertion", rootHex2
+
+    var rootValue3 = cast[ptr array[32,byte]] (root3.`ptr`)
+    let rootHex3 = rootValue3[].toHex
+    debug "The root after deletion", rootHex3
+
+    # the root must change after the insertion
+    doAssert(not(rootHex1 == rootHex2))
+
+    ## The initial root of the tree (empty tree) must be identical to 
+    ## the root of the tree after one insertion followed by a deletion
+    doAssert(rootHex1 == rootHex3)

vendor/nim-libbacktrace/vendor/libbacktrace-upstream/libtool

@@ -2,7 +2,7 @@
 
 # libtool - Provide generalized library-building support services.
 # Generated automatically by config.status (libbacktrace) version-unused
-# Libtool was configured on host fv-az193-323:
+# Libtool was configured on host fv-az129-143:
 # NOTE: Changes made to this file will be lost: look at ltmain.sh.
 #
 #   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,

waku/v2/node/wakunode2.nim

@@ -15,7 +15,7 @@ import
   ../protocol/waku_store/waku_store,
   ../protocol/waku_swap/waku_swap,
   ../protocol/waku_filter/waku_filter,
-  ../protocol/waku_rln_relay/waku_rln_relay_utils,
+  ../protocol/waku_rln_relay/[rln,waku_rln_relay_utils],
   ../utils/peers,
   ./message_store/message_store,
   ../utils/requests,
@@ -327,13 +327,21 @@ proc mountStore*(node: WakuNode, store: MessageStore = nil) =
   node.subscriptions.subscribe(WakuStoreCodec, node.wakuStore.subscription())
 
 proc mountRlnRelay*(node: WakuNode, ethClientAddress: Option[string] = none(string), ethAccountAddress: Option[Address] = none(Address), membershipContractAddress:  Option[Address] = none(Address)) {.async.} =
+  # TODO return a bool value to indicate the success of the call
   # check whether inputs are provided
   doAssert(ethClientAddress.isSome())
   doAssert(ethAccountAddress.isSome())
   doAssert(membershipContractAddress.isSome())
 
+  # create an RLN instance
+  var 
+    ctx = RLN[Bn256]()
+    ctxPtr = addr(ctx)
+    ctxPtrPtr = addr(ctxPtr)
+  doAssert(createRLNInstance(32, ctxPtrPtr))
+
   # generate the membership keys
-  let membershipKeyPair = membershipKeyGen()
+  let membershipKeyPair = membershipKeyGen(ctxPtrPtr[])
   # check whether keys are generated
   doAssert(membershipKeyPair.isSome())
   debug "the membership key for the rln relay is generated"

waku/v2/protocol/waku_rln_relay/rln.nim

@@ -2,9 +2,6 @@
 
 import os
 
-# librln.dylib is the rln library taken from https://github.com/kilic/rln (originally implemented in rust with an exposed C API)  
-# contains the key generation and other relevant functions
-
 
 const libPath = "vendor/rln/target/debug/"
 when defined(Windows):
@@ -14,58 +11,31 @@ elif defined(Linux):
 elif defined(MacOsX):
   const libName* = libPath / "librln.dylib"
 
-# Data types -----------------------------
-
-# pub struct Buffer {
-#     pub ptr: *const u8,
-#     pub len: usize,
-# }
-
-type
-  Buffer* = object
-    `ptr`*: pointer
-    len*: csize_t
-  RLNBn256* = object
-
-# Procedures ------------------------------
  # all the following procedures are Nim wrappers for the functions defined in libName
 {.push dynlib: libName.}
 
-# pub extern "C" fn new_circuit_from_params(
+type RLN*[E] {.incompleteStruct.} = object
-#     merkle_depth: usize,
+type Bn256* = pointer
-#     index: usize,
-#     parameters_buffer: *const Buffer,
-#     ctx: *mut *mut RLN<Bn256>,
-# ) -> bool
-proc newCircuitFromParams*(merkle_depth: csize_t, parameters_buffer: ptr Buffer, ctx: var  ptr RLNBn256): bool{.importc: "new_circuit_from_params".}
 
-# pub extern "C" fn key_gen(ctx: *const RLN<Bn256>, keypair_buffer: *mut Buffer) -> bool
+## Buffer struct is taken from
-proc keyGen*(ctx: ptr RLNBn256, keypair_buffer: var Buffer): bool {.importc: "key_gen".}
+# https://github.com/celo-org/celo-threshold-bls-rs/blob/master/crates/threshold-bls-ffi/src/ffi.rs
+type Buffer* = object
+  `ptr`*: ptr uint8
+  len*: uint
 
+proc key_gen*(ctx: ptr RLN[Bn256], keypair_buffer: ptr Buffer): bool {.importc: "key_gen".}
 
-# pub extern "C" fn hash(
+proc new_circuit_from_params*(merkle_depth: uint,
-#     ctx: *const RLN<Bn256>,
+                              parameters_buffer: ptr Buffer,
-#     inputs_buffer: *const Buffer,
+                              ctx: ptr (ptr RLN[Bn256])): bool {.importc: "new_circuit_from_params".}
-#     input_len: *const usize,
-#     output_buffer: *mut Buffer,
-# ) -> bool 
-proc hash*(ctx: ptr RLNBn256, inputs_buffer:ptr Buffer, input_len: ptr csize_t, output_buffer: ptr Buffer ) {.importc: "hash".} #TODO not tested yet
 
-# pub extern "C" fn verify(
+#------------------------------Merkle Tree operations -----------------------------------------
-#     ctx: *const RLN<Bn256>,
+proc update_next_member*(ctx: ptr RLN[Bn256],
-#     proof_buffer: *const Buffer,
+                         input_buffer: ptr Buffer): bool {.importc: "update_next_member".}
-#     public_inputs_buffer: *const Buffer,
-#     result_ptr: *mut u32,
-# ) -> bool
 
+proc delete_member*(ctx: ptr RLN[Bn256], index: uint): bool {.importc: "delete_member".}
 
-
+proc get_root*(ctx: ptr RLN[Bn256], output_buffer: ptr Buffer): bool {.importc: "get_root".}
-# pub extern "C" fn generate_proof(
+#----------------------------------------------------------------------------------------------
-#     ctx: *const RLN<Bn256>,
-#     input_buffer: *const Buffer,
-#     output_buffer: *mut Buffer,
-# ) -> bool
 
 {.pop.}
-
-

waku/v2/protocol/waku_rln_relay/waku_rln_relay_utils.nim

@@ -31,10 +31,12 @@ contract(MembershipContract):
   # TODO define a return type of bool for register method to signify a successful registration
   proc register(pubkey: Uint256) # external payable
 
-proc membershipKeyGen*(): Option[MembershipKeyPair] =
+proc createRLNInstance*(d: int, ctxPtrPtr: ptr (ptr RLN[Bn256])): bool = 
-  # generates a MembershipKeyPair that can be used for the registration into the rln membership contract
+  ## generates an instance of RLN 
+  ## An RLN instance supports both zkSNARKs logics and Merkle tree data structure and operations
+  ## d indicates the depth of Merkle tree 
   var  
-    merkleDepth: csize_t = 32
+    merkleDepth: csize_t = uint(d)
     # parameters.key contains the parameters related to the Poseidon hasher
     # to generate this file, clone this repo https://github.com/kilic/rln 
     # and run the following command in the root directory of the cloned project
@@ -43,29 +45,29 @@ proc membershipKeyGen*(): Option[MembershipKeyPair] =
     parameters = readFile("waku/v2/protocol/waku_rln_relay/parameters.key")
     pbytes = parameters.toBytes()
     len : csize_t = uint(pbytes.len)
-    parametersBuffer = Buffer(`ptr`: unsafeAddr(pbytes[0]), len: len)
+    parametersBuffer = Buffer(`ptr`: addr(pbytes[0]), len: len)
 
   # check the parameters.key is not empty
   if (pbytes.len == 0):
     debug "error in parameters.key"
-    return none(MembershipKeyPair)
+    return false
-    
-  # ctx holds the information that is going to be used for  the key generation
-  var 
-    obj = RLNBn256()
-    objPtr = unsafeAddr(obj)
-    ctx = objPtr
-  let res = newCircuitFromParams(merkleDepth, unsafeAddr parametersBuffer, ctx)
   
+  # create an instance of RLN
+  let res = new_circuit_from_params(merkleDepth, addr parametersBuffer, ctxPtrPtr)
   # check whether the circuit parameters are generated successfully
   if (res == false): 
     debug "error in parameters generation"
-    return none(MembershipKeyPair)
+    return false
+  return true
+
+proc membershipKeyGen*(ctxPtr: ptr RLN[Bn256]): Option[MembershipKeyPair] =
+  ## generates a MembershipKeyPair that can be used for the registration into the rln membership contract
     
   # keysBufferPtr will hold the generated key pairs i.e., secret and public keys 
   var 
-    keysBufferPtr : Buffer
+    keysBuffer : Buffer
-    done = keyGen(ctx, keysBufferPtr) 
+    keysBufferPtr = addr(keysBuffer)
+    done = key_gen(ctxPtr, keysBufferPtr)  
 
   # check whether the keys are generated successfully
   if(done == false):
@@ -78,9 +80,14 @@ proc membershipKeyGen*(): Option[MembershipKeyPair] =
     debug "the generated keys are invalid"
     return none(MembershipKeyPair)
   
+  # TODO define a separate proc to decode the generated keys to the secret and public components
+  var 
+    secret: array[32, byte] 
+    public: array[32, byte]
+  for (i,x) in secret.mpairs: x = generatedKeys[i]
+  for (i,x) in public.mpairs: x = generatedKeys[i+32]
+  
   var 
-    secret = cast[array[32, byte]](generatedKeys[0..31])
-    public = cast[array[32, byte]](generatedKeys[31..^1])
     keypair = MembershipKeyPair(secretKey: secret, publicKey: public)
 
   return some(keypair)