@arbitrum/nitro-contracts 1.0.0-beta.1 → 1.0.0-beta.4

package/test/contract/sequencerInboxForceInclude.spec.ts

@@ -1,516 +0,0 @@
-/*
- * 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

@@ -1,40 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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);
-    }
-  });
-});