From 128741ec843403ecb305f9e171901c2cfd8d55ed Mon Sep 17 00:00:00 2001 From: oskarth Date: Mon, 1 Mar 2021 06:17:28 +0000 Subject: [PATCH] deploy: 52d0ea6445870087ab65cf8ea4711b452eb6ad96 --- .update.timestamp | 2 +- tests/v2/test_waku_swap.nim | 3 + .../protocol/waku_protocol.nim.generated.nim | 64 +++++++++---------- waku/v2/protocol/waku_swap/waku_swap.nim | 50 +++++++++++++-- 4 files changed, 82 insertions(+), 37 deletions(-) diff --git a/.update.timestamp b/.update.timestamp index 79e314ba8..d77964947 100644 --- a/.update.timestamp +++ b/.update.timestamp @@ -1 +1 @@ -1614324620 \ No newline at end of file +1614578120 \ No newline at end of file diff --git a/tests/v2/test_waku_swap.nim b/tests/v2/test_waku_swap.nim index 8fdc99db3..56d765466 100644 --- a/tests/v2/test_waku_swap.nim +++ b/tests/v2/test_waku_swap.nim @@ -40,6 +40,9 @@ procSuite "Waku SWAP Accounting": decodedCheque.isErr == false decodedCheque.get() == cheque + # TODO To do this reliably we need access to contract node + # With current logic state isn't updated because of bad cheque + # Consider moving this test to e2e test, and/or move swap module to be on by default asyncTest "Update accounting state after store operations": let nodeKey1 = crypto.PrivateKey.random(Secp256k1, rng[])[] diff --git a/waku/v1/protocol/waku_protocol.nim.generated.nim b/waku/v1/protocol/waku_protocol.nim.generated.nim index 4559feb54..866e2c726 100644 --- a/waku/v1/protocol/waku_protocol.nim.generated.nim +++ b/waku/v1/protocol/waku_protocol.nim.generated.nim @@ -188,10 +188,10 @@ proc statusRawSender(peerOrResponder: Peer; options: StatusOptions; template status*(peer: Peer; options: StatusOptions; timeout: Duration = milliseconds(10000'i64)): Future[statusObj] = - let peer_184785056 = peer - let sendingFuture`gensym184785057 = statusRawSender(peer, options) - handshakeImpl(peer_184785056, sendingFuture`gensym184785057, - nextMsg(peer_184785056, statusObj), timeout) + let peer_185365056 = peer + let sendingFuture`gensym185365057 = statusRawSender(peer, options) + handshakeImpl(peer_185365056, sendingFuture`gensym185365057, + nextMsg(peer_185365056, statusObj), timeout) proc messages*(peerOrResponder: Peer; envelopes: openarray[Envelope]): Future[void] {. gcsafe.} = @@ -272,9 +272,9 @@ proc p2pSyncResponse*(peerOrResponder: ResponderWithId[p2pSyncResponseObj]): Fut let msgBytes = finish(writer) return sendMsg(peer, msgBytes) -template send*(r`gensym184785072: ResponderWithId[p2pSyncResponseObj]; - args`gensym184785073: varargs[untyped]): auto = - p2pSyncResponse(r`gensym184785072, args`gensym184785073) +template send*(r`gensym185365072: ResponderWithId[p2pSyncResponseObj]; + args`gensym185365073: varargs[untyped]): auto = + p2pSyncResponse(r`gensym185365072, args`gensym185365073) proc p2pSyncRequest*(peerOrResponder: Peer; timeout: Duration = milliseconds(10000'i64)): Future[ @@ -458,71 +458,71 @@ proc p2pRequestCompleteUserHandler(peer: Peer; requestId: Hash; discard -proc statusThunk(peer: Peer; _`gensym184785033: int; data`gensym184785034: Rlp) {. +proc statusThunk(peer: Peer; _`gensym185365033: int; data`gensym185365034: Rlp) {. async, gcsafe.} = - var rlp = data`gensym184785034 + var rlp = data`gensym185365034 var msg {.noinit.}: statusObj msg.options = checkedRlpRead(peer, rlp, StatusOptions) -proc messagesThunk(peer: Peer; _`gensym184785058: int; data`gensym184785059: Rlp) {. +proc messagesThunk(peer: Peer; _`gensym185365058: int; data`gensym185365059: Rlp) {. async, gcsafe.} = - var rlp = data`gensym184785059 + var rlp = data`gensym185365059 var msg {.noinit.}: messagesObj msg.envelopes = checkedRlpRead(peer, rlp, openarray[Envelope]) await(messagesUserHandler(peer, msg.envelopes)) -proc statusOptionsThunk(peer: Peer; _`gensym184785060: int; data`gensym184785061: Rlp) {. +proc statusOptionsThunk(peer: Peer; _`gensym185365060: int; data`gensym185365061: Rlp) {. async, gcsafe.} = - var rlp = data`gensym184785061 + var rlp = data`gensym185365061 var msg {.noinit.}: statusOptionsObj msg.options = checkedRlpRead(peer, rlp, StatusOptions) await(statusOptionsUserHandler(peer, msg.options)) -proc p2pRequestThunk(peer: Peer; _`gensym184785062: int; data`gensym184785063: Rlp) {. +proc p2pRequestThunk(peer: Peer; _`gensym185365062: int; data`gensym185365063: Rlp) {. async, gcsafe.} = - var rlp = data`gensym184785063 + var rlp = data`gensym185365063 var msg {.noinit.}: p2pRequestObj msg.envelope = checkedRlpRead(peer, rlp, Envelope) await(p2pRequestUserHandler(peer, msg.envelope)) -proc p2pMessageThunk(peer: Peer; _`gensym184785064: int; data`gensym184785065: Rlp) {. +proc p2pMessageThunk(peer: Peer; _`gensym185365064: int; data`gensym185365065: Rlp) {. async, gcsafe.} = - var rlp = data`gensym184785065 + var rlp = data`gensym185365065 var msg {.noinit.}: p2pMessageObj msg.envelopes = checkedRlpRead(peer, rlp, openarray[Envelope]) await(p2pMessageUserHandler(peer, msg.envelopes)) -proc batchAcknowledgedThunk(peer: Peer; _`gensym184785066: int; - data`gensym184785067: Rlp) {.async, gcsafe.} = - var rlp = data`gensym184785067 +proc batchAcknowledgedThunk(peer: Peer; _`gensym185365066: int; + data`gensym185365067: Rlp) {.async, gcsafe.} = + var rlp = data`gensym185365067 var msg {.noinit.}: batchAcknowledgedObj await(batchAcknowledgedUserHandler(peer)) -proc messageResponseThunk(peer: Peer; _`gensym184785068: int; - data`gensym184785069: Rlp) {.async, gcsafe.} = - var rlp = data`gensym184785069 +proc messageResponseThunk(peer: Peer; _`gensym185365068: int; + data`gensym185365069: Rlp) {.async, gcsafe.} = + var rlp = data`gensym185365069 var msg {.noinit.}: messageResponseObj await(messageResponseUserHandler(peer)) -proc p2pSyncResponseThunk(peer: Peer; _`gensym184785070: int; - data`gensym184785071: Rlp) {.async, gcsafe.} = - var rlp = data`gensym184785071 +proc p2pSyncResponseThunk(peer: Peer; _`gensym185365070: int; + data`gensym185365071: Rlp) {.async, gcsafe.} = + var rlp = data`gensym185365071 var msg {.noinit.}: p2pSyncResponseObj let reqId = read(rlp, int) await(p2pSyncResponseUserHandler(peer, reqId)) resolveResponseFuture(peer, perPeerMsgId(peer, p2pSyncResponseObj), addr(msg), reqId) -proc p2pSyncRequestThunk(peer: Peer; _`gensym184785074: int; - data`gensym184785075: Rlp) {.async, gcsafe.} = - var rlp = data`gensym184785075 +proc p2pSyncRequestThunk(peer: Peer; _`gensym185365074: int; + data`gensym185365075: Rlp) {.async, gcsafe.} = + var rlp = data`gensym185365075 var msg {.noinit.}: p2pSyncRequestObj let reqId = read(rlp, int) await(p2pSyncRequestUserHandler(peer, reqId)) -proc p2pRequestCompleteThunk(peer: Peer; _`gensym184785076: int; - data`gensym184785077: Rlp) {.async, gcsafe.} = - var rlp = data`gensym184785077 +proc p2pRequestCompleteThunk(peer: Peer; _`gensym185365076: int; + data`gensym185365077: Rlp) {.async, gcsafe.} = + var rlp = data`gensym185365077 var msg {.noinit.}: p2pRequestCompleteObj tryEnterList(rlp) msg.requestId = checkedRlpRead(peer, rlp, Hash) diff --git a/waku/v2/protocol/waku_swap/waku_swap.nim b/waku/v2/protocol/waku_swap/waku_swap.nim index b4385ae50..2036f4cb9 100644 --- a/waku/v2/protocol/waku_swap/waku_swap.nim +++ b/waku/v2/protocol/waku_swap/waku_swap.nim @@ -122,7 +122,7 @@ proc sendCheque*(ws: WakuSwap) {.async.} = var res = waku_swap_contracts.signCheque(aliceSwapAddress) if res.isOk(): - echo "signCheque ", res[] + info "signCheque ", res=res[] let json = res[] signature = json["signature"].getStr() else: @@ -139,13 +139,56 @@ proc sendCheque*(ws: WakuSwap) {.async.} = info "New accounting state", accounting = ws.accounting[peerId] # TODO Authenticate cheque, check beneficiary etc -# TODO Redeem cheque proc handleCheque*(ws: WakuSwap, cheque: Cheque) = info "handle incoming cheque" # XXX Assume peerId is first peer let peerOpt = ws.peerManager.selectPeer(WakuSwapCodec) let peerId = peerOpt.get().peerId - ws.accounting[peerId] += int(cheque.amount) + + # TODO Redeem cheque here + var signature = cast[string](cheque.signature) + # TODO Where should Alice Swap Address come from? Handshake probably? + # Hacky for now + var aliceSwapAddress = "0x6C3d502f1a97d4470b881015b83D9Dd1062172e1" + info "Redeeming cheque with", swapAddress=aliceSwapAddress, signature=signature + var res = waku_swap_contracts.redeemCheque(aliceSwapAddress, signature) + if res.isOk(): + info "redeemCheque ok", redeem=res[] + else: + info "Unable to redeem cheque" + + # Check balance here + # TODO How do we get ERC20 address here? + # XXX This one is wrong + # Normally this would be part of initial setup, otherwise we need some temp persistence here + # Possibly as part of handshake? + var erc20address = "0x6C3d502f1a97d4470b881015b83D9Dd1062172e1" + let balRes = waku_swap_contracts.getERC20Balances(erc20address) + if balRes.isOk(): + # XXX: Assumes Alice and Bob here... + var bobBalance = balRes[]["bobBalance"].getInt() + info "New balance is", balance = bobBalance + else: + info "Problem getting Bob balance" + + # TODO Could imagine scenario where you don't cash cheque but leave it as credit + # In that case, we would probably update accounting state, but keep track of cheques + + # When this is true we update accounting state anyway when node is offline, + # makes waku_swap test pass for now + # Consider desired logic here + var stateUpdateOverRide = true + + if res.isOk(): + info "Updating accounting state with redeemed cheque" + ws.accounting[peerId] += int(cheque.amount) + else: + if stateUpdateOverRide: + info "Updating accounting state with even if cheque failed" + ws.accounting[peerId] += int(cheque.amount) + else: + info "Not updating accounting state with due to bad cheque" + info "New accounting state", accounting = ws.accounting[peerId] proc init*(wakuSwap: WakuSwap) = @@ -218,4 +261,3 @@ proc setPeer*(ws: WakuSwap, peer: PeerInfo) = waku_swap_peers.inc() # TODO End to end communication -