Merge branch 'master' into async-tree-building

codex/contracts/market.nim

@@ -56,7 +56,7 @@ proc approveFunds(market: OnChainMarket, amount: UInt256) {.async.} =
     discard await token.increaseAllowance(market.contract.address(), amount).confirm(0)
 
 method getZkeyHash*(market: OnChainMarket): Future[?string] {.async.} =
-  let config = await market.contract.config()
+  let config = await market.contract.configuration()
   return some config.proofs.zkeyHash
 
 method getSigner*(market: OnChainMarket): Future[Address] {.async.} =
@@ -65,18 +65,18 @@ method getSigner*(market: OnChainMarket): Future[Address] {.async.} =
 
 method periodicity*(market: OnChainMarket): Future[Periodicity] {.async.} =
   convertEthersError:
-    let config = await market.contract.config()
+    let config = await market.contract.configuration()
     let period = config.proofs.period
     return Periodicity(seconds: period)
 
 method proofTimeout*(market: OnChainMarket): Future[UInt256] {.async.} =
   convertEthersError:
-    let config = await market.contract.config()
+    let config = await market.contract.configuration()
     return config.proofs.timeout
 
 method proofDowntime*(market: OnChainMarket): Future[uint8] {.async.} =
   convertEthersError:
-    let config = await market.contract.config()
+    let config = await market.contract.configuration()
     return config.proofs.downtime
 
 method getPointer*(market: OnChainMarket, slotId: SlotId): Future[uint8] {.async.} =
@@ -176,7 +176,7 @@ method fillSlot(market: OnChainMarket,
 
 method freeSlot*(market: OnChainMarket, slotId: SlotId) {.async.} =
   convertEthersError:
-    var freeSlot: Future[?TransactionResponse]
+    var freeSlot: Future[Confirmable]
     if rewardRecipient =? market.rewardRecipient:
       # If --reward-recipient specified, use it as the reward recipient, and use
       # the SP's address as the collateral recipient

codex/contracts/marketplace.nim

@@ -17,18 +17,18 @@ export requests
 type
   Marketplace* = ref object of Contract
 
-proc config*(marketplace: Marketplace): MarketplaceConfig {.contract, view.}
+proc configuration*(marketplace: Marketplace): MarketplaceConfig {.contract, view.}
 proc token*(marketplace: Marketplace): Address {.contract, view.}
 proc slashMisses*(marketplace: Marketplace): UInt256 {.contract, view.}
 proc slashPercentage*(marketplace: Marketplace): UInt256 {.contract, view.}
 proc minCollateralThreshold*(marketplace: Marketplace): UInt256 {.contract, view.}
 
-proc requestStorage*(marketplace: Marketplace, request: StorageRequest): ?TransactionResponse {.contract.}
-proc fillSlot*(marketplace: Marketplace, requestId: RequestId, slotIndex: UInt256, proof: Groth16Proof): ?TransactionResponse {.contract.}
-proc withdrawFunds*(marketplace: Marketplace, requestId: RequestId): ?TransactionResponse {.contract.}
-proc withdrawFunds*(marketplace: Marketplace, requestId: RequestId, withdrawAddress: Address): ?TransactionResponse {.contract.}
-proc freeSlot*(marketplace: Marketplace, id: SlotId): ?TransactionResponse {.contract.}
-proc freeSlot*(marketplace: Marketplace, id: SlotId, rewardRecipient: Address, collateralRecipient: Address): ?TransactionResponse {.contract.}
+proc requestStorage*(marketplace: Marketplace, request: StorageRequest): Confirmable {.contract.}
+proc fillSlot*(marketplace: Marketplace, requestId: RequestId, slotIndex: UInt256, proof: Groth16Proof): Confirmable {.contract.}
+proc withdrawFunds*(marketplace: Marketplace, requestId: RequestId): Confirmable {.contract.}
+proc withdrawFunds*(marketplace: Marketplace, requestId: RequestId, withdrawAddress: Address): Confirmable {.contract.}
+proc freeSlot*(marketplace: Marketplace, id: SlotId): Confirmable {.contract.}
+proc freeSlot*(marketplace: Marketplace, id: SlotId, rewardRecipient: Address, collateralRecipient: Address): Confirmable {.contract.}
 proc getRequest*(marketplace: Marketplace, id: RequestId): StorageRequest {.contract, view.}
 proc getHost*(marketplace: Marketplace, id: SlotId): Address {.contract, view.}
 proc getActiveSlot*(marketplace: Marketplace, id: SlotId): Slot {.contract, view.}
@@ -49,8 +49,8 @@ proc willProofBeRequired*(marketplace: Marketplace, id: SlotId): bool {.contract
 proc getChallenge*(marketplace: Marketplace, id: SlotId): array[32, byte] {.contract, view.}
 proc getPointer*(marketplace: Marketplace, id: SlotId): uint8 {.contract, view.}
 
-proc submitProof*(marketplace: Marketplace, id: SlotId, proof: Groth16Proof): ?TransactionResponse {.contract.}
-proc markProofAsMissing*(marketplace: Marketplace, id: SlotId, period: UInt256): ?TransactionResponse {.contract.}
+proc submitProof*(marketplace: Marketplace, id: SlotId, proof: Groth16Proof): Confirmable {.contract.}
+proc markProofAsMissing*(marketplace: Marketplace, id: SlotId, period: UInt256): Confirmable {.contract.}
 
-proc reserveSlot*(marketplace: Marketplace, requestId: RequestId, slotIndex: UInt256): ?TransactionResponse {.contract.}
+proc reserveSlot*(marketplace: Marketplace, requestId: RequestId, slotIndex: UInt256): Confirmable {.contract.}
 proc canReserveSlot*(marketplace: Marketplace, requestId: RequestId, slotIndex: UInt256): bool {.contract, view.}

codex/node.nim

@@ -765,15 +765,15 @@ proc stop*(self: CodexNodeRef) {.async.} =
   if not self.discovery.isNil:
     await self.discovery.stop()
 
-  if not self.clock.isNil:
-    await self.clock.stop()
-
   if clientContracts =? self.contracts.client:
     await clientContracts.stop()
 
   if hostContracts =? self.contracts.host:
     await hostContracts.stop()
 
+  if not self.clock.isNil:
+    await self.clock.stop()
+
   if validatorContracts =? self.contracts.validator:
     await validatorContracts.stop()
 

codex/utils/asyncstatemachine.nim

@@ -59,19 +59,16 @@ proc onError(machine: Machine, error: ref CatchableError): Event =
     state.onError(error)
 
 proc run(machine: Machine, state: State) {.async.} =
-  try:
   if next =? await state.run(machine):
     machine.schedule(Event.transition(state, next))
-  except CancelledError:
-    discard
 
 proc scheduler(machine: Machine) {.async.} =
   var running: Future[void]
-  try:
   while machine.started:
     let event = await machine.scheduled.get().track(machine)
     if next =? event(machine.state):
       if not running.isNil and not running.finished:
+        trace "cancelling current state", state = $machine.state
         await running.cancelAndWait()
       let fromState = if machine.state.isNil: "<none>" else: $machine.state
       machine.state = next
@@ -79,11 +76,11 @@ proc scheduler(machine: Machine) {.async.} =
       running = machine.run(machine.state)
       running
         .track(machine)
-          .catch((err: ref CatchableError) =>
+        .cancelled(proc() = trace "state.run cancelled, swallowing", state = $machine.state)
+        .catch(proc(err: ref CatchableError) =
+          trace "error caught in state.run, calling state.onError", state = $machine.state
           machine.schedule(machine.onError(err))
         )
-  except CancelledError:
-    discard
 
 proc start*(machine: Machine, initialState: State) =
   if machine.started:
@@ -93,12 +90,13 @@ proc start*(machine: Machine, initialState: State) =
     machine.scheduled = newAsyncQueue[Event]()
 
   machine.started = true
-  machine.scheduler()
-    .track(machine)
-    .catch((err: ref CatchableError) =>
-      error("Error in scheduler", error = err.msg)
-    )
+  try:
+    discard machine.scheduler().track(machine)
     machine.schedule(Event.transition(machine.state, initialState))
+  except CancelledError as e:
+    discard
+  except CatchableError as e:
+    error("Error in scheduler", error = e.msg)
 
 proc stop*(machine: Machine) {.async.} =
   if not machine.started:

openapi.yaml

@@ -443,21 +443,6 @@ paths:
       summary: "Lists manifest CIDs stored locally in node."
       tags: [ Data ]
       operationId: listData
-      parameters:
-        - name: content-type
-          in: header
-          required: false
-          description: The content type of the file. Must be valid.
-          schema:
-            type: string
-            example: "image/png"
-        - name: content-disposition
-          in: header
-          required: false
-          description: The content disposition used to send the filename.
-          schema:
-            type: string
-            example: "attachment; filename=\"codex.png\""
       responses:
         "200":
           description: Retrieved list of content CIDs
@@ -478,6 +463,21 @@ paths:
       summary: "Upload a file in a streaming manner. Once finished, the file is stored in the node and can be retrieved by any node in the network using the returned CID."
       tags: [ Data ]
       operationId: upload
+      parameters:
+        - name: content-type
+          in: header
+          required: false
+          description: The content type of the file. Must be valid.
+          schema:
+            type: string
+            example: "image/png"
+        - name: content-disposition
+          in: header
+          required: false
+          description: The content disposition used to send the filename.
+          schema:
+            type: string
+            example: "attachment; filename=\"codex.png\""
       requestBody:
         content:
           application/octet-stream:

tests/contracts/testContracts.nim

@@ -38,7 +38,7 @@ ethersuite "Marketplace contracts":
     let tokenAddress = await marketplace.token()
     token = Erc20Token.new(tokenAddress, ethProvider.getSigner())
 
-    let config = await marketplace.config()
+    let config = await marketplace.configuration()
     periodicity = Periodicity(seconds: config.proofs.period)
 
     request = StorageRequest.example

tests/contracts/testDeployment.nim

@@ -9,7 +9,7 @@ import ../checktest
 type MockProvider = ref object of Provider
   chainId*: UInt256
 
-method getChainId*(provider: MockProvider): Future[UInt256] {.async.} =
+method getChainId*(provider: MockProvider): Future[UInt256] {.async: (raises:[ProviderError]).} =
   return provider.chainId
 
 proc configFactory(): CodexConf =

tests/contracts/testMarket.nim

@@ -34,7 +34,7 @@ ethersuite "On-Chain Market":
   setup:
     let address = Marketplace.address(dummyVerifier = true)
     marketplace = Marketplace.new(address, ethProvider.getSigner())
-    let config = await marketplace.config()
+    let config = await marketplace.configuration()
     hostRewardRecipient = accounts[2]
 
     market = OnChainMarket.new(marketplace)
@@ -76,13 +76,13 @@ ethersuite "On-Chain Market":
 
   test "can retrieve proof periodicity":
     let periodicity = await market.periodicity()
-    let config = await marketplace.config()
+    let config = await marketplace.configuration()
     let periodLength = config.proofs.period
     check periodicity.seconds == periodLength
 
   test "can retrieve proof timeout":
     let proofTimeout = await market.proofTimeout()
-    let config = await marketplace.config()
+    let config = await marketplace.configuration()
     check proofTimeout == config.proofs.timeout
 
   test "supports marketplace requests":

tests/contracts/time.nim

@@ -1,4 +1,5 @@
 import pkg/ethers
+import pkg/serde/json
 
 proc currentTime*(provider: Provider): Future[UInt256] {.async.} =
   return (!await provider.getBlock(BlockTag.pending)).timestamp

tests/integration/marketplacesuite.nim

@@ -85,7 +85,7 @@ template marketplacesuite*(name: string, body: untyped) =
       marketplace = Marketplace.new(Marketplace.address, ethProvider.getSigner())
       let tokenAddress = await marketplace.token()
       token = Erc20Token.new(tokenAddress, ethProvider.getSigner())
-      let config = await mp.config(marketplace)
+      let config = await marketplace.configuration()
       period = config.proofs.period.truncate(uint64)
       periodicity = Periodicity(seconds: period.u256)
 

tests/tools/cirdl/testcirdl.nim

@@ -2,10 +2,11 @@ import std/os
 import std/osproc
 import std/options
 import pkg/chronos
-import codex/contracts
-import ../../integration/marketplacesuite
+import pkg/codex/contracts
+import ../../asynctest
+import ../../contracts/deployment
 
-marketplacesuite "tools/cirdl":
+suite "tools/cirdl":
   const
     cirdl = "build" / "cirdl"
     workdir = "."
@@ -14,11 +15,11 @@ marketplacesuite "tools/cirdl":
     let
       circuitPath = "testcircuitpath"
       rpcEndpoint = "ws://localhost:8545"
-      marketplaceAddress = $marketplace.address
+      marketplaceAddress = Marketplace.address
 
     discard existsOrCreateDir(circuitPath)
 
-    let args = [circuitPath, rpcEndpoint, marketplaceAddress]
+    let args = [circuitPath, rpcEndpoint, $marketplaceAddress]
 
     let process = osproc.startProcess(
       cirdl,

tools/cirdl/cirdl.nim

@@ -34,7 +34,7 @@ proc getCircuitHash(rpcEndpoint: string, marketplaceAddress: string): Future[?!s
     return failure("Invalid address: " & marketplaceAddress)
 
   let marketplace = Marketplace.new(address, provider)
-  let config = await marketplace.config()
+  let config = await marketplace.configuration()
   return success config.proofs.zkeyHash
 
 proc formatUrl(hash: string): string =

vendor/codex-contracts-eth

@@ -1 +1 @@
-Subproject commit 997696a20e0976011cdbc2f0ff3a844672056ba2
+Subproject commit 1ce3d10fa2ed325f4f4d1608434e5c6bd666ce24

vendor/nim-ethers

@@ -1 +1 @@
-Subproject commit 5b170adcb1ffb1dbb273d1b7679bf3d9a08adb76
+Subproject commit 6523e70eafecc3b9728a491058818e685bd384fb

vendor/nim-json-rpc

@@ -1 +1 @@
-Subproject commit 0bf2bcbe74a18a3c7a709d57108bb7b51e748a92
+Subproject commit 0408795be95c00d75e96eaef6eae8a9c734014f5

vendor/nim-json-serialization

@@ -1 +1 @@
-Subproject commit bb53d49caf2a6c6cf1df365ba84af93cdcfa7aa3
+Subproject commit 5127b26ee58076e9369e7c126c196793c2b12e73

vendor/nim-serde

@@ -1 +1 @@
-Subproject commit b1e5e5d39a99ea56b750f6d9272dd319f4ad4291
+Subproject commit 83e4a2ccf621d3040c6e7e0267393ca2d205988e

vendor/nim-serialization

@@ -1 +1 @@
-Subproject commit 384eb2561ee755446cff512a8e057325848b86a7
+Subproject commit f709bd9e16b1b6870fe3e4401196479e014a2ef6