@aztec/pxe 0.0.1-commit.b9865e97 → 0.0.1-commit.be03c316

package/src/storage/backwards_compatibility_tests/__snapshots__/SenderTaggingStore.json

@@ -1,21 +1,29 @@
 {
   "pending_indexes": [
     {
-      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000002:0x0000000000000000000000000000000000000000000000000000000000000003",
+      "key": "utf8:constrained:0x0000000000000000000000000000000000000000000000000000000000000013:0x0000000000000000000000000000000000000000000000000000000000000017",
+      "value": "[{\"lowestIndex\":4,\"highestIndex\":7,\"txHash\":\"0x0000000000000000000000000000000000000000000000000000000000000025\"}]"
+    },
+    {
+      "key": "utf8:unconstrained:0x0000000000000000000000000000000000000000000000000000000000000002:0x0000000000000000000000000000000000000000000000000000000000000003",
       "value": "[{\"lowestIndex\":4,\"highestIndex\":7,\"txHash\":\"0x0000000000000000000000000000000000000000000000000000000000000013\"},{\"lowestIndex\":8,\"highestIndex\":11,\"txHash\":\"0x0000000000000000000000000000000000000000000000000000000000000017\"}]"
     },
     {
-      "key": "utf8:0x000000000000000000000000000000000000000000000000000000000000000b:0x000000000000000000000000000000000000000000000000000000000000000d",
+      "key": "utf8:unconstrained:0x000000000000000000000000000000000000000000000000000000000000000b:0x000000000000000000000000000000000000000000000000000000000000000d",
       "value": "[{\"lowestIndex\":1,\"highestIndex\":9,\"txHash\":\"0x000000000000000000000000000000000000000000000000000000000000001d\"}]"
     }
   ],
   "last_finalized_indexes": [
     {
-      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000002:0x0000000000000000000000000000000000000000000000000000000000000003",
+      "key": "utf8:constrained:0x0000000000000000000000000000000000000000000000000000000000000013:0x0000000000000000000000000000000000000000000000000000000000000017",
+      "value": "num:3"
+    },
+    {
+      "key": "utf8:unconstrained:0x0000000000000000000000000000000000000000000000000000000000000002:0x0000000000000000000000000000000000000000000000000000000000000003",
       "value": "num:3"
     },
     {
-      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000005:0x0000000000000000000000000000000000000000000000000000000000000007",
+      "key": "utf8:unconstrained:0x0000000000000000000000000000000000000000000000000000000000000005:0x0000000000000000000000000000000000000000000000000000000000000007",
       "value": "num:5"
     }
   ]

package/src/storage/backwards_compatibility_tests/__snapshots__/TaggingSecretSourcesStore.json

@@ -0,0 +1,30 @@
+{
+  "senders": [
+    {
+      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000002",
+      "value": "true"
+    },
+    {
+      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000003",
+      "value": "true"
+    },
+    {
+      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000005",
+      "value": "true"
+    }
+  ],
+  "recipient_shared_secrets": [
+    {
+      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000007",
+      "value": "{\"kind\":\"arbitrary-secret\",\"secret\":\"0x00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000003\"}"
+    },
+    {
+      "key": "utf8:0x0000000000000000000000000000000000000000000000000000000000000007",
+      "value": "{\"kind\":\"handshake\",\"secret\":\"0x00000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000007\"}"
+    },
+    {
+      "key": "utf8:0x000000000000000000000000000000000000000000000000000000000000000b",
+      "value": "{\"kind\":\"arbitrary-secret\",\"secret\":\"0x000000000000000000000000000000000000000000000000000000000000000d0000000000000000000000000000000000000000000000000000000000000011\"}"
+    }
+  ]
+}

package/src/storage/backwards_compatibility_tests/__snapshots__/opened_stores.json

@@ -1,10 +1,6 @@
 {
-  "schemaVersion": 6,
+  "schemaVersion": 13,
   "stores": [
-    {
-      "name": "address_book",
-      "kind": "map"
-    },
     {
       "name": "capsules",
       "kind": "map"
@@ -37,6 +33,18 @@
       "name": "events_by_contract_selector",
       "kind": "multimap"
     },
+    {
+      "name": "facts",
+      "kind": "map"
+    },
+    {
+      "name": "facts_by_block",
+      "kind": "multimap"
+    },
+    {
+      "name": "facts_by_collection",
+      "kind": "multimap"
+    },
     {
       "name": "header",
       "kind": "singleton"
@@ -58,7 +66,15 @@
       "kind": "map"
     },
     {
-      "name": "note_block_number_to_nullifier",
+      "name": "note_nullifications_by_block",
+      "kind": "multimap"
+    },
+    {
+      "name": "note_nullifications_by_nullifier",
+      "kind": "map"
+    },
+    {
+      "name": "note_nullifiers_by_block",
       "kind": "multimap"
     },
     {
@@ -82,15 +98,19 @@
       "kind": "map"
     },
     {
-      "name": "pxe_l2_block_number_to_checkpoint_number",
+      "name": "pxe_l2_tip_checkpoints",
       "kind": "map"
     },
     {
-      "name": "pxe_l2_checkpoint_store",
+      "name": "pxe_l2_tips",
       "kind": "map"
     },
     {
-      "name": "pxe_l2_tips",
+      "name": "recipient_shared_secrets",
+      "kind": "multimap"
+    },
+    {
+      "name": "senders",
       "kind": "map"
     }
   ]

package/src/storage/backwards_compatibility_tests/schema_tests.ts

@@ -2,6 +2,7 @@
 import { CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Tuple } from '@aztec/foundation/serialize';
 import { KeyStore } from '@aztec/key-store';
@@ -14,9 +15,10 @@ import { BlockHash, Body, GENESIS_BLOCK_HEADER_HASH, L2Block } from '@aztec/stdl
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
 import { CompleteAddress, SerializableContractInstance } from '@aztec/stdlib/contract';
 import { GasFees } from '@aztec/stdlib/gas';
-import { PublicKey, PublicKeys } from '@aztec/stdlib/keys';
+import { PublicKey, PublicKeys, deriveKeys } from '@aztec/stdlib/keys';
 import {
   AppTaggingSecret,
+  AppTaggingSecretKind,
   ContractClassLog,
   ContractClassLogFields,
   PrivateLog,
@@ -36,12 +38,14 @@ import {
 } from '@aztec/stdlib/tx';
 
 import { AddressStore } from '../address_store/address_store.js';
-import { AnchorBlockStore } from '../anchor_block_store/anchor_block_store.js';
+import { AnchorBlockStore } from '../anchor_block_store/index.js';
 import { CapsuleStore } from '../capsule_store/capsule_store.js';
 import { ContractStore } from '../contract_store/contract_store.js';
+import { FactStore } from '../fact_store/fact_store.js';
+import { FactCollectionKey } from '../fact_store/fact_store_keys.js';
 import { NoteStore } from '../note_store/note_store.js';
 import { PrivateEventStore } from '../private_event_store/private_event_store.js';
-import { RecipientTaggingStore, SenderAddressBookStore, SenderTaggingStore } from '../tagging_store/index.js';
+import { RecipientTaggingStore, SenderTaggingStore, TaggingSecretSourcesStore } from '../tagging_store/index.js';
 import { snapshotArray, snapshotMap, snapshotSingleton } from './kv_store_snapshot.js';
 
 /**
@@ -106,7 +110,7 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
             SlotNumber(47),
             53n,
             EthAddress.fromField(new Fr(59n)),
-            AztecAddress.fromBigInt(61n),
+            AztecAddress.fromBigIntUnsafe(61n),
             new GasFees(67n, 71n),
           ),
           new Fr(73n),
@@ -125,8 +129,8 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
       const capsuleStore = new CapsuleStore(kvStore);
 
       const jobId = 'fixture-job';
-      const contractAddress = AztecAddress.fromBigInt(2n);
-      const scope = AztecAddress.fromBigInt(3n);
+      const contractAddress = AztecAddress.fromBigIntUnsafe(2n);
+      const scope = AztecAddress.fromBigIntUnsafe(3n);
 
       // Three setCapsule calls (2-element, 1-element, 0-element value vector) pin every value-encoding length case.
       capsuleStore.setCapsule(contractAddress, new Fr(5n), [new Fr(7n), new Fr(11n)], jobId, scope);
@@ -188,7 +192,7 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
         new SerializableContractInstance({
           version: 2,
           salt: new Fr(73n),
-          deployer: AztecAddress.fromBigInt(79n),
+          deployer: AztecAddress.fromBigIntUnsafe(79n),
           currentContractClassId: new Fr(83n),
           originalContractClassId: new Fr(89n),
           initializationHash: new Fr(97n),
@@ -204,7 +208,7 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
             new Fr(71n),
             new Fr(73n),
           ),
-        }).withAddress(AztecAddress.fromBigInt(101n)),
+        }).withAddress(AztecAddress.fromBigIntUnsafe(101n)),
       );
     },
     snapshotStore: async kvStore => ({
@@ -214,11 +218,45 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
     }),
   },
 
+  {
+    name: 'FactStore',
+    writeToStore: async kvStore => {
+      const factStore = new FactStore(kvStore);
+      const jobId = 'fixture-job';
+      const contract = AztecAddress.fromBigIntUnsafe(100n);
+      const scope = AztecAddress.fromBigIntUnsafe(1n);
+      const factCollectionTypeId = new Fr(7n);
+      const keyA = FactCollectionKey.from({
+        contractAddress: contract,
+        scope,
+        factCollectionTypeId,
+        factCollectionId: new Fr(0xaan),
+      });
+      const keyB = FactCollectionKey.from({
+        contractAddress: contract,
+        scope,
+        factCollectionTypeId,
+        factCollectionId: new Fr(0xbbn),
+      });
+      // A collection whose only fact is retractable (origin block 6): pruned on a reorg above block 6.
+      await factStore.recordFact(keyA, new Fr(3n), [new Fr(5n)], { blockNumber: 6, blockHash: new Fr(2n) }, jobId);
+      // A collection with a non-retractable and a retractable fact.
+      await factStore.recordFact(keyB, new Fr(1n), [new Fr(9n)], undefined, jobId);
+      await factStore.recordFact(keyB, new Fr(2n), [], { blockNumber: 5, blockHash: new Fr(1n) }, jobId);
+      await kvStore.transactionAsync(() => factStore.commit(jobId));
+    },
+    snapshotStore: async kvStore => ({
+      facts: await snapshotMap(kvStore.openMap<string, Buffer>('facts')),
+      facts_by_collection: await snapshotMap(kvStore.openMultiMap<string, string>('facts_by_collection')),
+      facts_by_block: await snapshotMap(kvStore.openMultiMap<number, string>('facts_by_block')),
+    }),
+  },
+
   {
     name: 'KeyStore',
     writeToStore: async kvStore => {
       const keyStore = new KeyStore(kvStore);
-      await keyStore.addAccount(new Fr(2n), new Fr(3n));
+      await keyStore.addAccount(await deriveKeys(new Fr(2n)), new Fr(3n));
     },
     snapshotStore: async kvStore => ({
       key_store: await snapshotMap(kvStore.openMap<string, Buffer>('key_store')),
@@ -243,9 +281,10 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
             SlotNumber(19),
             23n,
             EthAddress.fromField(new Fr(29n)),
-            AztecAddress.fromBigInt(31n),
+            AztecAddress.fromBigIntUnsafe(31n),
             new GasFees(37n, 41n),
             new Fr(43n),
+            new Fr(47n),
           ),
           [block],
           CheckpointNumber(47),
@@ -256,28 +295,30 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
       );
 
       // `'blocks-added'` writes to `pxe_l2_tips` (proposed tag) and `pxe_l2_block_hashes`.
-      // `'chain-checkpointed'` writes to all four sub-stores: tips ('checkpointed' and 'proposedCheckpoint' tags),
-      // block-to-checkpoint mapping, and the checkpoint store.
+      // `'chain-checkpointed'` writes the 'checkpointed' tip and its checkpoint id (`pxe_l2_tip_checkpoints`).
       await l2TipsStore.handleBlockStreamEvent({ type: 'blocks-added', blocks: [block] });
       await l2TipsStore.handleBlockStreamEvent({
         type: 'chain-checkpointed',
         block: { number: BlockNumber(71), hash: new Fr(73n).toString() },
-        checkpoint: publishedCheckpoint,
+        checkpoint: {
+          number: publishedCheckpoint.checkpoint.number,
+          hash: publishedCheckpoint.checkpoint.hash().toString(),
+        },
       });
       // `'chain-proven'` writes the 'proven' tag. `'finalized'` is omitted because its handler runs delete-before
       // logic that would depend on the order of preceding events.
       await l2TipsStore.handleBlockStreamEvent({
         type: 'chain-proven',
         block: { number: BlockNumber(79), hash: new Fr(83n).toString() },
+        checkpoint: { number: CheckpointNumber(47), hash: new Fr(89n).toString() },
       });
     },
     snapshotStore: async kvStore => ({
       pxe_l2_tips: await snapshotMap(kvStore.openMap<string, number>('pxe_l2_tips')),
-      pxe_l2_block_hashes: await snapshotMap(kvStore.openMap<number, string>('pxe_l2_block_hashes')),
-      pxe_l2_block_number_to_checkpoint_number: await snapshotMap(
-        kvStore.openMap<number, number>('pxe_l2_block_number_to_checkpoint_number'),
+      pxe_l2_tip_checkpoints: await snapshotMap(
+        kvStore.openMap<string, { number: number; hash: string }>('pxe_l2_tip_checkpoints'),
       ),
-      pxe_l2_checkpoint_store: await snapshotMap(kvStore.openMap<number, Buffer>('pxe_l2_checkpoint_store')),
+      pxe_l2_block_hashes: await snapshotMap(kvStore.openMap<number, string>('pxe_l2_block_hashes')),
     }),
   },
 
@@ -290,17 +331,17 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
 
       // Two contracts so `note_nullifiers_by_contract` exhibits both a multi-value row (contractA → {n1, n2}) and a
       // single-value row (contractB → {n3}).
-      const contractA = AztecAddress.fromBigInt(2n);
-      const contractB = AztecAddress.fromBigInt(3n);
-      const scopeX = AztecAddress.fromBigInt(5n);
-      const scopeY = AztecAddress.fromBigInt(7n);
+      const contractA = AztecAddress.fromBigIntUnsafe(2n);
+      const contractB = AztecAddress.fromBigIntUnsafe(3n);
+      const scopeX = AztecAddress.fromBigIntUnsafe(5n);
+      const scopeY = AztecAddress.fromBigIntUnsafe(7n);
 
       // note1: active, will be added under two scopes to exercise the multi-element scopes vector encoding in
       // `StoredNote.toBuffer`.
       const note1 = new NoteDao(
         new Note([new Fr(13n), new Fr(17n), new Fr(19n)]),
         contractA,
-        AztecAddress.fromBigInt(23n),
+        AztecAddress.fromBigIntUnsafe(23n),
         new Fr(29n),
         new Fr(31n),
         new Fr(37n),
@@ -317,7 +358,7 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
       const note2 = new NoteDao(
         new Note([new Fr(71n), new Fr(73n), new Fr(79n)]),
         contractA,
-        AztecAddress.fromBigInt(83n),
+        AztecAddress.fromBigIntUnsafe(83n),
         new Fr(89n),
         new Fr(97n),
         new Fr(101n),
@@ -330,12 +371,12 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
         137,
       );
 
-      // note3: different contract; will be nullified to populate `note_block_number_to_nullifier` and exercise the
-      // populated `_nullifiedAt` trailer of `StoredNote.toBuffer`.
+      // note3: different contract; will be nullified to populate `note_nullifications_by_nullifier` and exercise the
+      // append-only nullification record written by `applyNullifiers`.
       const note3 = new NoteDao(
         new Note([new Fr(139n), new Fr(149n), new Fr(151n)]),
         contractB,
-        AztecAddress.fromBigInt(157n),
+        AztecAddress.fromBigIntUnsafe(157n),
         new Fr(163n),
         new Fr(167n),
         new Fr(173n),
@@ -355,9 +396,8 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
       await noteStore.addNotes([note2], scopeX, jobId);
       await noteStore.addNotes([note3], scopeX, jobId);
 
-      // Nullify note3 within the same job. `applyNullifiers` reads the staged StoredNote, sets `_nullifiedAt`, and
-      // writes back to the staged map; `commit` then flushes it to disk with the populated trailer and adds the
-      // corresponding `note_block_number_to_nullifier` entry.
+      // Nullify note3 within the same job. `applyNullifiers` stages the emission block number for the note; `commit`
+      // then flushes it to disk into `note_nullifications_by_nullifier`.
       await noteStore.applyNullifiers(
         [{ data: note3.siloedNullifier, l2BlockNumber: BlockNumber(223), l2BlockHash: BlockHash.ZERO }],
         jobId,
@@ -370,8 +410,12 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
       note_nullifiers_by_contract: await snapshotMap(
         kvStore.openMultiMap<string, string>('note_nullifiers_by_contract'),
       ),
-      note_block_number_to_nullifier: await snapshotMap(
-        kvStore.openMultiMap<number, string>('note_block_number_to_nullifier'),
+      note_nullifications_by_nullifier: await snapshotMap(
+        kvStore.openMap<string, number>('note_nullifications_by_nullifier'),
+      ),
+      note_nullifiers_by_block: await snapshotMap(kvStore.openMultiMap<number, string>('note_nullifiers_by_block')),
+      note_nullifications_by_block: await snapshotMap(
+        kvStore.openMultiMap<number, string>('note_nullifications_by_block'),
       ),
     }),
   },
@@ -385,12 +429,12 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
 
       // Two (contract, selector) pairs and two block numbers so each multimap exhibits both a multi-value row
       // (contractA/selectorA → {e1, e2} and blockN1 → {e1, e2}) and a contrasting single-value row.
-      const contractA = AztecAddress.fromBigInt(2n);
-      const contractB = AztecAddress.fromBigInt(3n);
+      const contractA = AztecAddress.fromBigIntUnsafe(2n);
+      const contractB = AztecAddress.fromBigIntUnsafe(3n);
       const selectorA = EventSelector.fromField(new Fr(5n));
       const selectorB = EventSelector.fromField(new Fr(7n));
-      const scopeX = AztecAddress.fromBigInt(11n);
-      const scopeY = AztecAddress.fromBigInt(13n);
+      const scopeX = AztecAddress.fromBigIntUnsafe(11n);
+      const scopeY = AztecAddress.fromBigIntUnsafe(13n);
       const blockN1 = BlockNumber(17);
       const blockN2 = BlockNumber(19);
 
@@ -485,12 +529,20 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
       const recipientTaggingStore = new RecipientTaggingStore(kvStore);
 
       const jobId = 'fixture-job';
-      const secretA = new AppTaggingSecret(new Fr(2n), AztecAddress.fromBigInt(3n));
-      const secretB = new AppTaggingSecret(new Fr(5n), AztecAddress.fromBigInt(7n));
+      const secretA = new AppTaggingSecret(new Fr(2n), AztecAddress.fromBigIntUnsafe(3n));
+      const secretB = new AppTaggingSecret(new Fr(5n), AztecAddress.fromBigIntUnsafe(7n));
+      // A constrained secret keys under the `constrained:` prefix, so the snapshot pins both kinds side by side.
+      const secretConstrained = new AppTaggingSecret(
+        new Fr(19n),
+        AztecAddress.fromBigIntUnsafe(23n),
+        AppTaggingSecretKind.CONSTRAINED,
+      );
 
       await recipientTaggingStore.updateHighestFinalizedIndex(secretA, 11, jobId);
       await recipientTaggingStore.updateHighestAgedIndex(secretA, 13, jobId);
       await recipientTaggingStore.updateHighestFinalizedIndex(secretB, 17, jobId);
+      await recipientTaggingStore.updateHighestFinalizedIndex(secretConstrained, 11, jobId);
+      await recipientTaggingStore.updateHighestAgedIndex(secretConstrained, 13, jobId);
       await kvStore.transactionAsync(() => recipientTaggingStore.commit(jobId));
     },
     snapshotStore: async kvStore => ({
@@ -500,16 +552,35 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
   },
 
   {
-    name: 'SenderAddressBookStore',
+    name: 'TaggingSecretSourcesStore',
     writeToStore: async kvStore => {
-      const senderAddressBookStore = new SenderAddressBookStore(kvStore);
+      const taggingSecretSourcesStore = new TaggingSecretSourcesStore(kvStore);
+
+      await taggingSecretSourcesStore.addSender(AztecAddress.fromBigIntUnsafe(2n));
+      await taggingSecretSourcesStore.addSender(AztecAddress.fromBigIntUnsafe(3n));
+      await taggingSecretSourcesStore.addSender(AztecAddress.fromBigIntUnsafe(5n));
 
-      await senderAddressBookStore.addSender(AztecAddress.fromBigInt(2n));
-      await senderAddressBookStore.addSender(AztecAddress.fromBigInt(3n));
-      await senderAddressBookStore.addSender(AztecAddress.fromBigInt(5n));
+      await taggingSecretSourcesStore.addSharedSecret(
+        AztecAddress.fromBigIntUnsafe(7n),
+        'arbitrary-secret',
+        new Point(new Fr(2n), new Fr(3n)),
+      );
+      await taggingSecretSourcesStore.addSharedSecret(
+        AztecAddress.fromBigIntUnsafe(7n),
+        'handshake',
+        new Point(new Fr(5n), new Fr(7n)),
+      );
+      await taggingSecretSourcesStore.addSharedSecret(
+        AztecAddress.fromBigIntUnsafe(11n),
+        'arbitrary-secret',
+        new Point(new Fr(13n), new Fr(17n)),
+      );
     },
     snapshotStore: async kvStore => ({
-      address_book: await snapshotMap(kvStore.openMap<string, true>('address_book')),
+      senders: await snapshotMap(kvStore.openMap<string, true>('senders')),
+      recipient_shared_secrets: await snapshotMap(
+        kvStore.openMultiMap<string, { kind: string; secret: string }>('recipient_shared_secrets'),
+      ),
     }),
   },
 
@@ -519,13 +590,20 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
       const senderTaggingStore = new SenderTaggingStore(kvStore);
 
       const jobId = 'fixture-job';
-      const secretA = new AppTaggingSecret(new Fr(2n), AztecAddress.fromBigInt(3n));
-      const secretB = new AppTaggingSecret(new Fr(5n), AztecAddress.fromBigInt(7n));
-      const secretC = new AppTaggingSecret(new Fr(11n), AztecAddress.fromBigInt(13n));
+      const secretA = new AppTaggingSecret(new Fr(2n), AztecAddress.fromBigIntUnsafe(3n));
+      const secretB = new AppTaggingSecret(new Fr(5n), AztecAddress.fromBigIntUnsafe(7n));
+      const secretC = new AppTaggingSecret(new Fr(11n), AztecAddress.fromBigIntUnsafe(13n));
+      const secretConstrained = new AppTaggingSecret(
+        new Fr(19n),
+        AztecAddress.fromBigIntUnsafe(23n),
+        AppTaggingSecretKind.CONSTRAINED,
+      );
       const txHashA = TxHash.fromBigInt(17n);
       const txHashB = TxHash.fromBigInt(19n);
       const txHashC = TxHash.fromBigInt(23n);
       const txHashD = TxHash.fromBigInt(29n);
+      const txHashE = TxHash.fromBigInt(31n);
+      const txHashF = TxHash.fromBigInt(37n);
 
       // secretA receives three pending ranges (one per tx); secretB receives one. After finalizing txHashA below,
       // secretA's array shrinks to two elements (the txHashB and txHashC ranges, both with highestIndex > 3) which
@@ -564,7 +642,20 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [
         jobId,
       );
 
-      await senderTaggingStore.finalizePendingIndexes([txHashA], jobId);
+      // secretConstrained gets a finalized range (txHashE) plus a surviving higher pending range (txHashF), so the
+      // `constrained:` key lands in both pending_indexes and last_finalized_indexes.
+      await senderTaggingStore.storePendingIndexes(
+        [{ extendedSecret: secretConstrained, lowestIndex: 1, highestIndex: 3 }],
+        txHashE,
+        jobId,
+      );
+      await senderTaggingStore.storePendingIndexes(
+        [{ extendedSecret: secretConstrained, lowestIndex: 4, highestIndex: 7 }],
+        txHashF,
+        jobId,
+      );
+
+      await senderTaggingStore.finalizePendingIndexes([txHashA, txHashE], jobId);
 
       await kvStore.transactionAsync(() => senderTaggingStore.commit(jobId));
     },
@@ -615,7 +706,7 @@ function buildL2Block(): L2Block {
       SlotNumber(181),
       191n,
       EthAddress.fromField(new Fr(193n)),
-      AztecAddress.fromBigInt(197n),
+      AztecAddress.fromBigIntUnsafe(197n),
       new GasFees(199n, 211n),
     ),
     new Fr(223n),
@@ -636,10 +727,10 @@ function buildL2Block(): L2Block {
         3,
       ),
     ],
-    [new PublicLog(AztecAddress.fromBigInt(281n), [new Fr(283n), new Fr(293n)])],
+    [new PublicLog(AztecAddress.fromBigIntUnsafe(281n), [new Fr(283n), new Fr(293n)])],
     [
       new ContractClassLog(
-        AztecAddress.fromBigInt(307n),
+        AztecAddress.fromBigIntUnsafe(307n),
         new ContractClassLogFields(paddedFrs([311n, 313n, 317n], CONTRACT_CLASS_LOG_SIZE_IN_FIELDS)),
         3,
       ),

package/src/storage/capsule_store/capsule_service.ts

@@ -2,6 +2,7 @@ import type { Fr } from '@aztec/foundation/curves/bn254';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { Capsule } from '@aztec/stdlib/tx';
 
+import { assertAllowedScope } from '../allowed_scopes.js';
 import type { CapsuleStore } from './capsule_store.js';
 
 /**
@@ -9,10 +10,15 @@ import type { CapsuleStore } from './capsule_store.js';
  * allowed scopes list before delegating to the underlying store.
  */
 export class CapsuleService {
+  private readonly allowedScopes: AztecAddress[];
+
   constructor(
     private readonly capsuleStore: CapsuleStore,
-    private readonly allowedScopes: AztecAddress[],
-  ) {}
+    allowedScopes: AztecAddress[],
+  ) {
+    // The zero address denotes the global capsule scope, which is always permitted.
+    this.allowedScopes = [...allowedScopes, AztecAddress.ZERO];
+  }
 
   setCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[], jobId: string, scope: AztecAddress) {
     assertAllowedScope(scope, this.allowedScopes);
@@ -77,14 +83,3 @@ export class CapsuleService {
     return this.capsuleStore.setCapsuleArray(contractAddress, baseSlot, content, jobId, scope);
   }
 }
-
-function assertAllowedScope(scope: AztecAddress, allowedScopes: AztecAddress[]) {
-  if (scope.equals(AztecAddress.ZERO)) {
-    return;
-  }
-  if (!allowedScopes.some((allowed: AztecAddress) => allowed.equals(scope))) {
-    throw new Error(
-      `Scope ${scope.toString()} is not in the allowed scopes list: [${allowedScopes.map((s: AztecAddress) => s.toString()).join(', ')}]. See https://docs.aztec.network/errors/10`,
-    );
-  }
-}