codex-contracts-eth/test/Proofs.test.js

308 lines
11 KiB
JavaScript

const { expect } = require("chai")
const { ethers } = require("hardhat")
const { hexlify, randomBytes } = ethers.utils
const {
snapshot,
revert,
mine,
ensureMinimumBlockHeight,
currentTime,
advanceTime,
advanceTimeTo,
} = require("./evm")
const { periodic, hours, minutes } = require("./time")
describe("Proofs", function () {
const id = hexlify(randomBytes(32))
const endId = hexlify(randomBytes(32))
const period = 30 * 60
const timeout = 5
const downtime = 64
const duration = 1000 * period
const probability = 4 // require a proof roughly once every 4 periods
const { periodOf, periodEnd } = periodic(period)
let proofs
beforeEach(async function () {
await snapshot()
await ensureMinimumBlockHeight(256)
const Proofs = await ethers.getContractFactory("TestProofs")
proofs = await Proofs.deploy(period, timeout, downtime)
})
afterEach(async function () {
await revert()
})
describe("general", function () {
beforeEach(async function () {
await proofs.setProofEnd(endId, (await currentTime()) + duration)
})
it("does not allow ids to be reused", async function () {
await proofs.expectProofs(id, endId, probability)
await expect(
proofs.expectProofs(id, endId, probability)
).to.be.revertedWith("Proof id already in use")
})
it("requires proofs with an agreed upon probability", async function () {
await proofs.expectProofs(id, endId, probability)
let amount = 0
for (let i = 0; i < 100; i++) {
if (await proofs.isProofRequired(id)) {
amount += 1
}
await advanceTime(period)
}
let expected = 100 / probability
expect(amount).to.be.closeTo(expected, expected / 2)
})
it("requires no proofs in the start period", async function () {
const startPeriod = Math.floor((await currentTime()) / period)
const probability = 1
await proofs.expectProofs(id, endId, probability)
while (Math.floor((await currentTime()) / period) == startPeriod) {
expect(await proofs.isProofRequired(id)).to.be.false
await advanceTime(Math.floor(period / 10))
}
})
it("requires no proofs in the end period", async function () {
const probability = 1
await proofs.expectProofs(id, endId, probability)
await advanceTime(duration)
expect(await proofs.isProofRequired(id)).to.be.false
})
it("requires no proofs after the end time", async function () {
const probability = 1
await proofs.expectProofs(id, endId, probability)
await advanceTime(duration + timeout)
expect(await proofs.isProofRequired(id)).to.be.false
})
it("requires proofs for different ids at different times", async function () {
let id1 = hexlify(randomBytes(32))
let id2 = hexlify(randomBytes(32))
let id3 = hexlify(randomBytes(32))
for (let id of [id1, id2, id3]) {
await proofs.expectProofs(id, endId, probability)
}
let req1, req2, req3
while (req1 === req2 && req2 === req3) {
req1 = await proofs.isProofRequired(id1)
req2 = await proofs.isProofRequired(id2)
req3 = await proofs.isProofRequired(id3)
await advanceTime(period)
}
})
it("moves pointer one block at a time", async function () {
await advanceTimeTo(periodEnd(periodOf(await currentTime())))
for (let i = 0; i < 256; i++) {
let previous = await proofs.getPointer(id)
await mine()
let current = await proofs.getPointer(id)
expect(current).to.equal((previous + 1) % 256)
}
})
})
describe("when proof requirement is upcoming", function () {
async function waitUntilProofWillBeRequired() {
while (!(await proofs.willProofBeRequired(id))) {
await mine()
}
}
beforeEach(async function () {
await proofs.setProofEnd(endId, (await currentTime()) + duration)
await proofs.expectProofs(id, endId, probability)
await advanceTimeTo(periodEnd(periodOf(await currentTime())))
await waitUntilProofWillBeRequired()
})
it("means the pointer is in downtime", async function () {
expect(await proofs.getPointer(id)).to.be.lt(downtime)
while ((await proofs.getPointer(id)) < downtime) {
expect(await proofs.willProofBeRequired(id)).to.be.true
await mine()
}
})
it("means that a proof is required after downtime", async function () {
while ((await proofs.getPointer(id)) < downtime) {
await mine()
}
expect(await proofs.willProofBeRequired(id)).to.be.false
expect(await proofs.isProofRequired(id)).to.be.true
})
it("will not require proofs when no longer expected", async function () {
expect(await proofs.getPointer(id)).to.be.lt(downtime)
expect(await proofs.willProofBeRequired(id)).to.be.true
await proofs.unexpectProofs(id)
expect(await proofs.willProofBeRequired(id)).to.be.false
})
})
describe("when proofs are required", function () {
const proof = hexlify(randomBytes(42))
beforeEach(async function () {
await proofs.setProofEnd(endId, (await currentTime()) + duration)
await proofs.expectProofs(id, endId, probability)
})
async function waitUntilProofIsRequired(id) {
await advanceTimeTo(periodEnd(periodOf(await currentTime())))
while (
!(
(await proofs.isProofRequired(id)) &&
(await proofs.getPointer(id)) < 250
)
) {
await advanceTime(period)
}
}
it("provides different challenges per period", async function () {
await waitUntilProofIsRequired(id)
const challenge1 = await proofs.getChallenge(id)
await waitUntilProofIsRequired(id)
const challenge2 = await proofs.getChallenge(id)
expect(challenge2).not.to.equal(challenge1)
})
it("provides different challenges per id", async function () {
const id2 = hexlify(randomBytes(32))
const id3 = hexlify(randomBytes(32))
const challenge1 = await proofs.getChallenge(id)
const challenge2 = await proofs.getChallenge(id2)
const challenge3 = await proofs.getChallenge(id3)
expect(challenge1 === challenge2 && challenge2 === challenge3).to.be.false
})
it("submits a correct proof", async function () {
await proofs.submitProof(id, proof)
})
it("fails proof submission when proof is incorrect", async function () {
await expect(proofs.submitProof(id, [])).to.be.revertedWith(
"Invalid proof"
)
})
it("emits an event when proof was submitted", async function () {
await expect(proofs.submitProof(id, proof))
.to.emit(proofs, "ProofSubmitted")
.withArgs(id, proof)
})
it("fails proof submission when already submitted", async function () {
await advanceTimeTo(periodEnd(periodOf(await currentTime())))
await proofs.submitProof(id, proof)
await expect(proofs.submitProof(id, proof)).to.be.revertedWith(
"Proof already submitted"
)
})
it("marks a proof as missing", async function () {
expect(await proofs.missed(id)).to.equal(0)
await waitUntilProofIsRequired(id)
let missedPeriod = periodOf(await currentTime())
await advanceTimeTo(periodEnd(missedPeriod))
await proofs.markProofAsMissing(id, missedPeriod)
expect(await proofs.missed(id)).to.equal(1)
})
it("does not mark a proof as missing before period end", async function () {
await waitUntilProofIsRequired(id)
let currentPeriod = periodOf(await currentTime())
await expect(
proofs.markProofAsMissing(id, currentPeriod)
).to.be.revertedWith("Period has not ended yet")
})
it("does not mark a proof as missing after timeout", async function () {
await waitUntilProofIsRequired(id)
let currentPeriod = periodOf(await currentTime())
await advanceTimeTo(periodEnd(currentPeriod) + timeout)
await expect(
proofs.markProofAsMissing(id, currentPeriod)
).to.be.revertedWith("Validation timed out")
})
it("does not mark a submitted proof as missing", async function () {
await waitUntilProofIsRequired(id)
let submittedPeriod = periodOf(await currentTime())
await proofs.submitProof(id, proof)
await advanceTimeTo(periodEnd(submittedPeriod))
await expect(
proofs.markProofAsMissing(id, submittedPeriod)
).to.be.revertedWith("Proof was submitted, not missing")
})
it("does not mark proof as missing when not required", async function () {
while (await proofs.isProofRequired(id)) {
await advanceTime(period)
}
let currentPeriod = periodOf(await currentTime())
await advanceTimeTo(periodEnd(currentPeriod))
await expect(
proofs.markProofAsMissing(id, currentPeriod)
).to.be.revertedWith("Proof was not required")
})
it("does not mark proof as missing twice", async function () {
await waitUntilProofIsRequired(id)
let missedPeriod = periodOf(await currentTime())
await advanceTimeTo(periodEnd(missedPeriod))
await proofs.markProofAsMissing(id, missedPeriod)
await expect(
proofs.markProofAsMissing(id, missedPeriod)
).to.be.revertedWith("Proof already marked as missing")
})
it("requires no proofs when no longer expected", async function () {
await waitUntilProofIsRequired(id)
await proofs.unexpectProofs(id)
await expect(await proofs.isProofRequired(id)).to.be.false
})
})
describe("set proof end", function () {
const proof = hexlify(randomBytes(42))
it("fails to get proof end when proof ending doesn't exist", async function () {
await expect(proofs.end(endId)).to.be.revertedWith(
"Proof ending doesn't exist"
)
})
it("sets proof end when proof ending doesn't already exist", async function () {
let ending = (await currentTime()) + duration
await expect(proofs.setProofEnd(endId, ending)).not.to.be.reverted
await expect(await proofs.end(endId)).to.equal(ending)
})
it("sets proof end when proof ending exists and ending set to past", async function () {
// let ending = (await currentTime()) + duration
// await proofs.setProofEnd(endId, ending)
let past = (await currentTime()) - 1
await expect(proofs.setProofEnd(endId, past)).not.to.be.reverted
})
it("fails when proof ending already exists and ending set to future", async function () {
let ending = (await currentTime()) + duration
await proofs.setProofEnd(endId, ending)
await expect(proofs.setProofEnd(endId, ending)).to.be.revertedWith(
"End exists or must be past"
)
})
})
})