mirror of
https://github.com/status-im/nim-dagger.git
synced 2025-03-01 06:40:54 +00:00
7065718e09
* Indicate that slot is being repaired when trying to download * Fix tests * Apply nph * Calculate the repair collateral when adding the item into the queue * Add slotCollateral calculation with getRequest cache and remove populationItem function * Update with pricePerByte * Simplify StorageAsk parameter * Minor fixes * Move cache request to another PR * Rename SlotQueueItem collateral and required in init * Use override func to optimise calls when the slot state is known * Remove unused code * Cosmetic change * Use raiseMarketError helper * Add exceptions to async pragma * Cosmetic change * Use raiseMarketError helper * Let slotCollateral determines the slot sate * Use configSync to avoid async pragma in onStorageRequested * Add loadConfig function * Add CatchableError to async pragma * Add missing pragma raises errors * Move loadConfig * Avoid swallow CancelledError * Avoid swallowing CancelledError * Avoid swallowing CancelledError * Update error messages * Except MarketError instead of CatchableError * Fix merge issue * Log fatal when configuration cannot be loaded * Propagate MarketError in slotCollateral * Remove useless configSync * Use result with explicit error * Fix syntax --------- Signed-off-by: Arnaud <arnaud@status.im>
300 lines
9.3 KiB
Nim
300 lines
9.3 KiB
Nim
import pkg/chronos
|
|
import pkg/upraises
|
|
import pkg/questionable
|
|
import pkg/ethers/erc20
|
|
import ./contracts/requests
|
|
import ./contracts/proofs
|
|
import ./clock
|
|
import ./errors
|
|
import ./periods
|
|
|
|
export chronos
|
|
export questionable
|
|
export requests
|
|
export proofs
|
|
export SecondsSince1970
|
|
export periods
|
|
|
|
type
|
|
Market* = ref object of RootObj
|
|
MarketError* = object of CodexError
|
|
Subscription* = ref object of RootObj
|
|
OnRequest* =
|
|
proc(id: RequestId, ask: StorageAsk, expiry: uint64) {.gcsafe, upraises: [].}
|
|
OnFulfillment* = proc(requestId: RequestId) {.gcsafe, upraises: [].}
|
|
OnSlotFilled* = proc(requestId: RequestId, slotIndex: uint64) {.gcsafe, upraises: [].}
|
|
OnSlotFreed* = proc(requestId: RequestId, slotIndex: uint64) {.gcsafe, upraises: [].}
|
|
OnSlotReservationsFull* =
|
|
proc(requestId: RequestId, slotIndex: uint64) {.gcsafe, upraises: [].}
|
|
OnRequestCancelled* = proc(requestId: RequestId) {.gcsafe, upraises: [].}
|
|
OnRequestFailed* = proc(requestId: RequestId) {.gcsafe, upraises: [].}
|
|
OnProofSubmitted* = proc(id: SlotId) {.gcsafe, upraises: [].}
|
|
ProofChallenge* = array[32, byte]
|
|
|
|
# Marketplace events -- located here due to the Market abstraction
|
|
MarketplaceEvent* = Event
|
|
StorageRequested* = object of MarketplaceEvent
|
|
requestId*: RequestId
|
|
ask*: StorageAsk
|
|
expiry*: uint64
|
|
|
|
SlotFilled* = object of MarketplaceEvent
|
|
requestId* {.indexed.}: RequestId
|
|
slotIndex*: uint64
|
|
|
|
SlotFreed* = object of MarketplaceEvent
|
|
requestId* {.indexed.}: RequestId
|
|
slotIndex*: uint64
|
|
|
|
SlotReservationsFull* = object of MarketplaceEvent
|
|
requestId* {.indexed.}: RequestId
|
|
slotIndex*: uint64
|
|
|
|
RequestFulfilled* = object of MarketplaceEvent
|
|
requestId* {.indexed.}: RequestId
|
|
|
|
RequestCancelled* = object of MarketplaceEvent
|
|
requestId* {.indexed.}: RequestId
|
|
|
|
RequestFailed* = object of MarketplaceEvent
|
|
requestId* {.indexed.}: RequestId
|
|
|
|
ProofSubmitted* = object of MarketplaceEvent
|
|
id*: SlotId
|
|
|
|
method loadConfig*(
|
|
market: Market
|
|
): Future[?!void] {.base, async: (raises: [CancelledError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getZkeyHash*(
|
|
market: Market
|
|
): Future[?string] {.base, async: (raises: [CancelledError, MarketError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getSigner*(market: Market): Future[Address] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method periodicity*(
|
|
market: Market
|
|
): Future[Periodicity] {.base, async: (raises: [CancelledError, MarketError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method proofTimeout*(
|
|
market: Market
|
|
): Future[uint64] {.base, async: (raises: [CancelledError, MarketError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method repairRewardPercentage*(
|
|
market: Market
|
|
): Future[uint8] {.base, async: (raises: [CancelledError, MarketError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method requestDurationLimit*(market: Market): Future[uint64] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method proofDowntime*(
|
|
market: Market
|
|
): Future[uint8] {.base, async: (raises: [CancelledError, MarketError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getPointer*(market: Market, slotId: SlotId): Future[uint8] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
proc inDowntime*(market: Market, slotId: SlotId): Future[bool] {.async.} =
|
|
let downtime = await market.proofDowntime
|
|
let pntr = await market.getPointer(slotId)
|
|
return pntr < downtime
|
|
|
|
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: (raises: [CancelledError]).} =
|
|
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: (raises: [CancelledError, MarketError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getRequestEnd*(
|
|
market: Market, id: RequestId
|
|
): Future[SecondsSince1970] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method requestExpiresAt*(
|
|
market: Market, id: RequestId
|
|
): Future[SecondsSince1970] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method getHost*(
|
|
market: Market, requestId: RequestId, slotIndex: uint64
|
|
): Future[?Address] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method currentCollateral*(
|
|
market: Market, slotId: SlotId
|
|
): Future[UInt256] {.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: uint64,
|
|
proof: Groth16Proof,
|
|
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 getChallenge*(
|
|
market: Market, id: SlotId
|
|
): Future[ProofChallenge] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method submitProof*(market: Market, id: SlotId, proof: Groth16Proof) {.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 reserveSlot*(
|
|
market: Market, requestId: RequestId, slotIndex: uint64
|
|
) {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method canReserveSlot*(
|
|
market: Market, requestId: RequestId, slotIndex: uint64
|
|
): Future[bool] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeFulfillment*(
|
|
market: Market, callback: OnFulfillment
|
|
): Future[Subscription] {.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: uint64, callback: OnSlotFilled
|
|
): Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeSlotFreed*(
|
|
market: Market, callback: OnSlotFreed
|
|
): Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeSlotReservationsFull*(
|
|
market: Market, callback: OnSlotReservationsFull
|
|
): Future[Subscription] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method subscribeRequestCancelled*(
|
|
market: Market, callback: OnRequestCancelled
|
|
): 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, callback: OnRequestFailed
|
|
): 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")
|
|
|
|
method queryPastSlotFilledEvents*(
|
|
market: Market, fromBlock: BlockTag
|
|
): Future[seq[SlotFilled]] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method queryPastSlotFilledEvents*(
|
|
market: Market, blocksAgo: int
|
|
): Future[seq[SlotFilled]] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method queryPastSlotFilledEvents*(
|
|
market: Market, fromTime: SecondsSince1970
|
|
): Future[seq[SlotFilled]] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method queryPastStorageRequestedEvents*(
|
|
market: Market, fromBlock: BlockTag
|
|
): Future[seq[StorageRequested]] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method queryPastStorageRequestedEvents*(
|
|
market: Market, blocksAgo: int
|
|
): Future[seq[StorageRequested]] {.base, async.} =
|
|
raiseAssert("not implemented")
|
|
|
|
method slotCollateral*(
|
|
market: Market, requestId: RequestId, slotIndex: uint64
|
|
): Future[?!UInt256] {.base, async: (raises: [CancelledError]).} =
|
|
raiseAssert("not implemented")
|
|
|
|
method slotCollateral*(
|
|
market: Market, collateralPerSlot: UInt256, slotState: SlotState
|
|
): ?!UInt256 {.base, gcsafe, raises: [].} =
|
|
raiseAssert("not implemented")
|