@aztec/sequencer-client 0.7.9 → 0.8.6

package/src/sequencer/public_processor.test.ts

@@ -1,265 +0,0 @@
-import { PublicExecution, PublicExecutionResult, PublicExecutor } from '@aztec/acir-simulator';
-import {
-  ARGS_LENGTH,
-  AztecAddress,
-  CallContext,
-  CircuitsWasm,
-  CombinedAccumulatedData,
-  EthAddress,
-  Fr,
-  FunctionData,
-  GlobalVariables,
-  HistoricBlockData,
-  MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX,
-  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  PUBLIC_DATA_TREE_HEIGHT,
-  Proof,
-  PublicCallRequest,
-  PublicKernelPublicInputs,
-  makeEmptyProof,
-  makeTuple,
-} from '@aztec/circuits.js';
-import { computeCallStackItemHash } from '@aztec/circuits.js/abis';
-import {
-  makeAztecAddress,
-  makePrivateKernelPublicInputsFinal,
-  makePublicCallRequest,
-  makeSelector,
-} from '@aztec/circuits.js/factories';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import {
-  ContractDataSource,
-  EncodedContractFunction,
-  ExtendedContractData,
-  FunctionCall,
-  FunctionL2Logs,
-  SiblingPath,
-  Tx,
-  TxL2Logs,
-  mockTx,
-} from '@aztec/types';
-import { MerkleTreeOperations, TreeInfo } from '@aztec/world-state';
-
-import { MockProxy, mock } from 'jest-mock-extended';
-import times from 'lodash.times';
-
-import { PublicProver } from '../prover/index.js';
-import { PublicKernelCircuitSimulator } from '../simulator/index.js';
-import { WasmPublicKernelCircuitSimulator } from '../simulator/public_kernel.js';
-import { PublicProcessor } from './public_processor.js';
-
-describe('public_processor', () => {
-  let db: MockProxy<MerkleTreeOperations>;
-  let publicExecutor: MockProxy<PublicExecutor>;
-  let publicProver: MockProxy<PublicProver>;
-  let contractDataSource: MockProxy<ContractDataSource>;
-
-  let publicFunction: EncodedContractFunction;
-  let contractData: ExtendedContractData;
-  let proof: Proof;
-  let root: Buffer;
-
-  let processor: PublicProcessor;
-
-  beforeEach(() => {
-    db = mock<MerkleTreeOperations>();
-    publicExecutor = mock<PublicExecutor>();
-    publicProver = mock<PublicProver>();
-    contractDataSource = mock<ContractDataSource>();
-
-    contractData = ExtendedContractData.random();
-    publicFunction = EncodedContractFunction.random();
-    proof = makeEmptyProof();
-    root = Buffer.alloc(32, 5);
-
-    publicProver.getPublicCircuitProof.mockResolvedValue(proof);
-    publicProver.getPublicKernelCircuitProof.mockResolvedValue(proof);
-    db.getTreeInfo.mockResolvedValue({ root } as TreeInfo);
-    contractDataSource.getExtendedContractData.mockResolvedValue(contractData);
-    contractDataSource.getPublicFunction.mockResolvedValue(publicFunction);
-  });
-
-  describe('with mock circuits', () => {
-    let publicKernel: MockProxy<PublicKernelCircuitSimulator>;
-
-    beforeEach(() => {
-      publicKernel = mock<PublicKernelCircuitSimulator>();
-      processor = new PublicProcessor(
-        db,
-        publicExecutor,
-        publicKernel,
-        publicProver,
-        contractDataSource,
-        GlobalVariables.empty(),
-        HistoricBlockData.empty(),
-      );
-    });
-
-    it('skips txs without public execution requests', async function () {
-      const tx = mockTx();
-      tx.data.end.publicCallStack = makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, Fr.zero);
-      const hash = await tx.getTxHash();
-      const [processed, failed] = await processor.process([tx]);
-
-      expect(processed).toEqual([
-        {
-          isEmpty: false,
-          hash,
-          data: new PublicKernelPublicInputs(
-            CombinedAccumulatedData.fromFinalAccumulatedData(tx.data.end),
-            tx.data.constants,
-          ),
-          proof: tx.proof,
-          encryptedLogs: tx.encryptedLogs,
-          unencryptedLogs: tx.unencryptedLogs,
-        },
-      ]);
-      expect(failed).toEqual([]);
-    });
-
-    it('returns failed txs without aborting entire operation', async function () {
-      publicExecutor.simulate.mockRejectedValue(new Error(`Failed`));
-
-      const tx = mockTx();
-      const [processed, failed] = await processor.process([tx]);
-
-      expect(processed).toEqual([]);
-      expect(failed[0].tx).toEqual(tx);
-    });
-  });
-
-  describe('with actual circuits', () => {
-    let publicKernel: PublicKernelCircuitSimulator;
-    let wasm: CircuitsWasm;
-
-    beforeAll(async () => {
-      wasm = await CircuitsWasm.get();
-    });
-
-    beforeEach(() => {
-      const path = times(PUBLIC_DATA_TREE_HEIGHT, i => Buffer.alloc(32, i));
-      db.getSiblingPath.mockResolvedValue(new SiblingPath<number>(PUBLIC_DATA_TREE_HEIGHT, path));
-      publicKernel = new WasmPublicKernelCircuitSimulator();
-      processor = new PublicProcessor(
-        db,
-        publicExecutor,
-        publicKernel,
-        publicProver,
-        contractDataSource,
-        GlobalVariables.empty(),
-        HistoricBlockData.empty(),
-      );
-    });
-
-    const expectedTxByHash = async (tx: Tx) =>
-      expect.objectContaining({
-        hash: await tx.getTxHash(),
-        proof,
-      });
-
-    it('runs a tx with enqueued public calls', async function () {
-      const callRequests: PublicCallRequest[] = [makePublicCallRequest(0x100), makePublicCallRequest(0x100)];
-      const callStackItems = await Promise.all(callRequests.map(call => call.toPublicCallStackItem()));
-      const callStackHashes = callStackItems.map(call => computeCallStackItemHash(wasm, call));
-
-      const kernelOutput = makePrivateKernelPublicInputsFinal(0x10);
-      kernelOutput.end.publicCallStack = padArrayEnd(callStackHashes, Fr.ZERO, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX);
-      kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX);
-
-      const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), callRequests, [
-        ExtendedContractData.random(),
-      ]);
-
-      publicExecutor.simulate.mockImplementation(execution => {
-        for (const request of callRequests) {
-          if (execution.contractAddress.equals(request.contractAddress)) {
-            return Promise.resolve(makePublicExecutionResultFromRequest(request));
-          }
-        }
-        throw new Error(`Unexpected execution request: ${execution}`);
-      });
-
-      const [processed, failed] = await processor.process([tx]);
-
-      expect(processed).toHaveLength(1);
-      expect(processed).toEqual([await expectedTxByHash(tx)]);
-      expect(failed).toHaveLength(0);
-      expect(publicExecutor.simulate).toHaveBeenCalledTimes(2);
-    });
-
-    it('runs a tx with an enqueued public call with nested execution', async function () {
-      const callRequest: PublicCallRequest = makePublicCallRequest(0x100);
-      const callStackItem = await callRequest.toPublicCallStackItem();
-      const callStackHash = computeCallStackItemHash(wasm, callStackItem);
-
-      const kernelOutput = makePrivateKernelPublicInputsFinal(0x10);
-      kernelOutput.end.publicCallStack = padArrayEnd([callStackHash], Fr.ZERO, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX);
-      kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX);
-
-      const tx = new Tx(
-        kernelOutput,
-        proof,
-        TxL2Logs.random(2, 3),
-        TxL2Logs.random(3, 2),
-        [callRequest],
-        [ExtendedContractData.random()],
-      );
-
-      const publicExecutionResult = makePublicExecutionResultFromRequest(callRequest);
-      publicExecutionResult.nestedExecutions = [
-        makePublicExecutionResult(publicExecutionResult.execution.contractAddress, {
-          to: makeAztecAddress(30),
-          functionData: new FunctionData(makeSelector(5), false, false, false),
-          args: new Array(ARGS_LENGTH).fill(Fr.ZERO),
-        }),
-      ];
-      publicExecutor.simulate.mockResolvedValue(publicExecutionResult);
-
-      const [processed, failed] = await processor.process([tx]);
-
-      expect(processed).toHaveLength(1);
-      expect(processed).toEqual([await expectedTxByHash(tx)]);
-      expect(failed).toHaveLength(0);
-      expect(publicExecutor.simulate).toHaveBeenCalledTimes(1);
-    });
-  });
-});
-
-function makePublicExecutionResultFromRequest(item: PublicCallRequest): PublicExecutionResult {
-  return {
-    execution: item,
-    nestedExecutions: [],
-    returnValues: [new Fr(1n)],
-    newCommitments: [],
-    newL2ToL1Messages: [],
-    newNullifiers: [],
-    contractStorageReads: [],
-    contractStorageUpdateRequests: [],
-    unencryptedLogs: new FunctionL2Logs([]),
-  };
-}
-
-function makePublicExecutionResult(
-  from: AztecAddress,
-  tx: FunctionCall,
-  nestedExecutions: PublicExecutionResult[] = [],
-): PublicExecutionResult {
-  const callContext = new CallContext(from, tx.to, EthAddress.ZERO, false, false, false);
-  const execution: PublicExecution = {
-    callContext,
-    contractAddress: tx.to,
-    functionData: tx.functionData,
-    args: tx.args,
-  };
-  return {
-    execution,
-    nestedExecutions,
-    returnValues: [],
-    newCommitments: [],
-    newNullifiers: [],
-    newL2ToL1Messages: [],
-    contractStorageReads: [],
-    contractStorageUpdateRequests: [],
-    unencryptedLogs: new FunctionL2Logs([]),
-  };
-}

package/src/sequencer/sequencer.test.ts

@@ -1,160 +0,0 @@
-import {
-  Fr,
-  GlobalVariables,
-  HistoricBlockData,
-  NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP,
-  makeEmptyProof,
-} from '@aztec/circuits.js';
-import { P2P, P2PClientState } from '@aztec/p2p';
-import { L1ToL2MessageSource, L2Block, L2BlockSource, MerkleTreeId, Tx, TxHash, mockTx } from '@aztec/types';
-import { MerkleTreeOperations, WorldStateRunningState, WorldStateSynchroniser } from '@aztec/world-state';
-
-import { MockProxy, mock } from 'jest-mock-extended';
-import times from 'lodash.times';
-
-import { BlockBuilder } from '../block_builder/index.js';
-import { GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { L1Publisher } from '../index.js';
-import { makeEmptyProcessedTx, makeProcessedTx } from './processed_tx.js';
-import { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
-import { Sequencer } from './sequencer.js';
-
-describe('sequencer', () => {
-  let publisher: MockProxy<L1Publisher>;
-  let globalVariableBuilder: MockProxy<GlobalVariableBuilder>;
-  let p2p: MockProxy<P2P>;
-  let worldState: MockProxy<WorldStateSynchroniser>;
-  let blockBuilder: MockProxy<BlockBuilder>;
-  let merkleTreeOps: MockProxy<MerkleTreeOperations>;
-  let publicProcessor: MockProxy<PublicProcessor>;
-  let l2BlockSource: MockProxy<L2BlockSource>;
-  let l1ToL2MessageSource: MockProxy<L1ToL2MessageSource>;
-  let publicProcessorFactory: MockProxy<PublicProcessorFactory>;
-
-  let lastBlockNumber: number;
-
-  let sequencer: TestSubject;
-
-  const chainId = Fr.ZERO;
-  const version = Fr.ZERO;
-
-  beforeEach(() => {
-    lastBlockNumber = 0;
-
-    publisher = mock<L1Publisher>();
-    globalVariableBuilder = mock<GlobalVariableBuilder>();
-    merkleTreeOps = mock<MerkleTreeOperations>();
-    blockBuilder = mock<BlockBuilder>();
-
-    p2p = mock<P2P>({
-      getStatus: () => Promise.resolve({ state: P2PClientState.IDLE, syncedToL2Block: lastBlockNumber }),
-    });
-
-    worldState = mock<WorldStateSynchroniser>({
-      getLatest: () => merkleTreeOps,
-      status: () => Promise.resolve({ state: WorldStateRunningState.IDLE, syncedToL2Block: lastBlockNumber }),
-    });
-
-    publicProcessor = mock<PublicProcessor>({
-      process: async txs => [await Promise.all(txs.map(tx => makeProcessedTx(tx))), []],
-      makeEmptyProcessedTx: () => makeEmptyProcessedTx(HistoricBlockData.empty(), chainId, version),
-    });
-
-    publicProcessorFactory = mock<PublicProcessorFactory>({
-      create: (_, __) => Promise.resolve(publicProcessor),
-    });
-
-    l2BlockSource = mock<L2BlockSource>({
-      getBlockNumber: () => Promise.resolve(lastBlockNumber),
-    });
-
-    l1ToL2MessageSource = mock<L1ToL2MessageSource>({
-      getPendingL1ToL2Messages: () => Promise.resolve(Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(Fr.ZERO)),
-    });
-
-    sequencer = new TestSubject(
-      publisher,
-      globalVariableBuilder,
-      p2p,
-      worldState,
-      blockBuilder,
-      l2BlockSource,
-      l1ToL2MessageSource,
-      publicProcessorFactory,
-      {
-        chainId: Number(chainId.value),
-        version: Number(version.value),
-      },
-    );
-  });
-
-  it('builds a block out of a single tx', async () => {
-    const tx = mockTx();
-    const block = L2Block.random(lastBlockNumber + 1);
-    const proof = makeEmptyProof();
-
-    p2p.getTxs.mockResolvedValueOnce([tx]);
-    blockBuilder.buildL2Block.mockResolvedValueOnce([block, proof]);
-    publisher.processL2Block.mockResolvedValueOnce(true);
-    globalVariableBuilder.buildGlobalVariables.mockResolvedValueOnce(
-      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
-    );
-
-    await sequencer.initialSync();
-    await sequencer.work();
-
-    const expectedTxHashes = [...(await Tx.getHashes([tx])), ...times(3, () => TxHash.ZERO)];
-
-    expect(blockBuilder.buildL2Block).toHaveBeenCalledWith(
-      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
-      expectedTxHashes.map(hash => expect.objectContaining({ hash })),
-      Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(new Fr(0n)),
-    );
-    expect(publisher.processL2Block).toHaveBeenCalledWith(block);
-  });
-
-  it('builds a block out of several txs rejecting double spends', async () => {
-    const txs = [mockTx(0x10000), mockTx(0x20000), mockTx(0x30000)];
-    const doubleSpendTx = txs[1];
-    const block = L2Block.random(lastBlockNumber + 1);
-    const proof = makeEmptyProof();
-
-    p2p.getTxs.mockResolvedValueOnce(txs);
-    blockBuilder.buildL2Block.mockResolvedValueOnce([block, proof]);
-    publisher.processL2Block.mockResolvedValueOnce(true);
-    globalVariableBuilder.buildGlobalVariables.mockResolvedValueOnce(
-      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
-    );
-
-    // We make a nullifier from tx1 a part of the nullifier tree, so it gets rejected as double spend
-    const doubleSpendNullifier = doubleSpendTx.data.end.newNullifiers[0].toBuffer();
-    merkleTreeOps.findLeafIndex.mockImplementation((treeId: MerkleTreeId, value: Buffer) => {
-      return Promise.resolve(
-        treeId === MerkleTreeId.NULLIFIER_TREE && value.equals(doubleSpendNullifier) ? 1n : undefined,
-      );
-    });
-
-    await sequencer.initialSync();
-    await sequencer.work();
-
-    const expectedTxHashes = [...(await Tx.getHashes([txs[0], txs[2]])), TxHash.ZERO, TxHash.ZERO];
-
-    expect(blockBuilder.buildL2Block).toHaveBeenCalledWith(
-      new GlobalVariables(chainId, version, new Fr(lastBlockNumber + 1), Fr.ZERO),
-      expectedTxHashes.map(hash => expect.objectContaining({ hash })),
-      Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(new Fr(0n)),
-    );
-    expect(publisher.processL2Block).toHaveBeenCalledWith(block);
-    expect(p2p.deleteTxs).toHaveBeenCalledWith([await doubleSpendTx.getTxHash()]);
-  });
-});
-
-class TestSubject extends Sequencer {
-  public work() {
-    return super.work();
-  }
-
-  public initialSync(): Promise<void> {
-    return super.initialSync();
-  }
-}

package/tsconfig.json

@@ -1,38 +0,0 @@
-{
-  "extends": "..",
-  "compilerOptions": {
-    "outDir": "dest",
-    "rootDir": "src",
-    "tsBuildInfoFile": ".tsbuildinfo"
-  },
-  "references": [
-    {
-      "path": "../acir-simulator"
-    },
-    {
-      "path": "../circuits.js"
-    },
-    {
-      "path": "../ethereum"
-    },
-    {
-      "path": "../foundation"
-    },
-    {
-      "path": "../l1-artifacts"
-    },
-    {
-      "path": "../merkle-tree"
-    },
-    {
-      "path": "../p2p"
-    },
-    {
-      "path": "../types"
-    },
-    {
-      "path": "../world-state"
-    }
-  ],
-  "include": ["src"]
-}