nwaku/tests/v1/test_rpc_waku.nim

{.used.}

import
  std/[options, os, strutils],
  testutils/unittests, stew/byteutils, json_rpc/[rpcserver, rpcclient],
  eth/common as eth_common, eth/[rlp, keys, p2p],
  ../../waku/v1/protocol/waku_protocol,
  ../../waku/v1/node/rpc/[hexstrings, rpc_types, waku, key_storage]

template sourceDir*: string = currentSourcePath.rsplit(DirSep, 1)[0]
## Generate client convenience marshalling wrappers from forward declarations
## For testing, ethcallsigs needs to be kept in sync with ../waku/node/v1/rpc/waku
const sigPath = sourceDir / ParDir / ParDir / "waku" / "v1" / "node" / "rpc" / "wakucallsigs.nim"
createRpcSigs(RpcSocketClient, sigPath)

proc setupNode(capabilities: varargs[ProtocolInfo, `protocolInfo`],
    rng: ref BrHmacDrbgContext, ): EthereumNode =
  let
    keypair = KeyPair.random(rng[])
    srvAddress = Address(ip: parseIpAddress("0.0.0.0"), tcpPort: Port(30303),
      udpPort: Port(30303))

  result = newEthereumNode(keypair, srvAddress, NetworkId(1), nil, "waku test rpc",
    addAllCapabilities = false, rng = rng)
  for capability in capabilities:
    result.addCapability capability

proc doTests {.async.} =
  suite "Waku Remote Procedure Calls":
    let
      rng = keys.newRng()
      ethNode = setupNode(Waku, rng)
      rpcPort = 8545
      rpcServer = newRpcSocketServer(["localhost:" & $rpcPort])
      client = newRpcSocketClient()
      keys = newKeyStorage()

    setupWakuRPC(ethNode, keys, rpcServer, rng)
    rpcServer.start()
    await client.connect("localhost", Port(rpcPort))

    asyncTest "waku_version":
      check await(client.waku_version()) == wakuVersionStr
    asyncTest "waku_info":
      let info = await client.waku_info()
      check info.maxMessageSize == defaultMaxMsgSize
    asyncTest "waku_setMaxMessageSize":
      let testValue = 1024'u64
      check await(client.waku_setMaxMessageSize(testValue)) == true
      var info = await client.waku_info()
      check info.maxMessageSize == testValue
      expect ValueError:
        discard await(client.waku_setMaxMessageSize(defaultMaxMsgSize + 1))
      info = await client.waku_info()
      check info.maxMessageSize == testValue
    asyncTest "waku_setMinPoW":
      let testValue = 0.0001
      check await(client.waku_setMinPoW(testValue)) == true
      let info = await client.waku_info()
      check info.minPow == testValue
    # test "waku_markTrustedPeer":
      # TODO: need to connect a peer to test
    asyncTest "waku asymKey tests":
      let keyID = await client.waku_newKeyPair()
      check:
        await(client.waku_hasKeyPair(keyID)) == true
        await(client.waku_deleteKeyPair(keyID)) == true
        await(client.waku_hasKeyPair(keyID)) == false
      expect ValueError:
        discard await(client.waku_deleteKeyPair(keyID))

      let privkey = "0x5dc5381cae54ba3174dc0d46040fe11614d0cc94d41185922585198b4fcef9d3"
      let pubkey = "0x04e5fd642a0f630bbb1e4cd7df629d7b8b019457a9a74f983c0484a045cebb176def86a54185b50bbba6bbf97779173695e92835d63109c23471e6da382f922fdb"
      let keyID2 = await client.waku_addPrivateKey(privkey)
      check:
        await(client.waku_getPublicKey(keyID2)) == pubkey.toPublicKey
        await(client.waku_getPrivateKey(keyID2)).toRaw() == privkey.toPrivateKey.toRaw()
        await(client.waku_hasKeyPair(keyID2)) == true
        await(client.waku_deleteKeyPair(keyID2)) == true
        await(client.waku_hasKeyPair(keyID2)) == false
      expect ValueError:
        discard await(client.waku_deleteKeyPair(keyID2))
    asyncTest "waku symKey tests":
      let keyID = await client.waku_newSymKey()
      check:
        await(client.waku_hasSymKey(keyID)) == true
        await(client.waku_deleteSymKey(keyID)) == true
        await(client.waku_hasSymKey(keyID)) == false
      expect ValueError:
        discard await(client.waku_deleteSymKey(keyID))

      let symKey = "0x0000000000000000000000000000000000000000000000000000000000000001"
      let keyID2 = await client.waku_addSymKey(symKey)
      check:
        await(client.waku_getSymKey(keyID2)) == symKey.toSymKey
        await(client.waku_hasSymKey(keyID2)) == true
        await(client.waku_deleteSymKey(keyID2)) == true
        await(client.waku_hasSymKey(keyID2)) == false
      expect ValueError:
        discard await(client.waku_deleteSymKey(keyID2))

      let keyID3 = await client.waku_generateSymKeyFromPassword("password")
      let keyID4 = await client.waku_generateSymKeyFromPassword("password")
      let keyID5 = await client.waku_generateSymKeyFromPassword("nimbus!")
      check:
        await(client.waku_getSymKey(keyID3)) ==
          await(client.waku_getSymKey(keyID4))
        await(client.waku_getSymKey(keyID3)) !=
          await(client.waku_getSymKey(keyID5))
        await(client.waku_hasSymKey(keyID3)) == true
        await(client.waku_deleteSymKey(keyID3)) == true
        await(client.waku_hasSymKey(keyID3)) == false
      expect ValueError:
        discard await(client.waku_deleteSymKey(keyID3))

    # Some defaults for the filter & post tests
    let
      ttl = 30'u64
      topicStr = "0x12345678"
      payload = "0x45879632"
      # A very low target and long time so we are sure the test never fails
      # because of this
      powTarget = 0.001
      powTime = 1.0

    asyncTest "waku filter create and delete":
      let
        topic = topicStr.toTopic()
        symKeyID = await client.waku_newSymKey()
        options = WakuFilterOptions(symKeyID: some(symKeyID),
                                       topics: some(@[topic]))
        filterID = await client.waku_newMessageFilter(options)

      check:
        filterID.string.isValidIdentifier
        await(client.waku_deleteMessageFilter(filterID)) == true
      expect ValueError:
        discard await(client.waku_deleteMessageFilter(filterID))

    asyncTest "waku symKey post and filter loop":
      let
        topic = topicStr.toTopic()
        symKeyID = await client.waku_newSymKey()
        options = WakuFilterOptions(symKeyID: some(symKeyID),
                                       topics: some(@[topic]))
        filterID = await client.waku_newMessageFilter(options)
        message = WakuPostMessage(symKeyID: some(symKeyID),
                                     ttl: ttl,
                                     topic: some(topic),
                                     payload: payload.HexDataStr,
                                     powTime: powTime,
                                     powTarget: powTarget)
      check:
        await(client.waku_setMinPoW(powTarget)) == true
        await(client.waku_post(message)) == true

      let messages = await client.waku_getFilterMessages(filterID)
      check:
        messages.len == 1
        messages[0].sig.isNone()
        messages[0].recipientPublicKey.isNone()
        messages[0].ttl == ttl
        messages[0].topic == topic
        messages[0].payload == hexToSeqByte(payload)
        messages[0].padding.len > 0
        messages[0].pow >= powTarget

        await(client.waku_deleteMessageFilter(filterID)) == true

    asyncTest "waku asymKey post and filter loop":
      let
        topic = topicStr.toTopic()
        privateKeyID = await client.waku_newKeyPair()
        options = WakuFilterOptions(privateKeyID: some(privateKeyID))
        filterID = await client.waku_newMessageFilter(options)
        pubKey = await client.waku_getPublicKey(privateKeyID)
        message = WakuPostMessage(pubKey: some(pubKey),
                                     ttl: ttl,
                                     topic: some(topic),
                                     payload: payload.HexDataStr,
                                     powTime: powTime,
                                     powTarget: powTarget)
      check:
        await(client.waku_setMinPoW(powTarget)) == true
        await(client.waku_post(message)) == true

      let messages = await client.waku_getFilterMessages(filterID)
      check:
        messages.len == 1
        messages[0].sig.isNone()
        messages[0].recipientPublicKey.get() == pubKey
        messages[0].ttl == ttl
        messages[0].topic == topic
        messages[0].payload == hexToSeqByte(payload)
        messages[0].padding.len > 0
        messages[0].pow >= powTarget

        await(client.waku_deleteMessageFilter(filterID)) == true

    asyncTest "waku signature in post and filter loop":
      let
        topic = topicStr.toTopic()
        symKeyID = await client.waku_newSymKey()
        privateKeyID = await client.waku_newKeyPair()
        pubKey = await client.waku_getPublicKey(privateKeyID)
        options = WakuFilterOptions(symKeyID: some(symKeyID),
                                       topics: some(@[topic]),
                                       sig: some(pubKey))
        filterID = await client.waku_newMessageFilter(options)
        message = WakuPostMessage(symKeyID: some(symKeyID),
                                     sig: some(privateKeyID),
                                     ttl: ttl,
                                     topic: some(topic),
                                     payload: payload.HexDataStr,
                                     powTime: powTime,
                                     powTarget: powTarget)
      check:
        await(client.waku_setMinPoW(powTarget)) == true
        await(client.waku_post(message)) == true

      let messages = await client.waku_getFilterMessages(filterID)
      check:
        messages.len == 1
        messages[0].sig.get() == pubKey
        messages[0].recipientPublicKey.isNone()
        messages[0].ttl == ttl
        messages[0].topic == topic
        messages[0].payload == hexToSeqByte(payload)
        messages[0].padding.len > 0
        messages[0].pow >= powTarget

        await(client.waku_deleteMessageFilter(filterID)) == true

    rpcServer.stop()
    rpcServer.close()

waitFor doTests()