@aztec/pxe 0.76.2 → 0.76.3

package/src/database/pxe_database_test_suite.ts

@@ -410,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);
       });
 
@@ -419,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);
       });
 
@@ -429,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);
       });
 
@@ -442,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);
@@ -454,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();
       });
 
@@ -462,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(contract: AztecAddress, storageSlot: Fr, capsule: Fr[]) {
-    return this.db.dbStore(contract, storageSlot, 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

@@ -825,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);
   }
 }