logos-storage-nim/codex/contracts/clock.nim

{.push raises: [].}

import std/times
import pkg/ethers
import pkg/questionable
import pkg/chronos
import pkg/stint
import ../clock
import ../conf
import ../utils/trackedfutures

export clock

logScope:
  topics = "contracts clock"

type OnChainClock* = ref object of Clock
  provider: Provider
  subscription: Subscription
  offset: times.Duration
  blockNumber: UInt256
  started: bool
  newBlock: AsyncEvent
  trackedFutures: TrackedFutures

proc new*(_: type OnChainClock, provider: Provider): OnChainClock =
  OnChainClock(
    provider: provider, newBlock: newAsyncEvent(), trackedFutures: TrackedFutures()
  )

proc update(clock: OnChainClock, blck: Block) =
  if number =? blck.number and number > clock.blockNumber:
    let blockTime = initTime(blck.timestamp.truncate(int64), 0)
    let computerTime = getTime()
    clock.offset = blockTime - computerTime
    clock.blockNumber = number
    trace "updated clock",
      blockTime = blck.timestamp, blockNumber = number, offset = clock.offset
    clock.newBlock.fire()

proc update(clock: OnChainClock) {.async: (raises: []).} =
  try:
    if latest =? (await clock.provider.getBlock(BlockTag.latest)):
      clock.update(latest)
  except CatchableError as error:
    debug "error updating clock: ", error = error.msg

method start*(clock: OnChainClock) {.async.} =
  if clock.started:
    return

  proc onBlock(blckResult: ?!Block) =
    if eventError =? blckResult.errorOption:
      error "There was an error in block subscription", msg = eventError.msg
      return

    # ignore block parameter; hardhat may call this with pending blocks
    clock.trackedFutures.track(clock.update())

  await clock.update()

  clock.subscription = await clock.provider.subscribe(onBlock)
  clock.started = true

method stop*(clock: OnChainClock) {.async.} =
  if not clock.started:
    return

  await clock.subscription.unsubscribe()
  await clock.trackedFutures.cancelTracked()
  clock.started = false

method now*(clock: OnChainClock): SecondsSince1970 =
  doAssert clock.started, "clock should be started before calling now()"
  return toUnix(getTime() + clock.offset)

method waitUntil*(
    clock: OnChainClock, time: SecondsSince1970
) {.async: (raises: [CancelledError]).} =
  while (let difference = time - clock.now(); difference > 0):
    clock.newBlock.clear()
    discard await clock.newBlock.wait().withTimeout(chronos.seconds(difference))