nim-codex/codex/sales.nim

189 lines
5.4 KiB
Nim
Raw Normal View History

2022-03-30 10:51:28 +00:00
import std/sequtils
import pkg/questionable
import pkg/upraises
import pkg/stint
import pkg/nimcrypto
import pkg/chronicles
2022-03-30 10:51:28 +00:00
import ./market
2022-05-17 15:02:03 +00:00
import ./clock
2022-03-30 10:51:28 +00:00
export stint
type
Sales* = ref object
market: Market
2022-05-17 15:02:03 +00:00
clock: Clock
2022-03-30 10:51:28 +00:00
subscription: ?Subscription
available*: seq[Availability]
store: ?Store
2022-07-05 08:24:33 +00:00
prove: ?Prove
onClear: ?OnClear
2022-03-31 09:41:45 +00:00
onSale: ?OnSale
2022-03-30 10:51:28 +00:00
Availability* = object
id*: array[32, byte]
size*: UInt256
duration*: UInt256
2022-03-30 10:51:28 +00:00
minPrice*: UInt256
SalesAgent = ref object
2022-03-31 12:35:53 +00:00
sales: Sales
requestId: array[32, byte]
ask: StorageAsk
2022-03-31 12:35:53 +00:00
availability: Availability
2022-07-05 08:51:01 +00:00
request: ?StorageRequest
2022-03-31 12:35:53 +00:00
subscription: ?Subscription
running: ?Future[void]
2022-03-31 12:35:53 +00:00
waiting: ?Future[void]
finished: bool
Store = proc(cid: string, availability: Availability): Future[void] {.gcsafe, upraises: [].}
2022-07-05 08:24:33 +00:00
Prove = proc(cid: string): Future[seq[byte]] {.gcsafe, upraises: [].}
OnClear = proc(availability: Availability, request: StorageRequest) {.gcsafe, upraises: [].}
2022-07-05 08:51:01 +00:00
OnSale = proc(availability: Availability, request: StorageRequest) {.gcsafe, upraises: [].}
2022-03-30 10:51:28 +00:00
2022-05-17 15:02:03 +00:00
func new*(_: type Sales, market: Market, clock: Clock): Sales =
Sales(
market: market,
clock: clock,
)
2022-03-30 10:51:28 +00:00
proc init*(_: type Availability,
size: UInt256,
duration: UInt256,
2022-03-30 10:51:28 +00:00
minPrice: UInt256): Availability =
var id: array[32, byte]
doAssert randomBytes(id) == 32
Availability(id: id, size: size, duration: duration, minPrice: minPrice)
proc `store=`*(sales: Sales, store: Store) =
sales.store = some store
2022-07-05 07:39:59 +00:00
2022-07-05 08:24:33 +00:00
proc `prove=`*(sales: Sales, prove: Prove) =
sales.prove = some prove
proc `onClear=`*(sales: Sales, onClear: OnClear) =
sales.onClear = some onClear
2022-03-31 09:41:45 +00:00
proc `onSale=`*(sales: Sales, callback: OnSale) =
sales.onSale = some callback
2022-03-30 10:51:28 +00:00
func add*(sales: Sales, availability: Availability) =
sales.available.add(availability)
func remove*(sales: Sales, availability: Availability) =
sales.available.keepItIf(it != availability)
func findAvailability(sales: Sales, ask: StorageAsk): ?Availability =
2022-03-30 10:51:28 +00:00
for availability in sales.available:
if ask.size <= availability.size and
ask.duration <= availability.duration and
ask.maxPrice >= availability.minPrice:
2022-03-30 10:51:28 +00:00
return some availability
proc finish(agent: SalesAgent, success: bool) =
if agent.finished:
return
agent.finished = true
if subscription =? agent.subscription:
2022-03-31 12:35:53 +00:00
asyncSpawn subscription.unsubscribe()
if running =? agent.running:
running.cancel()
if waiting =? agent.waiting:
waiting.cancel()
if success:
if onSale =? agent.sales.onSale and request =? agent.request:
onSale(agent.availability, request)
2022-03-31 12:35:53 +00:00
else:
if onClear =? agent.sales.onClear and request =? agent.request:
onClear(agent.availability, request)
agent.sales.add(agent.availability)
2022-03-31 12:35:53 +00:00
proc onFulfill(agent: SalesAgent, requestId: array[32, byte]) {.async.} =
try:
let market = agent.sales.market
let host = await market.getHost(requestId)
let me = await market.getSigner()
agent.finish(success = (host == me.some))
except CatchableError:
agent.finish(success = false)
proc subscribeFulfill(agent: SalesAgent) {.async.} =
proc onFulfill(requestId: array[32, byte]) {.gcsafe, upraises:[].} =
asyncSpawn agent.onFulfill(requestId)
let market = agent.sales.market
let subscription = await market.subscribeFulfillment(agent.requestId, onFulfill)
agent.subscription = some subscription
proc waitForExpiry(agent: SalesAgent) {.async.} =
without request =? agent.request:
2022-03-31 12:35:53 +00:00
return
await agent.sales.clock.waitUntil(request.expiry.truncate(int64))
agent.finish(success = false)
2022-03-31 12:35:53 +00:00
proc start(agent: SalesAgent) {.async.} =
try:
let sales = agent.sales
let market = sales.market
let availability = agent.availability
2022-07-05 07:39:59 +00:00
without store =? sales.store:
raiseAssert "store proc not set"
2022-07-05 07:39:59 +00:00
without prove =? sales.prove:
raiseAssert "prove proc not set"
2022-07-05 08:24:33 +00:00
sales.remove(availability)
2022-07-05 07:39:59 +00:00
await agent.subscribeFulfill()
agent.request = await market.getRequest(agent.requestId)
without request =? agent.request:
agent.finish(success = false)
2022-07-05 07:39:59 +00:00
return
agent.waiting = some agent.waitForExpiry()
2022-07-05 13:04:25 +00:00
await store(request.content.cid, availability)
2022-07-05 08:24:33 +00:00
let proof = await prove(request.content.cid)
2022-07-05 08:37:55 +00:00
await market.fulfillRequest(request.id, proof)
except CancelledError:
raise
except CatchableError as e:
error "SalesAgent failed", msg = e.msg
agent.finish(success = false)
proc handleRequest(sales: Sales, requestId: array[32, byte], ask: StorageAsk) =
without availability =? sales.findAvailability(ask):
2022-03-31 12:35:53 +00:00
return
let agent = SalesAgent(
2022-03-31 12:35:53 +00:00
sales: sales,
requestId: requestId,
ask: ask,
2022-03-31 12:35:53 +00:00
availability: availability
)
agent.running = some agent.start()
2022-03-30 10:51:28 +00:00
proc start*(sales: Sales) {.async.} =
2022-03-30 10:51:28 +00:00
doAssert sales.subscription.isNone, "Sales already started"
proc onRequest(requestId: array[32, byte], ask: StorageAsk) {.gcsafe, upraises:[].} =
sales.handleRequest(requestId, ask)
2022-03-30 10:51:28 +00:00
try:
sales.subscription = some await sales.market.subscribeRequests(onRequest)
except CatchableError as e:
error "Unable to start sales", msg = e.msg
2022-03-30 10:51:28 +00:00
proc stop*(sales: Sales) {.async.} =
2022-03-30 10:51:28 +00:00
if subscription =? sales.subscription:
sales.subscription = Subscription.none
try:
await subscription.unsubscribe()
except CatchableError as e:
warn "Unsubscribe failed", msg = e.msg