@aztec/pxe 0.76.1 → 0.76.3

package/src/database/pxe_database.ts

@@ -35,20 +35,6 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    */
   getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
 
-  /**
-   * Adding a capsule to the capsule dispenser.
-   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle.
-   * @param capsule - An array of field elements representing the capsule.
-   */
-  addCapsule(capsule: Fr[]): Promise<void>;
-
-  /**
-   * Get the next capsule from the capsule dispenser.
-   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle.
-   * @returns A promise that resolves to an array of field elements representing the capsule.
-   */
-  popCapsule(): Promise<Fr[] | undefined>;
-
   /**
    * Gets notes based on the provided filter.
    * @param filter - The filter to apply to the notes.
@@ -215,32 +201,35 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
   resetNoteSyncData(): Promise<void>;
 
   /**
-   * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `dbLoad`.
-   * If data was already stored at this slot, it is overwrriten.
+   * Stores arbitrary information in a per-contract non-volatile database (called capsules), which can later
+   * be retrieved with `loadCapsule`. If data was already stored at this slot, it is overwritten.
    * @param contractAddress - The contract address to scope the data under.
    * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
-   * @param values - The data to store.
+   * @param capsule - An array of field elements representing the capsule.
+   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle. It works similarly
+   * to public contract storage in that it's indexed by the contract address and storage slot but instead of the global
+   * network state it's backed by local PXE db.
    */
-  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void>;
+  storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void>;
 
   /**
-   * Returns data previously stored via `dbStore` in the per-contract non-volatile database.
+   * Returns data previously stored via `storeCapsule` in the per-contract non-volatile database (called capsules).
    * @param contractAddress - The contract address under which the data is scoped.
    * @param slot - The slot in the database to read.
    * @returns The stored data or `null` if no data is stored under the slot.
    */
-  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
+  loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
 
   /**
-   * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
+   * Deletes data in the per-contract non-volatile database (called capsules). Does nothing if no data was present.
    * @param contractAddress - The contract address under which the data is scoped.
    * @param slot - The slot in the database to delete.
    */
-  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void>;
+  deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void>;
 
   /**
-   * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
-   * structures by avoiding repeated calls to `dbLoad` and `dbStore`.
+   * Copies a number of contiguous entries in the per-contract non-volatile database (called capsules). This allows for
+   * efficient data structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.
    * Supports overlapping source and destination regions (which will result in the overlapped source values being
    * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
    *
@@ -249,5 +238,5 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
    * @param dstSlot - The first slot to copy to.
    * @param numEntries - The number of entries to copy.
    */
-  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
+  copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void>;
 }

package/src/database/pxe_database_test_suite.ts

@@ -54,29 +54,6 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
     });
 
-    describe('capsules', () => {
-      it('stores and retrieves capsules', async () => {
-        const capsule = [Fr.random(), Fr.random()];
-
-        await database.addCapsule(capsule);
-        await expect(database.popCapsule()).resolves.toEqual(capsule);
-      });
-
-      it("returns undefined if it doesn't have capsules", async () => {
-        await expect(database.popCapsule()).resolves.toBeUndefined();
-      });
-
-      it('behaves like a stack when storing capsules', async () => {
-        const capsule1 = [Fr.random(), Fr.random()];
-        const capsule2 = [Fr.random(), Fr.random()];
-
-        await database.addCapsule(capsule1);
-        await database.addCapsule(capsule2);
-        await expect(database.popCapsule()).resolves.toEqual(capsule2);
-        await expect(database.popCapsule()).resolves.toEqual(capsule1);
-      });
-    });
-
     describe('incoming notes', () => {
       let owners: CompleteAddress[];
       let contractAddresses: AztecAddress[];
@@ -433,8 +410,8 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         const slot = new Fr(1);
         const values = [new Fr(42)];
 
-        await database.dbStore(contract, slot, values);
-        const result = await database.dbLoad(contract, slot);
+        await database.storeCapsule(contract, slot, values);
+        const result = await database.loadCapsule(contract, slot);
         expect(result).toEqual(values);
       });
 
@@ -442,8 +419,8 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         const slot = new Fr(1);
         const values = [new Fr(42), new Fr(43), new Fr(44)];
 
-        await database.dbStore(contract, slot, values);
-        const result = await database.dbLoad(contract, slot);
+        await database.storeCapsule(contract, slot, values);
+        const result = await database.loadCapsule(contract, slot);
         expect(result).toEqual(values);
       });
 
@@ -452,10 +429,10 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         const initialValues = [new Fr(42)];
         const newValues = [new Fr(100)];
 
-        await database.dbStore(contract, slot, initialValues);
-        await database.dbStore(contract, slot, newValues);
+        await database.storeCapsule(contract, slot, initialValues);
+        await database.storeCapsule(contract, slot, newValues);
 
-        const result = await database.dbLoad(contract, slot);
+        const result = await database.loadCapsule(contract, slot);
         expect(result).toEqual(newValues);
       });
 
@@ -465,11 +442,11 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         const values1 = [new Fr(42)];
         const values2 = [new Fr(100)];
 
-        await database.dbStore(contract, slot, values1);
-        await database.dbStore(anotherContract, slot, values2);
+        await database.storeCapsule(contract, slot, values1);
+        await database.storeCapsule(anotherContract, slot, values2);
 
-        const result1 = await database.dbLoad(contract, slot);
-        const result2 = await database.dbLoad(anotherContract, slot);
+        const result1 = await database.loadCapsule(contract, slot);
+        const result2 = await database.loadCapsule(anotherContract, slot);
 
         expect(result1).toEqual(values1);
         expect(result2).toEqual(values2);
@@ -477,7 +454,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
       it('returns null for non-existent slots', async () => {
         const slot = Fr.random();
-        const result = await database.dbLoad(contract, slot);
+        const result = await database.loadCapsule(contract, slot);
         expect(result).toBeNull();
       });
 
@@ -485,99 +462,99 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
         const slot = new Fr(1);
         const values = [new Fr(42)];
 
-        await database.dbStore(contract, slot, values);
-        await database.dbDelete(contract, slot);
+        await database.storeCapsule(contract, slot, values);
+        await database.deleteCapsule(contract, slot);
 
-        expect(await database.dbLoad(contract, slot)).toBeNull();
+        expect(await database.loadCapsule(contract, slot)).toBeNull();
       });
 
       it('deletes an empty slot', async () => {
         const slot = new Fr(1);
-        await database.dbDelete(contract, slot);
+        await database.deleteCapsule(contract, slot);
 
-        expect(await database.dbLoad(contract, slot)).toBeNull();
+        expect(await database.loadCapsule(contract, slot)).toBeNull();
       });
 
       it('copies a single value', async () => {
         const slot = new Fr(1);
         const values = [new Fr(42)];
 
-        await database.dbStore(contract, slot, values);
+        await database.storeCapsule(contract, slot, values);
 
         const dstSlot = new Fr(5);
-        await database.dbCopy(contract, slot, dstSlot, 1);
+        await database.copyCapsule(contract, slot, dstSlot, 1);
 
-        expect(await database.dbLoad(contract, dstSlot)).toEqual(values);
+        expect(await database.loadCapsule(contract, dstSlot)).toEqual(values);
       });
 
       it('copies multiple non-overlapping values', async () => {
         const src = new Fr(1);
         const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
 
-        await database.dbStore(contract, src, valuesArray[0]);
-        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
-        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+        await database.storeCapsule(contract, src, valuesArray[0]);
+        await database.storeCapsule(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.storeCapsule(contract, src.add(new Fr(2)), valuesArray[2]);
 
         const dst = new Fr(5);
-        await database.dbCopy(contract, src, dst, 3);
+        await database.copyCapsule(contract, src, dst, 3);
 
-        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
-        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
-        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+        expect(await database.loadCapsule(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.loadCapsule(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.loadCapsule(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
       });
 
       it('copies overlapping values with src ahead', async () => {
         const src = new Fr(1);
         const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
 
-        await database.dbStore(contract, src, valuesArray[0]);
-        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
-        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+        await database.storeCapsule(contract, src, valuesArray[0]);
+        await database.storeCapsule(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.storeCapsule(contract, src.add(new Fr(2)), valuesArray[2]);
 
         const dst = new Fr(2);
-        await database.dbCopy(contract, src, dst, 3);
+        await database.copyCapsule(contract, src, dst, 3);
 
-        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
-        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
-        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+        expect(await database.loadCapsule(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.loadCapsule(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.loadCapsule(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
 
         // Slots 2 and 3 (src[1] and src[2]) should have been overwritten since they are also dst[0] and dst[1]
-        expect(await database.dbLoad(contract, src)).toEqual(valuesArray[0]); // src[0] (unchanged)
-        expect(await database.dbLoad(contract, src.add(new Fr(1)))).toEqual(valuesArray[0]); // dst[0]
-        expect(await database.dbLoad(contract, src.add(new Fr(2)))).toEqual(valuesArray[1]); // dst[1]
+        expect(await database.loadCapsule(contract, src)).toEqual(valuesArray[0]); // src[0] (unchanged)
+        expect(await database.loadCapsule(contract, src.add(new Fr(1)))).toEqual(valuesArray[0]); // dst[0]
+        expect(await database.loadCapsule(contract, src.add(new Fr(2)))).toEqual(valuesArray[1]); // dst[1]
       });
 
       it('copies overlapping values with dst ahead', async () => {
         const src = new Fr(5);
         const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
 
-        await database.dbStore(contract, src, valuesArray[0]);
-        await database.dbStore(contract, src.add(new Fr(1)), valuesArray[1]);
-        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+        await database.storeCapsule(contract, src, valuesArray[0]);
+        await database.storeCapsule(contract, src.add(new Fr(1)), valuesArray[1]);
+        await database.storeCapsule(contract, src.add(new Fr(2)), valuesArray[2]);
 
         const dst = new Fr(4);
-        await database.dbCopy(contract, src, dst, 3);
+        await database.copyCapsule(contract, src, dst, 3);
 
-        expect(await database.dbLoad(contract, dst)).toEqual(valuesArray[0]);
-        expect(await database.dbLoad(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
-        expect(await database.dbLoad(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
+        expect(await database.loadCapsule(contract, dst)).toEqual(valuesArray[0]);
+        expect(await database.loadCapsule(contract, dst.add(new Fr(1)))).toEqual(valuesArray[1]);
+        expect(await database.loadCapsule(contract, dst.add(new Fr(2)))).toEqual(valuesArray[2]);
 
         // Slots 5 and 6 (src[0] and src[1]) should have been overwritten since they are also dst[1] and dst[2]
-        expect(await database.dbLoad(contract, src)).toEqual(valuesArray[1]); // dst[1]
-        expect(await database.dbLoad(contract, src.add(new Fr(1)))).toEqual(valuesArray[2]); // dst[2]
-        expect(await database.dbLoad(contract, src.add(new Fr(2)))).toEqual(valuesArray[2]); // src[2] (unchanged)
+        expect(await database.loadCapsule(contract, src)).toEqual(valuesArray[1]); // dst[1]
+        expect(await database.loadCapsule(contract, src.add(new Fr(1)))).toEqual(valuesArray[2]); // dst[2]
+        expect(await database.loadCapsule(contract, src.add(new Fr(2)))).toEqual(valuesArray[2]); // src[2] (unchanged)
       });
 
       it('copying fails if any value is empty', async () => {
         const src = new Fr(1);
         const valuesArray = [[new Fr(42)], [new Fr(1337)], [new Fr(13)]];
 
-        await database.dbStore(contract, src, valuesArray[0]);
+        await database.storeCapsule(contract, src, valuesArray[0]);
         // We skip src[1]
-        await database.dbStore(contract, src.add(new Fr(2)), valuesArray[2]);
+        await database.storeCapsule(contract, src.add(new Fr(2)), valuesArray[2]);
 
         const dst = new Fr(5);
-        await expect(database.dbCopy(contract, src, dst, 3)).rejects.toThrow('Attempted to copy empty slot');
+        await expect(database.copyCapsule(contract, src, dst, 3)).rejects.toThrow('Attempted to copy empty slot');
       });
     });
   });

package/src/kernel_prover/kernel_prover.ts

@@ -330,7 +330,7 @@ export class KernelProver {
       const ivcProof = await this.proofCreator.createClientIvcProof(acirs, witnessStack);
       tailOutput.clientIvcProof = ivcProof;
     } else {
-      tailOutput.clientIvcProof = ClientIvcProof.empty();
+      tailOutput.clientIvcProof = ClientIvcProof.random();
     }
 
     return tailOutput;

package/src/pxe_service/pxe_service.ts

@@ -137,8 +137,8 @@ export class PXEService implements PXE {
     return this.db.getAuthWitness(messageHash);
   }
 
-  public addCapsule(capsule: Fr[]) {
-    return this.db.addCapsule(capsule);
+  public storeCapsule(contract: AztecAddress, storageSlot: Fr, capsule: Fr[]) {
+    return this.db.storeCapsule(contract, storageSlot, capsule);
   }
 
   public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {

package/src/simulator_oracle/index.ts

@@ -101,14 +101,6 @@ export class SimulatorOracle implements DBOracle {
     return witness;
   }
 
-  async popCapsule(): Promise<Fr[]> {
-    const capsule = await this.db.popCapsule();
-    if (!capsule) {
-      throw new Error(`No capsules available`);
-    }
-    return capsule;
-  }
-
   async getNotes(contractAddress: AztecAddress, storageSlot: Fr, status: NoteStatus, scopes?: AztecAddress[]) {
     const noteDaos = await this.db.getNotes({
       contractAddress,
@@ -833,20 +825,20 @@ export class SimulatorOracle implements DBOracle {
     );
   }
 
-  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void> {
-    return this.db.dbStore(contractAddress, slot, values);
+  storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
+    return this.db.storeCapsule(contractAddress, slot, capsule);
   }
 
-  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
-    return this.db.dbLoad(contractAddress, slot);
+  loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+    return this.db.loadCapsule(contractAddress, slot);
   }
 
-  dbDelete(contractAddress: AztecAddress, slot: Fr): Promise<void> {
-    return this.db.dbDelete(contractAddress, slot);
+  deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
+    return this.db.deleteCapsule(contractAddress, slot);
   }
 
-  dbCopy(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
-    return this.db.dbCopy(contractAddress, srcSlot, dstSlot, numEntries);
+  copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
+    return this.db.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
   }
 }