mirror of https://github.com/waku-org/nwaku.git
refactor(rln): remove kilic lib (#1365)
* refactor(rln): remove kilic lib * chore(rln): address reviewerS
This commit is contained in:
G
GitHub
parent
b07cdb1841
commit
63137f3e2a
24
Makefile
24
Makefile
|
|
@ -116,7 +116,7 @@ deps: | libbacktrace
|
|||
endif
|
||||
|
||||
# Waku v2-only dependencies
|
||||
deps2: | rlnlib rlnzerokitlib
|
||||
deps2: | rlnlib
|
||||
|
||||
|
||||
#- deletes and recreates "waku.nims" which on Windows is a copy instead of a proper symlink
|
||||
|
|
@ -203,12 +203,8 @@ docs: | build deps
|
|||
|
||||
# control rln code compilation
|
||||
ifeq ($(RLN), true)
|
||||
NIM_PARAMS := $(NIM_PARAMS) -d:rlnzerokit
|
||||
NIM_PARAMS := $(NIM_PARAMS) -d:rln
|
||||
else ifeq ($(CI), true)
|
||||
NIM_PARAMS := $(NIM_PARAMS) -d:rlnzerokit
|
||||
endif
|
||||
|
||||
ifeq ($(RLNKILIC), true)
|
||||
NIM_PARAMS := $(NIM_PARAMS) -d:rln
|
||||
endif
|
||||
|
||||
|
|
@ -220,14 +216,6 @@ NIM_PARAMS := $(NIM_PARAMS) -d:onchain_rln
|
|||
endif
|
||||
|
||||
rlnlib:
|
||||
ifeq ($(RLNKILIC), true)
|
||||
cargo build --manifest-path vendor/rln/Cargo.toml
|
||||
# Avoid compiling the non-default implementation of RLN in CI
|
||||
# else ifeq ($(CI), true)
|
||||
# cargo build --manifest-path vendor/rln/Cargo.toml
|
||||
endif
|
||||
|
||||
rlnzerokitlib:
|
||||
ifeq ($(RLN), true)
|
||||
cargo build --manifest-path vendor/zerokit/rln/Cargo.toml --release
|
||||
# Enable zerokit rln in CI
|
||||
|
|
@ -237,10 +225,6 @@ endif
|
|||
|
||||
# clean the rln build (forces recompile of old crates on next build)
|
||||
cleanrln:
|
||||
cargo clean --manifest-path vendor/rln/Cargo.toml
|
||||
|
||||
# clean the rln build (forces recompile of old crates on next build)
|
||||
cleanrlnzerokit:
|
||||
cargo clean --manifest-path vendor/zerokit/rln/Cargo.toml
|
||||
|
||||
|
||||
|
|
@ -260,13 +244,11 @@ docker-push:
|
|||
docker push $(DOCKER_IMAGE_NAME)
|
||||
|
||||
# usual cleaning
|
||||
clean: | clean-common
|
||||
clean: | cleanrln
|
||||
rm -rf build
|
||||
ifneq ($(USE_LIBBACKTRACE), 0)
|
||||
+ $(MAKE) -C vendor/nim-libbacktrace clean $(HANDLE_OUTPUT)
|
||||
endif
|
||||
cargo clean --manifest-path vendor/rln/Cargo.toml
|
||||
cargo clean --manifest-path vendor/zerokit/rln/Cargo.toml
|
||||
|
||||
|
||||
endif # "variables.mk" was not included
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@ import
|
|||
../../waku/common/utils/nat,
|
||||
./config_chat2
|
||||
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
import
|
||||
libp2p/protocols/pubsub/rpc/messages,
|
||||
libp2p/protocols/pubsub/pubsub,
|
||||
|
|
@ -223,7 +223,7 @@ proc publish(c: Chat, line: string) =
|
|||
if encodedPayload.isOk():
|
||||
var message = WakuMessage(payload: encodedPayload.get(),
|
||||
contentTopic: c.contentTopic, version: version, timestamp: getNanosecondTime(time))
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
if not isNil(c.node.wakuRlnRelay):
|
||||
# for future version when we support more than one rln protected content topic,
|
||||
# we should check the message content topic as well
|
||||
|
|
@ -251,7 +251,7 @@ proc publish(c: Chat, line: string) =
|
|||
# No payload encoding/encryption from Waku
|
||||
var message = WakuMessage(payload: chat2pb.buffer,
|
||||
contentTopic: c.contentTopic, version: 0, timestamp: getNanosecondTime(time))
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
if not isNil(c.node.wakuRlnRelay):
|
||||
# for future version when we support more than one rln protected content topic,
|
||||
# we should check the message content topic as well
|
||||
|
|
@ -524,7 +524,7 @@ proc processInput(rfd: AsyncFD) {.async.} =
|
|||
let topic = DefaultPubsubTopic
|
||||
node.subscribe(topic, handler)
|
||||
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
if conf.rlnRelay:
|
||||
info "WakuRLNRelay is enabled"
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ import
|
|||
./wakunode2_setup_rpc,
|
||||
./config
|
||||
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
import
|
||||
../../waku/v2/protocol/waku_rln_relay/waku_rln_relay_types,
|
||||
../../waku/v2/protocol/waku_rln_relay/waku_rln_relay_utils
|
||||
|
|
@ -356,7 +356,7 @@ proc setupProtocols(node: WakuNode, conf: WakuNodeConf,
|
|||
except:
|
||||
return err("failed to mount libp2p ping protocol: " & getCurrentExceptionMsg())
|
||||
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
if conf.rlnRelay:
|
||||
|
||||
let rlnConf = WakuRlnConfig(
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ import
|
|||
# Utils
|
||||
./v2/test_utils_keyfile
|
||||
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
import
|
||||
./v2/test_waku_rln_relay,
|
||||
./v2/test_wakunode_rln_relay
|
||||
|
|
|
|||
|
|
@ -82,48 +82,6 @@ procSuite "Waku rln relay":
|
|||
|
||||
suite "Waku rln relay":
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
test "key_gen Nim Wrappers":
|
||||
var
|
||||
merkleDepth: csize_t = 32
|
||||
# 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
|
||||
# cargo run --example export_test_keys
|
||||
# the file is generated separately and copied here
|
||||
parameters = readFile("waku/v2/protocol/waku_rln_relay/parameters.key")
|
||||
pbytes = parameters.toBytes()
|
||||
len: csize_t = uint(pbytes.len)
|
||||
parametersBuffer = Buffer(`ptr`: addr(pbytes[0]), len: len)
|
||||
check:
|
||||
# check the parameters.key is not empty
|
||||
pbytes.len != 0
|
||||
|
||||
var
|
||||
rlnInstance: RLN[Bn256]
|
||||
let res = new_circuit_from_params(merkleDepth, addr parametersBuffer,
|
||||
addr rlnInstance)
|
||||
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
|
||||
keysBuffer: Buffer
|
||||
keysBufferPtr = addr(keysBuffer)
|
||||
done = key_gen(rlnInstance, keysBufferPtr)
|
||||
check:
|
||||
# check whether the keys are generated successfully
|
||||
done == true
|
||||
|
||||
if done:
|
||||
var generatedKeys = cast[ptr array[64, byte]](keysBufferPtr.`ptr`)[]
|
||||
check:
|
||||
# the public and secret keys together are 64 bytes
|
||||
generatedKeys.len == 64
|
||||
debug "generated keys: ", generatedKeys
|
||||
|
||||
when defined(rlnzerokit):
|
||||
test "key_gen Nim Wrappers":
|
||||
var
|
||||
merkleDepth: csize_t = 20
|
||||
|
|
@ -430,11 +388,6 @@ suite "Waku rln relay":
|
|||
hashSuccess
|
||||
let outputArr = cast[ptr array[32, byte]](outputBuffer.`ptr`)[]
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
check:
|
||||
"1dbd46f91d740145dd4a49323f2fbc8da79bb905b485fe77f3ea22dc39acb8ef" ==
|
||||
outputArr.inHex()
|
||||
when defined(rlnzerokit):
|
||||
check:
|
||||
"1e32b3ab545c07c8b4a7ab1ca4f46bc31e4fdc29ac3b240ef1d54b4017a26e4c" ==
|
||||
outputArr.inHex()
|
||||
|
|
@ -457,11 +410,6 @@ suite "Waku rln relay":
|
|||
|
||||
let hash = rln.hash(msg)
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
check:
|
||||
"1dbd46f91d740145dd4a49323f2fbc8da79bb905b485fe77f3ea22dc39acb8ef" ==
|
||||
hash.inHex()
|
||||
when defined(rlnzerokit):
|
||||
check:
|
||||
"1e32b3ab545c07c8b4a7ab1ca4f46bc31e4fdc29ac3b240ef1d54b4017a26e4c" ==
|
||||
hash.inHex()
|
||||
|
|
@ -512,38 +460,6 @@ suite "Waku rln relay":
|
|||
# compare the calculated root against the correct root
|
||||
root == StaticGroupMerkleRoot
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
test "RateLimitProof Protobuf encode/init test":
|
||||
var
|
||||
proof: ZKSNARK
|
||||
merkleRoot: MerkleNode
|
||||
epoch: Epoch
|
||||
shareX: MerkleNode
|
||||
shareY: MerkleNode
|
||||
nullifier: Nullifier
|
||||
# populate fields with dummy values
|
||||
for x in proof.mitems: x = 1
|
||||
for x in merkleRoot.mitems: x = 2
|
||||
for x in epoch.mitems: x = 3
|
||||
for x in shareX.mitems: x = 4
|
||||
for x in shareY.mitems: x = 5
|
||||
for x in nullifier.mitems: x = 6
|
||||
|
||||
let
|
||||
rateLimitProof = RateLimitProof(proof: proof,
|
||||
merkleRoot: merkleRoot,
|
||||
epoch: epoch,
|
||||
shareX: shareX,
|
||||
shareY: shareY,
|
||||
nullifier: nullifier)
|
||||
protobuf = rateLimitProof.encode()
|
||||
decodednsp = RateLimitProof.init(protobuf.buffer)
|
||||
|
||||
check:
|
||||
decodednsp.isErr == false
|
||||
decodednsp.value == rateLimitProof
|
||||
|
||||
when defined(rlnzerokit):
|
||||
test "RateLimitProof Protobuf encode/init test":
|
||||
var
|
||||
proof: ZKSNARK
|
||||
|
|
@ -575,7 +491,7 @@ suite "Waku rln relay":
|
|||
decodednsp = RateLimitProof.init(protobuf.buffer)
|
||||
|
||||
check:
|
||||
decodednsp.isErr == false
|
||||
decodednsp.isErr() == false
|
||||
decodednsp.value == rateLimitProof
|
||||
|
||||
test "test proofVerify and proofGen for a valid proof":
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ import
|
|||
./peer_manager/peer_manager,
|
||||
./waku_node
|
||||
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
import ../protocol/waku_rln_relay/waku_rln_relay_metrics
|
||||
|
||||
|
||||
|
|
@ -46,7 +46,7 @@ proc startMetricsLog*() =
|
|||
var cumulativeErrors = 0.float64
|
||||
var cumulativeConns = 0.float64
|
||||
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
let logRlnMetrics = getRlnMetricsLogger()
|
||||
|
||||
logMetrics = proc(udata: pointer) =
|
||||
|
|
@ -69,7 +69,7 @@ proc startMetricsLog*() =
|
|||
info "Total active filter subscriptions", count = collectorAsF64(waku_filter_subscribers)
|
||||
|
||||
# Start protocol specific metrics logging
|
||||
when defined(rln) or defined(rlnzerokit):
|
||||
when defined(rln):
|
||||
logRlnMetrics()
|
||||
|
||||
discard setTimer(Moment.fromNow(LogInterval), logMetrics)
|
||||
|
|
|
|||
|
|
@ -9,9 +9,6 @@ import
|
|||
os,
|
||||
waku_rln_relay_types
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
const libPath = "vendor/rln/target/debug/"
|
||||
when defined(rlnzerokit):
|
||||
const libPath = "vendor/zerokit/target/release/"
|
||||
|
||||
when defined(Windows):
|
||||
|
|
@ -31,79 +28,10 @@ type Buffer* = object
|
|||
`ptr`*: ptr uint8
|
||||
len*: uint
|
||||
|
||||
######################################################################
|
||||
## Kilic's RLN module APIs
|
||||
######################################################################
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
|
||||
#------------------------------ Merkle Tree operations -----------------------------------------
|
||||
proc update_next_member*(ctx: RLN[Bn256],
|
||||
input_buffer: ptr Buffer): bool {.importc: "update_next_member".}
|
||||
## input_buffer points to the id commitment byte seq
|
||||
## the return bool value indicates the success or failure of the operation
|
||||
|
||||
proc delete_member*(ctx: RLN[Bn256], index: uint): bool {.importc: "delete_member".}
|
||||
## index is the position of the id commitment key to be deleted from the tree
|
||||
## the deleted id commitment key is replaced with a zero leaf
|
||||
## the return bool value indicates the success or failure of the operation
|
||||
|
||||
proc get_root*(ctx: RLN[Bn256], output_buffer: ptr Buffer): bool {.importc: "get_root".}
|
||||
## get_root populates the passed pointer output_buffer with the current tree root
|
||||
## the output_buffer holds the Merkle tree root of size 32 bytes
|
||||
## the return bool value indicates the success or failure of the operation
|
||||
##
|
||||
#----------------------------------------------------------------------------------------------
|
||||
#-------------------------------- zkSNARKs operations -----------------------------------------
|
||||
proc key_gen*(ctx: RLN[Bn256], keypair_buffer: ptr Buffer): bool {.importc: "key_gen".}
|
||||
## generates id key and id commitment key serialized inside keypair_buffer as | id_key <32 bytes>| id_commitment_key <32 bytes> |
|
||||
## id commitment is the poseidon hash of the id key
|
||||
## the return bool value indicates the success or failure of the operation
|
||||
|
||||
proc generate_proof*(ctx: RLN[Bn256],
|
||||
input_buffer: ptr Buffer,
|
||||
output_buffer: ptr Buffer): bool {.importc: "generate_proof".}
|
||||
## input_buffer serialized as [ id_key<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
|
||||
## output_buffer holds the proof data and should be parsed as |proof<256>|root<32>|epoch<32>|share_x<32>|share_y<32>|nullifier<32>|
|
||||
## integers wrapped in <> indicate value sizes in bytes
|
||||
## the return bool value indicates the success or failure of the operation
|
||||
##
|
||||
proc verify*(ctx: RLN[Bn256],
|
||||
proof_buffer: ptr Buffer,
|
||||
result_ptr: ptr uint32): bool {.importc: "verify".}
|
||||
## proof_buffer [ proof<256>| root<32>| epoch<32>| share_x<32>| share_y<32>| nullifier<32> | signal_len<8> | signal<var> ]
|
||||
## the return bool value indicates the success or failure of the call to the verify function
|
||||
## the result of the verification of the zk proof is stored in the value pointed by result_ptr, where 0 indicates success and 1 is failure
|
||||
|
||||
|
||||
#----------------------------------------------------------------------------------------------
|
||||
#-------------------------------- Common procedures -------------------------------------------
|
||||
|
||||
proc new_circuit_from_params*(merkle_depth: uint,
|
||||
parameters_buffer: ptr Buffer,
|
||||
ctx: ptr RLN[Bn256]): bool {.importc: "new_circuit_from_params".}
|
||||
## creates an instance of rln object as defined by the rln lib https://github.com/kilic/rln/blob/7ac74183f8b69b399e3bc96c1ae8ab61c026dc43/src/public.rs#L48
|
||||
## merkle_depth represent the depth of the Merkle tree
|
||||
## parameters_buffer holds prover and verifier keys
|
||||
## ctx holds the final created rln object
|
||||
## the return bool value indicates the success or failure of the operation
|
||||
|
||||
|
||||
proc hash*(ctx: RLN[Bn256],
|
||||
inputs_buffer: ptr Buffer,
|
||||
output_buffer: ptr Buffer): bool {.importc: "signal_to_field".}
|
||||
## as explained in https://github.com/kilic/rln/blob/7ac74183f8b69b399e3bc96c1ae8ab61c026dc43/src/public.rs#L135, it hashes (sha256) the plain text supplied in inputs_buffer and then maps it to a field element
|
||||
## this proc is used to map arbitrary signals to field element for the sake of proof generation
|
||||
## inputs_buffer holds the hash input as a byte seq
|
||||
## the hash output is generated and populated inside output_buffer
|
||||
## the output_buffer contains 32 bytes hash output
|
||||
|
||||
|
||||
######################################################################
|
||||
## RLN Zerokit module APIs
|
||||
######################################################################
|
||||
|
||||
when defined(rlnzerokit):
|
||||
#------------------------------ Merkle Tree operations -----------------------------------------
|
||||
proc update_next_member*(ctx: ptr RLN, input_buffer: ptr Buffer): bool {.importc: "set_next_leaf".}
|
||||
## adds an element in the merkle tree to the next available position
|
||||
|
|
|
|||
|
|
@ -22,8 +22,6 @@ const
|
|||
# the size of poseidon hash output as the number hex digits
|
||||
HashHexSize* = int(HashBitSize/4)
|
||||
|
||||
|
||||
when defined(rlnzerokit):
|
||||
const
|
||||
# The relative folder where the circuit, proving and verification key for RLN can be found
|
||||
# Note that resources has to be compiled with respect to the above MerkleTreeDepth
|
||||
|
|
@ -37,216 +35,6 @@ const
|
|||
# this list is temporary and is created to test the performance of waku-rln-relay for the static groups
|
||||
# in the later versions, this static hardcoded group will be replaced with a dynamic one
|
||||
|
||||
when defined(rln):
|
||||
const
|
||||
StaticGroupKeys* = @[("1754e80116f859952d343497fcbcafbeaa89ee79a01590c5659d531f5bd0a4e9",
|
||||
"134ec3c055614df49366c5a7d9d497a43df3963439eefb2611ab00325b3a4db7"), (
|
||||
"2311a6596f06fcf1a140e4d2aae7047e007010ce36afbe1938e55752c2bfb227",
|
||||
"2701fc7c513748cb838f289e186f141f66b98f506f47a8791e0496ff1ae52c52"), (
|
||||
"1dff8ec1abe4f3a9928f6e9d707a3190ba4394d393e35fc5674267e6aa2e3966",
|
||||
"2aba77fb760a82bdb0efcc39e8eb505a41f1d0ec9f24fc431981c1485e23dce3"), (
|
||||
"0ed4c2d68e6664cf120be470389c267bfe652d054b01b80d230514b8eb2e46e7",
|
||||
"2a21425cf4cf0c0fc259310b0123e4571ec88c2018be37a64e14345e96f07d72"), (
|
||||
"0450eb7d85db7487c68a01dc33072c48b01725a061652d3a0175704c8b52d81a",
|
||||
"0822b60c2c17cbd68258e9e6b96b7d2b0926508fe79e2ada8457137775a7f35d"), (
|
||||
"00e7e86c5fec0c49336b4313eb4cf4970bacc318df941d871f8650fc3bf50faa",
|
||||
"2768594ac3b97e0023dcd76668403cf74b03ce9aa23b47c0aeae05b9051d4230"), (
|
||||
"2443e28a18873e4405438142a87e4ef2298db578e45dc4c477b157eda6c04804",
|
||||
"02b06a1a610f7b24c9a4a36e3c601ae68eb43f8e7c3628a0f52a97d804a7a15e"), (
|
||||
"0030668f19bb3e609b128f18cb4b0c32caba76c9a3f4e3ef9be611dddb6e6a4b",
|
||||
"1ebde6f3193f1ce0d3ab39b8b1cea73ea4ac9c3b6834f073882cade885611d45"), (
|
||||
"2bcf2ce1e4b2fb88446aed5904d947fbc3dd80296d329656023fb35548a3fbc3",
|
||||
"0e6a7bccf4eaa5532c41cb97b9074ada3b7856e233e68fad66a84e14864a6774"), (
|
||||
"05e4104c85681bf35eb23037cf872a33a53e9f1c24c6d7261c0f724ab9b8350c",
|
||||
"2d08ba0d89b68d3ee16379cd41e8639b2f76ed9e297ce37bc19ed18a8ddf1569"), (
|
||||
"0999028058041c111795188d7a93063b3e7fc71a41c3c846ba95da7716020ba6",
|
||||
"0fc941adf2e210865dcba6e1912c8b6e6eb2210fcd1707fdc6ce44cb2ed2fcbb"), (
|
||||
"0f563bcc1d2176235c613cf37b4dead2015ad7a37eb808b754e7fb662e664d2f",
|
||||
"108820acff8c4963b65ea308d35feb5195c4821e57869f8b0293322c627e7fc6"), (
|
||||
"2ee26c5b01ae74aca3444e7242da07998b6e3df29c9a983b8d4cc196fa1a0ad9",
|
||||
"2e2017c800ec4b1a3f469da66ea176e07bd9427604abb65272900add1b5b79f0"), (
|
||||
"1064fb1843470365b272bade45418bcfac1b4f27e504757710dac8894d76a0df",
|
||||
"254e25ce3b6b98c1050c5419309f9cbed74ff0f2d9b6cfcc132fea33e8a88a9f"), (
|
||||
"12e7a5d4bfc1397b5294e32fe32135d7d422b96710ff6409a4536b3b019074e1",
|
||||
"260ae876bf8f65cca680a78d024c93e4f63986d9a718286fa3144b0e3aa28f7a"), (
|
||||
"10845ab17088c0fda8951b9132b6f9a1fa7f21e800111bdbdd735307d128937a",
|
||||
"22c1e3958316a8fe73eba7e61fd3b27db1e718fe198c097348b946c070aeb294"), (
|
||||
"1d16525cb0f78c0431f1c4d331a4b539a5be9d37b38aa851bfa57d44b19b31ce",
|
||||
"2cf26f5c78cef9a552c2a807e8a7bb6ab04b54cf3257ff9fbc1ba5b84a26facd"), (
|
||||
"13d38f4469f75248e5c51f0020176a93b47ce72b47c43fa09cefcbbf038581d3",
|
||||
"0b9c940a6487299c8a3374cf93520c724a8914e50d67a5756c9706d9ab9227e7"), (
|
||||
"1e90c015c440cf0487c8b874434d8d9362ed3a2dd10226b66e736084118d9b4f",
|
||||
"1cf0a5922f52d0b2562e318b8724490b0a950402fe53104a9231de8a58e4cb2e"), (
|
||||
"05f9e72ed636a4af8aaf80acf87d5fdfcd4900f1cec8dc3e63f9da6ad99fb539",
|
||||
"00bf64c7a42e1d5948bcd6b7f7da149af38f30969a6a76c25fa9f89d977a4fb9"), (
|
||||
"22c30094233a91a20d739fe91d95bbb8eaaf2b8537821c362b185d99250dcb73",
|
||||
"06461491db94fa4d47282d57765bbcab26d84414747b6654cd6b6b44e4e604da"), (
|
||||
"095087b0756edc2c779d57e805ec03fb465c1258bc99278bbba5bb833b425327",
|
||||
"0db33f6fdf6ea729036b316a172d16716f41062d69a3313429e720ec100004ee"), (
|
||||
"1b36e58cbda349ee1405b2aa9093bb28de59074a14515b27e65c35679bec73cb",
|
||||
"0d8ed588232e3dc3b97da1f1cae8d58d007bb6dd1b2498b3031ffe3eade2c6c7"), (
|
||||
"1b372ea1e7d8808a819d6c7f2f39325d2a684602d826e9ed1356fef3d986b3bd",
|
||||
"0209844720b22d3e5608c8ce99cbd0113c6b919987b19dcb72ef22f4748cd421"), (
|
||||
"09a8e4fc8a5f88a4d3d6a737987a73ffce6a0f33fac1469044341034fefcf260",
|
||||
"0c379326bd364e5633d0b77c76a2ea7b3d9105171fb25a1b5127419e6ff2c8e4"), (
|
||||
"0b18d1e647544e9ce084e1e7baf7c23406784315d966aec12149c4b54fd62312",
|
||||
"06a45e4705ac7b779a401ccfc912ed03ac9676aab222bac53435fc1447b80a29"), (
|
||||
"2f2bfeee70344624046ccad18697e2f5a5c7433b7fbb16d38022c41633599cb7",
|
||||
"25f0bf499ce5b26ab61146d0348e0dee4e5500dd713e40ab324d4c57c94ae4f4"), (
|
||||
"149cdb177594cc519b2820366e28a73dc414afe1320460b65c65be9e668f54e6",
|
||||
"0249958294df9248fe37ae56685e47cd184010523f699a38cb1d4a96e361e2ac"), (
|
||||
"00f10851bfd49611e19097cc17f09dfd0a199bf7e0092284f464939c4054be81",
|
||||
"231b39567453e6194bb5fe4f3d91ff28308108d66f2bf165e00327422eb286d9"), (
|
||||
"05f32eddbce7efe611c4397e773b8302deed6acf00d97aaf1b9d54b4d3f00f94",
|
||||
"129494c8e268671b4de666967c287b82faf31605de65b3db7fb4756e8abb72d6"), (
|
||||
"0a8cdce6703196a77b9f8d0b201372fb086df87d164cccb336c8c8a10a30feb4",
|
||||
"202015161c8f8f8132d40c95be25126d0596cf025c95d19f5c3f7f86a9b67d5f"), (
|
||||
"2a524092c44e12ba4420bd1642bf7871e40ae4ca7d207082b78c73b3bda2342c",
|
||||
"153e677112e9594875fd6ce4473f2d74c3c92ecc10354932ab35d7d7780c498c"), (
|
||||
"2dfae9b260de4cc77d145084694cfe851ee0999bbbf90bd4172df93f7a8503fc",
|
||||
"0908e0d70b8e7cd3ae40346615b2742c9fefa24502bca5bb42bcababcd2aa2c0"), (
|
||||
"239298ea28c9ecf0b63725e00b2b83aca90d449abb908e78033bc6356aa967a2",
|
||||
"2d1785c3ef21a2c893edb66d3c0810af52932ef37d3b30ca99e9bca5cdea6c63"), (
|
||||
"09a21707464456896bbec9f849c423c5f8916cde32474cac9d7a66c1a2154ece",
|
||||
"12bdc6dc385440fdc5e7afdbdba6ed9a46bd732829309b51d2360bf423655cd5"), (
|
||||
"062341fa151ad9d6e97fa1cf844d3009543701b7596c398c00cbe3a4de7c614c",
|
||||
"192836c5846b8464f3dd4ec4ec6fb3b08d73dfe9d8f2699ca31854c3a921dca6"), (
|
||||
"06c84c54ced6dc86c867bfbb4e3870e32bb904a3d12ec61cb1f9943d2baa338c",
|
||||
"2c1d40f1a17ce628cdd709dd042a0cc56efd88a99467a38bb5708cabb1a2ac7c"), (
|
||||
"28a202c8f544970a453068e6badbbba3b011e7f06c499af8dc6c7e00f4c86f1b",
|
||||
"1824c19235314ac12aed38238cadfd3e9597fb1e00920c9ab9fe32bd7894b7c3"), (
|
||||
"06dbd49b8330f96d880c7cdef72e16a2ef0a96f0bd31fee5b1f1e03ee837680c",
|
||||
"2bf5b861ea14b591bd0ef028a5921eabb7ebd34c01fb870f3fb11a15b567268b"), (
|
||||
"270c2532ca6de9a54f9f47d1a7ad8e4de3a23204b1d84445c39735966080a38d",
|
||||
"2ef4080d8fe149320c185ef80f3e23d4b0a6f2b04d6deb2f776f8e5a1125f57b"), (
|
||||
"0d34c89be7770c9493d2df6d93df0b3878b7439efcf152fc119d6a5fd8c6b050",
|
||||
"118840ba5709bc2baffe1414bee3d9e7293bb3d78424031e34ef81de97e2b9bb"), (
|
||||
"0851726d44987f5faad3cb3186d820ccf3054f8dbde4a68bff32cf20add38f6e",
|
||||
"10521f381a50c78d7a04872001d7535b17f20153209a041204043b610474fea9"), (
|
||||
"2820de5043c0c4d10365be30eb23ac058d19a1d2ad6d0be8f7fe9cd632bb91c2",
|
||||
"22d451429f862f9ce71a30d3020caaef9e3193c792662af75195849da08c4ff4"), (
|
||||
"1d6888b239d40d68719b539eadc949466ac5de31def0879a811f10212e4c6d11",
|
||||
"0c81dd6f090634f6ec356fd557d3d51761fb8a8de3e3d63be60b39055ef64d9f"), (
|
||||
"0cb0dba2a97f353a90f8448713f8aa2cb1e92d854a0823e6169a296037ed1318",
|
||||
"0f3a65bfb8ff5ce76880da9ddd415e428ac807f851b8509f48bc07cdccaa7bf3"), (
|
||||
"1eb0e5c3d7a2d95204eb161b41bcf8740a66b08bade7171cdb89bb2cd7625e54",
|
||||
"19ae9f92e872f22aaa50e40686c3852d350af871731d95b1c791b0863ac9dd96"), (
|
||||
"1415cd7a3beaaa401a433195f2db28bdad7cff29ccaea61ec297464741595d0f",
|
||||
"25a5b2db7048df069d0463d4a8834aa3e4d2d725611b9cb11fb84dabf30f3de8"), (
|
||||
"1c380ee1d11e957424c9f9eef2aee629f1600a842a4cadd5f99280f4c15b6052",
|
||||
"0c1926f4c88aa09b9f7aa7d8e1afcd6f05e4c7bf9ef272c88506b2b8aff32d22"), (
|
||||
"0b2f464574212657197698090da1c2a2c3a4bb14154c17d01af1e957eecde8ee",
|
||||
"240adbe97b27474995d130f5579afb14c722b5098c22ae4b1533c99a79e500a0"), (
|
||||
"1a494d7cdc7334d15b6ae39c9cb44a2982d42ac9ffdc86810f371639dc047d8c",
|
||||
"19ebc99a0625cd499132c6bf67db3ace370333364f44b315cefb2ed8bc358e78"), (
|
||||
"271fa65913ec18801e3e5869eba5bcccce5aa48da730eb827fbbda9e0f724a00",
|
||||
"168eb1fe167e11f5d4f396029e79da6123b25938d3ac49a66980ea4bd619d3e3"), (
|
||||
"2fb2efd125cc02eec6dcf7dcc6adf0cbee17636d2d5b5a79377ede7c1d6f7138",
|
||||
"01131ac227d77ca684adee2b6555eaa20196e4e63da2e02b5f48c1cfd029c295"), (
|
||||
"136c6f48c73cd54c8e72698730659abfa4afdd0abb2a8171d0f3999ea4c7ca22",
|
||||
"00fd7a1f068d69bde38a992451f2a293abcacbb976d720bc6499800606b9e5a2"), (
|
||||
"0fe2e20e36747bb834a0867add2a60395409f12fb7587378a4ba731fa4c70951",
|
||||
"0cf9bd35d34de3c0d2dc8ff09d256702a46e8f8f42b9515a8b82ed33203e1ba3"), (
|
||||
"1c470a109f5aa434557259b64eab5b8814edd6d6c385705635a1290f47877a95",
|
||||
"1330fa967506fa60e0cbcf871e73053d2313a3355e4033fa875a2d28df05308f"), (
|
||||
"2e3dd0e3134de90a4a28e9031041d23697b25c961c847cdc93b2c20676d5dae0",
|
||||
"27ba6aa6ce8db9ed6acb28657020ad8bcecaeb512429cc0d0317b6f03e644305"), (
|
||||
"09da242f70ba7f2d3f5c7c93351140332170bbee2bf1b3156b5ba5c83809f1f1",
|
||||
"1d09919e24cc30b288bf54368c8764401e567f1a7350d5217410d55a8a2a86dc"), (
|
||||
"116977ae96ae633647e6cdd1b988bdb1b2c73999bdd678572370998cd708bc4b",
|
||||
"1350c30b0511497e57885a223b576ab8eed3f4115051e8aab37f1ae39cbe8435"), (
|
||||
"1367d64194704d5fdabf008ed217c5ccc5eb6e25f5d823ca575729c9315b32c8",
|
||||
"09f0da5356fcfe42f73e2740b7d8449b2118cb19556270c48504160309361fb8"), (
|
||||
"148aae61dbb4167903ba281e317fbf325760505ddb6ca5ef7958be2fe2b3a669",
|
||||
"24699648af51b9912defd47ed90695d4f0b10c1556545720da673eeb00f8dd10"), (
|
||||
"01e4de198b62b492d54196c84ad5d019169a3a6c6879f92e9fb44b6d58e3a0c2",
|
||||
"15d3022d4d41547f4bd2cf90ef10a9eec373f0b9a3d423f0f93ed1f677a63bbc"), (
|
||||
"052cc59fc19d36bd6f30df6ceb475e95be68bc2eafd760774537ff791b05895b",
|
||||
"11bac4cdd46789ccbd849e2b0d6721af67c8077aa28e05f9e0adb25b9d2afe7b"), (
|
||||
"05416432bca14ab5eb32189cd8a1a054002429ad33699068bf23bc5cf345ac46",
|
||||
"11bda5087d3250462d8840dd0d5159e3e42c6f8ff638b88a1b5a61d583e791e8"), (
|
||||
"23cd701c8cc4969f15eb7cdf400585cbe616f82209191c86af0cc4377b061e58",
|
||||
"25fbd6073b49887a51c99f41d36a20c93aaab0ea21416fc3692320748cfa490d"), (
|
||||
"15367d2c2adde7c908b012f96fab7a8ebead4ec063d9fa142ea2452bbab47ebb",
|
||||
"2531e38c637ae2eb941b40b2c7f6eef0f0658275fa728050821ff5cec8d08e75"), (
|
||||
"2807baf0d6905013a0ec665bda29d24eefbded4da1f5d1942b674f90c93c8fa0",
|
||||
"0a70bb3afb67ad6dd6a3da20d1bd2d29fcc7e92289d45ba1cf41d29523952c54"), (
|
||||
"08bdfd28c75e42dfcf860da9306a8f2e3e701f439bf35c5fbd4194445cac5b10",
|
||||
"0d3e710bf7cf81faea828cc31e86a4e6f19bc8e311719a3298fb56d5f10692b5"), (
|
||||
"1359d98332177364920c993cff41a8ea2f0d2c409afa9eb9da34a2aedf2edf45",
|
||||
"277513cbe4ece6e3df0284166ebd27c82d8bf1f5143a374905a5c322f98c00db"), (
|
||||
"14ebf13977acdd66b327fcd25e198c07cc99e5b70744e8855bef157c43d68d48",
|
||||
"17bef44e79d4cb92fe18278a3e71c60fa17b10df0a547e4e4677c6557f884804"), (
|
||||
"302a37a86e3ccbff42ebbe24ae4eaad92416a9ef09d5b55ee104358f6997e63f",
|
||||
"1781abe1087e7d834a6452e43ddf0a5d1c7c9b3c51f7583a89c1c6e728cb1c44"), (
|
||||
"042e3cf71e65ef512ddda40f88a68e33bf472781c6f175db744c26721280b59b",
|
||||
"0eb24732c383df3473d146039d4356151ecbcf3f31b01f3f0bc338e880fdeee2"), (
|
||||
"11d91c5cca940d43e9d4cce22a60ef146481f2568650785b87fec467147ad3ba",
|
||||
"1d59ad1bb34bfae22a7f12992132c9647b46311588c3daa93e2eedbacd2cc721"), (
|
||||
"0ded6352cbe2615a5ef63fbb81df7541459c0559fcabb185c1edbacc3722c795",
|
||||
"0d9da073ec3a6e6316e9b502b2d6ab1fee0a2fda5dc7a9f75cac75478a724010"), (
|
||||
"2a5f7478603258a0ecf2026a5cf19ab399e9259b2a0bf795bc99d1f49a8b8e73",
|
||||
"0dcaa540efb2836a05bdd94ab410b9dfef3c45df0789811d103ea00a96354800"), (
|
||||
"2ed1b60adba545f156ffe4380e88ec86b517b6d19786c0bf60fef286f4ca880d",
|
||||
"1a2b7b8ffb6895003ceb414443fcdb534d3d2cb63505c584bc9552812393b1a7"), (
|
||||
"1f7903f37f81dc7d1a1df3d3867fa9dacf970373bf8eba0f59904d31fdf77ab3",
|
||||
"03b7982eb26d8922279aaf3b5f2cdb291e124fa32d648427f997aece0ea89682"), (
|
||||
"0b6a36fe2f31cf88f53fb0cc98477b0b919d274ea1f5313411cba85130dd676b",
|
||||
"129af8e6d724a95d162a40c4363df3b130cdb2e36dd6a0e43b790b3a54cc389c"), (
|
||||
"279f31fa071b1f4e83b56dbd1a9553fc22094614a6ab4db3d1b906e4404cfc72",
|
||||
"020d4186d347cedebc7e96b479058e1d8b269b8a84e38aa7c447ba8104d5a4da"), (
|
||||
"00f00d0ddd55e78292d2e76e3e79c4012909a45850279f01cf3da2b2b25ccea4",
|
||||
"26b2cd897a4da9fb6dcd83223d2793d0c2e2524dc3117958f35130d253947400"), (
|
||||
"214597ea586b9f544af091c6149769133a370611abfeab728eace81602df009e",
|
||||
"27ef532cd34e56d76121c2f964849ed4947c2d97177ece58bbb82390fddb690e"), (
|
||||
"1be73dd5739e70d50082841b2bb6d7ac69b86dcf4dc0a7fe25f415638c551afe",
|
||||
"2210b28ea59b7fa6afe29ea32456c54f0106e5c06ad7927080cb618dcc33cd66"), (
|
||||
"0a431af62dae6c7e9b5066e9e5badf155d29129b39fb7af474bc4c7ee142a53c",
|
||||
"1bb4b3ddaf25e67ccc66770c2f47413b2417460a72ca61ee0d72d39e42dfa057"), (
|
||||
"2e2b8c08ed285ade22eadc53f7f165fafd68ff69cd9a1c38f7b1b0e95578a7c1",
|
||||
"196dc800723f80d3af767a2b51d874b396f4222a9ac3d8308abb5a721d52ce4f"), (
|
||||
"2e83baf08662693cee151edff384f259b9793dfe5214bf2b04f3ad90d5a8cd17",
|
||||
"04d404a2e406b1e9e069961a86daa98a22046a546eca793300555b172ae91989"), (
|
||||
"022f2f47364290282e85f8e2cd7fcf4a346a09f97ffffce59c474b7b33a99f95",
|
||||
"06cd7d85da6f61db154e152be1ae02cbbf6054b9e445b7239223cefeec88e679"), (
|
||||
"1cb34f7d1e74bcdc1fa70a83533b6746b4218fdde331a60400c5fbbd4cd362d0",
|
||||
"0f6df63f4f5f10e2bfb9d0ef88d34ae62850b24bc45e1c8a4e7f652701af0322"), (
|
||||
"23ae5d5cdcf23d5940c9edb018bd275f8b0627ce499570144994644803e3d3d2",
|
||||
"13816093a98fe9c5b5180441e24ae8a14b464b4c5d3d67a8548fdcbf0652e75a"), (
|
||||
"1f4a130e81f7b8235ce0f8d1be55cd29bb0ce0c20b5f341472b28f47d657b44a",
|
||||
"198de1c806777c6c97aae2178d6a707bb387ae316ebb81ea46ed55e31177b33d"), (
|
||||
"04c4b02c7e38a410ac7833e53519e4ace451f0db43b3e281afcd6ec98478a15a",
|
||||
"14076e60b8cecbd44e7853be02c7af400be90810fc44611f8848a76862981871"), (
|
||||
"303bb4886b0448aca8844044ab141d7a6e8015511dae51e467c01a756bcaf482",
|
||||
"025a3406e9dca3be4941c5e7af776a00200671a8e63b276ef1b05c2a6c18098a"), (
|
||||
"12490ac2f30f05d29eb822155eb54c87d9d6d407e597acd2c40c1ee87dd9d555",
|
||||
"041d0f7353723fbf01b879873e3ea7eb116caf059288211ae141204efecefa27"), (
|
||||
"09c183f38f4939c34730070c8e40a9e1170a6c9a1ea2de1d07614f58f4775184",
|
||||
"03a18d2f01cc6d806e273d725282be10917d0e44fdc25601e81f861c2d57bc25"), (
|
||||
"029011dd041c39900f44afec9bde49c047c7c8d98fe72ef8495ff4dadf46ecec",
|
||||
"1f1ac817a635e6d82e1c204c0c018d7275cec7242406cc9db62df7caa7e122b9"), (
|
||||
"2558d8aa598541ecf010758b119e90af24610a00da4beba558b1a4f2d95f268e",
|
||||
"0cdd4b468ef0cf2627c124b34812a36eb45377bb099f6cced23b93e9212ad9ae"), (
|
||||
"0f52ebbfa546e9f39ac6dc3ccf6ebb8bb9b9350ccc7d277a63aed3721518d799",
|
||||
"30532d7da331dd982a46ebac45420da76ee2b267f873e45e49a27143557b2189"), (
|
||||
"294ed26529dfb8a0259d80e8379ff0b7c0770238bf2e90e7347fe29a14fde1a5",
|
||||
"2f1cb401f0839e1081c3681cc56b87841eeb0fc4f800554d89c3cf54a2166a2d"), (
|
||||
"1c66254453e0f36b97cb1cb7cfeedb5d6149aaf147e00afde5b65b23da21d27f",
|
||||
"24b35ebe700a2f00800f6a8b61334f385d13e118f6d9b0272957093ecc1ca49e"), (
|
||||
"213bc498a45437b71e846d22469ee4a0e424dde4b3a5e66bf968aa5db4c125b1",
|
||||
"183c156f72de0625a97554b59242321ef95501531c65cf58ae5154d2399c0b36"), (
|
||||
"1ad8181f52261458350c9baa0938074bcfcab7f7840ba9efabab4948233645d6",
|
||||
"10153f17e3dddb49bd688dd7b469ed9b6bb23634aa36b05b32d42c3130e0dad2"), (
|
||||
"2497d1f6f2efcf5a904b9b97f3ce347e4bbefc768d7ed132e17bfb6cea3aced1",
|
||||
"21bb38990896c623ff412adeeed422ec079fa173f9564b5f531f799762b747be")]
|
||||
|
||||
# StaticGroupMerkleRoot is the root of the Merkle tree constructed from the StaticGroupKeys above
|
||||
# only identity commitments are used for the Merkle tree construction
|
||||
# the root is created locally, using createMembershipList proc from waku_rln_relay_utils module, and the result is hardcoded in here
|
||||
StaticGroupMerkleRoot* = "2d7b393411745699c6c67cad60805b5c6a915a54a03216b2e112ff3e557a87a1"
|
||||
|
||||
|
||||
when defined(rlnzerokit):
|
||||
const
|
||||
StaticGroupKeys* = @[("2c0198101a2828a0ac6c9e58fc131e1bd83326a4f748ef592588eeb8c3112dc1",
|
||||
"1ca742a54641e2de14c5cb87ad707fd869693f682cedb901e47b8138918aecb3"), (
|
||||
|
|
|
|||
|
|
@ -14,17 +14,8 @@ import
|
|||
import
|
||||
../../utils/protobuf
|
||||
|
||||
|
||||
type RlnRelayResult*[T] = Result[T, string]
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
## Bn256 and RLN are Nim wrappers for the data types used in
|
||||
## the rln library https://github.com/kilic/rln/blob/3bbec368a4adc68cd5f9bfae80b17e1bbb4ef373/src/ffi.rs
|
||||
type Bn256* = pointer
|
||||
type RLN*[E] = pointer
|
||||
type RLNResult* = RlnRelayResult[RLN[Bn256]]
|
||||
|
||||
when defined(rlnzerokit):
|
||||
## RLN is a Nim wrapper for the data types used in zerokit RLN
|
||||
type RLN* {.incompleteStruct.} = object
|
||||
type RLNResult* = RlnRelayResult[ptr RLN]
|
||||
|
|
@ -38,15 +29,8 @@ type
|
|||
Nullifier* = array[32, byte]
|
||||
Epoch* = array[32, byte]
|
||||
RlnIdentifier* = array[32, byte]
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
type
|
||||
ZKSNARK* = array[256, byte]
|
||||
when defined(rlnzerokit):
|
||||
type
|
||||
ZKSNARK* = array[128, byte]
|
||||
|
||||
|
||||
# Custom data types defined for waku rln relay -------------------------
|
||||
type MembershipKeyPair* = object
|
||||
## user's identity key (a secret key) which is selected randomly
|
||||
|
|
@ -88,32 +72,6 @@ type ProofMetadata* = object
|
|||
shareX*: MerkleNode
|
||||
shareY*: MerkleNode
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
type WakuRLNRelay* = ref object
|
||||
membershipKeyPair*: MembershipKeyPair
|
||||
# membershipIndex denotes the index of a leaf in the Merkle tree
|
||||
# that contains the pk of the current peer
|
||||
# this index is used to retrieve the peer's authentication path
|
||||
membershipIndex*: MembershipIndex
|
||||
membershipContractAddress*: Address
|
||||
ethClientAddress*: string
|
||||
ethAccountAddress*: Option[Address]
|
||||
# this field is required for signing transactions
|
||||
# TODO may need to erase this ethAccountPrivateKey when is not used
|
||||
# TODO may need to make ethAccountPrivateKey mandatory
|
||||
ethAccountPrivateKey*: Option[PrivateKey]
|
||||
rlnInstance*: RLN[Bn256]
|
||||
pubsubTopic*: string # the pubsub topic for which rln relay is mounted
|
||||
# contentTopic should be of type waku_message.ContentTopic, however, due to recursive module dependency, the underlying type of ContentTopic is used instead
|
||||
# TODO a long-term solution is to place types with recursive dependency inside one file
|
||||
contentTopic*: string
|
||||
# the log of nullifiers and Shamir shares of the past messages grouped per epoch
|
||||
nullifierLog*: Table[Epoch, seq[ProofMetadata]]
|
||||
lastEpoch*: Epoch # the epoch of the last published rln message
|
||||
validMerkleRoots*: Deque[MerkleNode] # An array of valid merkle roots, which are updated in a FIFO fashion
|
||||
lastSeenMembershipIndex*: MembershipIndex # the last seen membership index
|
||||
|
||||
when defined(rlnzerokit):
|
||||
type WakuRLNRelay* = ref object
|
||||
membershipKeyPair*: MembershipKeyPair
|
||||
# membershipIndex denotes the index of a leaf in the Merkle tree
|
||||
|
|
@ -138,9 +96,13 @@ when defined(rlnzerokit):
|
|||
validMerkleRoots*: Deque[MerkleNode] # An array of valid merkle roots, which are updated in a FIFO fashion
|
||||
lastSeenMembershipIndex*: MembershipIndex # the last seen membership index
|
||||
|
||||
|
||||
type MessageValidationResult* {.pure.} = enum
|
||||
Valid, Invalid, Spam
|
||||
type
|
||||
MessageValidationResult* {.pure.} = enum
|
||||
Valid,
|
||||
Invalid,
|
||||
Spam
|
||||
MerkleNodeResult* = RlnRelayResult[MerkleNode]
|
||||
RateLimitProofResult* = RlnRelayResult[RateLimitProof]
|
||||
|
||||
# Protobufs enc and init
|
||||
proc init*(T: type RateLimitProof, buffer: seq[byte]): ProtoResult[T] =
|
||||
|
|
|
|||
|
|
@ -26,10 +26,22 @@ import
|
|||
logScope:
|
||||
topics = "waku rln_relay"
|
||||
|
||||
type MerkleNodeResult* = RlnRelayResult[MerkleNode]
|
||||
type RateLimitProofResult* = RlnRelayResult[RateLimitProof]
|
||||
type SpamHandler* = proc(wakuMessage: WakuMessage): void {.gcsafe, closure, raises: [Defect].}
|
||||
type RegistrationHandler* = proc(txHash: string): void {.gcsafe, closure, raises: [Defect].}
|
||||
type WakuRlnConfig* = object
|
||||
rlnRelayDynamic*: bool
|
||||
rlnRelayPubsubTopic*: PubsubTopic
|
||||
rlnRelayContentTopic*: ContentTopic
|
||||
rlnRelayMembershipIndex*: uint
|
||||
rlnRelayEthContractAddress*: string
|
||||
rlnRelayEthClientAddress*: string
|
||||
rlnRelayEthAccountPrivateKey*: string
|
||||
rlnRelayEthAccountAddress*: string
|
||||
rlnRelayCredPath*: string
|
||||
rlnRelayCredentialsPassword*: string
|
||||
|
||||
type
|
||||
SpamHandler* = proc(wakuMessage: WakuMessage): void {.gcsafe, closure, raises: [Defect].}
|
||||
RegistrationHandler* = proc(txHash: string): void {.gcsafe, closure, raises: [Defect].}
|
||||
GroupUpdateHandler* = proc(pubkey: Uint256, index: Uint256): RlnRelayResult[void] {.gcsafe.}
|
||||
|
||||
# membership contract interface
|
||||
contract(MembershipContract):
|
||||
|
|
@ -48,83 +60,6 @@ proc toBuffer*(x: openArray[byte]): Buffer =
|
|||
let output = Buffer(`ptr`: cast[ptr uint8](baseAddr), len: uint(temp.len))
|
||||
return output
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
|
||||
proc createRLNInstanceLocal(d: int = MerkleTreeDepth): RLNResult =
|
||||
## 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
|
||||
## Returns an error if the instance creation fails
|
||||
var
|
||||
rlnInstance: RLN[Bn256]
|
||||
merkleDepth: csize_t = uint(d)
|
||||
## parameters.key contains the prover and verifier keys
|
||||
## 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
|
||||
## cargo run --example export_test_keys
|
||||
## the file is generated separately and copied here
|
||||
## parameters are function of tree depth and poseidon hasher
|
||||
## to generate parameters for a different tree depth, change the tree size in the following line of rln library
|
||||
## https://github.com/kilic/rln/blob/3bbec368a4adc68cd5f9bfae80b17e1bbb4ef373/examples/export_test_keys/main.rs#L4
|
||||
## and then proceed as explained above
|
||||
parameters: string
|
||||
try:
|
||||
parameters = readFile("waku/v2/protocol/waku_rln_relay/parameters.key")
|
||||
except Exception as err:
|
||||
return err("failed to read the parameters file: " & err.msg)
|
||||
var
|
||||
pbytes = parameters.toBytes()
|
||||
len: csize_t = uint(pbytes.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 err("error in parameters.key")
|
||||
|
||||
# create an instance of RLN
|
||||
let res = new_circuit_from_params(merkleDepth, addr parametersBuffer,
|
||||
addr rlnInstance)
|
||||
# check whether the circuit parameters are generated successfully
|
||||
if (res == false):
|
||||
debug "error in parameters generation"
|
||||
return err("error in parameters generation")
|
||||
return ok(rlnInstance)
|
||||
|
||||
|
||||
proc membershipKeyGen*(ctxPtr: RLN[Bn256]): RlnRelayResult[MembershipKeyPair] =
|
||||
## generates a MembershipKeyPair that can be used for the registration into the rln membership contract
|
||||
## Returns an error if the key generation fails
|
||||
|
||||
# keysBufferPtr will hold the generated key pairs i.e., secret and public keys
|
||||
var
|
||||
keysBuffer: Buffer
|
||||
keysBufferPtr = addr(keysBuffer)
|
||||
done = key_gen(ctxPtr, keysBufferPtr)
|
||||
|
||||
# check whether the keys are generated successfully
|
||||
if(done == false):
|
||||
return err("error in key generation")
|
||||
|
||||
var generatedKeys = cast[ptr array[64, byte]](keysBufferPtr.`ptr`)[]
|
||||
# the public and secret keys together are 64 bytes
|
||||
if (generatedKeys.len != 64):
|
||||
return err("generated keys are of invalid length")
|
||||
|
||||
# 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
|
||||
keypair = MembershipKeyPair(idKey: secret, idCommitment: public)
|
||||
|
||||
|
||||
return ok(keypair)
|
||||
|
||||
when defined(rlnzerokit):
|
||||
proc createRLNInstanceLocal(d: int = MerkleTreeDepth): RLNResult =
|
||||
## generates an instance of RLN
|
||||
## An RLN instance supports both zkSNARKs logics and Merkle tree data structure and operations
|
||||
|
|
@ -143,7 +78,6 @@ when defined(rlnzerokit):
|
|||
return err("error in parameters generation")
|
||||
return ok(rlnInstance)
|
||||
|
||||
|
||||
proc membershipKeyGen*(ctxPtr: ptr RLN): RlnRelayResult[MembershipKeyPair] =
|
||||
## generates a MembershipKeyPair that can be used for the registration into the rln membership contract
|
||||
## Returns an error if the key generation fails
|
||||
|
|
@ -285,23 +219,6 @@ proc appendLength*(input: openArray[byte]): seq[byte] =
|
|||
output = concat(@len, @input)
|
||||
return output
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
proc hash*(rlnInstance: RLN[Bn256], data: openArray[byte]): MerkleNode =
|
||||
## a thin layer on top of the Nim wrapper of the Poseidon hasher
|
||||
debug "hash input", hashhex = data.toHex()
|
||||
var lenPrefData = appendLength(data)
|
||||
var
|
||||
hashInputBuffer = lenPrefData.toBuffer()
|
||||
outputBuffer: Buffer # will holds the hash output
|
||||
|
||||
debug "hash input buffer length", bufflen = hashInputBuffer.len
|
||||
let
|
||||
hashSuccess = hash(rlnInstance, addr hashInputBuffer, addr outputBuffer)
|
||||
output = cast[ptr MerkleNode](outputBuffer.`ptr`)[]
|
||||
|
||||
return output
|
||||
|
||||
when defined(rlnzerokit):
|
||||
proc hash*(rlnInstance: ptr RLN, data: openArray[byte]): MerkleNode =
|
||||
## a thin layer on top of the Nim wrapper of the Poseidon hasher
|
||||
debug "hash input", hashhex = data.toHex()
|
||||
|
|
@ -328,127 +245,6 @@ proc serialize(idKey: IDKey, memIndex: MembershipIndex, epoch: Epoch,
|
|||
let output = concat(@idKey, @memIndexBytes, @epoch, lenPrefMsg)
|
||||
return output
|
||||
|
||||
when defined(rln) or (not defined(rln) and not defined(rlnzerokit)):
|
||||
proc proofGen*(rlnInstance: RLN[Bn256], data: openArray[byte],
|
||||
memKeys: MembershipKeyPair, memIndex: MembershipIndex,
|
||||
epoch: Epoch): RateLimitProofResult =
|
||||
|
||||
# serialize inputs
|
||||
let serializedInputs = serialize(idKey = memKeys.idKey,
|
||||
memIndex = memIndex,
|
||||
epoch = epoch,
|
||||
msg = data)
|
||||
var inputBuffer = toBuffer(serializedInputs)
|
||||
|
||||
debug "input buffer ", inputBuffer
|
||||
|
||||
# generate the proof
|
||||
var proof: Buffer
|
||||
waku_rln_proof_generation_duration_seconds.nanosecondTime:
|
||||
let proofIsSuccessful = generateProof(rlnInstance, addr inputBuffer, addr proof)
|
||||
# check whether the generateProof call is done successfully
|
||||
if not proofIsSuccessful:
|
||||
return err("could not generate the proof")
|
||||
|
||||
var proofValue = cast[ptr array[416, byte]] (proof.`ptr`)
|
||||
let proofBytes: array[416, byte] = proofValue[]
|
||||
debug "proof content", proofHex = proofValue[].toHex
|
||||
|
||||
## parse the proof as |zkSNARKs<256>|root<32>|epoch<32>|share_x<32>|share_y<32>|nullifier<32>|
|
||||
let
|
||||
proofOffset = 256
|
||||
rootOffset = proofOffset + 32
|
||||
epochOffset = rootOffset + 32
|
||||
shareXOffset = epochOffset + 32
|
||||
shareYOffset = shareXOffset + 32
|
||||
nullifierOffset = shareYOffset + 32
|
||||
|
||||
var
|
||||
zkproof: ZKSNARK
|
||||
proofRoot, shareX, shareY: MerkleNode
|
||||
epoch: Epoch
|
||||
nullifier: Nullifier
|
||||
|
||||
discard zkproof.copyFrom(proofBytes[0..proofOffset-1])
|
||||
discard proofRoot.copyFrom(proofBytes[proofOffset..rootOffset-1])
|
||||
discard epoch.copyFrom(proofBytes[rootOffset..epochOffset-1])
|
||||
discard shareX.copyFrom(proofBytes[epochOffset..shareXOffset-1])
|
||||
discard shareY.copyFrom(proofBytes[shareXOffset..shareYOffset-1])
|
||||
discard nullifier.copyFrom(proofBytes[shareYOffset..nullifierOffset-1])
|
||||
|
||||
let output = RateLimitProof(proof: zkproof,
|
||||
merkleRoot: proofRoot,
|
||||
epoch: epoch,
|
||||
shareX: shareX,
|
||||
shareY: shareY,
|
||||
nullifier: nullifier)
|
||||
|
||||
return ok(output)
|
||||
|
||||
proc serialize(proof: RateLimitProof, data: openArray[byte]): seq[byte] =
|
||||
## a private proc to convert RateLimitProof and data to a byte seq
|
||||
## this conversion is used in the proof verification proc
|
||||
## the order of serialization is based on https://github.com/kilic/rln/blob/7ac74183f8b69b399e3bc96c1ae8ab61c026dc43/src/public.rs#L205
|
||||
## [ proof<256>| root<32>| epoch<32>| share_x<32>| share_y<32>| nullifier<32> | signal_len<8> | signal<var> ]
|
||||
let lenPrefMsg = appendLength(@data)
|
||||
var proofBytes = concat(@(proof.proof),
|
||||
@(proof.merkleRoot),
|
||||
@(proof.epoch),
|
||||
@(proof.shareX),
|
||||
@(proof.shareY),
|
||||
@(proof.nullifier),
|
||||
lenPrefMsg)
|
||||
|
||||
return proofBytes
|
||||
|
||||
proc getMerkleRoot*(rlnInstance: RLN[Bn256]): MerkleNodeResult =
|
||||
# read the Merkle Tree root after insertion
|
||||
var
|
||||
root {.noinit.}: Buffer = Buffer()
|
||||
rootPtr = addr(root)
|
||||
getRootSuccessful = getRoot(rlnInstance, rootPtr)
|
||||
if not getRootSuccessful:
|
||||
return err("could not get the root")
|
||||
if not root.len == 32:
|
||||
return err("wrong output size")
|
||||
|
||||
var rootValue = cast[ptr MerkleNode] (root.`ptr`)[]
|
||||
return ok(rootValue)
|
||||
|
||||
proc proofVerify*(rlnInstance: RLN[Bn256], data: openArray[byte], proof: RateLimitProof, validRoots: seq[MerkleNode] = @[]): RlnRelayResult[bool] =
|
||||
## verifies the proof, returns an error if the proof verification fails
|
||||
## returns true if the proof is valid
|
||||
var
|
||||
proofBytes = serialize(proof, data)
|
||||
proofBuffer = proofBytes.toBuffer()
|
||||
f = 0.uint32
|
||||
trace "serialized proof", proof = proofBytes.toHex()
|
||||
|
||||
let verifyIsSuccessful = verify(rlnInstance, addr proofBuffer, addr f)
|
||||
if not verifyIsSuccessful:
|
||||
# something went wrong in verification
|
||||
return err("could not verify proof")
|
||||
# f = 0 means the proof is verified
|
||||
if f != 0:
|
||||
return ok(false)
|
||||
|
||||
return ok(true)
|
||||
|
||||
proc insertMember*(rlnInstance: RLN[Bn256], idComm: IDCommitment): bool =
|
||||
var pkBuffer = toBuffer(idComm)
|
||||
let pkBufferPtr = addr pkBuffer
|
||||
|
||||
# add the member to the tree
|
||||
var member_is_added = update_next_member(rlnInstance, pkBufferPtr)
|
||||
return member_is_added
|
||||
|
||||
proc removeMember*(rlnInstance: RLN[Bn256], index: MembershipIndex): bool =
|
||||
let deletion_success = delete_member(rlnInstance, index)
|
||||
return deletion_success
|
||||
|
||||
|
||||
|
||||
when defined(rlnzerokit):
|
||||
proc proofGen*(rlnInstance: ptr RLN, data: openArray[byte],
|
||||
memKeys: MembershipKeyPair, memIndex: MembershipIndex,
|
||||
epoch: Epoch): RateLimitProofResult =
|
||||
|
|
@ -586,7 +382,6 @@ when defined(rlnzerokit):
|
|||
var rootValue = cast[ptr MerkleNode] (root.`ptr`)[]
|
||||
return ok(rootValue)
|
||||
|
||||
|
||||
proc updateValidRootQueue*(wakuRlnRelay: WakuRLNRelay, root: MerkleNode): void =
|
||||
## updates the valid Merkle root queue with the latest root and pops the oldest one when the capacity of `AcceptableRootWindowSize` is reached
|
||||
let overflowCount = wakuRlnRelay.validMerkleRoots.len() - AcceptableRootWindowSize
|
||||
|
|
@ -610,7 +405,6 @@ proc insertMember*(wakuRlnRelay: WakuRLNRelay, idComm: IDCommitment): RlnRelayRe
|
|||
wakuRlnRelay.updateValidRootQueue(rootAfterUpdate)
|
||||
return ok()
|
||||
|
||||
|
||||
proc removeMember*(wakuRlnRelay: WakuRLNRelay, index: MembershipIndex): RlnRelayResult[void] =
|
||||
## removes a commitment from the local merkle tree at `index`, and adds the changed root to the
|
||||
## queue of valid roots
|
||||
|
|
@ -836,7 +630,6 @@ proc absDiff*(e1, e2: Epoch): uint64 =
|
|||
else:
|
||||
return epoch2 - epoch1
|
||||
|
||||
|
||||
proc validateMessage*(rlnPeer: WakuRLNRelay, msg: WakuMessage,
|
||||
timeOption: Option[float64] = none(float64)): MessageValidationResult =
|
||||
## validate the supplied `msg` based on the waku-rln-relay routing protocol i.e.,
|
||||
|
|
@ -917,7 +710,6 @@ proc validateMessage*(rlnPeer: WakuRLNRelay, msg: WakuMessage,
|
|||
waku_rln_valid_messages_total.observe(rootIndex.toFloat())
|
||||
return MessageValidationResult.Valid
|
||||
|
||||
|
||||
proc toRLNSignal*(wakumessage: WakuMessage): seq[byte] =
|
||||
## it is a utility proc that prepares the `data` parameter of the proof generation procedure i.e., `proofGen` that resides in the current module
|
||||
## it extracts the `contentTopic` and the `payload` of the supplied `wakumessage` and serializes them into a byte sequence
|
||||
|
|
@ -926,7 +718,6 @@ proc toRLNSignal*(wakumessage: WakuMessage): seq[byte] =
|
|||
output = concat(wakumessage.payload, contentTopicBytes)
|
||||
return output
|
||||
|
||||
|
||||
proc appendRLNProof*(rlnPeer: WakuRLNRelay, msg: var WakuMessage,
|
||||
senderEpochTime: float64): bool =
|
||||
## returns true if it can create and append a `RateLimitProof` to the supplied `msg`
|
||||
|
|
@ -957,8 +748,6 @@ proc addAll*(wakuRlnRelay: WakuRLNRelay, list: seq[IDCommitment]): RlnRelayResul
|
|||
return err(memberAdded.error())
|
||||
return ok()
|
||||
|
||||
type GroupUpdateHandler* = proc(pubkey: Uint256, index: Uint256): RlnRelayResult[void] {.gcsafe.}
|
||||
|
||||
proc generateGroupUpdateHandler(rlnPeer: WakuRLNRelay): GroupUpdateHandler =
|
||||
## assuming all the members arrive in order
|
||||
## TODO: check the index and the pubkey depending on
|
||||
|
|
@ -1042,7 +831,6 @@ proc subscribeToGroupEvents*(ethClientUri: string,
|
|||
web3.onDisconnect = proc() =
|
||||
debug "connection to ethereum node dropped", lastBlock = latestBlock
|
||||
|
||||
|
||||
proc handleGroupUpdates*(rlnPeer: WakuRLNRelay) {.async, gcsafe.} =
|
||||
## generates the groupUpdateHandler which is called when a new member is registered,
|
||||
## and has the WakuRLNRelay instance as a closure
|
||||
|
|
@ -1052,7 +840,6 @@ proc handleGroupUpdates*(rlnPeer: WakuRLNRelay) {.async, gcsafe.} =
|
|||
contractAddress = rlnPeer.membershipContractAddress,
|
||||
handler = handler)
|
||||
|
||||
|
||||
proc addRLNRelayValidator*(node: WakuNode, pubsubTopic: PubsubTopic, contentTopic: ContentTopic, spamHandler: Option[SpamHandler] = none(SpamHandler)) =
|
||||
## this procedure is a thin wrapper for the pubsub addValidator method
|
||||
## it sets a validator for the waku messages published on the supplied pubsubTopic and contentTopic
|
||||
|
|
@ -1281,20 +1068,6 @@ proc readRlnCredentials*(path: string,
|
|||
except:
|
||||
return err("Error while loading keyfile for RLN credentials at " & path)
|
||||
|
||||
|
||||
type WakuRlnConfig* = object
|
||||
rlnRelayDynamic*: bool
|
||||
rlnRelayPubsubTopic*: PubsubTopic
|
||||
rlnRelayContentTopic*: ContentTopic
|
||||
rlnRelayMembershipIndex*: uint
|
||||
rlnRelayEthContractAddress*: string
|
||||
rlnRelayEthClientAddress*: string
|
||||
rlnRelayEthAccountPrivateKey*: string
|
||||
rlnRelayEthAccountAddress*: string
|
||||
rlnRelayCredPath*: string
|
||||
rlnRelayCredentialsPassword*: string
|
||||
|
||||
|
||||
proc mount(node: WakuNode,
|
||||
conf: WakuRlnConfig,
|
||||
spamHandler: Option[SpamHandler] = none(SpamHandler),
|
||||
|
|
@ -1440,7 +1213,6 @@ proc mount(node: WakuNode,
|
|||
return err("dynamic rln-relay could not be mounted: " & res.error())
|
||||
return ok()
|
||||
|
||||
|
||||
proc mountRlnRelay*(node: WakuNode,
|
||||
conf: WakuRlnConfig,
|
||||
spamHandler: Option[SpamHandler] = none(SpamHandler),
|
||||
|
|
|
|||
Loading…
Reference in New Issue