From f7b3f51985ac89c330315163404d1b317b0a2117 Mon Sep 17 00:00:00 2001 From: Arnaud Date: Tue, 28 Jan 2025 15:53:26 +0100 Subject: [PATCH] Rename SlotQueueItem collateral and required in init --- codex/sales.nim | 14 +- codex/sales/slotqueue.nim | 35 ++-- tests/codex/helpers/mockslotqueueitem.nim | 5 +- tests/codex/sales/testsales.nim | 17 +- tests/codex/sales/testslotqueue.nim | 210 +++++++++++++++------- tests/contracts/testMarket.nim | 1 - tests/examples.nim | 4 +- 7 files changed, 189 insertions(+), 97 deletions(-) diff --git a/codex/sales.nim b/codex/sales.nim index 3150a158..832f698c 100644 --- a/codex/sales.nim +++ b/codex/sales.nim @@ -153,7 +153,7 @@ proc cleanUp( # Re-add items back into the queue to prevent small availabilities from # draining the queue. Seen items will be ordered last. if reprocessSlot and request =? data.request: - let collateralPerSlot = + let collateral = await sales.context.market.slotCollateral(data.requestId, data.slotIndex) let queue = sales.context.slotQueue @@ -163,7 +163,7 @@ proc cleanUp( data.ask, request.expiry, seen = true, - collateralPerSlot = collateralPerSlot, + collateral = collateral, ) trace "pushing ignored item to queue, marked as seen" if err =? queue.push(seenItem).errorOption: @@ -299,7 +299,8 @@ proc onStorageRequested( trace "storage requested, adding slots to queue" - without items =? SlotQueueItem.init(requestId, ask, expiry).catch, err: + without items =? + SlotQueueItem.init(requestId, ask, expiry, ask.collateralPerSlot).catch, err: if err of SlotsOutOfRangeError: warn "Too many slots, cannot add to queue" else: @@ -343,11 +344,10 @@ proc onSlotFreed(sales: Sales, requestId: RequestId, slotIndex: UInt256) = # Note: The slotCollateral function will invoke the contract method slotState, # but this is unnecessary since we already know the slot's state (Repair). # To avoid an unnecessary RPC call, we could eliminate this redundant call. - let collateralPerSlot = await market.slotCollateral(request.id, slotIndex) + let collateral = await market.slotCollateral(request.id, slotIndex) - slotQueueItem = SlotQueueItem.init( - request, slotIndex.truncate(uint16), collateralPerSlot = collateralPerSlot - ) + slotQueueItem = + SlotQueueItem.init(request, slotIndex.truncate(uint16), collateral = collateral) if err =? queue.push(slotQueueItem).errorOption: error "failed to push slot items to queue", error = err.msgDetail diff --git a/codex/sales/slotqueue.nim b/codex/sales/slotqueue.nim index 030626e3..7281545f 100644 --- a/codex/sales/slotqueue.nim +++ b/codex/sales/slotqueue.nim @@ -33,8 +33,7 @@ type slotSize: UInt256 duration: UInt256 pricePerBytePerSecond: UInt256 - collateralPerByte: UInt256 - collateralPerSlot: UInt256 + collateral: UInt256 # Collateral computed expiry: UInt256 seen: bool @@ -92,8 +91,8 @@ proc `<`*(a, b: SlotQueueItem): bool = scoreA.addIf(a.profitability > b.profitability, 3) scoreB.addIf(a.profitability < b.profitability, 3) - scoreA.addIf(a.collateralPerSlot < b.collateralPerSlot, 2) - scoreB.addIf(a.collateralPerSlot > b.collateralPerSlot, 2) + scoreA.addIf(a.collateral < b.collateral, 2) + scoreB.addIf(a.collateral > b.collateral, 2) scoreA.addIf(a.expiry > b.expiry, 1) scoreB.addIf(a.expiry < b.expiry, 1) @@ -134,8 +133,8 @@ proc init*( slotIndex: uint16, ask: StorageAsk, expiry: UInt256, + collateral: UInt256, seen = false, - collateralPerSlot: UInt256 = 0.u256, ): SlotQueueItem = SlotQueueItem( requestId: requestId, @@ -143,9 +142,7 @@ proc init*( slotSize: ask.slotSize, duration: ask.duration, pricePerBytePerSecond: ask.pricePerBytePerSecond, - collateralPerByte: ask.collateralPerByte, - collateralPerSlot: - if collateralPerSlot.isZero: ask.collateralPerSlot else: collateralPerSlot, + collateral: collateral, expiry: expiry, seen: seen, ) @@ -154,25 +151,25 @@ proc init*( _: type SlotQueueItem, request: StorageRequest, slotIndex: uint16, - collateralPerSlot: UInt256 = 0.u256, + collateral: UInt256, ): SlotQueueItem = SlotQueueItem.init( - request.id, - slotIndex, - request.ask, - request.expiry, - collateralPerSlot = collateralPerSlot, + request.id, slotIndex, request.ask, request.expiry, collateral = collateral ) proc init*( - _: type SlotQueueItem, requestId: RequestId, ask: StorageAsk, expiry: UInt256 + _: type SlotQueueItem, + requestId: RequestId, + ask: StorageAsk, + expiry: UInt256, + collateral: UInt256, ): seq[SlotQueueItem] = if not ask.slots.inRange: raise newException(SlotsOutOfRangeError, "Too many slots") var i = 0'u16 proc initSlotQueueItem(): SlotQueueItem = - let item = SlotQueueItem.init(requestId, i, ask, expiry) + let item = SlotQueueItem.init(requestId, i, ask, expiry, collateral) inc i return item @@ -180,8 +177,10 @@ proc init*( Rng.instance.shuffle(items) return items -proc init*(_: type SlotQueueItem, request: StorageRequest): seq[SlotQueueItem] = - return SlotQueueItem.init(request.id, request.ask, request.expiry) +proc init*( + _: type SlotQueueItem, request: StorageRequest, collateral: UInt256 +): seq[SlotQueueItem] = + return SlotQueueItem.init(request.id, request.ask, request.expiry, collateral) proc inRange*(val: SomeUnsignedInt): bool = val.uint16 in SlotQueueSize.low .. SlotQueueSize.high diff --git a/tests/codex/helpers/mockslotqueueitem.nim b/tests/codex/helpers/mockslotqueueitem.nim index 8827a99c..eb2de169 100644 --- a/tests/codex/helpers/mockslotqueueitem.nim +++ b/tests/codex/helpers/mockslotqueueitem.nim @@ -7,7 +7,7 @@ type MockSlotQueueItem* = object slotSize*: UInt256 duration*: UInt256 pricePerBytePerSecond*: UInt256 - collateralPerByte*: UInt256 + collateral*: UInt256 expiry*: UInt256 seen*: bool @@ -19,9 +19,8 @@ proc toSlotQueueItem*(item: MockSlotQueueItem): SlotQueueItem = slotSize: item.slotSize, duration: item.duration, pricePerBytePerSecond: item.pricePerBytePerSecond, - collateralPerByte: item.collateralPerByte, ), expiry = item.expiry, seen = item.seen, - collateralPerSlot = item.collateralPerByte * item.slotSize, + collateral = item.collateral, ) diff --git a/tests/codex/sales/testsales.nim b/tests/codex/sales/testsales.nim index f714552d..4ec56391 100644 --- a/tests/codex/sales/testsales.nim +++ b/tests/codex/sales/testsales.nim @@ -224,7 +224,7 @@ asyncchecksuite "Sales": availability = a.get # update id proc notProcessed(itemsProcessed: seq[SlotQueueItem], request: StorageRequest): bool = - let items = SlotQueueItem.init(request) + let items = SlotQueueItem.init(request, collateral = request.ask.collateralPerSlot) for i in 0 ..< items.len: if itemsProcessed.contains(items[i]): return false @@ -261,7 +261,7 @@ asyncchecksuite "Sales": done.complete() createAvailability() await market.requestStorage(request) - let items = SlotQueueItem.init(request) + let items = SlotQueueItem.init(request, collateral = request.ask.collateralPerSlot) check eventually items.allIt(itemsProcessed.contains(it)) test "removes slots from slot queue once RequestCancelled emitted": @@ -282,13 +282,15 @@ asyncchecksuite "Sales": test "removes slot index from slot queue once SlotFilled emitted": let request1 = await addRequestToSaturatedQueue() market.emitSlotFilled(request1.id, 1.u256) - let expected = SlotQueueItem.init(request1, 1'u16) + let expected = + SlotQueueItem.init(request1, 1'u16, collateral = request1.ask.collateralPerSlot) check always (not itemsProcessed.contains(expected)) test "removes slot index from slot queue once SlotReservationsFull emitted": let request1 = await addRequestToSaturatedQueue() market.emitSlotReservationsFull(request1.id, 1.u256) - let expected = SlotQueueItem.init(request1, 1'u16) + let expected = + SlotQueueItem.init(request1, 1'u16, collateral = request1.ask.collateralPerSlot) check always (not itemsProcessed.contains(expected)) test "adds slot index to slot queue once SlotFreed emitted": @@ -303,13 +305,14 @@ asyncchecksuite "Sales": let collateralPerSlot = await market.slotCollateral(request.id, 2.u256) - let expected = SlotQueueItem.init(request, 2.uint16) + let expected = + SlotQueueItem.init(request, 2.uint16, collateral = request.ask.collateralPerSlot) check eventually itemsProcessed.contains(expected) test "items in queue are readded (and marked seen) once ignored": await market.requestStorage(request) - let items = SlotQueueItem.init(request) + let items = SlotQueueItem.init(request, collateral = request.ask.collateralPerSlot) check eventually queue.len > 0 # queue starts paused, allow items to be added to the queue check eventually queue.paused @@ -330,7 +333,7 @@ asyncchecksuite "Sales": test "queue is paused once availability is insufficient to service slots in queue": createAvailability() # enough to fill a single slot await market.requestStorage(request) - let items = SlotQueueItem.init(request) + let items = SlotQueueItem.init(request, collateral = request.ask.collateralPerSlot) check eventually queue.len > 0 # queue starts paused, allow items to be added to the queue check eventually queue.paused diff --git a/tests/codex/sales/testslotqueue.nim b/tests/codex/sales/testslotqueue.nim index 74aad342..8aaa97cc 100644 --- a/tests/codex/sales/testslotqueue.nim +++ b/tests/codex/sales/testslotqueue.nim @@ -159,8 +159,10 @@ suite "Slot queue": requestB.ask.collateralPerByte = 1.u256 requestB.expiry = 1000.u256 - let itemA = SlotQueueItem.init(requestA, 0) - let itemB = SlotQueueItem.init(requestB, 0) + let itemA = + SlotQueueItem.init(requestA, 0, collateral = requestA.ask.collateralPerSlot) + let itemB = + SlotQueueItem.init(requestB, 0, collateral = requestB.ask.collateralPerSlot) check itemB < itemA # B higher priority than A check itemA > itemB @@ -172,7 +174,7 @@ suite "Slot queue": slotSize: 1.u256, duration: 1.u256, pricePerBytePerSecond: 2.u256, # profitability is higher (good) - collateralPerByte: 1.u256, + collateral: 1.u256, expiry: 1.u256, seen: true, # seen (bad), more weight than profitability ) @@ -182,7 +184,7 @@ suite "Slot queue": slotSize: 1.u256, duration: 1.u256, pricePerBytePerSecond: 1.u256, # profitability is lower (bad) - collateralPerByte: 1.u256, + collateral: 1.u256, expiry: 1.u256, seen: false, # not seen (good) ) @@ -197,7 +199,7 @@ suite "Slot queue": slotSize: 1.u256, duration: 1.u256, pricePerBytePerSecond: 1.u256, # reward is lower (bad) - collateralPerByte: 1.u256, # collateral is lower (good) + collateral: 1.u256, # collateral is lower (good) expiry: 1.u256, seen: false, ) @@ -208,7 +210,7 @@ suite "Slot queue": duration: 1.u256, pricePerBytePerSecond: 2.u256, # reward is higher (good), more weight than collateral - collateralPerByte: 2.u256, # collateral is higher (bad) + collateral: 2.u256, # collateral is higher (bad) expiry: 1.u256, seen: false, ) @@ -223,7 +225,7 @@ suite "Slot queue": slotSize: 1.u256, duration: 1.u256, pricePerBytePerSecond: 1.u256, - collateralPerByte: 2.u256, # collateral is higher (bad) + collateral: 2.u256, # collateral is higher (bad) expiry: 2.u256, # expiry is longer (good) seen: false, ) @@ -233,7 +235,7 @@ suite "Slot queue": slotSize: 1.u256, duration: 1.u256, pricePerBytePerSecond: 1.u256, - collateralPerByte: 1.u256, # collateral is lower (good), more weight than expiry + collateral: 1.u256, # collateral is lower (good), more weight than expiry expiry: 1.u256, # expiry is shorter (bad) seen: false, ) @@ -248,7 +250,7 @@ suite "Slot queue": slotSize: 1.u256, # slotSize is smaller (good) duration: 1.u256, pricePerBytePerSecond: 1.u256, - collateralPerByte: 1.u256, + collateral: 1.u256, expiry: 1.u256, # expiry is shorter (bad) seen: false, ) @@ -258,7 +260,7 @@ suite "Slot queue": slotSize: 2.u256, # slotSize is larger (bad) duration: 1.u256, pricePerBytePerSecond: 1.u256, - collateralPerByte: 1.u256, + collateral: 1.u256, expiry: 2.u256, # expiry is longer (good), more weight than slotSize seen: false, ) @@ -273,7 +275,7 @@ suite "Slot queue": slotSize: 2.u256, # slotSize is larger (bad) duration: 1.u256, pricePerBytePerSecond: 1.u256, - collateralPerByte: 1.u256, + collateral: 1.u256, expiry: 1.u256, # expiry is shorter (bad) seen: false, ) @@ -283,7 +285,7 @@ suite "Slot queue": slotSize: 1.u256, # slotSize is smaller (good) duration: 1.u256, pricePerBytePerSecond: 1.u256, - collateralPerByte: 1.u256, + collateral: 1.u256, expiry: 1.u256, seen: false, ) @@ -292,11 +294,16 @@ suite "Slot queue": test "expands available all possible slot indices on init": let request = StorageRequest.example - let items = SlotQueueItem.init(request) + let items = SlotQueueItem.init(request, collateral = request.ask.collateralPerSlot) check items.len.uint64 == request.ask.slots var checked = 0 for slotIndex in 0'u16 ..< request.ask.slots.uint16: - check items.anyIt(it == SlotQueueItem.init(request, slotIndex)) + check items.anyIt( + it == + SlotQueueItem.init( + request, slotIndex, collateral = request.ask.collateralPerSlot + ) + ) inc checked check checked == items.len @@ -327,7 +334,12 @@ suite "Slot queue": let maxUInt16 = uint16.high let uint64Slots = uint64(maxUInt16) request.ask.slots = uint64Slots - let items = SlotQueueItem.init(request.id, request.ask, request.expiry) + let items = SlotQueueItem.init( + request.id, + request.ask, + request.expiry, + collateral = request.ask.collateralPerSlot, + ) check items.len.uint16 == maxUInt16 test "cannot support greater than uint16.high slots": @@ -336,7 +348,12 @@ suite "Slot queue": let uint64Slots = uint64(int32Slots) request.ask.slots = uint64Slots expect SlotsOutOfRangeError: - discard SlotQueueItem.init(request.id, request.ask, request.expiry) + discard SlotQueueItem.init( + request.id, + request.ask, + request.expiry, + collateral = request.ask.collateralPerSlot, + ) test "cannot push duplicate items": newSlotQueue(maxSize = 6, maxWorkers = 1, processSlotDelay = 15.millis) @@ -377,8 +394,10 @@ suite "Slot queue": let request0 = StorageRequest.example var request1 = StorageRequest.example request1.ask.collateralPerByte += 1.u256 - let items0 = SlotQueueItem.init(request0) - let items1 = SlotQueueItem.init(request1) + let items0 = + SlotQueueItem.init(request0, collateral = request0.ask.collateralPerSlot) + let items1 = + SlotQueueItem.init(request1, collateral = request1.ask.collateralPerSlot) check queue.push(items0).isOk check queue.push(items1).isOk let last = items1[items1.high] @@ -391,8 +410,10 @@ suite "Slot queue": let request0 = StorageRequest.example var request1 = StorageRequest.example request1.ask.collateralPerByte += 1.u256 - let items0 = SlotQueueItem.init(request0) - let items1 = SlotQueueItem.init(request1) + let items0 = + SlotQueueItem.init(request0, collateral = request0.ask.collateralPerSlot) + let items1 = + SlotQueueItem.init(request1, collateral = request1.ask.collateralPerSlot) check queue.push(items0).isOk check queue.push(items1).isOk queue.delete(request1.id) @@ -411,43 +432,56 @@ suite "Slot queue": request3.ask.collateralPerByte = request2.ask.collateralPerByte + 1 request4.ask.collateralPerByte = request3.ask.collateralPerByte + 1 request5.ask.collateralPerByte = request4.ask.collateralPerByte + 1 - let item0 = SlotQueueItem.init(request0, 0) - let item1 = SlotQueueItem.init(request1, 0) - let item2 = SlotQueueItem.init(request2, 0) - let item3 = SlotQueueItem.init(request3, 0) - let item4 = SlotQueueItem.init(request4, 0) - let item5 = SlotQueueItem.init(request5, 0) + let item0 = + SlotQueueItem.init(request0, 0, collateral = request0.ask.collateralPerSlot) + let item1 = + SlotQueueItem.init(request1, 0, collateral = request1.ask.collateralPerSlot) + let item2 = + SlotQueueItem.init(request2, 0, collateral = request2.ask.collateralPerSlot) + let item3 = + SlotQueueItem.init(request3, 0, collateral = request3.ask.collateralPerSlot) + let item4 = + SlotQueueItem.init(request4, 0, collateral = request4.ask.collateralPerSlot) + let item5 = + SlotQueueItem.init(request5, 0, collateral = request5.ask.collateralPerSlot) check queue.contains(item5) == false check queue.push(@[item0, item1, item2, item3, item4, item5]).isOk check queue.contains(item5) test "sorts items by profitability descending (higher pricePerBytePerSecond == higher priority == goes first in the list)": var request = StorageRequest.example - let item0 = SlotQueueItem.init(request, 0) + let item0 = + SlotQueueItem.init(request, 0, collateral = request.ask.collateralPerSlot) request.ask.pricePerBytePerSecond += 1.u256 - let item1 = SlotQueueItem.init(request, 1) + let item1 = + SlotQueueItem.init(request, 1, collateral = request.ask.collateralPerSlot) check item1 < item0 - test "sorts items by collateral ascending (higher required collateralPerSlot = lower priority == comes later in the list)": + test "sorts items by collateral ascending (higher required collateral = lower priority == comes later in the list)": var request = StorageRequest.example - let item0 = SlotQueueItem.init(request, 0) + let item0 = + SlotQueueItem.init(request, 0, collateral = request.ask.collateralPerSlot) let item1 = SlotQueueItem.init( - request, 1, collateralPerSlot = request.ask.collateralPerSlot + 1.u256 + request, 1, collateral = request.ask.collateralPerSlot + 1.u256 ) check item1 > item0 test "sorts items by expiry descending (longer expiry = higher priority)": var request = StorageRequest.example - let item0 = SlotQueueItem.init(request, 0) + let item0 = + SlotQueueItem.init(request, 0, collateral = request.ask.collateralPerSlot) request.expiry += 1.u256 - let item1 = SlotQueueItem.init(request, 1) + let item1 = + SlotQueueItem.init(request, 1, collateral = request.ask.collateralPerSlot) check item1 < item0 test "sorts items by slot size descending (bigger dataset = higher profitability = higher priority)": var request = StorageRequest.example - let item0 = SlotQueueItem.init(request, 0) + let item0 = + SlotQueueItem.init(request, 0, collateral = request.ask.collateralPerSlot) request.ask.slotSize += 1.u256 - let item1 = SlotQueueItem.init(request, 1) + let item1 = + SlotQueueItem.init(request, 1, collateral = request.ask.collateralPerSlot) check item1 < item0 test "should call callback once an item is added": @@ -468,13 +502,17 @@ suite "Slot queue": # sleeping after push allows the slotqueue loop to iterate, # calling the callback for each pushed/updated item var request = StorageRequest.example - let item0 = SlotQueueItem.init(request, 0) + let item0 = + SlotQueueItem.init(request, 0, collateral = request.ask.collateralPerSlot) request.ask.pricePerBytePerSecond += 1.u256 - let item1 = SlotQueueItem.init(request, 1) + let item1 = + SlotQueueItem.init(request, 1, collateral = request.ask.collateralPerSlot) request.ask.pricePerBytePerSecond += 1.u256 - let item2 = SlotQueueItem.init(request, 2) + let item2 = + SlotQueueItem.init(request, 2, collateral = request.ask.collateralPerSlot) request.ask.pricePerBytePerSecond += 1.u256 - let item3 = SlotQueueItem.init(request, 3) + let item3 = + SlotQueueItem.init(request, 3, collateral = request.ask.collateralPerSlot) check queue.push(item0).isOk await sleepAsync(1.millis) @@ -499,13 +537,17 @@ suite "Slot queue": # sleeping after push allows the slotqueue loop to iterate, # calling the callback for each pushed/updated item var request = StorageRequest.example - let item0 = SlotQueueItem.init(request, 0) + let item0 = + SlotQueueItem.init(request, 0, collateral = request.ask.collateralPerSlot) request.ask.pricePerBytePerSecond += 1.u256 - let item1 = SlotQueueItem.init(request, 1) + let item1 = + SlotQueueItem.init(request, 1, collateral = request.ask.collateralPerSlot) request.ask.pricePerBytePerSecond += 1.u256 - let item2 = SlotQueueItem.init(request, 2) + let item2 = + SlotQueueItem.init(request, 2, collateral = request.ask.collateralPerSlot) request.ask.pricePerBytePerSecond += 1.u256 - let item3 = SlotQueueItem.init(request, 3) + let item3 = + SlotQueueItem.init(request, 3, collateral = request.ask.collateralPerSlot) check queue.push(item0).isOk check queue.push(item1).isOk @@ -529,7 +571,7 @@ suite "Slot queue": queue.pause let request = StorageRequest.example - var items = SlotQueueItem.init(request) + var items = SlotQueueItem.init(request, collateral = request.ask.collateralPerSlot) check queue.push(items).isOk # check all items processed check eventually queue.len == 0 @@ -537,8 +579,14 @@ suite "Slot queue": test "pushing seen item does not unpause queue": newSlotQueue(maxSize = 4, maxWorkers = 4) let request = StorageRequest.example - let item0 = - SlotQueueItem.init(request.id, 0'u16, request.ask, request.expiry, seen = true) + let item0 = SlotQueueItem.init( + request.id, + 0'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = true, + ) check queue.paused check queue.push(item0).isOk check queue.paused @@ -546,8 +594,14 @@ suite "Slot queue": test "paused queue waits for unpause before continuing processing": newSlotQueue(maxSize = 4, maxWorkers = 4) let request = StorageRequest.example - let item = - SlotQueueItem.init(request.id, 1'u16, request.ask, request.expiry, seen = false) + let item = SlotQueueItem.init( + request.id, + 1'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = false, + ) check queue.paused # push causes unpause check queue.push(item).isOk @@ -558,10 +612,22 @@ suite "Slot queue": test "processing a 'seen' item pauses the queue": newSlotQueue(maxSize = 4, maxWorkers = 4) let request = StorageRequest.example - let unseen = - SlotQueueItem.init(request.id, 0'u16, request.ask, request.expiry, seen = false) - let seen = - SlotQueueItem.init(request.id, 1'u16, request.ask, request.expiry, seen = true) + let unseen = SlotQueueItem.init( + request.id, + 0'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = false, + ) + let seen = SlotQueueItem.init( + request.id, + 1'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = true, + ) # push causes unpause check queue.push(unseen).isSuccess # check all items processed @@ -574,10 +640,22 @@ suite "Slot queue": test "processing a 'seen' item does not decrease the number of workers": newSlotQueue(maxSize = 4, maxWorkers = 4) let request = StorageRequest.example - let unseen = - SlotQueueItem.init(request.id, 0'u16, request.ask, request.expiry, seen = false) - let seen = - SlotQueueItem.init(request.id, 1'u16, request.ask, request.expiry, seen = true) + let unseen = SlotQueueItem.init( + request.id, + 0'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = false, + ) + let seen = SlotQueueItem.init( + request.id, + 1'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = true, + ) # push seen item to ensure that queue is pausing check queue.push(seen).isSuccess # unpause and pause a number of times @@ -594,10 +672,22 @@ suite "Slot queue": test "item 'seen' flags can be cleared": newSlotQueue(maxSize = 4, maxWorkers = 1) let request = StorageRequest.example - let item0 = - SlotQueueItem.init(request.id, 0'u16, request.ask, request.expiry, seen = true) - let item1 = - SlotQueueItem.init(request.id, 1'u16, request.ask, request.expiry, seen = true) + let item0 = SlotQueueItem.init( + request.id, + 0'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = true, + ) + let item1 = SlotQueueItem.init( + request.id, + 1'u16, + request.ask, + request.expiry, + request.ask.collateralPerSlot, + seen = true, + ) check queue.push(item0).isOk check queue.push(item1).isOk check queue[0].seen diff --git a/tests/contracts/testMarket.nim b/tests/contracts/testMarket.nim index 561ac66b..5b41c75d 100644 --- a/tests/contracts/testMarket.nim +++ b/tests/contracts/testMarket.nim @@ -2,7 +2,6 @@ import std/options import std/importutils import pkg/chronos import pkg/ethers/erc20 -import pkg/lrucache import codex/contracts import ../ethertest import ./examples diff --git a/tests/examples.nim b/tests/examples.nim index bfb34cff..70abc46a 100644 --- a/tests/examples.nim +++ b/tests/examples.nim @@ -72,7 +72,9 @@ proc example*(_: type Slot): Slot = proc example*(_: type SlotQueueItem): SlotQueueItem = let request = StorageRequest.example let slot = Slot.example - SlotQueueItem.init(request, slot.slotIndex.truncate(uint16)) + SlotQueueItem.init( + request, slot.slotIndex.truncate(uint16), collateral = request.ask.collateralPerSlot + ) proc example(_: type G1Point): G1Point = G1Point(x: UInt256.example, y: UInt256.example)