@aztec/pxe 0.76.2 → 0.76.4-devnet-test

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

@@ -13,7 +13,6 @@ import {
   CLIENT_IVC_VERIFICATION_KEY_LENGTH_IN_FIELDS,
   ClientIvcProof,
   Fr,
-  PROTOCOL_CONTRACT_TREE_HEIGHT,
   PrivateCallData,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelData,
@@ -28,18 +27,13 @@ import {
   VerificationKeyAsFields,
 } from '@aztec/circuits.js';
 import { hashVK } from '@aztec/circuits.js/hash';
-import { makeTuple } from '@aztec/foundation/array';
 import { vkAsFieldsMegaHonk } from '@aztec/foundation/crypto';
 import { createLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { Timer } from '@aztec/foundation/timer';
 import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vks';
-import {
-  getProtocolContractSiblingPath,
-  isProtocolContract,
-  protocolContractTreeRoot,
-} from '@aztec/protocol-contracts';
+import { getProtocolContractLeafAndMembershipWitness, protocolContractTreeRoot } from '@aztec/protocol-contracts';
 
 import { type WitnessMap } from '@noir-lang/types';
 import { strict as assert } from 'assert';
@@ -330,7 +324,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;
@@ -356,9 +350,8 @@ export class KernelProver {
     // const acirHash = keccak256(Buffer.from(bytecode, 'hex'));
     const acirHash = Fr.fromBuffer(Buffer.alloc(32, 0));
 
-    const protocolContractSiblingPath = isProtocolContract(contractAddress)
-      ? await getProtocolContractSiblingPath(contractAddress)
-      : makeTuple(PROTOCOL_CONTRACT_TREE_HEIGHT, Fr.zero);
+    const { lowLeaf: protocolContractLeaf, witness: protocolContractMembershipWitness } =
+      await getProtocolContractLeafAndMembershipWitness(contractAddress);
 
     return PrivateCallData.from({
       publicInputs,
@@ -368,7 +361,8 @@ export class KernelProver {
       contractClassPublicBytecodeCommitment,
       saltedInitializationHash,
       functionLeafMembershipWitness,
-      protocolContractSiblingPath,
+      protocolContractMembershipWitness,
+      protocolContractLeaf,
       acirHash,
     });
   }

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);
   }
 }