@arbitrum/nitro-contracts 1.0.0-beta.1

package/test/contract/common/challengeLib.ts

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

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

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

@@ -0,0 +1,82 @@
+/*
+ * 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)
+  })
+})