From 7eba2f46b3208806004dda72e2298abbb8b48bf6 Mon Sep 17 00:00:00 2001
From: Eric Mastro <eric.mastro@gmail.com>
Date: Thu, 19 Jan 2023 17:01:21 +1100
Subject: [PATCH] [marketplace] update to work with latest contracts

---
 codex/contracts/market.nim         |  4 ++--
 codex/contracts/requests.nim       | 12 ++++++------
 codex/market.nim                   |  2 +-
 codex/sales.nim                    |  7 ++-----
 tests/codex/helpers/mockmarket.nim |  2 +-
 tests/contracts/testContracts.nim  |  3 ++-
 6 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/codex/contracts/market.nim b/codex/contracts/market.nim
index 975e84ce..60097122 100644
--- a/codex/contracts/market.nim
+++ b/codex/contracts/market.nim
@@ -31,8 +31,8 @@ method getSigner*(market: OnChainMarket): Future[Address] {.async.} =
 method myRequests*(market: OnChainMarket): Future[seq[RequestId]] {.async.} =
   return await market.contract.myRequests
 
-method mySlots*(market: OnChainMarket, requestId: RequestId): Future[seq[SlotId]] {.async.} =
-  return await market.contract.mySlots(requestId)
+method mySlots*(market: OnChainMarket): Future[seq[SlotId]] {.async.} =
+  return await market.contract.mySlots()
 
 method requestStorage(market: OnChainMarket, request: StorageRequest){.async.} =
   await market.contract.requestStorage(request)
diff --git a/codex/contracts/requests.nim b/codex/contracts/requests.nim
index b0422753..3ac45ddb 100644
--- a/codex/contracts/requests.nim
+++ b/codex/contracts/requests.nim
@@ -118,8 +118,8 @@ func solidityType*(_: type StorageRequest): string =
 func solidityType*(_: type Slot): string =
   solidityType(Slot.fieldTypes)
 
-func solidityType*[T: RequestId | SlotId | Nonce](_: type T): string =
-  solidityType(array[32, byte])
+# func solidityType*[T: RequestId | SlotId | Nonce](_: type T): string =
+#   solidityType(array[32, byte])
 func encode*(encoder: var AbiEncoder, por: StoragePoR) =
   encoder.write(por.fieldValues)
 
@@ -140,10 +140,10 @@ func encode*(encoder: var AbiEncoder, request: StorageRequest) =
 func encode*(encoder: var AbiEncoder, slot: Slot) =
   encoder.write(slot.fieldValues)
 
-func decode*[T: RequestId | SlotId | Nonce](decoder: var AbiDecoder,
-                                            _: type T): ?!T =
-  let nonce = ?decoder.read(type array[32, byte])
-  success T(nonce)
+# func decode*[T: RequestId | SlotId | Nonce](decoder: var AbiDecoder,
+#                                             _: type T): ?!T =
+#   let nonce = ?decoder.read(type array[32, byte])
+#   success T(nonce)
 
 func decode*(decoder: var AbiDecoder, T: type StoragePoR): ?!T =
   let tupl = ?decoder.read(StoragePoR.fieldTypes)
diff --git a/codex/market.nim b/codex/market.nim
index 1dd4e5f4..713f1ac0 100644
--- a/codex/market.nim
+++ b/codex/market.nim
@@ -28,7 +28,7 @@ method requestStorage*(market: Market,
 method myRequests*(market: Market): Future[seq[RequestId]] {.base, async.} =
   raiseAssert("not implemented")
 
-method mySlots*(market: Market, requestId: RequestId): Future[seq[SlotId]] {.base, async.} =
+method mySlots*(market: Market): Future[seq[SlotId]] {.base, async.} =
   raiseAssert("not implemented")
 
 method getRequest*(market: Market,
diff --git a/codex/sales.nim b/codex/sales.nim
index 42ceb3ae..89828903 100644
--- a/codex/sales.nim
+++ b/codex/sales.nim
@@ -89,11 +89,8 @@ proc load*(sales: Sales) {.async.} =
 
   # TODO: restore availability from disk
   let requestIds = await market.myRequests()
-  var slotIds: seq[SlotId]
-  # TODO: this needs to be optimised
-  for requestId in requestIds:
-    let reqSlotIds = await market.mySlots(requestId)
-    slotIds.add reqSlotIds
+  let slotIds = await market.mySlots()
+
   for slotId in slotIds:
     # TODO: this needs to be optimised
     if slot =? await market.getSlot(slotId):
diff --git a/tests/codex/helpers/mockmarket.nim b/tests/codex/helpers/mockmarket.nim
index bca0727b..3b649ed2 100644
--- a/tests/codex/helpers/mockmarket.nim
+++ b/tests/codex/helpers/mockmarket.nim
@@ -74,7 +74,7 @@ method requestStorage*(market: MockMarket, request: StorageRequest) {.async.} =
 method myRequests*(market: MockMarket): Future[seq[RequestId]] {.async.} =
   return market.activeRequests[market.signer]
 
-method mySlots*(market: MockMarket, requestId: RequestId): Future[seq[SlotId]] {.async.} =
+method mySlots*(market: MockMarket): Future[seq[SlotId]] {.async.} =
   return market.activeSlots[market.signer]
 
 method getRequest(market: MockMarket,
diff --git a/tests/contracts/testContracts.nim b/tests/contracts/testContracts.nim
index d8c77a5d..4b30951f 100644
--- a/tests/contracts/testContracts.nim
+++ b/tests/contracts/testContracts.nim
@@ -82,10 +82,11 @@ ethersuite "Marketplace contracts":
     let requestEnd = await marketplace.requestEnd(request.id)
     await provider.advanceTimeTo(requestEnd.u256)
     let startBalance = await token.balanceOf(address)
-    await marketplace.freeSlot(slotId)
+    await storage.payoutSlot(request.id, 0.u256)
     let endBalance = await token.balanceOf(address)
     check endBalance == (startBalance + request.ask.duration * request.ask.reward)
 
+
   test "cannot mark proofs missing for cancelled request":
     await provider.advanceTimeTo(request.expiry + 1)
     switchAccount(client)