## Nim wrappers for the functions defined in librln
when (NimMajor, NimMinor) < (1, 4):
  {.push raises: [Defect].}
else:
  {.push raises: [].}

import stew/results

######################################################################
## ERC-5564-BN254 module APIs
######################################################################

type CErrorCode* = uint8

type CG1Projective* = object
  x0: array[32, uint8]

type CReturn*[T] = object
  value: T
  err_code: CErrorCode

type CFr* = object
  x0: array[32, uint8]

type CStealthCommitment* = object
  stealth_commitment: CG1Projective
  view_tag: uint64

type CKeyPair* = object
  private_key: CFr
  public_key: CG1Projective

proc drop_ffi_derive_public_key*(ptrx: ptr CReturn[CG1Projective]) {.importc: "drop_ffi_derive_public_key".}

proc drop_ffi_generate_random_fr*(ptrx: ptr CReturn[CFr]) {.importc: "drop_ffi_generate_random_fr".}

proc drop_ffi_generate_stealth_commitment*(ptrx: ptr CReturn[CStealthCommitment]) {.importc: "drop_ffi_generate_stealth_commitment".}

proc drop_ffi_generate_stealth_private_key*(ptrx: ptr CReturn[CFr]) {.importc: "drop_ffi_generate_stealth_private_key".}

proc drop_ffi_random_keypair*(ptrx: ptr CReturn[CKeyPair]) {.importc: "drop_ffi_random_keypair".}

proc ffi_derive_public_key*(private_key: ptr CFr): (ptr CReturn[CG1Projective]) {.importc: "ffi_derive_public_key".}

proc ffi_generate_random_fr*(): (ptr CReturn[CFr]) {.importc: "ffi_generate_random_fr".}

proc ffi_generate_stealth_commitment*(viewing_public_key: ptr CG1Projective,
                                      spending_public_key: ptr CG1Projective,
                                      ephemeral_private_key: ptr CFr): (ptr CReturn[CStealthCommitment]) {.importc: "ffi_generate_stealth_commitment".}

proc ffi_generate_stealth_private_key*(ephemeral_public_key: ptr CG1Projective,
                                       spending_key: ptr CFr,
                                       viewing_key: ptr CFr,
                                       view_tag: ptr uint64): (ptr CReturn[CFr]) {.importc: "ffi_generate_stealth_private_key".}

proc ffi_random_keypair*(): (ptr CReturn[CKeyPair]) {.importc: "ffi_random_keypair".}


## Nim wrappers and types for the ERC-5564-BN254 module

type FFIResult[T] = Result[T, string]
type Fr = array[32, uint8]
type G1Projective = array[32, uint8]
type KeyPair* = object
  private_key*: Fr
  public_key*: G1Projective
type StealthCommitment* = object
  stealth_commitment*: G1Projective
  view_tag*: uint64
type PrivateKey* = Fr
type PublicKey* = G1Projective

proc generateRandomFr*(): FFIResult[Fr] =
  let res_ptr = (ffi_generate_random_fr())
  let res_value = res_ptr[]
  if res_value.err_code != 0:
    drop_ffi_generate_random_fr(res_ptr)
    return err("Error generating random field element: " & $res_value.err_code)

  let ret = res_value.value.x0
  drop_ffi_generate_random_fr(res_ptr)
  return ok(ret)

proc generateKeypair*(): FFIResult[KeyPair] =
  let res_ptr = (ffi_random_keypair())
  let res_value = res_ptr[]
  if res_value.err_code != 0:
    drop_ffi_random_keypair(res_ptr)
    return err("Error generating random keypair: " & $res_value.err_code)

  let ret = KeyPair(private_key: res_value.value.private_key.x0, public_key: res_value.value.public_key.x0)
  drop_ffi_random_keypair(res_ptr)
  return ok(ret)

proc generateStealthCommitment*(viewing_public_key: G1Projective,
                                spending_public_key: G1Projective,
                                ephemeral_private_key: Fr): FFIResult[StealthCommitment] =
  let viewing_public_key = CG1Projective(x0: viewing_public_key)
  let viewing_public_key_ptr = unsafeAddr(viewing_public_key)
  let spending_public_key = CG1Projective(x0: spending_public_key)
  let spending_public_key_ptr = unsafeAddr(spending_public_key)
  let ephemeral_private_key = CFr(x0: ephemeral_private_key)
  let ephemeral_private_key_ptr = unsafeAddr(ephemeral_private_key)

  let res_ptr = (ffi_generate_stealth_commitment(viewing_public_key_ptr, spending_public_key_ptr, ephemeral_private_key_ptr))
  let res_value = res_ptr[]
  if res_value.err_code != 0:
    drop_ffi_generate_stealth_commitment(res_ptr)
    return err("Error generating stealth commitment: " & $res_value.err_code)

  let ret = StealthCommitment(stealth_commitment: res_value.value.stealth_commitment.x0, view_tag: res_value.value.view_tag)
  drop_ffi_generate_stealth_commitment(res_ptr)
  return ok(ret)

proc generateStealthPrivateKey*(ephemeral_public_key: G1Projective,
                                spending_key: Fr,
                                viewing_key: Fr,
                                view_tag: uint64): FFIResult[Fr] =
  let ephemeral_public_key = CG1Projective(x0: ephemeral_public_key)
  let ephemeral_public_key_ptr = unsafeAddr(ephemeral_public_key)
  let spending_key = CFr(x0: spending_key)
  let spending_key_ptr = unsafeAddr(spending_key)
  let viewing_key = CFr(x0: viewing_key)
  let viewing_key_ptr = unsafeAddr(viewing_key)
  let view_tag_ptr = unsafeAddr(view_tag)

  let res_ptr = (ffi_generate_stealth_private_key(ephemeral_public_key_ptr, spending_key_ptr, viewing_key_ptr, view_tag_ptr))
  let res_value = res_ptr[]
  if res_value.err_code != 0:
    drop_ffi_generate_stealth_private_key(res_ptr)
    return err("Error generating stealth private key: " & $res_value.err_code)

  let ret = res_value.value.x0
  drop_ffi_generate_stealth_private_key(res_ptr)
  return ok(ret)