mirror of
https://github.com/status-im/nim-codex.git
synced 2025-01-11 03:16:16 +00:00
d56eb6aee1
* [contracts] Add SlotFreed event * [integration] allow test node to be stopped twice * [cli] add --validator option * [contracts] remove dead code * [contracts] instantiate OnChainMarket and OnChainClock only once * [contracts] add Validation * [sales] remove duplicate import * [market] add missing import * [market] subscribe to all SlotFilled events * [market] add freeSlot() * [sales] fix warnings * [market] subscribe to SlotFreed events * [contracts] fix warning * [validator] keep track of filled slots * [validation] remove slots that have ended * [proving] absorb Proofs into Market Both Proofs and Market are abstractions around the Marketplace contract, having them separately is more trouble than it's worth at the moment. * [market] add markProofAsMissing() * [clock] speed up waiting for clock in tests * [validator] mark proofs as missing * [timer] fix error on node shutdown * [cli] handle --persistence and --validator separately * [market] allow retrieval of proof timeout value * [validator] do not subscribe to SlotFreed events Freed slots are already handled in removeSlotsThatHaveEnded(), and onSlotsFreed() interfered with its iterator. * [validator] Start validation at the start of a new period To decrease the likelihood that we hit the validation timeout. * [validator] do not mark proofs as missing after timeout * [market] check whether proof can be marked as missing * [validator] simplify validation Simulate a transaction to mark proof as missing, instead of trying to keep track of all the conditions that may lead to a proof being marked as missing. * [build] use nim-ethers PR #40 Uses "pending" blocktag instead of "latest" blocktag for better simulation of transactions before sending them. https://github.com/status-im/nim-ethers/pull/40 * [integration] integration test for validator * [validator] monitor a maximum number of slots Adds cli parameter --validator-max-slots. * [market] fix missing collateral argument After rebasing, add the new argument to fillSlot calls. * [build] update to nim-ethers 0.2.5 * [validator] use Set instead of Table to keep track of slots * [validator] add logging * [validator] add test for slot failure * [market] use "pending" blocktag to use more up to date block time * [contracts] remove unused import * [validator] fix: wait until after period ends The smart contract checks that 'end < block.timestamp', so we need to wait until the block timestamp is greater than the period end.
157 lines
5.6 KiB
Nim
157 lines
5.6 KiB
Nim
import pkg/chronos
|
|
import pkg/upraises
|
|
import pkg/questionable
|
|
import pkg/ethers/erc20
|
|
import ./contracts/requests
|
|
import ./clock
|
|
import ./periods
|
|
|
|
export chronos
|
|
export questionable
|
|
export requests
|
|
export SecondsSince1970
|
|
export periods
|
|
|
|
type
|
|
Market* = ref object of RootObj
|
|
Subscription* = ref object of RootObj
|
|
OnRequest* = proc(id: RequestId, ask: StorageAsk) {.gcsafe, upraises:[].}
|
|
OnFulfillment* = proc(requestId: RequestId) {.gcsafe, upraises: [].}
|
|
OnSlotFilled* = proc(requestId: RequestId, slotIndex: UInt256) {.gcsafe, upraises:[].}
|
|
OnSlotFreed* = proc(slotId: SlotId) {.gcsafe, upraises: [].}
|
|
OnRequestCancelled* = proc(requestId: RequestId) {.gcsafe, upraises:[].}
|
|
OnRequestFailed* = proc(requestId: RequestId) {.gcsafe, upraises:[].}
|
|
OnProofSubmitted* = proc(id: SlotId, proof: seq[byte]) {.gcsafe, upraises:[].}
|
|
|
|
method getSigner*(market: Market): Future[Address] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method periodicity*(market: Market): Future[Periodicity] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method proofTimeout*(market: Market): Future[UInt256] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method requestStorage*(market: Market,
|
|
request: StorageRequest) {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method myRequests*(market: Market): Future[seq[RequestId]] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method mySlots*(market: Market): Future[seq[SlotId]] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getRequest*(market: Market,
|
|
id: RequestId):
|
|
Future[?StorageRequest] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method requestState*(market: Market,
|
|
requestId: RequestId): Future[?RequestState] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method slotState*(market: Market,
|
|
slotId: SlotId): Future[SlotState] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getRequestEnd*(market: Market,
|
|
id: RequestId): Future[SecondsSince1970] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getHost*(market: Market,
|
|
requestId: RequestId,
|
|
slotIndex: UInt256): Future[?Address] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getActiveSlot*(
|
|
market: Market,
|
|
slotId: SlotId): Future[?Slot] {.base, async.} =
|
|
|
|
raiseAssert("not implemented")
|
|
|
|
method fillSlot*(market: Market,
|
|
requestId: RequestId,
|
|
slotIndex: UInt256,
|
|
proof: seq[byte],
|
|
collateral: UInt256) {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method freeSlot*(market: Market, slotId: SlotId) {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method withdrawFunds*(market: Market,
|
|
requestId: RequestId) {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeRequests*(market: Market,
|
|
callback: OnRequest):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method isProofRequired*(market: Market,
|
|
id: SlotId): Future[bool] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method willProofBeRequired*(market: Market,
|
|
id: SlotId): Future[bool] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method submitProof*(market: Market,
|
|
id: SlotId,
|
|
proof: seq[byte]) {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method markProofAsMissing*(market: Market,
|
|
id: SlotId,
|
|
period: Period) {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method canProofBeMarkedAsMissing*(market: Market,
|
|
id: SlotId,
|
|
period: Period): Future[bool] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeFulfillment*(market: Market,
|
|
requestId: RequestId,
|
|
callback: OnFulfillment):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeSlotFilled*(market: Market,
|
|
callback: OnSlotFilled):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeSlotFilled*(market: Market,
|
|
requestId: RequestId,
|
|
slotIndex: UInt256,
|
|
callback: OnSlotFilled):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeSlotFreed*(market: Market,
|
|
callback: OnSlotFreed):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeRequestCancelled*(market: Market,
|
|
requestId: RequestId,
|
|
callback: OnRequestCancelled):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeRequestFailed*(market: Market,
|
|
requestId: RequestId,
|
|
callback: OnRequestFailed):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeProofSubmission*(market: Market,
|
|
callback: OnProofSubmitted):
|
|
Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method unsubscribe*(subscription: Subscription) {.base, async, upraises:[].} =
|
|
raiseAssert("not implemented")
|