@aztec/pxe 0.70.0 → 0.72.1

package/src/database/note_dao.ts

@@ -1,12 +1,10 @@
-import { type L1NotePayload, Note, TxHash, randomTxHash } from '@aztec/circuit-types';
+import { Note, TxHash, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, Fr, Point, type PublicKey } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { type NoteData } from '@aztec/simulator/client';
 
-import { type NoteInfo } from '../note_decryption_utils/index.js';
-
 /**
  * A Note Data Access Object, representing a note that was comitted to the note hash tree, holding all of the
  * information required to use it during execution and manage its state.
@@ -61,32 +59,6 @@ export class NoteDao implements NoteData {
     public noteTypeId: NoteSelector,
   ) {}
 
-  static fromPayloadAndNoteInfo(
-    note: Note,
-    payload: L1NotePayload,
-    noteInfo: NoteInfo,
-    l2BlockNumber: number,
-    l2BlockHash: string,
-    dataStartIndexForTx: number,
-    addressPoint: PublicKey,
-  ) {
-    const noteHashIndexInTheWholeTree = BigInt(dataStartIndexForTx + noteInfo.noteHashIndex);
-    return new NoteDao(
-      note,
-      payload.contractAddress,
-      payload.storageSlot,
-      noteInfo.nonce,
-      noteInfo.noteHash,
-      noteInfo.siloedNullifier,
-      noteInfo.txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      noteHashIndexInTheWholeTree,
-      addressPoint,
-      payload.noteTypeId,
-    );
-  }
-
   toBuffer(): Buffer {
     return serializeToBuffer([
       this.note,
@@ -155,9 +127,9 @@ export class NoteDao implements NoteData {
     return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize;
   }
 
-  static random({
+  static async random({
     note = Note.random(),
-    contractAddress = AztecAddress.random(),
+    contractAddress = undefined,
     storageSlot = Fr.random(),
     nonce = Fr.random(),
     noteHash = Fr.random(),
@@ -166,12 +138,12 @@ export class NoteDao implements NoteData {
     l2BlockNumber = Math.floor(Math.random() * 1000),
     l2BlockHash = Fr.random().toString(),
     index = Fr.random().toBigInt(),
-    addressPoint = Point.random(),
+    addressPoint = undefined,
     noteTypeId = NoteSelector.random(),
   }: Partial<NoteDao> = {}) {
     return new NoteDao(
       note,
-      contractAddress,
+      contractAddress ?? (await AztecAddress.random()),
       storageSlot,
       nonce,
       noteHash,
@@ -180,7 +152,7 @@ export class NoteDao implements NoteData {
       l2BlockNumber,
       l2BlockHash,
       index,
-      addressPoint,
+      addressPoint ?? (await Point.random()),
       noteTypeId,
     );
   }

package/src/database/outgoing_note_dao.ts

@@ -1,11 +1,9 @@
-import { type L1NotePayload, Note, TxHash, randomTxHash } from '@aztec/circuit-types';
+import { Note, TxHash, randomTxHash } from '@aztec/circuit-types';
 import { AztecAddress, Fr, Point, type PublicKey } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import { type NoteInfo } from '../note_decryption_utils/index.js';
-
 /**
  * A note with contextual data which was decrypted as outgoing.
  */
@@ -38,31 +36,6 @@ export class OutgoingNoteDao {
     public ovpkM: PublicKey,
   ) {}
 
-  static fromPayloadAndNoteInfo(
-    note: Note,
-    payload: L1NotePayload,
-    noteInfo: NoteInfo,
-    l2BlockNumber: number,
-    l2BlockHash: string,
-    dataStartIndexForTx: number,
-    ovpkM: PublicKey,
-  ) {
-    const noteHashIndexInTheWholeTree = BigInt(dataStartIndexForTx + noteInfo.noteHashIndex);
-    return new OutgoingNoteDao(
-      note,
-      payload.contractAddress,
-      payload.storageSlot,
-      payload.noteTypeId,
-      noteInfo.txHash,
-      l2BlockNumber,
-      l2BlockHash,
-      noteInfo.nonce,
-      noteInfo.noteHash,
-      noteHashIndexInTheWholeTree,
-      ovpkM,
-    );
-  }
-
   toBuffer(): Buffer {
     return serializeToBuffer([
       this.note,
@@ -126,9 +99,9 @@ export class OutgoingNoteDao {
     return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 2 + TxHash.SIZE + Point.SIZE_IN_BYTES;
   }
 
-  static random({
+  static async random({
     note = Note.random(),
-    contractAddress = AztecAddress.random(),
+    contractAddress = undefined,
     txHash = randomTxHash(),
     storageSlot = Fr.random(),
     noteTypeId = NoteSelector.random(),
@@ -137,11 +110,11 @@ export class OutgoingNoteDao {
     l2BlockHash = Fr.random().toString(),
     noteHash = Fr.random(),
     index = Fr.random().toBigInt(),
-    ovpkM = Point.random(),
+    ovpkM = undefined,
   }: Partial<OutgoingNoteDao> = {}) {
     return new OutgoingNoteDao(
       note,
-      contractAddress,
+      contractAddress ?? (await AztecAddress.random()),
       storageSlot,
       noteTypeId,
       txHash,
@@ -150,7 +123,7 @@ export class OutgoingNoteDao {
       nonce,
       noteHash,
       index,
-      ovpkM,
+      ovpkM ?? (await Point.random()),
     );
   }
 }

package/src/database/pxe_database.ts

@@ -215,20 +215,39 @@ export interface PxeDatabase extends ContractArtifactDatabase, ContractInstanceD
   resetNoteSyncData(): Promise<void>;
 
   /**
-   * Used by contracts during execution to store arbitrary data in the local PXE database. The data is siloed/scoped
-   * to a specific `contract`.
-   * @param contract - An address of a contract that is requesting to store the data.
-   * @param key - A field element representing the key to store the data under.
-   * @param values - An array of field elements representing the data to store.
+   * 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.
+   * @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.
    */
-  store(contract: AztecAddress, key: Fr, values: Fr[]): Promise<void>;
+  dbStore(contractAddress: AztecAddress, slot: Fr, values: Fr[]): Promise<void>;
 
   /**
-   * Used by contracts during execution to load arbitrary data from the local PXE database. The data is siloed/scoped
-   * to a specific `contract`.
-   * @param contract - An address of a contract that is requesting to load the data.
-   * @param key - A field element representing the key under which to load the data..
-   * @returns An array of field elements representing the stored data or `null` if no data is stored under the key.
+   * Returns data previously stored via `dbStore` in the per-contract non-volatile database.
+   * @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.
    */
-  load(contract: AztecAddress, key: Fr): Promise<Fr[] | null>;
+  dbLoad(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null>;
+
+  /**
+   * Deletes data in the per-contract non-volatile database. 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>;
+
+  /**
+   * 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`.
+   * 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)
+   *
+   * @param contractAddress - The contract address under which the data is scoped.
+   * @param srcSlot - The first slot to copy from.
+   * @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>;
 }

package/src/database/pxe_database_test_suite.ts

@@ -8,11 +8,14 @@ import {
 } from '@aztec/circuits.js';
 import { makeHeader } from '@aztec/circuits.js/testing';
 import { FunctionType } from '@aztec/foundation/abi';
+import { timesParallel } from '@aztec/foundation/collection';
 import { randomInt } from '@aztec/foundation/crypto';
 import { Fr, Point } from '@aztec/foundation/fields';
 import { BenchmarkingContractArtifact } from '@aztec/noir-contracts.js/Benchmarking';
 import { TestContractArtifact } from '@aztec/noir-contracts.js/Test';
 
+import times from 'lodash.times';
+
 import { NoteDao } from './note_dao.js';
 import { type PxeDatabase } from './pxe_database.js';
 
@@ -80,53 +83,62 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       let storageSlots: Fr[];
       let notes: NoteDao[];
 
-      const filteringTests: [() => NotesFilter, () => NoteDao[]][] = [
-        [() => ({}), () => notes],
+      const filteringTests: [() => Promise<NotesFilter>, () => Promise<NoteDao[]>][] = [
+        [() => Promise.resolve({}), () => Promise.resolve(notes)],
 
         [
-          () => ({ contractAddress: contractAddresses[0] }),
-          () => notes.filter(note => note.contractAddress.equals(contractAddresses[0])),
+          () => Promise.resolve({ contractAddress: contractAddresses[0] }),
+          () => Promise.resolve(notes.filter(note => note.contractAddress.equals(contractAddresses[0]))),
         ],
-        [() => ({ contractAddress: AztecAddress.random() }), () => []],
+        [async () => ({ contractAddress: await AztecAddress.random() }), () => Promise.resolve([])],
 
         [
-          () => ({ storageSlot: storageSlots[0] }),
-          () => notes.filter(note => note.storageSlot.equals(storageSlots[0])),
+          () => Promise.resolve({ storageSlot: storageSlots[0] }),
+          () => Promise.resolve(notes.filter(note => note.storageSlot.equals(storageSlots[0]))),
         ],
-        [() => ({ storageSlot: Fr.random() }), () => []],
+        [() => Promise.resolve({ storageSlot: Fr.random() }), () => Promise.resolve([])],
 
-        [() => ({ txHash: notes[0].txHash }), () => [notes[0]]],
-        [() => ({ txHash: randomTxHash() }), () => []],
+        [() => Promise.resolve({ txHash: notes[0].txHash }), () => Promise.resolve([notes[0]])],
+        [() => Promise.resolve({ txHash: randomTxHash() }), () => Promise.resolve([])],
 
         [
-          () => ({ owner: owners[0].address }),
-          () => notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint())),
+          () => Promise.resolve({ owner: owners[0].address }),
+          async () => {
+            const ownerAddressPoint = await owners[0].address.toAddressPoint();
+            return notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
+          },
         ],
 
         [
-          () => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[0] }),
+          () => Promise.resolve({ contractAddress: contractAddresses[0], storageSlot: storageSlots[0] }),
           () =>
-            notes.filter(
-              note => note.contractAddress.equals(contractAddresses[0]) && note.storageSlot.equals(storageSlots[0]),
+            Promise.resolve(
+              notes.filter(
+                note => note.contractAddress.equals(contractAddresses[0]) && note.storageSlot.equals(storageSlots[0]),
+              ),
             ),
         ],
-        [() => ({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }), () => []],
+        [
+          () => Promise.resolve({ contractAddress: contractAddresses[0], storageSlot: storageSlots[1] }),
+          () => Promise.resolve([]),
+        ],
       ];
 
       beforeEach(async () => {
-        owners = Array.from({ length: 2 }).map(() => CompleteAddress.random());
-        contractAddresses = Array.from({ length: 2 }).map(() => AztecAddress.random());
-        storageSlots = Array.from({ length: 2 }).map(() => Fr.random());
+        owners = await timesParallel(2, () => CompleteAddress.random());
+        contractAddresses = await timesParallel(2, () => AztecAddress.random());
+        storageSlots = times(2, () => Fr.random());
 
-        notes = Array.from({ length: 10 }).map((_, i) =>
-          NoteDao.random({
+        notes = await timesParallel(10, async i => {
+          const addressPoint = await owners[i % owners.length].address.toAddressPoint();
+          return NoteDao.random({
             contractAddress: contractAddresses[i % contractAddresses.length],
             storageSlot: storageSlots[i % storageSlots.length],
-            addressPoint: owners[i % owners.length].address.toAddressPoint(),
+            addressPoint,
             index: BigInt(i),
             l2BlockNumber: i,
-          }),
-        );
+          });
+        });
 
         for (const owner of owners) {
           await database.addCompleteAddress(owner);
@@ -135,9 +147,9 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
       it.each(filteringTests)('stores notes in bulk and retrieves notes', async (getFilter, getExpected) => {
         await database.addNotes(notes);
-        const returnedNotes = await database.getNotes(getFilter());
-
-        expect(returnedNotes.sort()).toEqual(getExpected().sort());
+        const returnedNotes = await database.getNotes(await getFilter());
+        const expected = await getExpected();
+        expect(returnedNotes.sort()).toEqual(expected.sort());
       });
 
       it.each(filteringTests)('stores notes one by one and retrieves notes', async (getFilter, getExpected) => {
@@ -145,9 +157,10 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
           await database.addNote(note);
         }
 
-        const returnedNotes = await database.getNotes(getFilter());
+        const returnedNotes = await database.getNotes(await getFilter());
 
-        expect(returnedNotes.sort()).toEqual(getExpected().sort());
+        const expected = await getExpected();
+        expect(returnedNotes.sort()).toEqual(expected.sort());
       });
 
       it.each(filteringTests)('retrieves nullified notes', async (getFilter, getExpected) => {
@@ -155,26 +168,25 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
         // Nullify all notes and use the same filter as other test cases
         for (const owner of owners) {
-          const notesToNullify = notes.filter(note => note.addressPoint.equals(owner.address.toAddressPoint()));
+          const ownerAddressPoint = await owner.address.toAddressPoint();
+          const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
           const nullifiers = notesToNullify.map(note => ({
             data: note.siloedNullifier,
             l2BlockNumber: note.l2BlockNumber,
             l2BlockHash: note.l2BlockHash,
           }));
-          await expect(database.removeNullifiedNotes(nullifiers, owner.address.toAddressPoint())).resolves.toEqual(
-            notesToNullify,
-          );
+          await expect(database.removeNullifiedNotes(nullifiers, ownerAddressPoint)).resolves.toEqual(notesToNullify);
         }
-
-        await expect(database.getNotes({ ...getFilter(), status: NoteStatus.ACTIVE_OR_NULLIFIED })).resolves.toEqual(
-          getExpected(),
-        );
+        const filter = await getFilter();
+        const returnedNotes = await database.getNotes({ ...filter, status: NoteStatus.ACTIVE_OR_NULLIFIED });
+        const expected = await getExpected();
+        expect(returnedNotes.sort()).toEqual(expected.sort());
       });
 
       it('skips nullified notes by default or when requesting active', async () => {
         await database.addNotes(notes);
-
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
         const nullifiers = notesToNullify.map(note => ({
           data: note.siloedNullifier,
           l2BlockNumber: note.l2BlockNumber,
@@ -194,8 +206,9 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       it('handles note unnullification', async () => {
         await database.setHeader(makeHeader(randomInt(1000), 100, 0 /** slot number */));
         await database.addNotes(notes);
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
 
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
         const nullifiers = notesToNullify.map(note => ({
           data: note.siloedNullifier,
           l2BlockNumber: 99,
@@ -213,8 +226,9 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
       it('returns active and nullified notes when requesting either', async () => {
         await database.addNotes(notes);
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
 
-        const notesToNullify = notes.filter(note => note.addressPoint.equals(owners[0].address.toAddressPoint()));
+        const notesToNullify = notes.filter(note => note.addressPoint.equals(ownerAddressPoint));
         const nullifiers = notesToNullify.map(note => ({
           data: note.siloedNullifier,
           l2BlockNumber: note.l2BlockNumber,
@@ -275,7 +289,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
             scopes: [owners[1].address],
           }),
         ).resolves.toEqual([notes[0]]);
-
+        const ownerAddressPoint = await owners[0].address.toAddressPoint();
         await expect(
           database.removeNullifiedNotes(
             [
@@ -285,7 +299,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
                 l2BlockNumber: notes[0].l2BlockNumber,
               },
             ],
-            owners[0].address.toAddressPoint(),
+            ownerAddressPoint,
           ),
         ).resolves.toEqual([notes[0]]);
 
@@ -325,22 +339,22 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
 
     describe('addresses', () => {
       it('stores and retrieves addresses', async () => {
-        const address = CompleteAddress.random();
+        const address = await CompleteAddress.random();
         await expect(database.addCompleteAddress(address)).resolves.toBe(true);
         await expect(database.getCompleteAddress(address.address)).resolves.toEqual(address);
       });
 
       it('silently ignores an address it already knows about', async () => {
-        const address = CompleteAddress.random();
+        const address = await CompleteAddress.random();
         await expect(database.addCompleteAddress(address)).resolves.toBe(true);
         await expect(database.addCompleteAddress(address)).resolves.toBe(false);
       });
 
       it.skip('refuses to overwrite an address with a different public key', async () => {
-        const address = CompleteAddress.random();
-        const otherAddress = new CompleteAddress(
+        const address = await CompleteAddress.random();
+        const otherAddress = await CompleteAddress.create(
           address.address,
-          new PublicKeys(Point.random(), Point.random(), Point.random(), Point.random()),
+          new PublicKeys(await Point.random(), await Point.random(), await Point.random(), await Point.random()),
           address.partialAddress,
         );
 
@@ -349,7 +363,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('returns all addresses', async () => {
-        const addresses = Array.from({ length: 10 }).map(() => CompleteAddress.random());
+        const addresses = await timesParallel(10, () => CompleteAddress.random());
         for (const address of addresses) {
           await database.addCompleteAddress(address);
         }
@@ -359,7 +373,7 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('returns a single address', async () => {
-        const addresses = Array.from({ length: 10 }).map(() => CompleteAddress.random());
+        const addresses = await timesParallel(10, () => CompleteAddress.random());
         for (const address of addresses) {
           await database.addCompleteAddress(address);
         }
@@ -373,7 +387,8 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it("returns undefined if it doesn't have an address", async () => {
-        expect(await database.getCompleteAddress(CompleteAddress.random().address)).toBeUndefined();
+        const completeAddress = await CompleteAddress.random();
+        expect(await database.getCompleteAddress(completeAddress.address)).toBeUndefined();
       });
     });
 
@@ -399,72 +414,171 @@ export function describePxeDatabase(getDatabase: () => PxeDatabase) {
       });
 
       it('stores a contract instance', async () => {
-        const address = AztecAddress.random();
-        const instance = SerializableContractInstance.random().withAddress(address);
+        const address = await AztecAddress.random();
+        const instance = (await SerializableContractInstance.random()).withAddress(address);
         await database.addContractInstance(instance);
         await expect(database.getContractInstance(address)).resolves.toEqual(instance);
       });
     });
 
-    describe('contract store', () => {
+    describe('contract non-volatile database', () => {
       let contract: AztecAddress;
 
-      beforeEach(() => {
+      beforeEach(async () => {
         // Setup mock contract address
-        contract = AztecAddress.random();
+        contract = await AztecAddress.random();
       });
 
       it('stores and loads a single value', async () => {
-        const key = new Fr(1);
+        const slot = new Fr(1);
         const values = [new Fr(42)];
 
-        await database.store(contract, key, values);
-        const result = await database.load(contract, key);
+        await database.dbStore(contract, slot, values);
+        const result = await database.dbLoad(contract, slot);
         expect(result).toEqual(values);
       });
 
       it('stores and loads multiple values', async () => {
-        const key = new Fr(1);
+        const slot = new Fr(1);
         const values = [new Fr(42), new Fr(43), new Fr(44)];
 
-        await database.store(contract, key, values);
-        const result = await database.load(contract, key);
+        await database.dbStore(contract, slot, values);
+        const result = await database.dbLoad(contract, slot);
         expect(result).toEqual(values);
       });
 
       it('overwrites existing values', async () => {
-        const key = new Fr(1);
+        const slot = new Fr(1);
         const initialValues = [new Fr(42)];
         const newValues = [new Fr(100)];
 
-        await database.store(contract, key, initialValues);
-        await database.store(contract, key, newValues);
+        await database.dbStore(contract, slot, initialValues);
+        await database.dbStore(contract, slot, newValues);
 
-        const result = await database.load(contract, key);
+        const result = await database.dbLoad(contract, slot);
         expect(result).toEqual(newValues);
       });
 
       it('stores values for different contracts independently', async () => {
-        const anotherContract = AztecAddress.random();
-        const key = new Fr(1);
+        const anotherContract = await AztecAddress.random();
+        const slot = new Fr(1);
         const values1 = [new Fr(42)];
         const values2 = [new Fr(100)];
 
-        await database.store(contract, key, values1);
-        await database.store(anotherContract, key, values2);
+        await database.dbStore(contract, slot, values1);
+        await database.dbStore(anotherContract, slot, values2);
 
-        const result1 = await database.load(contract, key);
-        const result2 = await database.load(anotherContract, key);
+        const result1 = await database.dbLoad(contract, slot);
+        const result2 = await database.dbLoad(anotherContract, slot);
 
         expect(result1).toEqual(values1);
         expect(result2).toEqual(values2);
       });
 
-      it('returns null for non-existent keys', async () => {
-        const key = Fr.random();
-        const result = await database.load(contract, key);
+      it('returns null for non-existent slots', async () => {
+        const slot = Fr.random();
+        const result = await database.dbLoad(contract, slot);
         expect(result).toBeNull();
       });
+
+      it('deletes a slot', async () => {
+        const slot = new Fr(1);
+        const values = [new Fr(42)];
+
+        await database.dbStore(contract, slot, values);
+        await database.dbDelete(contract, slot);
+
+        expect(await database.dbLoad(contract, slot)).toBeNull();
+      });
+
+      it('deletes an empty slot', async () => {
+        const slot = new Fr(1);
+        await database.dbDelete(contract, slot);
+
+        expect(await database.dbLoad(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);
+
+        const dstSlot = new Fr(5);
+        await database.dbCopy(contract, slot, dstSlot, 1);
+
+        expect(await database.dbLoad(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]);
+
+        const dst = new Fr(5);
+        await database.dbCopy(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]);
+      });
+
+      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]);
+
+        const dst = new Fr(2);
+        await database.dbCopy(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]);
+
+        // 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]
+      });
+
+      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]);
+
+        const dst = new Fr(4);
+        await database.dbCopy(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]);
+
+        // 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)
+      });
+
+      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]);
+        // We skip src[1]
+        await database.dbStore(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');
+      });
     });
   });
 }