@arbitrum/nitro-contracts 1.0.0-beta.1

package/test/contract/sequencerInboxForceInclude.spec.ts

@@ -0,0 +1,516 @@
+/*
+ * Copyright 2019-2020, Offchain Labs, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* eslint-env node, mocha */
+
+import { ethers, network } from 'hardhat'
+import { BigNumber } from '@ethersproject/bignumber'
+import { Block, TransactionReceipt } from '@ethersproject/providers'
+import { expect } from 'chai'
+import {
+  Bridge,
+  Bridge__factory,
+  Inbox,
+  Inbox__factory,
+  MessageTester,
+  SequencerInbox,
+  SequencerInbox__factory,
+  TransparentUpgradeableProxy__factory,
+} from '../../build/types'
+import { initializeAccounts } from './utils'
+import { Event } from '@ethersproject/contracts'
+import { Interface } from '@ethersproject/abi'
+import {
+  BridgeInterface,
+  MessageDeliveredEvent,
+} from '../../build/types/Bridge'
+import { Signer } from 'ethers'
+
+const mineBlocks = async (count: number, timeDiffPerBlock = 14) => {
+  const block = (await network.provider.send('eth_getBlockByNumber', [
+    'latest',
+    false,
+  ])) as Block
+  let timestamp = BigNumber.from(block.timestamp).toNumber()
+  for (let i = 0; i < count; i++) {
+    timestamp = timestamp + timeDiffPerBlock
+    await network.provider.send('evm_mine', [timestamp])
+  }
+}
+
+describe('SequencerInboxForceInclude', async () => {
+  const findMatchingLogs = <TInterface extends Interface, TEvent extends Event>(
+    receipt: TransactionReceipt,
+    iFace: TInterface,
+    eventTopicGen: (i: TInterface) => string,
+  ): TEvent['args'][] => {
+    const logs = receipt.logs.filter(
+      (log) => log.topics[0] === eventTopicGen(iFace),
+    )
+    return logs.map((l) => iFace.parseLog(l).args as TEvent['args'])
+  }
+
+  const getMessageDeliveredEvents = (receipt: TransactionReceipt) => {
+    const bridgeInterface = Bridge__factory.createInterface()
+    return findMatchingLogs<BridgeInterface, MessageDeliveredEvent>(
+      receipt,
+      bridgeInterface,
+      (i) => i.getEventTopic(i.getEvent('MessageDelivered')),
+    )
+  }
+
+  const sendDelayedTx = async (
+    sender: Signer,
+    inbox: Inbox,
+    bridge: Bridge,
+    messageTester: MessageTester,
+    l2Gas: number,
+    l2GasPrice: number,
+    nonce: number,
+    destAddr: string,
+    amount: BigNumber,
+    data: string,
+  ) => {
+    const countBefore = (await bridge.functions.messageCount())[0].toNumber()
+    const sendUnsignedTx = await inbox
+      .connect(sender)
+      .sendUnsignedTransaction(l2Gas, l2GasPrice, nonce, destAddr, amount, data)
+    const sendUnsignedTxReceipt = await sendUnsignedTx.wait()
+
+    const countAfter = (await bridge.functions.messageCount())[0].toNumber()
+    expect(countAfter, 'Unexpected inbox count').to.eq(countBefore + 1)
+
+    const senderAddr = await sender.getAddress()
+
+    const messageDeliveredEvent = getMessageDeliveredEvents(
+      sendUnsignedTxReceipt,
+    )[0]
+    const l1BlockNumber = sendUnsignedTxReceipt.blockNumber
+    const blockL1 = await sender.provider!.getBlock(l1BlockNumber)
+    const baseFeeL1 = blockL1.baseFeePerGas!.toNumber()
+    const l1BlockTimestamp = blockL1.timestamp
+    const delayedAcc = await bridge.inboxAccs(countBefore)
+
+    // need to hex pad the address
+    const messageDataHash = ethers.utils.solidityKeccak256(
+      ['uint8', 'uint256', 'uint256', 'uint256', 'uint256', 'uint256', 'bytes'],
+      [
+        0,
+        l2Gas,
+        l2GasPrice,
+        nonce,
+        ethers.utils.hexZeroPad(destAddr, 32),
+        amount,
+        data,
+      ],
+    )
+    expect(
+      messageDeliveredEvent.messageDataHash,
+      'Incorrect messageDataHash',
+    ).to.eq(messageDataHash)
+
+    const messageHash = (
+      await messageTester.functions.messageHash(
+        3,
+        senderAddr,
+        l1BlockNumber,
+        l1BlockTimestamp,
+        countBefore,
+        baseFeeL1,
+        messageDataHash,
+      )
+    )[0]
+
+    const prevAccumulator = messageDeliveredEvent.beforeInboxAcc
+    expect(prevAccumulator, 'Incorrect prev accumulator').to.eq(
+      countBefore === 0
+        ? ethers.utils.hexZeroPad('0x', 32)
+        : await bridge.inboxAccs(countBefore - 1),
+    )
+
+    const nextAcc = (
+      await messageTester.functions.accumulateInboxMessage(
+        prevAccumulator,
+        messageHash,
+      )
+    )[0]
+
+    expect(delayedAcc, 'Incorrect delayed acc').to.eq(nextAcc)
+
+    return {
+      baseFeeL1: baseFeeL1,
+      deliveredMessageEvent: messageDeliveredEvent,
+      l1BlockNumber,
+      l1BlockTimestamp,
+      delayedAcc,
+      l2Gas,
+      l2GasPrice,
+      nonce,
+      destAddr,
+      amount,
+      data,
+      senderAddr,
+      inboxAccountLength: countAfter,
+    }
+  }
+
+  const forceIncludeMessages = async (
+    sequencerInbox: SequencerInbox,
+    newTotalDelayedMessagesRead: number,
+    kind: number,
+    l1blockNumber: number,
+    l1Timestamp: number,
+    l1BaseFee: number,
+    senderAddr: string,
+    messageDataHash: string,
+    expectedErrorType?: string,
+  ) => {
+    const inboxLengthBefore = (await sequencerInbox.batchCount()).toNumber()
+
+    const forceInclusionTx = sequencerInbox.forceInclusion(
+      newTotalDelayedMessagesRead,
+      kind,
+      [l1blockNumber, l1Timestamp],
+      l1BaseFee,
+      senderAddr,
+      messageDataHash,
+    )
+    if (expectedErrorType) {
+      await expect(forceInclusionTx).to.be.revertedWith(`reverted with custom error '${expectedErrorType}()'`)
+    } else {
+      await (await forceInclusionTx).wait()
+
+      const totalDelayedMessagsReadAfter = (
+        await sequencerInbox.totalDelayedMessagesRead()
+      ).toNumber()
+      expect(
+        totalDelayedMessagsReadAfter,
+        'Incorrect totalDelayedMessagesRead after.',
+      ).to.eq(newTotalDelayedMessagesRead)
+      const inboxLengthAfter = (await sequencerInbox.batchCount()).toNumber()
+      expect(
+        inboxLengthAfter - inboxLengthBefore,
+        'Inbox not incremented',
+      ).to.eq(1)
+    }
+  }
+
+  const setupSequencerInbox = async (maxDelayBlocks = 10, maxDelayTime = 0) => {
+    const accounts = await initializeAccounts()
+    const admin = accounts[0]
+    const adminAddr = await admin.getAddress()
+    const user = accounts[1]
+    const dummyRollup = accounts[2]
+
+    const sequencerInboxFac = (await ethers.getContractFactory(
+      'SequencerInbox',
+    )) as SequencerInbox__factory
+    const seqInboxTemplate = await sequencerInboxFac.deploy()
+    const inboxFac = (await ethers.getContractFactory(
+      'Inbox',
+    )) as Inbox__factory
+    const inboxTemplate = await inboxFac.deploy()
+    const bridgeFac = (await ethers.getContractFactory(
+      'Bridge',
+    )) as Bridge__factory
+    const bridgeTemplate = await bridgeFac.deploy()
+    const transparentUpgradeableProxyFac = (await ethers.getContractFactory(
+      'TransparentUpgradeableProxy',
+    )) as TransparentUpgradeableProxy__factory
+
+    const bridgeProxy = await transparentUpgradeableProxyFac.deploy(
+      bridgeTemplate.address,
+      adminAddr,
+      '0x',
+    )
+    const sequencerInboxProxy = await transparentUpgradeableProxyFac.deploy(
+      seqInboxTemplate.address,
+      adminAddr,
+      '0x',
+    )
+    const inboxProxy = await transparentUpgradeableProxyFac.deploy(
+      inboxTemplate.address,
+      adminAddr,
+      '0x',
+    )
+
+    const bridge = await bridgeFac.attach(bridgeProxy.address).connect(user)
+    const sequencerInbox = await sequencerInboxFac
+      .attach(sequencerInboxProxy.address)
+      .connect(user)
+    const inbox = await inboxFac.attach(inboxProxy.address).connect(user)
+
+    await bridge.initialize()
+
+    await sequencerInbox.initialize(
+      bridgeProxy.address,
+      await dummyRollup.getAddress(),
+      {
+        delayBlocks: maxDelayBlocks,
+        delaySeconds: maxDelayTime,
+        futureBlocks: 10,
+        futureSeconds: 3000,
+      },
+    )
+    await inbox.initialize(bridgeProxy.address)
+
+    await bridge.setInbox(inbox.address, true)
+
+    const messageTester = (await (
+      await ethers.getContractFactory('MessageTester')
+    ).deploy()) as MessageTester
+
+    return {
+      user,
+      bridge: bridge,
+      inbox: inbox,
+      sequencerInbox: sequencerInbox,
+      messageTester,
+    }
+  }
+
+  it('can force-include', async () => {
+    const {
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      sequencerInbox,
+    } = await setupSequencerInbox()
+
+    const delayedTx = await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      0,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0x1010',
+    )
+    const maxTimeVariation = await sequencerInbox.maxTimeVariation()
+
+    await mineBlocks(maxTimeVariation.delayBlocks.toNumber())
+
+    await forceIncludeMessages(
+      sequencerInbox,
+      delayedTx.inboxAccountLength,
+      delayedTx.deliveredMessageEvent.kind,
+      delayedTx.l1BlockNumber,
+      delayedTx.l1BlockTimestamp,
+      delayedTx.baseFeeL1,
+      delayedTx.senderAddr,
+      delayedTx.deliveredMessageEvent.messageDataHash,
+    )
+  })
+
+  it('can force-include one after another', async () => {
+    const {
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      sequencerInbox,
+    } = await setupSequencerInbox()
+    const delayedTx = await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      0,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0x1010',
+    )
+
+    const delayedTx2 = await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      1,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0xdeadface',
+    )
+
+    const maxTimeVariation = await sequencerInbox.maxTimeVariation()
+    await mineBlocks(maxTimeVariation.delayBlocks.toNumber())
+
+    await forceIncludeMessages(
+      sequencerInbox,
+      delayedTx.inboxAccountLength,
+      delayedTx.deliveredMessageEvent.kind,
+      delayedTx.l1BlockNumber,
+      delayedTx.l1BlockTimestamp,
+      delayedTx.baseFeeL1,
+      delayedTx.senderAddr,
+      delayedTx.deliveredMessageEvent.messageDataHash,
+    )
+    await forceIncludeMessages(
+      sequencerInbox,
+      delayedTx2.inboxAccountLength,
+      delayedTx2.deliveredMessageEvent.kind,
+      delayedTx2.l1BlockNumber,
+      delayedTx2.l1BlockTimestamp,
+      delayedTx2.baseFeeL1,
+      delayedTx2.senderAddr,
+      delayedTx2.deliveredMessageEvent.messageDataHash,
+    )
+  })
+
+  it('can force-include three at once', async () => {
+    const {
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      sequencerInbox,
+    } = await setupSequencerInbox()
+    await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      0,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0x1010',
+    )
+    await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      1,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0x101010',
+    )
+    const delayedTx3 = await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      10,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0x10101010',
+    )
+
+    const maxTimeVariation = await sequencerInbox.maxTimeVariation()
+    await mineBlocks(maxTimeVariation.delayBlocks.toNumber())
+
+    await forceIncludeMessages(
+      sequencerInbox,
+      delayedTx3.inboxAccountLength,
+      delayedTx3.deliveredMessageEvent.kind,
+      delayedTx3.l1BlockNumber,
+      delayedTx3.l1BlockTimestamp,
+      delayedTx3.baseFeeL1,
+      delayedTx3.senderAddr,
+      delayedTx3.deliveredMessageEvent.messageDataHash,
+    )
+  })
+
+  it('cannot include before max block delay', async () => {
+    const {
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      sequencerInbox,
+    } = await setupSequencerInbox(10, 100)
+    const delayedTx = await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      0,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0x1010',
+    )
+
+    const maxTimeVariation = await sequencerInbox.maxTimeVariation()
+    await mineBlocks(maxTimeVariation.delayBlocks.toNumber() - 1, 5)
+
+    await forceIncludeMessages(
+      sequencerInbox,
+      delayedTx.inboxAccountLength,
+      delayedTx.deliveredMessageEvent.kind,
+      delayedTx.l1BlockNumber,
+      delayedTx.l1BlockTimestamp,
+      delayedTx.baseFeeL1,
+      delayedTx.senderAddr,
+      delayedTx.deliveredMessageEvent.messageDataHash,
+      'ForceIncludeBlockTooSoon',
+    )
+  })
+
+  it('cannot include before max time delay', async () => {
+    const {
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      sequencerInbox,
+    } = await setupSequencerInbox(10, 100)
+    const delayedTx = await sendDelayedTx(
+      user,
+      inbox,
+      bridge,
+      messageTester,
+      1000000,
+      21000000000,
+      0,
+      await user.getAddress(),
+      BigNumber.from(10),
+      '0x1010',
+    )
+
+    const maxTimeVariation = await sequencerInbox.maxTimeVariation()
+    // mine a lot of blocks - but use a short time per block
+    // this should mean enough blocks have passed, but not enough time
+    await mineBlocks(maxTimeVariation.delayBlocks.toNumber() + 1, 5)
+
+    await forceIncludeMessages(
+      sequencerInbox,
+      delayedTx.inboxAccountLength,
+      delayedTx.deliveredMessageEvent.kind,
+      delayedTx.l1BlockNumber,
+      delayedTx.l1BlockTimestamp,
+      delayedTx.baseFeeL1,
+      delayedTx.senderAddr,
+      delayedTx.deliveredMessageEvent.messageDataHash,
+      'ForceIncludeTimeTooSoon',
+    )
+  })
+})

package/test/contract/utils.ts

@@ -0,0 +1,40 @@
+import { ethers } from 'hardhat'
+import { Signer } from '@ethersproject/abstract-signer'
+
+export async function initializeAccounts(): Promise<Signer[]> {
+  const [account0] = await ethers.getSigners()
+  const provider = account0.provider!
+
+  const accounts: Signer[] = [account0]
+  for (let i = 0; i < 9; i++) {
+    const account = ethers.Wallet.createRandom().connect(provider)
+    accounts.push(account)
+    const tx = await account0.sendTransaction({
+      value: ethers.utils.parseEther('10000.0'),
+      to: await account.getAddress(),
+    })
+    await tx.wait()
+  }
+  return accounts
+}
+
+export async function tryAdvanceChain(
+  account: Signer,
+  blocks: number
+): Promise<void> {
+  try {
+    for (let i = 0; i < blocks; i++) {
+      await ethers.provider.send('evm_mine', [])
+    }
+  } catch (e) {
+    // EVM mine failed. Try advancing the chain by sending txes if the node
+    // is in dev mode and mints blocks when txes are sent
+    for (let i = 0; i < blocks; i++) {
+      const tx = await account.sendTransaction({
+        value: 0,
+        to: await account.getAddress(),
+      })
+      await tx.wait()
+    }
+  }
+}

package/test/prover/hash-proofs.ts

@@ -0,0 +1,75 @@
+import { assert } from "chai";
+import { ethers, run } from "hardhat";
+
+describe("HashProofHelper", function () {
+  it("Should produce valid proofs from full preimages", async function () {
+    await run("deploy", { tags: "HashProofHelper" });
+    
+    const hashProofHelper = await ethers.getContract("HashProofHelper");
+
+    for (let i = 0; i < 16; i += 1) {
+      const len = Math.floor(Math.random() * 256);
+      const data = Math.floor(Math.random() * 256);
+      const offset = Math.floor(Math.random() * 256);
+      const bytes = Array(len).fill(data);
+      const hash = ethers.utils.keccak256(bytes);
+
+      const proofTx = await hashProofHelper.proveWithFullPreimage(bytes, offset);
+      const receipt = await proofTx.wait();
+      const log = hashProofHelper.interface.parseLog(receipt.logs[0]);
+      const provenPart = await hashProofHelper.getPreimagePart(hash, offset);
+
+      let dataHex = data.toString(16);
+      dataHex = "00".slice(dataHex.length) + dataHex;
+      const partLen = Math.min(32, Math.max(0, len - offset));
+      const partString = "0x" + dataHex.repeat(partLen);
+      assert.equal(log.args["fullHash"], hash);
+      assert.equal(log.args["offset"], offset);
+      assert.equal(log.args["part"], partString);
+      assert.equal(provenPart, partString);
+    }
+  });
+
+  it("Should produce valid proofs from split preimages", async function () {
+    await run("deploy", { tags: "HashProofHelper" });
+
+    const hashProofHelper = await ethers.getContract("HashProofHelper");
+
+    for (let i = 0; i < 16; i += 1) {
+      const len = Math.floor(Math.random() * 1024);
+      const data = Math.floor(Math.random() * 256);
+      const offset = Math.floor(Math.random() * 256);
+      const bytes = Array(len).fill(data);
+      const hash = ethers.utils.keccak256(bytes);
+
+      let provenLen = 0;
+      let provenPart = null;
+      let log = null;
+      while (provenPart === null) {
+        let nextPartialLen = 136 * (1 + Math.floor(Math.random() * 2));
+        if (nextPartialLen > len - provenLen) {
+          nextPartialLen = len - provenLen;
+        }
+        const newProvenLen = provenLen + nextPartialLen;
+        const isFinal = newProvenLen == len;
+        const proofTx = await hashProofHelper.proveWithSplitPreimage(bytes.slice(provenLen, newProvenLen), offset, isFinal ? 1 : 0);
+        const receipt = await proofTx.wait();
+        if (receipt.logs.length > 0) {
+          log = hashProofHelper.interface.parseLog(receipt.logs[0]);
+          provenPart = await hashProofHelper.getPreimagePart(hash, offset);
+        }
+        provenLen = newProvenLen;
+      }
+
+      let dataHex = data.toString(16);
+      dataHex = "00".slice(dataHex.length) + dataHex;
+      const partLen = Math.min(32, Math.max(0, len - offset));
+      const partString = "0x" + dataHex.repeat(partLen);
+      assert.isNotNull(log);
+      assert.equal(log!.args["fullHash"], hash);
+      assert.equal(log!.args["offset"], offset);
+      assert.equal(log!.args["part"], partString);
+      assert.equal(provenPart, partString);
+    }
+  });
+});