mirror of
https://github.com/logos-storage/logos-storage-nim.git
synced 2026-01-05 15:03:07 +00:00
ccf349bd14
* [marketplace] reservations module - add de/serialization for Availability - add markUsed/markUnused in persisted availability - add query for unused - add reserve/release - reservation module tests - split ContractInteractions into client contracts and host contracts - remove reservations start/stop as the repo start/stop is being managed by the node - remove dedicated reservations metadata store and use the metadata store from the repo instead - Split ContractInteractions into: - ClientInteractions (with purchasing) - HostInteractions (with sales and proving) - compilation fix for nim 1.2 [repostore] fix started flag, add tests [marketplace] persist slot index For loading the sales state from chain, the slot index was not previously persisted in the contract. Will retrieve the slot index from the contract when the sales state is loaded. * Revert repostore changes In favour of separate PR https://github.com/status-im/nim-codex/pull/374. * remove warnings * clean up * tests: stop repostore during teardown * change constructor type identifier Change Contracts constructor to accept Contracts type instead of ContractInteractions. * change constructor return type to Result instead of Option * fix and split interactions tests * clean up, fix tests * find availability by slot id * remove duplication in host/client interactions * add test for finding availability by slotId * log instead of raiseAssert when failed to mark availability as unused * move to SaleErrored state instead of raiseAssert * remove unneeded reverse It appears that order is not preserved in the repostore, so reversing does not have the intended effect here. * update open api spec for potential rest endpoint errors * move functions about available bytes to repostore * WIP: reserve and release availabilities as needed WIP: not tested yet Availabilities are marked as used when matched (just before downloading starts) so that future matching logic does not match an availability currently in use. As the download progresses, batches of blocks are written to disk, and the equivalent bytes are released from the reservation module. The size of the availability is reduced as well. During a reserve or release operation, availability updates occur after the repo is manipulated. If the availability update operation fails, the reserve or release is rolled back to maintain correct accounting of bytes. Finally, once download completes, or if an error occurs, the availability is marked as unused so future matching can occur. * delete availability when all bytes released * fix tests + cleanup * remove availability from SalesContext callbacks Availability is no longer used past the SaleDownloading state in the state machine. Cleanup of Availability (marking unused) is handled directly in the SaleDownloading state, and no longer in SaleErrored or SaleFinished. Likewise, Availabilities shouldn’t need to be handled on node restart. Additionally, Availability was being passed in SalesContext callbacks, and now that Availability is only used temporarily in the SaleDownloading state, Availability is contextually irrelevant to the callbacks, except in OnStore possibly, though it was not being consumed. * test clean up * - remove availability from callbacks and constructors from previous commit that needed to be removed (oopsie) - fix integration test that checks availabilities - there was a bug fixed that crashed the node due to a missing `return success` in onStore - the test was fixed by ensuring that availabilities are remaining on the node, and the size has been reduced - change Availability back to non-ref object and constructor back to init - add trace logging of all state transitions in state machine - add generally useful trace logging * fixes after rebase 1. Fix onProve callbacks 2. Use Slot type instead of tuple for retrieving active slot. 3. Bump codex-contracts-eth that exposes getActivceSlot call. * swap contracts branch to not support slot collateral Slot collateral changes in the contracts require further changes in the client code, so we’ll skip those changes for now and add in a separate commit. * modify Interactions and Deployment constructors - `HostInteractions` and `ClientInteractions` constructors were simplified to take a contract address and no overloads - `Interactions` prepared simplified so there are no overloads - `Deployment` constructor updated so that it takes an optional string parameter, instead `Option[string]` * Move `batchProc` declaration `batchProc` needs to be consumed by both `node` and `salescontext`, and they can’t reference each other as it creates a circular dependency. * [reservations] rename `available` to `hasAvailable` * [reservations] default error message to inner error msg * add SaleIngored state When a storage request is handled but the request does match availabilities, the sales agent machine is sent to the SaleIgnored state. In addition, the agent is constructed in a way that if the request is ignored, the sales agent is removed from the list of active agents being tracked in the sales module.
276 lines
11 KiB
Nim
276 lines
11 KiB
Nim
import std/options
|
|
import pkg/chronos
|
|
import pkg/stew/byteutils
|
|
import codex/contracts
|
|
import codex/storageproofs
|
|
import ../ethertest
|
|
import ./examples
|
|
import ./time
|
|
import ./token
|
|
|
|
ethersuite "On-Chain Market":
|
|
let proof = exampleProof()
|
|
|
|
var market: OnChainMarket
|
|
var marketplace: Marketplace
|
|
var token: TestToken
|
|
var request: StorageRequest
|
|
var slotIndex: UInt256
|
|
var periodicity: Periodicity
|
|
|
|
setup:
|
|
let deployment = Deployment.init()
|
|
marketplace = Marketplace.new(!deployment.address(Marketplace), provider.getSigner())
|
|
token = TestToken.new(!deployment.address(TestToken), provider.getSigner())
|
|
await token.mint(accounts[0], 1_000_000_000.u256)
|
|
|
|
let config = await marketplace.config()
|
|
let collateral = config.collateral.initialAmount
|
|
await token.approve(marketplace.address, collateral)
|
|
await marketplace.deposit(collateral)
|
|
|
|
market = OnChainMarket.new(marketplace)
|
|
periodicity = Periodicity(seconds: config.proofs.period)
|
|
|
|
request = StorageRequest.example
|
|
request.client = accounts[0]
|
|
|
|
slotIndex = (request.ask.slots div 2).u256
|
|
|
|
proc waitUntilProofRequired(slotId: SlotId) {.async.} =
|
|
let currentPeriod = periodicity.periodOf(await provider.currentTime())
|
|
await provider.advanceTimeTo(periodicity.periodEnd(currentPeriod))
|
|
while not (
|
|
(await marketplace.isProofRequired(slotId)) and
|
|
(await marketplace.getPointer(slotId)) < 250
|
|
):
|
|
await provider.advanceTime(periodicity.seconds)
|
|
|
|
test "fails to instantiate when contract does not have a signer":
|
|
let storageWithoutSigner = marketplace.connect(provider)
|
|
expect AssertionDefect:
|
|
discard OnChainMarket.new(storageWithoutSigner)
|
|
|
|
test "knows signer address":
|
|
check (await market.getSigner()) == (await provider.getSigner().getAddress())
|
|
|
|
test "supports marketplace requests":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
|
|
test "can retrieve previously submitted requests":
|
|
check (await market.getRequest(request.id)) == none StorageRequest
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
let r = await market.getRequest(request.id)
|
|
check (r) == some request
|
|
|
|
test "supports withdrawing of funds":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
await provider.advanceTimeTo(request.expiry)
|
|
await market.withdrawFunds(request.id)
|
|
|
|
test "supports request subscriptions":
|
|
var receivedIds: seq[RequestId]
|
|
var receivedAsks: seq[StorageAsk]
|
|
proc onRequest(id: RequestId, ask: StorageAsk) =
|
|
receivedIds.add(id)
|
|
receivedAsks.add(ask)
|
|
let subscription = await market.subscribeRequests(onRequest)
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
check receivedIds == @[request.id]
|
|
check receivedAsks == @[request.ask]
|
|
await subscription.unsubscribe()
|
|
|
|
test "supports filling of slots":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
await market.fillSlot(request.id, slotIndex, proof)
|
|
|
|
test "can retrieve host that filled slot":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
check (await market.getHost(request.id, slotIndex)) == none Address
|
|
await market.fillSlot(request.id, slotIndex, proof)
|
|
check (await market.getHost(request.id, slotIndex)) == some accounts[0]
|
|
|
|
test "support slot filled subscriptions":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
var receivedIds: seq[RequestId]
|
|
var receivedSlotIndices: seq[UInt256]
|
|
proc onSlotFilled(id: RequestId, slotIndex: UInt256) =
|
|
receivedIds.add(id)
|
|
receivedSlotIndices.add(slotIndex)
|
|
let subscription = await market.subscribeSlotFilled(request.id, slotIndex, onSlotFilled)
|
|
await market.fillSlot(request.id, slotIndex, proof)
|
|
check receivedIds == @[request.id]
|
|
check receivedSlotIndices == @[slotIndex]
|
|
await subscription.unsubscribe()
|
|
|
|
test "subscribes only to a certain slot":
|
|
var otherSlot = slotIndex - 1
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
var receivedSlotIndices: seq[UInt256]
|
|
proc onSlotFilled(requestId: RequestId, slotIndex: UInt256) =
|
|
receivedSlotIndices.add(slotIndex)
|
|
let subscription = await market.subscribeSlotFilled(request.id, slotIndex, onSlotFilled)
|
|
await market.fillSlot(request.id, otherSlot, proof)
|
|
check receivedSlotIndices.len == 0
|
|
await market.fillSlot(request.id, slotIndex, proof)
|
|
check receivedSlotIndices == @[slotIndex]
|
|
await subscription.unsubscribe()
|
|
|
|
test "support fulfillment subscriptions":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
var receivedIds: seq[RequestId]
|
|
proc onFulfillment(id: RequestId) =
|
|
receivedIds.add(id)
|
|
let subscription = await market.subscribeFulfillment(request.id, onFulfillment)
|
|
for slotIndex in 0..<request.ask.slots:
|
|
await market.fillSlot(request.id, slotIndex.u256, proof)
|
|
check receivedIds == @[request.id]
|
|
await subscription.unsubscribe()
|
|
|
|
test "subscribes only to fulfillment of a certain request":
|
|
var otherRequest = StorageRequest.example
|
|
otherRequest.client = accounts[0]
|
|
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
await token.approve(marketplace.address, otherRequest.price)
|
|
await market.requestStorage(otherRequest)
|
|
|
|
var receivedIds: seq[RequestId]
|
|
proc onFulfillment(id: RequestId) =
|
|
receivedIds.add(id)
|
|
|
|
let subscription = await market.subscribeFulfillment(request.id, onFulfillment)
|
|
|
|
for slotIndex in 0..<request.ask.slots:
|
|
await market.fillSlot(request.id, slotIndex.u256, proof)
|
|
for slotIndex in 0..<otherRequest.ask.slots:
|
|
await market.fillSlot(otherRequest.id, slotIndex.u256, proof)
|
|
|
|
check receivedIds == @[request.id]
|
|
|
|
await subscription.unsubscribe()
|
|
|
|
test "support request cancelled subscriptions":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
|
|
var receivedIds: seq[RequestId]
|
|
proc onRequestCancelled(id: RequestId) =
|
|
receivedIds.add(id)
|
|
let subscription = await market.subscribeRequestCancelled(request.id, onRequestCancelled)
|
|
|
|
await provider.advanceTimeTo(request.expiry)
|
|
await market.withdrawFunds(request.id)
|
|
check receivedIds == @[request.id]
|
|
await subscription.unsubscribe()
|
|
|
|
test "support request failed subscriptions":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
|
|
var receivedIds: seq[RequestId]
|
|
proc onRequestFailed(id: RequestId) =
|
|
receivedIds.add(id)
|
|
let subscription = await market.subscribeRequestFailed(request.id, onRequestFailed)
|
|
|
|
for slotIndex in 0..<request.ask.slots:
|
|
await market.fillSlot(request.id, slotIndex.u256, proof)
|
|
for slotIndex in 0..request.ask.maxSlotLoss:
|
|
let slotId = request.slotId(slotIndex.u256)
|
|
while true:
|
|
let slotState = await marketplace.slotState(slotId)
|
|
if slotState == SlotState.Free:
|
|
break
|
|
await waitUntilProofRequired(slotId)
|
|
let missingPeriod = periodicity.periodOf(await provider.currentTime())
|
|
await provider.advanceTime(periodicity.seconds)
|
|
await marketplace.markProofAsMissing(slotId, missingPeriod)
|
|
check receivedIds == @[request.id]
|
|
await subscription.unsubscribe()
|
|
|
|
test "subscribes only to a certain request cancellation":
|
|
var otherRequest = request
|
|
otherRequest.nonce = Nonce.example
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
await token.approve(marketplace.address, otherRequest.price)
|
|
await market.requestStorage(otherRequest)
|
|
|
|
var receivedIds: seq[RequestId]
|
|
proc onRequestCancelled(requestId: RequestId) =
|
|
receivedIds.add(requestId)
|
|
|
|
let subscription = await market.subscribeRequestCancelled(request.id, onRequestCancelled)
|
|
await provider.advanceTimeTo(request.expiry) # shares expiry with otherRequest
|
|
await market.withdrawFunds(otherRequest.id)
|
|
check receivedIds.len == 0
|
|
await market.withdrawFunds(request.id)
|
|
check receivedIds == @[request.id]
|
|
await subscription.unsubscribe()
|
|
|
|
test "request is none when unknown":
|
|
check isNone await market.getRequest(request.id)
|
|
|
|
test "can retrieve active requests":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
var request2 = StorageRequest.example
|
|
request2.client = accounts[0]
|
|
await token.approve(marketplace.address, request2.price)
|
|
await market.requestStorage(request2)
|
|
check (await market.myRequests()) == @[request.id, request2.id]
|
|
|
|
test "retrieves correct request state when request is unknown":
|
|
check (await market.requestState(request.id)) == none RequestState
|
|
|
|
test "can retrieve request state":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
for slotIndex in 0..<request.ask.slots:
|
|
await market.fillSlot(request.id, slotIndex.u256, proof)
|
|
check (await market.requestState(request.id)) == some RequestState.Started
|
|
|
|
test "can retrieve active slots":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
await market.fillSlot(request.id, slotIndex - 1, proof)
|
|
await market.fillSlot(request.id, slotIndex, proof)
|
|
let slotId1 = request.slotId(slotIndex - 1)
|
|
let slotId2 = request.slotId(slotIndex)
|
|
check (await market.mySlots()) == @[slotId1, slotId2]
|
|
|
|
test "returns none when slot is empty":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
let slotId = request.slotId(slotIndex)
|
|
check (await market.getActiveSlot(slotId)) == none Slot
|
|
|
|
test "can retrieve request details from slot id":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
await market.fillSlot(request.id, slotIndex, proof)
|
|
let slotId = request.slotId(slotIndex)
|
|
let expected = Slot(request: request, slotIndex: slotIndex)
|
|
check (await market.getActiveSlot(slotId)) == some expected
|
|
|
|
test "retrieves correct slot state when request is unknown":
|
|
let slotId = request.slotId(slotIndex)
|
|
check (await market.slotState(slotId)) == SlotState.Free
|
|
|
|
test "retrieves correct slot state once filled":
|
|
await token.approve(marketplace.address, request.price)
|
|
await market.requestStorage(request)
|
|
await market.fillSlot(request.id, slotIndex, proof)
|
|
let slotId = request.slotId(slotIndex)
|
|
check (await market.slotState(slotId)) == SlotState.Filled
|