@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.21caa21

package/src/storage/auth_witness_data_provider/auth_witness_data_provider.ts

@@ -1,34 +0,0 @@
-import { Fr } from '@aztec/foundation/fields';
-import { toArray } from '@aztec/foundation/iterable';
-import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-
-import type { DataProvider } from '../data_provider.js';
-
-export class AuthWitnessDataProvider implements DataProvider {
-  #store: AztecAsyncKVStore;
-  #authWitnesses: AztecAsyncMap<string, Buffer[]>;
-
-  constructor(store: AztecAsyncKVStore) {
-    this.#store = store;
-    this.#authWitnesses = this.#store.openMap('auth_witnesses');
-  }
-
-  async addAuthWitness(messageHash: Fr, witness: Fr[]): Promise<void> {
-    await this.#authWitnesses.set(
-      messageHash.toString(),
-      witness.map(w => w.toBuffer()),
-    );
-  }
-
-  async getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined> {
-    const witness = await this.#authWitnesses.getAsync(messageHash.toString());
-    return witness?.map(w => Fr.fromBuffer(w));
-  }
-
-  async getSize(): Promise<number> {
-    return (await toArray(this.#authWitnesses.valuesAsync())).reduce(
-      (sum, value) => sum + value.length * Fr.SIZE_IN_BYTES,
-      0,
-    );
-  }
-}

package/src/storage/auth_witness_data_provider/index.ts

@@ -1 +0,0 @@
-export { AuthWitnessDataProvider } from './auth_witness_data_provider.js';

package/src/storage/data_provider.ts

@@ -1,3 +0,0 @@
-export interface DataProvider {
-  getSize(): Promise<number>;
-}

package/src/storage/note_data_provider/note_dao.ts

@@ -1,162 +0,0 @@
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
-import { Fr, Point } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
-import type { NoteData } from '@aztec/simulator/client';
-import { NoteSelector } from '@aztec/stdlib/abi';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { PublicKey } from '@aztec/stdlib/keys';
-import { Note } from '@aztec/stdlib/note';
-import { TxHash } from '@aztec/stdlib/tx';
-
-/**
- * A Note Data Access Object, representing a note that was committed to the note hash tree, holding all of the
- * information required to use it during execution and manage its state.
- */
-export class NoteDao implements NoteData {
-  constructor(
-    // Note information
-
-    /** The packed content of the note, as will be returned in the getNotes oracle. */
-    public note: Note,
-    /** The address of the contract that created the note (i.e. the address used by the kernel during siloing). */
-    public contractAddress: AztecAddress,
-    /**
-     * The storage location of the note. This value is not used for anything in PXE, but we do index by storage slot
-     * since contracts typically make queries based on it.
-     * */
-    public storageSlot: Fr,
-    /** The kernel-provided nonce of the note, required to compute the uniqueNoteHash. */
-    public nonce: Fr,
-
-    // Computed values
-    /**
-     * The inner hash (non-unique, non-siloed) of the note. Each contract determines how the note is hashed. Can
-     * be used alongside contractAddress and nonce to compute the uniqueNoteHash and the siloedNoteHash.
-     */
-    public noteHash: Fr,
-    /**
-     * The nullifier of the note, siloed by contract address.
-     * Note: Might be set as 0 if the note was added to PXE as nullified.
-     */
-    public siloedNullifier: Fr,
-
-    // Metadata
-    /** The hash of the tx in which this note was created. Knowing the tx hash allows for efficient node queries e.g.
-     *  when searching for txEffects.
-     */
-    public txHash: TxHash,
-    /** The L2 block number in which the tx with this note was included. Used for note management while processing
-     * reorgs.*/
-    public l2BlockNumber: number,
-    /** The L2 block hash in which the tx with this note was included. Used for note management while processing
-     * reorgs.*/
-    public l2BlockHash: string,
-    /** The index of the leaf in the global note hash tree the note is stored at */
-    public index: bigint,
-    /** The public key with which the note log was encrypted during delivery. */
-    public addressPoint: PublicKey,
-
-    /** The note type identifier for the contract.
-     * TODO(#12013): remove
-     */
-    public noteTypeId: NoteSelector,
-  ) {}
-
-  toBuffer(): Buffer {
-    return serializeToBuffer([
-      this.note,
-      this.contractAddress,
-      this.storageSlot,
-      this.nonce,
-      this.noteHash,
-      this.siloedNullifier,
-      this.txHash,
-      this.l2BlockNumber,
-      Fr.fromHexString(this.l2BlockHash),
-      this.index,
-      this.addressPoint,
-      this.noteTypeId,
-    ]);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-
-    const note = Note.fromBuffer(reader);
-    const contractAddress = AztecAddress.fromBuffer(reader);
-    const storageSlot = Fr.fromBuffer(reader);
-    const nonce = Fr.fromBuffer(reader);
-    const noteHash = Fr.fromBuffer(reader);
-    const siloedNullifier = Fr.fromBuffer(reader);
-    const txHash = reader.readObject(TxHash);
-    const l2BlockNumber = reader.readNumber();
-    const l2BlockHash = Fr.fromBuffer(reader).toString();
-    const index = toBigIntBE(reader.readBytes(32));
-    const publicKey = Point.fromBuffer(reader);
-    const noteTypeId = reader.readObject(NoteSelector);
-
-    return new NoteDao(
-      note,
-      contractAddress,
-      storageSlot,
-      nonce,
-      noteHash,
-      siloedNullifier,
-      txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      index,
-      publicKey,
-      noteTypeId,
-    );
-  }
-
-  toString() {
-    return '0x' + this.toBuffer().toString('hex');
-  }
-
-  static fromString(str: string) {
-    const hex = str.replace(/^0x/, '');
-    return NoteDao.fromBuffer(Buffer.from(hex, 'hex'));
-  }
-
-  /**
-   * Returns the size in bytes of the Note Dao.
-   * @returns - Its size in bytes.
-   */
-  public getSize() {
-    const indexSize = Math.ceil(Math.log2(Number(this.index)));
-    const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
-    return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize;
-  }
-
-  static async random({
-    note = Note.random(),
-    contractAddress = undefined,
-    storageSlot = Fr.random(),
-    nonce = Fr.random(),
-    noteHash = Fr.random(),
-    siloedNullifier = Fr.random(),
-    txHash = TxHash.random(),
-    l2BlockNumber = Math.floor(Math.random() * 1000),
-    l2BlockHash = Fr.random().toString(),
-    index = Fr.random().toBigInt(),
-    addressPoint = undefined,
-    noteTypeId = NoteSelector.random(),
-  }: Partial<NoteDao> = {}) {
-    return new NoteDao(
-      note,
-      contractAddress ?? (await AztecAddress.random()),
-      storageSlot,
-      nonce,
-      noteHash,
-      siloedNullifier,
-      txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      index,
-      addressPoint ?? (await Point.random()),
-      noteTypeId,
-    );
-  }
-}

package/src/test/pxe_test_suite.ts

@@ -1,111 +0,0 @@
-import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import { getContractClassFromArtifact } from '@aztec/stdlib/contract';
-import type { PXE } from '@aztec/stdlib/interfaces/client';
-import {
-  randomContractArtifact,
-  randomContractInstanceWithAddress,
-  randomDeployedContract,
-} from '@aztec/stdlib/testing';
-
-import omit from 'lodash.omit';
-
-export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) => {
-  describe(testName, () => {
-    let pxe: PXE;
-
-    beforeAll(async () => {
-      pxe = await pxeSetup();
-    }, 120_000);
-
-    it('registers an account and returns it as an account only and not as a recipient', async () => {
-      const randomSecretKey = Fr.random();
-      const randomPartialAddress = Fr.random();
-      const completeAddress = await pxe.registerAccount(randomSecretKey, randomPartialAddress);
-
-      // Check that the account is correctly registered using the getAccounts and getRecipients methods
-      const accounts = await pxe.getRegisteredAccounts();
-      expect(accounts).toContainEqual(completeAddress);
-    });
-
-    it('does not throw when registering the same account twice (just ignores the second attempt)', async () => {
-      const randomSecretKey = Fr.random();
-      const randomPartialAddress = Fr.random();
-
-      await pxe.registerAccount(randomSecretKey, randomPartialAddress);
-      await pxe.registerAccount(randomSecretKey, randomPartialAddress);
-    });
-
-    it('successfully adds a contract', async () => {
-      const contracts = await Promise.all([randomDeployedContract(), randomDeployedContract()]);
-      for (const contract of contracts) {
-        await pxe.registerContract(contract);
-      }
-
-      const expectedContractAddresses = contracts.map(contract => contract.instance.address);
-      const contractAddresses = await pxe.getContracts();
-      expect(contractAddresses).toEqual(expect.arrayContaining(expectedContractAddresses));
-    });
-
-    it('registers a class and adds a contract for it', async () => {
-      const artifact = randomContractArtifact();
-      const contractClass = await getContractClassFromArtifact(artifact);
-      const contractClassId = contractClass.id;
-      const instance = await randomContractInstanceWithAddress({ contractClassId });
-
-      await pxe.registerContractClass(artifact);
-      expect((await pxe.getContractClassMetadata(contractClassId)).contractClass).toMatchObject(
-        omit(contractClass, 'privateFunctionsRoot', 'publicBytecodeCommitment'),
-      );
-
-      await pxe.registerContract({ instance });
-      expect((await pxe.getContractMetadata(instance.address)).contractInstance).toEqual(instance);
-    });
-
-    it('refuses to register a class with a mismatched address', async () => {
-      const artifact = randomContractArtifact();
-      const contractClass = await getContractClassFromArtifact(artifact);
-      const contractClassId = contractClass.id;
-      const instance = await randomContractInstanceWithAddress({ contractClassId });
-      await expect(
-        pxe.registerContract({
-          instance: {
-            ...instance,
-            address: await AztecAddress.random(),
-          },
-          artifact,
-        }),
-      ).rejects.toThrow(/Added a contract in which the address does not match the contract instance./);
-    });
-
-    it('refuses to register a contract with a class that has not been registered', async () => {
-      const instance = await randomContractInstanceWithAddress();
-      await expect(pxe.registerContract({ instance })).rejects.toThrow(/DB has no contract class with id/i);
-    });
-
-    it('refuses to register a contract with an artifact with mismatching class id', async () => {
-      const artifact = randomContractArtifact();
-      const instance = await randomContractInstanceWithAddress();
-      await expect(pxe.registerContract({ instance, artifact })).rejects.toThrow(/Artifact does not match/i);
-    });
-
-    // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `simulateUnconstrained` here as it requires
-    //       a larger setup and it's sufficiently tested in the e2e tests.
-
-    // Note: Not testing `getContractData`, `getPublicLogs` and `getPublicStorageAt` here as these
-    //       functions only call AztecNode and these methods are frequently used by the e2e tests.
-
-    it('successfully gets a block number', async () => {
-      const blockNum = await pxe.getBlockNumber();
-      expect(blockNum).toBeGreaterThanOrEqual(INITIAL_L2_BLOCK_NUM);
-    });
-
-    it('successfully gets node info', async () => {
-      const nodeInfo = await pxe.getNodeInfo();
-      expect(typeof nodeInfo.protocolVersion).toEqual('number');
-      expect(typeof nodeInfo.l1ChainId).toEqual('number');
-      expect(nodeInfo.l1ContractAddresses.rollupAddress.toString()).toMatch(/0x[a-fA-F0-9]+/);
-    });
-  });
-};