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

package/test/contract/common/challengeLib.ts

@@ -1,43 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber'
-import { solidityKeccak256 } from 'ethers/lib/utils'
-
-export enum MachineStatus {
-  RUNNING = 0,
-  FINISHED = 1,
-  ERRORED = 2,
-  TOO_FAR = 3,
-}
-
-export function hashChallengeState(
-  segmentsStart: BigNumber,
-  segmentsLength: BigNumber,
-  segments: string[],
-) {
-  return solidityKeccak256(
-    ['uint256', 'uint256', 'bytes32[]'],
-    [segmentsStart, segmentsLength, segments],
-  )
-}
-
-export function blockStateHash(
-  machineStatus: BigNumber,
-  globalStateHash: string,
-) {
-  const machineStatusNum = machineStatus.toNumber()
-  if (machineStatusNum === MachineStatus.FINISHED) {
-    return solidityKeccak256(
-      ['string', 'bytes32'],
-      ['Block state:', globalStateHash],
-    )
-  } else if (machineStatusNum === MachineStatus.ERRORED) {
-    return solidityKeccak256(
-      ['string', 'bytes32'],
-      ['Block state, errored:', globalStateHash],
-    )
-  } else if (machineStatusNum === MachineStatus.TOO_FAR) {
-    return solidityKeccak256(['string', 'bytes32'], ['Block state, too far:'])
-  } else {
-    console.log(machineStatus.toNumber())
-    throw new Error('BAD_BLOCK_STATUS')
-  }
-}

package/test/contract/common/globalStateLib.ts

@@ -1,17 +0,0 @@
-import {
-  GlobalStateStruct,
-} from '../../../build/types/RollupUserLogic'
-import { solidityKeccak256 } from 'ethers/lib/utils'
-
-export function hash(state: GlobalStateStruct) {
-  return solidityKeccak256(
-    ['string', 'bytes32', 'bytes32', 'uint64', 'uint64'],
-    [
-      'Global state:',
-      state.bytes32Vals[0],
-      state.bytes32Vals[1],
-      state.u64Vals[0],
-      state.u64Vals[1],
-    ],
-  )
-}

package/test/contract/common/rolluplib.ts

@@ -1,259 +0,0 @@
-import { ethers } from "hardhat";
-import { Interface, LogDescription } from "@ethersproject/abi";
-import { Signer } from "@ethersproject/abstract-signer";
-import { BigNumberish, BigNumber } from "@ethersproject/bignumber";
-import { BytesLike } from "@ethersproject/bytes";
-import { ContractTransaction, PayableOverrides } from "@ethersproject/contracts";
-import { Provider } from "@ethersproject/providers";
-import { RollupUserLogic, RollupAdminLogic, SequencerInbox } from "../../../build/types";
-import {
-  RollupLib,
-  NodeCreatedEvent,
-} from "../../../build/types/RollupUserLogic";
-type AssertionStruct = RollupLib.AssertionStruct;
-type ExecutionStateStruct = RollupLib.ExecutionStateStruct;
-import { blockStateHash, hashChallengeState } from "./challengeLib";
-import * as globalStateLib from "./globalStateLib";
-import { constants } from "ethers";
-import { GlobalStateStruct } from "../../../build/types/ChallengeManager";
-
-export interface Node {
-  nodeNum: number;
-  proposedBlock: number;
-  assertion: AssertionStruct;
-  inboxMaxCount: BigNumber;
-  nodeHash: BytesLike;
-  wasmModuleRoot: BytesLike;
-}
-
-export function nodeHash(
-  hasSibling: boolean,
-  lastHash: BytesLike,
-  assertionExecHash: BytesLike,
-  inboxAcc: BytesLike
-): BytesLike {
-  return ethers.utils.solidityKeccak256(
-    ["bool", "bytes32", "bytes32", "bytes32"],
-    [hasSibling, lastHash, assertionExecHash, inboxAcc]
-  );
-}
-
-const globalStateEquals = (globalState1: GlobalStateStruct, globalState2: GlobalStateStruct) => {
-  return (
-    globalState1.bytes32Vals[0] === globalState2.bytes32Vals[0] &&
-    globalState1.bytes32Vals[1] === globalState2.bytes32Vals[1] &&
-    BigNumber.from(globalState1.u64Vals[0]).eq(globalState2.u64Vals[0]) &&
-    BigNumber.from(globalState1.u64Vals[1]).eq(globalState2.u64Vals[1])
-  );
-};
-
-export const executionStateEquals = (
-  executionState1: ExecutionStateStruct,
-  executionState2: ExecutionStateStruct
-) => {
-  return (
-    globalStateEquals(executionState1.globalState, executionState2.globalState) &&
-    BigNumber.from(executionState1.machineStatus).eq(executionState2.machineStatus)
-  );
-};
-
-export const assertionEquals = (assertion1: AssertionStruct, assertion2: AssertionStruct) => {
-  return (
-    executionStateEquals(assertion1.beforeState, assertion2.beforeState) &&
-    executionStateEquals(assertion1.afterState, assertion2.afterState) &&
-    BigNumber.from(assertion1.numBlocks).eq(assertion2.numBlocks)
-  );
-};
-
-export function executionStateHash(e: ExecutionStateStruct, inboxMaxCount: BigNumberish) {
-  return ethers.utils.solidityKeccak256(
-    ["bytes32", "uint256", "uint8"],
-    [globalStateLib.hash(e.globalState), inboxMaxCount, e.machineStatus]
-  );
-}
-
-export function executionStructHash(e: ExecutionStateStruct) {
-  return ethers.utils.solidityKeccak256(
-    ["bytes32", "uint8"],
-    [globalStateLib.hash(e.globalState), e.machineStatus]
-  );
-}
-
-export function assertionExecutionHash(a: AssertionStruct): BytesLike {
-  const seg0 = blockStateHash(
-    BigNumber.from(a.beforeState.machineStatus),
-    globalStateLib.hash(a.beforeState.globalState)
-  );
-  const seg1 = blockStateHash(
-    BigNumber.from(a.afterState.machineStatus),
-    globalStateLib.hash(a.afterState.globalState)
-  );
-  return hashChallengeState(BigNumber.from(0), BigNumber.from(a.numBlocks), [seg0, seg1]);
-}
-
-async function nodeFromNodeCreatedLog(blockNumber: number, log: LogDescription): Promise<Node> {
-  if (log.name != "NodeCreated") {
-    throw Error("wrong event type");
-  }
-  const parsedEv = log.args as NodeCreatedEvent["args"];
-
-  const node: Node = {
-    assertion: parsedEv.assertion,
-    nodeHash: parsedEv.nodeHash,
-    wasmModuleRoot: parsedEv.wasmModuleRoot,
-    nodeNum: parsedEv.nodeNum.toNumber(),
-    proposedBlock: blockNumber,
-    inboxMaxCount: parsedEv.inboxMaxCount,
-  };
-  return node;
-}
-
-async function nodeFromTx(abi: Interface, tx: ContractTransaction): Promise<Node> {
-  const receipt = await tx.wait();
-  if (receipt.logs == undefined) {
-    throw Error("expected receipt to have logs");
-  }
-  const evs = receipt.logs
-    .map((log) => {
-      try {
-        return abi.parseLog(log);
-      } catch (e) {
-        return undefined;
-      }
-    })
-    .filter((ev) => ev && ev.name == "NodeCreated");
-  if (evs.length != 1) {
-    throw Error("unique event not found");
-  }
-
-  return nodeFromNodeCreatedLog(receipt.blockNumber, evs[0]!);
-}
-
-export class RollupContract {
-  constructor(public rollup: RollupUserLogic) {}
-
-  connect(signerOrProvider: Signer | Provider | string): RollupContract {
-    return new RollupContract(this.rollup.connect(signerOrProvider));
-  }
-
-  async stakeOnNewNode(
-    sequencerInbox: SequencerInbox,
-    parentNode: {
-      nodeHash: BytesLike;
-      inboxMaxCount: BigNumber;
-    },
-    assertion: AssertionStruct,
-    siblingNode?: Node,
-    stakeToAdd?: BigNumber
-  ): Promise<{
-    tx: ContractTransaction;
-    node: Node;
-    expectedNewNodeHash: BytesLike;
-  }> {
-    const inboxPosition = BigNumber.from(assertion.afterState.globalState.u64Vals[0]).toNumber();
-    const afterInboxAcc =
-      inboxPosition > 0 ? await sequencerInbox.inboxAccs(inboxPosition - 1) : constants.HashZero;
-    const newNodeHash = nodeHash(
-      !!siblingNode,
-      (siblingNode || parentNode).nodeHash,
-      assertionExecutionHash(assertion),
-      afterInboxAcc
-    );
-    const tx = stakeToAdd
-      ? await this.rollup.newStakeOnNewNode(assertion, newNodeHash, parentNode.inboxMaxCount, {
-          value: stakeToAdd,
-        })
-      : await this.rollup.stakeOnNewNode(assertion, newNodeHash, parentNode.inboxMaxCount);
-    const node = await nodeFromTx(this.rollup.interface, tx);
-    return { tx, node, expectedNewNodeHash: newNodeHash };
-  }
-
-  stakeOnExistingNode(nodeNum: BigNumberish, nodeHash: BytesLike): Promise<ContractTransaction> {
-    return this.rollup.stakeOnExistingNode(nodeNum, nodeHash);
-  }
-
-  confirmNextNode(
-    node: Node,
-  ): Promise<ContractTransaction> {
-    return this.rollup.confirmNextNode(
-      node.assertion.afterState.globalState.bytes32Vals[0],
-      node.assertion.afterState.globalState.bytes32Vals[1]
-    );
-  }
-
-  rejectNextNode(stakerAddress: string): Promise<ContractTransaction> {
-    return this.rollup.rejectNextNode(stakerAddress);
-  }
-
-  async createChallenge(
-    staker1Address: string,
-    staker2Address: string,
-    node1: Node,
-    node2: Node
-  ): Promise<ContractTransaction> {
-    return this.rollup.createChallenge(
-      [staker1Address, staker2Address],
-      [node1.nodeNum, node2.nodeNum],
-      [node1.assertion.beforeState.machineStatus, node1.assertion.afterState.machineStatus],
-      [node1.assertion.beforeState.globalState, node1.assertion.afterState.globalState],
-      node1.assertion.numBlocks,
-      assertionExecutionHash(node2.assertion),
-      [node1.proposedBlock, node2.proposedBlock],
-      [node1.wasmModuleRoot, node2.wasmModuleRoot]
-    );
-  }
-
-  addToDeposit(staker: string, overrides: PayableOverrides = {}): Promise<ContractTransaction> {
-    return this.rollup.addToDeposit(staker, overrides);
-  }
-
-  reduceDeposit(amount: BigNumberish): Promise<ContractTransaction> {
-    return this.rollup.reduceDeposit(amount);
-  }
-
-  returnOldDeposit(stakerAddress: string): Promise<ContractTransaction> {
-    return this.rollup.returnOldDeposit(stakerAddress);
-  }
-
-  latestConfirmed(): Promise<BigNumber> {
-    return this.rollup.latestConfirmed();
-  }
-
-  getNodeStateHash(index: BigNumberish): Promise<string> {
-    return this.rollup.getNode(index).then((n) => n.stateHash);
-  }
-
-  latestStakedNode(staker: string): Promise<BigNumber> {
-    return this.rollup.latestStakedNode(staker);
-  }
-
-  currentRequiredStake(): Promise<BigNumber> {
-    return this.rollup.currentRequiredStake();
-  }
-}
-
-export async function forceCreateNode(
-  rollupAdmin: RollupAdminLogic,
-  sequencerInbox: SequencerInbox,
-  parentNode: Node,
-  assertion: AssertionStruct,
-  siblingNode?: Node
-): Promise<{ tx: ContractTransaction; node: Node }> {
-  const inboxPosition = BigNumber.from(assertion.afterState.globalState.u64Vals[0]).toNumber();
-  const afterInboxAcc =
-    inboxPosition > 0 ? await sequencerInbox.inboxAccs(inboxPosition - 1) : constants.HashZero;
-  const newNodeHash = nodeHash(
-    !!siblingNode,
-    (siblingNode || parentNode).nodeHash,
-    assertionExecutionHash(assertion),
-    afterInboxAcc
-  );
-  const tx = await rollupAdmin.forceCreateNode(
-    parentNode.nodeNum,
-    parentNode.inboxMaxCount,
-    assertion,
-    newNodeHash
-  );
-  const node = await nodeFromTx(rollupAdmin.interface, tx);
-  return { tx, node };
-}

package/test/contract/cryptographyPrimitives.spec.ts

@@ -1,82 +0,0 @@
-/*
- * Copyright 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 } from 'hardhat'
-import { BytesLike } from '@ethersproject/bytes'
-import { expect } from 'chai'
-import { CryptographyPrimitivesTester } from '../../build/types'
-
-let cryptographyPrimitivesTester: CryptographyPrimitivesTester
-
-describe('CryptographyPrimitives', () => {
-  before(async () => {
-    const CryptographyPrimitivesTester = await ethers.getContractFactory(
-      'CryptographyPrimitivesTester'
-    )
-    cryptographyPrimitivesTester = (await CryptographyPrimitivesTester.deploy()) as CryptographyPrimitivesTester
-    await cryptographyPrimitivesTester.deployed()
-  })
-
-  it('calculates sha256 compression function correctly', async () => {
-    // test vectors from https://homes.esat.kuleuven.be/~nsmart/MPC/sha-256-test.txt
-
-    const initialHashState =
-      '0x6a09e667bb67ae853c6ef372a54ff53a510e527f9b05688c1f83d9ab5be0cd19'
-
-    const input1: [BytesLike, BytesLike] = [
-      ethers.constants.HashZero,
-      ethers.constants.HashZero,
-    ]
-
-    const input2: [BytesLike, BytesLike] = [
-      '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f',
-      '0x202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f',
-    ]
-
-    const input3: [BytesLike, BytesLike] = [
-      '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
-      '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF',
-    ]
-
-    const input4: [BytesLike, BytesLike] = [
-      '0x243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89',
-      '0x452821E638D01377BE5466CF34E90C6CC0AC29B7C97C50DD3f84D5B5b5470917',
-    ]
-
-    const output1 =
-      '0xda5698be17b9b46962335799779fbeca8ce5d491c0d26243bafef9ea1837a9d8'
-    const output2 =
-      '0xfc99a2df88f42a7a7bb9d18033cdc6a20256755f9d5b9a5044a9cc315abe84a7'
-    const output3 =
-      '0xef0c748df4da50a8d6c43c013edc3ce76c9d9fa9a1458ade56eb86c0a64492d2'
-    const output4 =
-      '0xcf0ae4eb67d38ffeb94068984b22abde4e92bc548d14585e48dca8882d7b09ce'
-    expect(
-      await cryptographyPrimitivesTester.sha256Block(input1, initialHashState)
-    ).to.equal(output1)
-    expect(
-      await cryptographyPrimitivesTester.sha256Block(input2, initialHashState)
-    ).to.equal(output2)
-    expect(
-      await cryptographyPrimitivesTester.sha256Block(input3, initialHashState)
-    ).to.equal(output3)
-    expect(
-      await cryptographyPrimitivesTester.sha256Block(input4, initialHashState)
-    ).to.equal(output4)
-  })
-})