dagger-contracts/test/Proofs.test.js

300 lines
11 KiB
JavaScript
Raw Normal View History

const { expect } = require("chai")
const { ethers } = require("hardhat")
const { hexlify, randomBytes } = ethers.utils
const {
snapshot,
revert,
mine,
2022-03-09 10:21:19 +00:00
ensureMinimumBlockHeight,
currentTime,
advanceTimeForNextBlock,
advanceTimeToForNextBlock,
} = require("./evm")
2023-01-09 13:21:23 +00:00
const { periodic } = require("./time")
const { loadProof, loadPublicInput, loadVerificationKey } = require("./proof")
const { SlotState } = require("./requests")
const binomialTest = require("@stdlib/stats-binomial-test")
2024-01-18 12:50:54 +00:00
const { exampleProof } = require("./examples")
describe("Proofs", function () {
const slotId = hexlify(randomBytes(32))
const period = 30 * 60
const timeout = 5
2022-03-10 09:19:21 +00:00
const downtime = 64
const probability = 4 // require a proof roughly once every 4 periods
const { periodOf, periodEnd } = periodic(period)
let proofs
beforeEach(async function () {
await snapshot()
2022-03-09 10:21:19 +00:00
await ensureMinimumBlockHeight(256)
const Proofs = await ethers.getContractFactory("TestProofs")
const Verifier = await ethers.getContractFactory("Groth16Verifier")
const verifier = await Verifier.deploy(loadVerificationKey("local"))
2024-01-10 14:12:18 +00:00
proofs = await Proofs.deploy(
{ period, timeout, downtime },
verifier.address
)
})
afterEach(async function () {
await revert()
})
describe("general", function () {
beforeEach(async function () {
await proofs.setSlotState(slotId, SlotState.Filled)
})
it("requires proofs with an agreed upon probability", async function () {
const samples = 256 // 256 samples avoids bias due to pointer downtime
await proofs.startRequiringProofs(slotId, probability)
await advanceTimeForNextBlock(period)
await mine()
let amount = 0
for (let i = 0; i < samples; i++) {
if (await proofs.isProofRequired(slotId)) {
amount += 1
}
await advanceTimeForNextBlock(period)
await mine()
}
const p = 1 / probability // expected probability
const alpha = 1 / 1000 // unit test can fail once every 1000 runs
// use binomial test to check that the measured amount is likely to occur
expect(binomialTest(amount, samples, { p, alpha }).rejected).to.be.false
})
it("supports probability 1 (proofs are always required)", async function () {
await proofs.startRequiringProofs(slotId, 1)
await advanceTimeForNextBlock(period)
await mine()
while ((await proofs.getPointer(slotId)) < downtime) {
await mine()
}
expect(await proofs.isProofRequired(slotId)).to.be.true
})
it("requires no proofs in the start period", async function () {
const startPeriod = Math.floor((await currentTime()) / period)
const probability = 1
await proofs.startRequiringProofs(slotId, probability)
while (Math.floor((await currentTime()) / period) == startPeriod) {
expect(await proofs.isProofRequired(slotId)).to.be.false
await advanceTimeForNextBlock(Math.floor(period / 10))
await mine()
}
})
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 slotId of [id1, id2, id3]) {
await proofs.setSlotState(slotId, SlotState.Filled)
await proofs.startRequiringProofs(slotId, 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 advanceTimeForNextBlock(period)
await mine()
}
})
it("moves pointer one block at a time", async function () {
await advanceTimeToForNextBlock(periodEnd(periodOf(await currentTime())))
await mine()
for (let i = 0; i < 256; i++) {
let previous = await proofs.getPointer(slotId)
await mine()
let current = await proofs.getPointer(slotId)
expect(current).to.equal((previous + 1) % 256)
}
})
})
describe("when proof requirement is upcoming", function () {
async function waitUntilProofWillBeRequired() {
while (!(await proofs.willProofBeRequired(slotId))) {
await mine()
}
}
beforeEach(async function () {
await proofs.setSlotState(slotId, SlotState.Filled)
await proofs.startRequiringProofs(slotId, probability)
await advanceTimeToForNextBlock(periodEnd(periodOf(await currentTime())))
await waitUntilProofWillBeRequired()
})
it("means the pointer is in downtime", async function () {
expect(await proofs.getPointer(slotId)).to.be.lt(downtime)
while ((await proofs.getPointer(slotId)) < downtime) {
expect(await proofs.willProofBeRequired(slotId)).to.be.true
await mine()
}
})
it("means that a proof is required after downtime", async function () {
while ((await proofs.getPointer(slotId)) < downtime) {
await mine()
}
expect(await proofs.willProofBeRequired(slotId)).to.be.false
expect(await proofs.isProofRequired(slotId)).to.be.true
})
it("will not require proofs when slot is finished", async function () {
expect(await proofs.getPointer(slotId)).to.be.lt(downtime)
expect(await proofs.willProofBeRequired(slotId)).to.be.true
await proofs.setSlotState(slotId, SlotState.Finished)
expect(await proofs.willProofBeRequired(slotId)).to.be.false
})
})
2022-04-11 12:09:48 +00:00
describe("when proofs are required", function () {
2024-01-18 08:54:21 +00:00
const proof = loadProof("local")
const pubSignals = loadPublicInput("local")
beforeEach(async function () {
await proofs.setSlotState(slotId, SlotState.Filled)
await proofs.startRequiringProofs(slotId, probability)
})
async function waitUntilProofIsRequired(slotId) {
await advanceTimeToForNextBlock(periodEnd(periodOf(await currentTime())))
await mine()
while (
!(
(await proofs.isProofRequired(slotId)) &&
(await proofs.getPointer(slotId)) < 250
)
) {
await advanceTimeForNextBlock(period)
await mine()
}
}
2022-03-10 12:04:46 +00:00
it("provides different challenges per period", async function () {
await waitUntilProofIsRequired(slotId)
const challenge1 = await proofs.getChallenge(slotId)
await waitUntilProofIsRequired(slotId)
const challenge2 = await proofs.getChallenge(slotId)
2022-03-10 12:04:46 +00:00
expect(challenge2).not.to.equal(challenge1)
})
it("provides different challenges per slotId", async function () {
const id2 = hexlify(randomBytes(32))
const id3 = hexlify(randomBytes(32))
const challenge1 = await proofs.getChallenge(slotId)
2022-03-10 12:04:46 +00:00
const challenge2 = await proofs.getChallenge(id2)
const challenge3 = await proofs.getChallenge(id3)
expect(challenge1 === challenge2 && challenge2 === challenge3).to.be.false
})
it("handles a correct proof", async function () {
await proofs.proofReceived(slotId, proof, pubSignals)
})
it("fails proof submission when proof is incorrect", async function () {
2024-01-18 12:50:54 +00:00
let invalid = exampleProof()
await expect(proofs.proofReceived(slotId, invalid, pubSignals)).to.be
.reverted
})
it("fails proof submission when public input is incorrect", async function () {
let invalid = [1, 2, 3]
await expect(proofs.proofReceived(slotId, proof, invalid)).to.be.reverted
})
it("emits an event when proof was submitted", async function () {
await expect(proofs.proofReceived(slotId, proof, pubSignals))
2024-01-15 15:25:30 +00:00
.to.emit(proofs, "ProofSubmitted")
.withArgs(slotId)
})
2022-02-09 13:17:23 +00:00
it("fails proof submission when already submitted", async function () {
await advanceTimeToForNextBlock(periodEnd(periodOf(await currentTime())))
await proofs.proofReceived(slotId, proof, pubSignals)
await expect(
proofs.proofReceived(slotId, proof, pubSignals)
).to.be.revertedWith("Proof already submitted")
})
it("marks a proof as missing", async function () {
expect(await proofs.missingProofs(slotId)).to.equal(0)
await waitUntilProofIsRequired(slotId)
let missedPeriod = periodOf(await currentTime())
await advanceTimeToForNextBlock(periodEnd(missedPeriod))
await mine()
await proofs.markProofAsMissing(slotId, missedPeriod)
expect(await proofs.missingProofs(slotId)).to.equal(1)
})
it("does not mark a proof as missing before period end", async function () {
await waitUntilProofIsRequired(slotId)
let currentPeriod = periodOf(await currentTime())
await expect(
proofs.markProofAsMissing(slotId, currentPeriod)
).to.be.revertedWith("Period has not ended yet")
})
it("does not mark a proof as missing after timeout", async function () {
await waitUntilProofIsRequired(slotId)
let currentPeriod = periodOf(await currentTime())
await advanceTimeToForNextBlock(periodEnd(currentPeriod) + timeout)
await expect(
proofs.markProofAsMissing(slotId, currentPeriod)
).to.be.revertedWith("Validation timed out")
})
it("does not mark a received proof as missing", async function () {
await waitUntilProofIsRequired(slotId)
let receivedPeriod = periodOf(await currentTime())
await proofs.proofReceived(slotId, proof, pubSignals)
await advanceTimeToForNextBlock(periodEnd(receivedPeriod))
await mine()
await expect(
proofs.markProofAsMissing(slotId, receivedPeriod)
).to.be.revertedWith("Proof was submitted, not missing")
})
it("does not mark proof as missing when not required", async function () {
while (await proofs.isProofRequired(slotId)) {
await advanceTimeForNextBlock(period)
await mine()
}
let currentPeriod = periodOf(await currentTime())
await advanceTimeToForNextBlock(periodEnd(currentPeriod))
await mine()
await expect(
proofs.markProofAsMissing(slotId, currentPeriod)
).to.be.revertedWith("Proof was not required")
})
it("does not mark proof as missing twice", async function () {
await waitUntilProofIsRequired(slotId)
let missedPeriod = periodOf(await currentTime())
await advanceTimeToForNextBlock(periodEnd(missedPeriod))
await mine()
await proofs.markProofAsMissing(slotId, missedPeriod)
await expect(
proofs.markProofAsMissing(slotId, missedPeriod)
).to.be.revertedWith("Proof already marked as missing")
})
it("requires no proofs when slot is finished", async function () {
await waitUntilProofIsRequired(slotId)
await proofs.setSlotState(slotId, SlotState.Finished)
expect(await proofs.isProofRequired(slotId)).to.be.false
})
})
})