nim-codex/tests/integration/testmarketplace.nim

import ../examples
import ../contracts/time
import ../contracts/deployment
import ./marketplacesuite
import ./twonodes
import ./nodeconfigs

marketplacesuite "Marketplace":
  let marketplaceConfig = NodeConfigs(
    clients: CodexConfigs.init(nodes=1).some,
    providers: CodexConfigs.init(nodes=1).some,
  )
  
  var host: CodexClient
  var hostAccount: Address
  var client: CodexClient
  var clientAccount: Address

  setup:
    host = providers()[0].client
    hostAccount = providers()[0].ethAccount
    client = clients()[0].client
    clientAccount = clients()[0].ethAccount

    # Our Hardhat configuration does use automine, which means that time tracked by `ethProvider.currentTime()` is not
    # advanced until blocks are mined and that happens only when transaction is submitted.
    # As we use in tests ethProvider.currentTime() which uses block timestamp this can lead to synchronization issues.
    await ethProvider.advanceTime(1.u256)

  test "nodes negotiate contracts on the marketplace", marketplaceConfig:
    let size = 0xFFFFFF.u256
    let data = await RandomChunker.example(blocks=8)
    # host makes storage available
    let availability = host.postAvailability(totalSize=size, duration=20*60.u256, minPrice=300.u256, maxCollateral=300.u256).get

    # client requests storage
    let cid = client.upload(data).get
    let id = client.requestStorage(
      cid,
      duration=20*60.u256,
      reward=400.u256,
      proofProbability=3.u256,
      expiry=10*60,
      collateral=200.u256,
      nodes = 3,
      tolerance = 1).get

    check eventually(client.purchaseStateIs(id, "started"), timeout=10*60*1000)
    let purchase = client.getPurchase(id).get
    check purchase.error == none string
    let availabilities = host.getAvailabilities().get
    check availabilities.len == 1
    let newSize = availabilities[0].freeSize
    check newSize > 0 and newSize < size

    let reservations = host.getAvailabilityReservations(availability.id).get
    check reservations.len == 3
    check reservations[0].requestId == purchase.requestId

  test "node slots gets paid out and rest of tokens are returned to client", marketplaceConfig:
    let size = 0xFFFFFF.u256
    let data = await RandomChunker.example(blocks = 8)
    let marketplace = Marketplace.new(Marketplace.address, ethProvider.getSigner())
    let tokenAddress = await marketplace.token()
    let token = Erc20Token.new(tokenAddress, ethProvider.getSigner())
    let reward = 400.u256
    let duration = 20*60.u256
    let nodes = 3'u

    # host makes storage available
    let startBalanceHost = await token.balanceOf(hostAccount)
    discard host.postAvailability(totalSize=size, duration=20*60.u256, minPrice=300.u256, maxCollateral=300.u256).get

    # client requests storage
    let cid = client.upload(data).get
    let id = client.requestStorage(
      cid,
      duration=duration,
      reward=reward,
      proofProbability=3.u256,
      expiry=10*60,
      collateral=200.u256,
      nodes = nodes,
      tolerance = 1).get

    check eventually(client.purchaseStateIs(id, "started"), timeout=10*60*1000)
    let purchase = client.getPurchase(id).get
    check purchase.error == none string

    let clientBalanceBeforeFinished = await token.balanceOf(clientAccount)

    # Proving mechanism uses blockchain clock to do proving/collect/cleanup round
    # hence we must use `advanceTime` over `sleepAsync` as Hardhat does mine new blocks
    # only with new transaction
    await ethProvider.advanceTime(duration)

    # Checking that the hosting node received reward for at least the time between <expiry;end>
    check eventually (await token.balanceOf(hostAccount)) - startBalanceHost >= (duration-5*60)*reward*nodes.u256

    # Checking that client node receives some funds back that were not used for the host nodes
    check eventually(
      (await token.balanceOf(clientAccount)) - clientBalanceBeforeFinished > 0,
      timeout = 10*1000 # give client a bit of time to withdraw its funds
    )

marketplacesuite "Marketplace payouts":

  test "expired request partially pays out for stored time",
    NodeConfigs(
      # Uncomment to start Hardhat automatically, typically so logs can be inspected locally
      hardhat: HardhatConfig.none,

      clients:
        CodexConfigs.init(nodes=1)
          # .debug() # uncomment to enable console log output.debug()
          # .withLogFile() # uncomment to output log file to tests/integration/logs/<start_datetime> <suite_name>/<test_name>/<node_role>_<node_idx>.log
          # .withLogTopics("node", "erasure")
          .some,

      providers:
        CodexConfigs.init(nodes=1)
          # .debug() # uncomment to enable console log output
          # .withLogFile() # uncomment to output log file to tests/integration/logs/<start_datetime> <suite_name>/<test_name>/<node_role>_<node_idx>.log
          # .withLogTopics("node", "marketplace", "sales", "reservations", "node", "proving", "clock")
          .some,
  ):
    let reward = 400.u256
    let duration = 20.periods
    let collateral = 200.u256
    let expiry = 10.periods
    let data = await RandomChunker.example(blocks=8)
    let client = clients()[0]
    let provider = providers()[0]
    let clientApi = client.client
    let providerApi = provider.client
    let startBalanceProvider = await token.balanceOf(provider.ethAccount)
    let startBalanceClient = await token.balanceOf(client.ethAccount)

    # provider makes storage available
    discard providerApi.postAvailability(
      # make availability size small enough that we can't fill all the slots,
      # thus causing a cancellation
      totalSize=(data.len div 2).u256,
      duration=duration.u256,
      minPrice=reward,
      maxCollateral=collateral)

    let cid = clientApi.upload(data).get

    var slotIdxFilled = none UInt256
    proc onSlotFilled(eventResult: ?!SlotFilled) =
      assert not eventResult.isErr
      slotIdxFilled = some (!eventResult).slotIndex

    let subscription = await marketplace.subscribe(SlotFilled, onSlotFilled)

    # client requests storage but requires multiple slots to host the content
    let id = await clientApi.requestStorage(
      cid,
      duration=duration,
      reward=reward,
      expiry=expiry,
      collateral=collateral,
      nodes=3,
      tolerance=1
    )

    # wait until one slot is filled
    check eventually(slotIdxFilled.isSome, timeout=expiry.int * 1000)
    let slotId = slotId(!clientApi.requestId(id), !slotIdxFilled)

    # wait until sale is cancelled
    await ethProvider.advanceTime(expiry.u256)
    check eventually providerApi.saleStateIs(slotId, "SaleCancelled")

    await advanceToNextPeriod()

    check eventually (
      let endBalanceProvider = (await token.balanceOf(provider.ethAccount));
      endBalanceProvider > startBalanceProvider and
      endBalanceProvider < startBalanceProvider + expiry.u256*reward
    )
    check eventually(
      (
        let endBalanceClient = (await token.balanceOf(client.ethAccount));
        let endBalanceProvider = (await token.balanceOf(provider.ethAccount));
        (startBalanceClient - endBalanceClient) == (endBalanceProvider - startBalanceProvider)
      ),
      timeout = 10*1000 # give client a bit of time to withdraw its funds
    )

    await subscription.unsubscribe()