remove extra unrequired things

Author: darshankabariya

waku/waku_rln_relay/rln/rln_interface.nim

@@ -44,11 +44,6 @@ type ffi_RLNProof* = object
   share_y*: CFr # Shamir secret share y
   nullifier*: CFr # Message nullifier
 
-## Merkle proof structure
-type ffi_MerkleProof* = object
-  path_elements*: Vec[CFr]
-  indices*: Vec[uint8]
-
 ######################################################################
 ## RLN Zerokit FFI2 APIs
 ######################################################################
@@ -61,13 +56,6 @@ proc ffi_key_gen*(output: ptr ffi_IdentityCredential): bool {.importc: "ffi_key_
 ## Output is written directly to the ffi_IdentityCredential struct
 ## Returns true on success, false on failure
 
-proc ffi_seeded_key_gen*(
-  seed: ptr Vec[uint8], output: ptr ffi_IdentityCredential
-): bool {.importc: "ffi_seeded_key_gen".}
-
-## Generates identity using a seed (hashed with Keccak256, then used with ChaCha20)
-## Returns true on success, false on failure
-
 #-------------------------------- Circuit/Context Initialization -----------------------------------------
 
 proc ffi_new*(config_path: cstring, ctx: ptr (ptr RLN)): bool {.importc: "ffi_new".}
@@ -76,16 +64,6 @@ proc ffi_new*(config_path: cstring, ctx: ptr (ptr RLN)): bool {.importc: "ffi_ne
 ## ctx: pointer to store the created RLN instance
 ## Returns true on success, false on failure
 
-proc ffi_new_with_params*(
-  zkey: ptr Vec[uint8], graph: ptr Vec[uint8], ctx: ptr (ptr RLN)
-): bool {.importc: "ffi_new_with_params".}
-
-## Creates an RLN instance from raw circuit parameters
-## zkey: proving key data
-## graph: circuit graph data
-## ctx: pointer to store the created RLN instance
-## Returns true on success, false on failure
-
 #-------------------------------- Proof Generation -----------------------------------------
 
 proc ffi_generate_rln_proof*(
@@ -101,18 +79,6 @@ proc ffi_generate_rln_proof*(
 ## output: structured proof output
 ## Returns true on success, false on failure
 
-proc ffi_generate_rln_proof_stateless*(
-  zkey: ptr Vec[uint8],
-  graph: ptr Vec[uint8],
-  witness: ptr ffi_RLNWitnessInput,
-  signal: ptr Vec[uint8],
-  output: ptr ffi_RLNProof,
-): bool {.importc: "ffi_generate_rln_proof_stateless".}
-
-## Generates an RLN proof without maintaining context state
-## Useful for one-off proof generation
-## Returns true on success, false on failure
-
 #-------------------------------- Proof Verification -----------------------------------------
 
 proc ffi_verify_rln_proof*(
@@ -131,55 +97,6 @@ proc ffi_verify_rln_proof*(
 ## Returns true if verification completed, false on error
 ## Check is_valid for actual proof validity
 
-#-------------------------------- Merkle Tree Operations -----------------------------------------
-
-proc ffi_set_leaf*(
-  ctx: ptr RLN, index: csize_t, leaf: ptr CFr
-): bool {.importc: "ffi_set_leaf".}
-
-## Sets a leaf at the specified index in the Merkle tree
-## Returns true on success, false on failure
-
-proc ffi_get_leaf*(
-  ctx: ptr RLN, index: csize_t, output: ptr CFr
-): bool {.importc: "ffi_get_leaf".}
-
-## Gets the leaf at the specified index from the Merkle tree
-## Returns true on success, false on failure
-
-proc ffi_get_root*(ctx: ptr RLN, output: ptr CFr): bool {.importc: "ffi_get_root".}
-## Gets the current Merkle tree root
-## Returns true on success, false on failure
-
-proc ffi_get_proof*(
-  ctx: ptr RLN, index: csize_t, output: ptr ffi_MerkleProof
-): bool {.importc: "ffi_get_proof".}
-
-## Gets the Merkle proof for the leaf at the specified index
-## Returns true on success, false on failure
-
-proc ffi_verify_merkle_proof*(
-  ctx: ptr RLN, leaf: ptr CFr, proof: ptr ffi_MerkleProof, is_valid: ptr bool
-): bool {.importc: "ffi_verify_proof".}
-
-## Verifies a Merkle proof
-## is_valid: output parameter - true if proof is valid
-## Returns true if verification completed, false on error
-
-proc ffi_set_leaves*(
-  ctx: ptr RLN, start_index: csize_t, leaves: ptr Vec[CFr]
-): bool {.importc: "ffi_set_leaves".}
-
-## Sets multiple leaves starting at start_index
-## Returns true on success, false on failure
-
-proc ffi_set_leaves_from*(
-  ctx: ptr RLN, start_index: csize_t, leaves: ptr Vec[CFr]
-): bool {.importc: "ffi_set_leaves_from".}
-
-## Sets leaves from a specific index (alternative batch operation)
-## Returns true on success, false on failure
-
 #-------------------------------- Hashing Functions -----------------------------------------
 
 proc ffi_hash_to_field_le*(
@@ -190,13 +107,6 @@ proc ffi_hash_to_field_le*(
 ## Used to map signals to field elements
 ## Returns true on success, false on failure
 
-proc ffi_hash_to_field_be*(
-  input: ptr Vec[uint8], output: ptr CFr
-): bool {.importc: "ffi_hash_to_field_be".}
-
-## Hashes arbitrary bytes to a field element (big-endian)
-## Returns true on success, false on failure
-
 proc ffi_poseidon_hash_pair*(
   a: ptr CFr, b: ptr CFr
 ): ptr CFr {.importc: "ffi_poseidon_hash_pair".}
@@ -212,54 +122,6 @@ proc cfr_to_bytes_le*(cfr: ptr CFr): Vec[uint8] {.importc: "cfr_to_bytes_le".}
 ## Serializes a field element to bytes (little-endian)
 ## Returns Vec[uint8] containing the serialized bytes
 
-proc cfr_to_bytes_be*(cfr: ptr CFr): Vec[uint8] {.importc: "cfr_to_bytes_be".}
-
-## Serializes a field element to bytes (big-endian)
-## Returns Vec[uint8] containing the serialized bytes
-
-proc bytes_le_to_cfr*(bytes: ptr Vec[uint8]): ptr CFr {.importc: "bytes_le_to_cfr".}
-
-## Deserializes bytes (little-endian) to a field element
-## Returns pointer to boxed CFr (must be freed with cfr_free)
-
-proc bytes_be_to_cfr*(bytes: ptr Vec[uint8]): ptr CFr {.importc: "bytes_be_to_cfr".}
-
-## Deserializes bytes (big-endian) to a field element
-## Returns pointer to boxed CFr (must be freed with cfr_free)
-
-proc vec_cfr_to_bytes_le*(
-  vec: ptr Vec[CFr]
-): Vec[uint8] {.importc: "vec_cfr_to_bytes_le".}
-
-## Serializes a vector of field elements to bytes (little-endian)
-## Returns Vec[uint8] containing the serialized bytes
-
-proc vec_cfr_to_bytes_be*(
-  vec: ptr Vec[CFr]
-): Vec[uint8] {.importc: "vec_cfr_to_bytes_be".}
-
-## Serializes a vector of field elements to bytes (big-endian)
-## Returns Vec[uint8] containing the serialized bytes
-
-## CResult type for functions that can return errors
-type CResult*[T, E] = object
-  ok*: ptr T
-  err*: ptr E
-
-proc bytes_le_to_vec_cfr*(
-  bytes: ptr Vec[uint8]
-): CResult[ptr Vec[CFr], cstring] {.importc: "bytes_le_to_vec_cfr".}
-
-## Deserializes bytes (little-endian) to a vector of field elements
-## Returns CResult with either ok (ptr Vec[CFr]) or err (cstring)
-
-proc bytes_be_to_vec_cfr*(
-  bytes: ptr Vec[uint8]
-): CResult[ptr Vec[CFr], cstring] {.importc: "bytes_be_to_vec_cfr".}
-
-## Deserializes bytes (big-endian) to a vector of field elements
-## Returns CResult with either ok (ptr Vec[CFr]) or err (cstring)
-
 proc uint_to_cfr*(value: uint32): ptr CFr {.importc: "uint_to_cfr".}
 
 ## Creates a field element from an unsigned integer
@@ -270,17 +132,10 @@ proc cfr_zero*(): ptr CFr {.importc: "cfr_zero".}
 ## Creates a zero field element
 ## Returns pointer to boxed CFr (must be freed with cfr_free)
 
-proc cfr_one*(): ptr CFr {.importc: "cfr_one".}
-## Creates a one field element
-## Returns pointer to boxed CFr (must be freed with cfr_free)
-
 proc cfr_free*(cfr: ptr CFr) {.importc: "cfr_free".}
 ## Frees a boxed CFr
 ## Must be called for all CFr pointers returned by the API
 
-proc cfr_debug*(cfr: ptr CFr): cstring {.importc: "cfr_debug".}
-## Returns debug string representation of CFr
-
 #-------------------------------- Helper Procedures -----------------------------------------
 
 proc newVec*[T](data: seq[T]): Vec[T] =

waku/waku_rln_relay/rln/wrappers.nim

@@ -254,139 +254,4 @@ proc extractMetadata*(proof: RateLimitProof): RlnRelayResult[ProofMetadata] =
       shareY: proof.shareY,
       externalNullifier: externalNullifier,
     )
-  )
-
-######################################################################
-## Example: Proof Generation (NEW - shows how to use FFI2)
-######################################################################
-
-proc generateProof*(
-    ctx: ptr RLN,
-    identitySecret: seq[byte],
-    userMessageLimit: uint64,
-    messageId: uint64,
-    merkleProof: seq[seq[byte]], # path elements
-    merkleIndices: seq[byte],
-    externalNullifier: seq[byte],
-    signal: seq[byte],
-): RlnRelayResult[ffi_RLNProof] =
-  ## Example of proof generation using FFI2
-  ## This shows the new structured approach
-
-  # Convert identity secret to CFr
-  var identitySecretVec = newVec(identitySecret)
-  var identitySecretCFr: CFr
-  if not ffi_hash_to_field_le(addr identitySecretVec, addr identitySecretCFr):
-    freeVec(identitySecretVec)
-    return err("failed to convert identity secret")
-  freeVec(identitySecretVec)
-
-  # Convert user message limit to CFr using new API
-  let userMessageLimitCFrPtr = uint_to_cfr(userMessageLimit.uint32)
-  if userMessageLimitCFrPtr == nil:
-    return err("failed to convert user message limit")
-  let userMessageLimitCFr = userMessageLimitCFrPtr[]
-  cfr_free(userMessageLimitCFrPtr)
-
-  # Convert message ID to CFr using new API
-  let messageIdCFrPtr = uint_to_cfr(messageId.uint32)
-  if messageIdCFrPtr == nil:
-    return err("failed to convert message ID")
-  let messageIdCFr = messageIdCFrPtr[]
-  cfr_free(messageIdCFrPtr)
-
-  # Convert merkle proof path elements to CFr
-  var pathElementsCFr: seq[CFr]
-  for element in merkleProof:
-    var elementVec = newVec(element)
-    var cfr: CFr
-    if not ffi_hash_to_field_le(addr elementVec, addr cfr):
-      freeVec(elementVec)
-      return err("failed to convert path element")
-    pathElementsCFr.add(cfr)
-    freeVec(elementVec)
-
-  # Convert external nullifier to CFr
-  var externalNullifierVec = newVec(externalNullifier)
-  var externalNullifierCFr: CFr
-  if not ffi_hash_to_field_le(addr externalNullifierVec, addr externalNullifierCFr):
-    freeVec(externalNullifierVec)
-    return err("failed to convert external nullifier")
-  freeVec(externalNullifierVec)
-
-  # Compute x (Shamir share x-coordinate) - simplified for example
-  let xCFrPtr = cfr_zero()
-  if xCFrPtr == nil:
-    return err("failed to create x coordinate")
-  let xCFr = xCFrPtr[]
-  cfr_free(xCFrPtr)
-
-  # Build witness input struct
-  var witness = ffi_RLNWitnessInput(
-    identity_secret: identitySecretCFr,
-    user_message_limit: userMessageLimitCFr,
-    message_id: messageIdCFr,
-    path_elements: newVec(pathElementsCFr),
-    identity_path_index: newVec(merkleIndices),
-    x: xCFr,
-    external_nullifier: externalNullifierCFr,
-  )
-
-  # Prepare signal
-  var signalVec = newVec(signal)
-
-  # Generate proof
-  var proof: ffi_RLNProof
-  let success = ffi_generate_rln_proof(ctx, addr witness, addr signalVec, addr proof)
-
-  # Clean up
-  freeVec(witness.path_elements)
-  freeVec(witness.identity_path_index)
-  freeVec(signalVec)
-
-  if not success:
-    return err("proof generation failed")
-
-  return ok(proof)
-
-######################################################################
-## Example: Proof Verification (NEW - shows how to use FFI2)
-######################################################################
-
-proc verifyProof*(
-    ctx: ptr RLN,
-    proof: ffi_RLNProof,
-    signal: seq[byte],
-    roots: seq[seq[byte]] = @[] # Optional multiple roots
-    ,
-): RlnRelayResult[bool] =
-  ## Example of proof verification using FFI2
-
-  var signalVec = newVec(signal)
-
-  # Convert roots to CFr if provided
-  var rootsCFr: seq[CFr]
-  for root in roots:
-    var rootVec = newVec(root)
-    var cfr: CFr
-    if not ffi_hash_to_field_le(addr rootVec, addr cfr):
-      freeVec(rootVec)
-      freeVec(signalVec)
-      return err("failed to convert root")
-    rootsCFr.add(cfr)
-    freeVec(rootVec)
-
-  var rootsVec = newVec(rootsCFr)
-  var isValid: bool
-
-  let success = ffi_verify_rln_proof(
-    ctx, unsafeAddr proof, addr signalVec, addr rootsVec, addr isValid
-  )
-
-  freeVec(signalVec)
-  freeVec(rootsVec)
-
-  if not success:
-    return err("proof verification call failed")
-
-  return ok(isValid)
+  )