diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 2854a01..acf3473 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -18,7 +18,7 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: '22'
+          node-version: '24'
           cache: 'pnpm'
 
       - name: Install dependencies
diff --git a/.gitignore b/.gitignore
index fa73992..b0aea58 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@ managed/
 tsconfig.tsbuildinfo
 
 logs/
+*.sqlite
 
 **/midnight-level-db/
 **/*-midnight/
@@ -18,4 +19,4 @@ logs/
 .eslintcache
 
 # Prettier
-.prettiercache
\ No newline at end of file
+.prettiercache
diff --git a/VERSIONS.md b/VERSIONS.md
index 1bae143..f0f2ab2 100644
--- a/VERSIONS.md
+++ b/VERSIONS.md
@@ -1,29 +1,37 @@
 # Component Versions
 
-2026-04-24
+2026-07-23
 
 ## Versions in Use
 
-- Compact compiler: 0.30.0
-- Indexer: 4.0.0
-- Proof server: 8.0.2
-- Midnight node: 0.22.0
+- Compact devtools: 0.5.1
+- Compact compiler: 0.31.1
+- Compact language: 0.23.0
+- Compact runtime: 0.16.0
+- Compact JS: 2.5.1
+- Midnight.js: 4.1.1
+- On-chain runtime: 3.0.0
+- Indexer (standalone devnet): 4.2.1
+- Proof server: 8.1.0
+- Midnight node (local devnet): 0.22.5
 - Node.js: 24.13.1
 
 ## Project dependencies
 
 ````json
 "dependencies": {
-    "@midnight-ntwrk/compact-js": "2.5.0",
-    "@midnight-ntwrk/compact-runtime": "0.15.0",
+    "@midnight-ntwrk/compact-js": "2.5.1",
+    "@midnight-ntwrk/compact-runtime": "0.16.0",
     "@midnight-ntwrk/ledger-v8": "8.0.3",
-    "@midnight-ntwrk/midnight-js-contracts": "4.0.4",
-    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-level-private-state-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-network-id": "4.0.4",
-    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-types": "4.0.4",
+    "@midnight-ntwrk/midnight-js-contracts": "4.1.1",
+    "@midnight-ntwrk/midnight-js-fetch-zk-config-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-level-private-state-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-network-id": "4.1.1",
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-types": "4.1.1",
+    "@midnight-ntwrk/onchain-runtime-v3": "3.0.0",
     "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0-rc.0",
     "@midnight-ntwrk/wallet-sdk-capabilities": "3.2.0-rc.0",
     "@midnight-ntwrk/wallet-sdk-abstractions": "2.0.0",
diff --git a/apps/cli/package.json b/apps/cli/package.json
index 1cbbea6..41de09b 100644
--- a/apps/cli/package.json
+++ b/apps/cli/package.json
@@ -15,9 +15,9 @@
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@midnight-ntwrk/compact-runtime": "0.15.0",
+    "@midnight-ntwrk/compact-runtime": "0.16.0",
     "@midnight-ntwrk/ledger-v8": "8.0.3",
-    "@midnight-ntwrk/midnight-js-contracts": "4.0.4",
+    "@midnight-ntwrk/midnight-js-contracts": "4.1.1",
     "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0-rc.0",
     "@midnight-ntwrk/zswap": "4.0.0",
     "@midnight-sentinel/api": "workspace:*",
diff --git a/apps/cli/src/cli/index.ts b/apps/cli/src/cli/index.ts
index 9e4712d..6df634d 100644
--- a/apps/cli/src/cli/index.ts
+++ b/apps/cli/src/cli/index.ts
@@ -1,7 +1,20 @@
 import { SentinelContract } from '@midnight-sentinel/api';
+import { sponsorshipAllowlistHash } from '@midnight-sentinel/api/sponsorship';
+import {
+  createHttpMidnightRegistrationProvider,
+  enrollmentSigningBytes,
+  type EnrollmentPayload,
+  type SignedEnrollment,
+} from '@midnight-sentinel/api/sponsorship/eligibility';
+import {
+  createMidnightSponsorSponsorshipApi,
+  dustPublicKeyToBytes,
+  nativeNightSponsorshipConfig,
+} from '@midnight-sentinel/api/sponsorship/midnight';
 import { configureProviders } from '@midnight-sentinel/contract/providers';
 import {
   getBalancesAndAddresses,
+  getNetworkId,
   printBalances,
   type WalletContext,
 } from '@midnight-sentinel/wallet';
@@ -12,54 +25,73 @@ import { circuitMenu, contractMenu } from './menus.js';
 async function handleCircuits(
   contract: SentinelContract,
   _walletDetails: { seed: string; privateStateStoreName: string },
-  walletCtx: WalletContext,
-  rli: Interface
+  _walletCtx: WalletContext,
+  rli: Interface,
+  config: Config
 ) {
   while (true) {
     const choice = await rli.question(circuitMenu);
     switch (choice) {
       case '1':
-        try {
-          const key = walletCtx.shieldedSecretKeys.coinPublicKey;
-          const amount = await rli.question('Enter the amount you would like to delegate: ');
-          await contract.delegate(key, BigInt(amount));
-        } catch (e) {
-          console.log('Error delegating: ', e);
-        }
+        await contract.getCurrentState();
         break;
       case '2':
         try {
-          await contract.redeemRewards();
+          await contract.setSponsorshipEnabled(false);
         } catch (e) {
-          console.log('Error redeeming rewards: ', e);
+          console.log('Error pausing sponsorship: ', e);
         }
-        return;
+        break;
       case '3':
         try {
-          await contract.withdraw();
+          await contract.setSponsorshipEnabled(true);
         } catch (e) {
-          console.log('Error wthdrawing: ', e);
+          console.log('Error resuming sponsorship: ', e);
         }
         break;
       case '4':
         try {
-          const amount = await rli.question(
-            'Enter the amount you would like to deposit as rewards: '
-          );
-          // TODO: wire up to wallet
-          await contract.depositRewards(
-            BigInt(amount),
-            new Uint8Array(32).fill(0),
-            new Uint8Array(32).fill(0)
-          );
-        } catch (e) {
-          console.log('Error depositing rewards: ', e);
+          const serviceUrl =
+            (await rli.question(`Eligibility service URL [${config.eligibilityService}]: `)) ||
+            config.eligibilityService;
+          const raw = await rli.question('Signed enrollment JSON: ');
+          const enrollment = JSON.parse(raw) as SignedEnrollment;
+          const response = await fetch(`${serviceUrl.replace(/\/$/, '')}/v1/enrollments`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(enrollment),
+          });
+          console.log(await response.text());
+          if (!response.ok) {
+            throw new Error(`Enrollment service returned HTTP ${response.status}`);
+          }
+        } catch (error) {
+          console.error('Enrollment failed:', error);
         }
-        return;
+        break;
       case '5':
-        await contract.getCurrentState();
+        try {
+          const identity = (await rli.question('Delegator identity (32-byte hex): ')).replace(
+            /^0x/,
+            ''
+          );
+          await contract.removeDelegator(Uint8Array.from(Buffer.from(identity, 'hex')));
+        } catch (error) {
+          console.error('Removal failed:', error);
+        }
         break;
       case '6':
+        try {
+          const authority = (await rli.question('New operator authority (32-byte hex): ')).replace(
+            /^0x/,
+            ''
+          );
+          await contract.rotateEligibilityOperator(Uint8Array.from(Buffer.from(authority, 'hex')));
+        } catch (error) {
+          console.error('Rotation failed:', error);
+        }
+        break;
+      case '7':
         console.log('Exiting...');
         return;
       default:
@@ -87,7 +119,35 @@ export async function runCli(
           config,
           walletDetails.privateStateStoreName
         );
-        contract = await SentinelContract.deploy(providers);
+        const sponsorShare = BigInt((await rli.question('Sponsor NIGHT share [1]: ')) || '1');
+        const delegatorShare = BigInt((await rli.question('Delegator NIGHT share [1]: ')) || '1');
+        const minimumRegisteredNight = BigInt(
+          (await rli.question('Minimum registered NIGHT [1]: ')) || '1'
+        );
+        const operatorHex = (
+          await rli.question('Eligibility operator authority key (32-byte hex): ')
+        )
+          .trim()
+          .replace(/^0x/, '');
+        if (!/^[0-9a-fA-F]{64}$/.test(operatorHex)) {
+          throw new Error('Eligibility operator key must be 32-byte hex');
+        }
+        const targetAddress = (
+          await rli.question('Initial allowed target contract address: ')
+        ).trim();
+        const targetEntryPoint = (await rli.question('Initial allowed target circuit: ')).trim();
+        const policyHash = sponsorshipAllowlistHash([
+          { address: targetAddress, entryPoint: targetEntryPoint },
+        ]);
+        contract = await SentinelContract.deploy(
+          providers,
+          nativeNightSponsorshipConfig(walletCtx, policyHash, {
+            sponsorShare,
+            delegatorShare,
+            minimumRegisteredNight,
+            initialEligibilityOperator: Uint8Array.from(Buffer.from(operatorHex, 'hex')),
+          })
+        );
 
         console.log(
           `[Contract Address]: ${contract.deployedContract?.deployTxData.public.contractAddress}`
@@ -113,8 +173,50 @@ export async function runCli(
         break;
       case '3':
         try {
-          const raw = await rli.question('Enter the raw transaction recipe: ');
-          await SentinelContract.zswapSponsor(walletCtx, raw);
+          const sentinelAddress = (
+            await rli.question('Sentinel sponsorship contract address: ')
+          ).trim();
+          const targetAddress = (await rli.question('Allowed target contract address: ')).trim();
+          const targetEntryPoint = (await rli.question('Allowed target circuit: ')).trim();
+          const maxFee = BigInt(await rli.question('Maximum DUST fee: '));
+          const sponsorDustAddress = (await rli.question('Campaign sponsor DUST address: ')).trim();
+          const eligibilityService =
+            (await rli.question(`Eligibility service URL [${config.eligibilityService}]: `)) ||
+            config.eligibilityService;
+          const raw = (await rli.question('Prepared transaction (hex): ')).trim();
+          const allowedTargets = [{ address: targetAddress, entryPoint: targetEntryPoint }];
+          const providers = await configureProviders(
+            walletCtx,
+            config,
+            walletDetails.privateStateStoreName
+          );
+          const sponsorshipApi = createMidnightSponsorSponsorshipApi({
+            policy: {
+              sentinelAddress,
+              sponsorId: dustPublicKeyToBytes(walletCtx.dustSecretKey.publicKey),
+              sponsorDustAddress,
+              registrationProvider: createHttpMidnightRegistrationProvider(eligibilityService),
+              policyHash: sponsorshipAllowlistHash(allowedTargets),
+              allowedTargets,
+              minTtlMs: 30_000,
+              maxTtlMs: 65 * 60 * 1_000,
+              maxFee,
+            },
+            sentinelProviders: providers,
+            sponsor: walletCtx,
+          });
+          const result = await sponsorshipApi.sponsorAndSubmit({
+            transaction: Uint8Array.from(Buffer.from(raw, 'hex')),
+          });
+          console.log(
+            JSON.stringify({
+              txId: result.txId,
+              status: result.status,
+              feeEstimate: result.feeEstimate.toString(),
+              targetAddress: result.targetAddress,
+              targetEntryPoint: result.targetEntryPoint,
+            })
+          );
         } catch (e) {
           console.log('Error sponsoring DUST: ', e);
         }
@@ -138,6 +240,38 @@ export async function runCli(
         break;
       }
       case '6':
+        try {
+          const sentinelAddress = (await rli.question('Sentinel contract address: ')).trim();
+          const sponsorDustAddress = (await rli.question('Campaign sponsor DUST address: ')).trim();
+          const nonce = (await rli.question('Enrollment nonce [1]: ')) || '1';
+          const expiresInMinutes = Number(
+            (await rli.question('Expires in minutes [60]: ')) || '60'
+          );
+          if (!Number.isFinite(expiresInMinutes) || expiresInMinutes <= 0) {
+            throw new Error('Expiry must be a positive number of minutes');
+          }
+          const payload: EnrollmentPayload = {
+            version: 1,
+            network: getNetworkId(),
+            sentinelAddress,
+            sponsorDustAddress,
+            nightRewardAddress: walletCtx.unshieldedKeystore.getBech32Address().toString(),
+            nightVerificationKey: walletCtx.unshieldedKeystore.getPublicKey(),
+            shieldedCoinPublicKey: walletCtx.shieldedSecretKeys.coinPublicKey,
+            shieldedEncryptionPublicKey: walletCtx.shieldedSecretKeys.encryptionPublicKey,
+            nonce: BigInt(nonce).toString(),
+            expiresAt: new Date(Date.now() + expiresInMinutes * 60_000).toISOString(),
+          };
+          const enrollment: SignedEnrollment = {
+            payload,
+            signature: walletCtx.unshieldedKeystore.signData(enrollmentSigningBytes(payload)),
+          };
+          console.log(JSON.stringify(enrollment));
+        } catch (error) {
+          console.error('Could not create enrollment:', error);
+        }
+        break;
+      case '7':
         console.log('Exiting...');
         return;
       default:
@@ -145,6 +279,8 @@ export async function runCli(
         continue;
     }
 
-    if (contract) await handleCircuits(contract, walletDetails, walletCtx, rli);
+    if (contract) {
+      await handleCircuits(contract, walletDetails, walletCtx, rli, config);
+    }
   }
 }
diff --git a/apps/cli/src/cli/menus.ts b/apps/cli/src/cli/menus.ts
index a20bbca..da23dfb 100644
--- a/apps/cli/src/cli/menus.ts
+++ b/apps/cli/src/cli/menus.ts
@@ -4,20 +4,22 @@ export const contractMenu: string = `
 ${DIVIDER}
   [1] Deploy a new contract
   [2] Join an existing contract
-  [3] (Admin) Submit transaction sponsoring DUST
+  [3] (Sponsor) Inspect, add only DUST, and submit
   [4] Start ZSwap to request DUST sponsorship
   [5] Get balances
-  [6] Exit
+  [6] Create signed delegator enrollment
+  [7] Exit
 ${DIVIDER}
 `;
 
 export const circuitMenu: string = `
 ${DIVIDER}
-  [1] Delegate NIGHT
-  [2] Redeem rewards
-  [3] (Admin) Withdraw NIGHTs
-  [4] (Admin) Deposit rewards
-  [5] Get contract state
-  [6] Exit
+  [1] Get sponsorship state
+  [2] (Owner) Pause sponsorship
+  [3] (Owner) Resume sponsorship
+  [4] (Operator) Verify and enroll signed request
+  [5] (Operator) Remove delegator
+  [6] (Owner) Rotate eligibility operator
+  [7] Exit
 ${DIVIDER}
 `;
diff --git a/apps/cli/src/config.ts b/apps/cli/src/config.ts
index 4c5a98b..eb4915e 100644
--- a/apps/cli/src/config.ts
+++ b/apps/cli/src/config.ts
@@ -9,6 +9,7 @@ export interface Config {
   readonly indexerWS: string;
   readonly node: string;
   readonly proofServer: string;
+  readonly eligibilityService: string;
 }
 
 export const currentDir = path.resolve(new URL(import.meta.url).pathname, '..');
@@ -30,4 +31,5 @@ export class StandaloneConfig implements Config {
   indexerWS = 'ws://127.0.0.1:8088/api/v3/graphql/ws';
   node = 'http://127.0.0.1:9944';
   proofServer = 'http://127.0.0.1:6300';
+  eligibilityService = 'http://127.0.0.1:8089';
 }
diff --git a/apps/cli/src/delegation-flow-example.ts b/apps/cli/src/delegation-flow-example.ts
index e3560f4..16328b7 100644
--- a/apps/cli/src/delegation-flow-example.ts
+++ b/apps/cli/src/delegation-flow-example.ts
@@ -17,6 +17,8 @@
  */
 
 import { SentinelContract } from '@midnight-sentinel/api';
+import { sponsorshipAllowlistHash } from '@midnight-sentinel/api/sponsorship';
+import { nativeNightSponsorshipConfig } from '@midnight-sentinel/api/sponsorship/midnight';
 import { configureProviders } from '@midnight-sentinel/contract/providers';
 import {
   buildWallet,
@@ -127,7 +129,12 @@ const main = async () => {
   console.log('\n=== 3. Admin deploys SentinelContract ===');
   const providers = await configureProviders(admin, config, 'delegation-contract');
 
-  const contract = await SentinelContract.deploy(providers);
+  const contract = await SentinelContract.deploy(
+    providers,
+    nativeNightSponsorshipConfig(admin, sponsorshipAllowlistHash([]), {
+      initialEligibilityOperator: new Uint8Array(32),
+    })
+  );
   console.log(
     '  ✓ Contract deployed at:',
     contract.deployedContract?.deployTxData.public.contractAddress
diff --git a/apps/cli/src/zswap-sponsor-example.ts b/apps/cli/src/zswap-sponsor-example.ts
index 8c34286..eb7d969 100644
--- a/apps/cli/src/zswap-sponsor-example.ts
+++ b/apps/cli/src/zswap-sponsor-example.ts
@@ -15,6 +15,8 @@
  */
 
 import { SentinelContract } from '@midnight-sentinel/api';
+import { sponsorshipAllowlistHash } from '@midnight-sentinel/api/sponsorship';
+import { nativeNightSponsorshipConfig } from '@midnight-sentinel/api/sponsorship/midnight';
 import { configureProviders } from '@midnight-sentinel/contract/providers';
 import {
   buildWallet,
@@ -99,7 +101,12 @@ const main = async () => {
   const providers = await configureProviders(ctxA, config, 'zswap-sponsor-contract');
 
   console.log('  Deploying Sentinel contract...');
-  const contract = await SentinelContract.deploy(providers);
+  const contract = await SentinelContract.deploy(
+    providers,
+    nativeNightSponsorshipConfig(ctxC, sponsorshipAllowlistHash([]), {
+      initialEligibilityOperator: new Uint8Array(32),
+    })
+  );
   console.log('  ✓ Contract deployed');
   await sleep(10_000);
 
diff --git a/apps/sponsor-service/README.md b/apps/sponsor-service/README.md
new file mode 100644
index 0000000..d655931
--- /dev/null
+++ b/apps/sponsor-service/README.md
@@ -0,0 +1,90 @@
+# Sentinel Sponsor Eligibility Service
+
+The service accepts signed Midnight enrollment requests, reconstructs current
+registered NIGHT from finalized indexer data, and serializes eligibility queue
+mutations for one Sentinel deployment.
+
+For a running local devnet (node, indexer, and proof server), the complete
+setup is one command:
+
+```sh
+pnpm --filter @midnight-sentinel/sponsor-service setup:devnet
+```
+
+It uses the known funded devnet wallets, generates a distinct circuit operator
+secret, deploys an `interact` target and a new Sentinel campaign, derives the
+sponsor DUST address, and writes `apps/sponsor-service/.env` with mode `0600`.
+The service loads this file automatically. Start it with:
+
+```sh
+pnpm --filter @midnight-sentinel/sponsor-service dev
+```
+
+The setup command builds full-ZK Sentinel artifacts from `packages/contract`
+and the composite target fixture from
+`packages/protocol-verification`. The resulting `.env` is local-devnet
+configuration and must not be reused for a public network. It will not replace
+an existing environment unless you explicitly append `-- --force`.
+
+For manual or non-devnet setup, the required environment variables are:
+
+- `SERVICE_ADMIN_TOKEN` — at least 24 characters.
+- `SERVICE_OPERATOR_SEED` — the 32-byte transaction wallet seed.
+- `SERVICE_OPERATOR_SECRET` — the 32-byte circuit authority secret. Keep this
+  separate from the wallet seed and never publish it.
+- `SERVICE_PRIVATE_STATE_STORE` — encrypted private-state store name used by
+  the service.
+- `SENTINEL_ADDRESS` — deployed Sentinel contract address.
+- `SPONSOR_DUST_ADDRESS` — campaign sponsor DUST address.
+- `EXPECTED_OPERATOR_AUTHORITY` — public authority stored in the contract.
+
+Indexer, node, proof server, database, host, port, network, and revalidation
+interval have local-devnet defaults.
+
+Generate a circuit secret and the corresponding public deployment/rotation
+authority with:
+
+```sh
+pnpm --filter @midnight-sentinel/sponsor-service operator:bootstrap
+```
+
+Use `operatorAuthority` when deploying Sentinel or rotating its operator. Set
+the matching `operatorSecret` as `SERVICE_OPERATOR_SECRET`, configure the
+remaining environment variables, and start the service. In the CLI, option 6
+creates a signed delegator enrollment; after joining Sentinel, circuit option 4
+submits it to this service. Sponsor submission now queries this service during
+its stale-delegator preflight.
+
+## Live devnet end-to-end test
+
+With the node, indexer, and proof server already running and the full-ZK
+Sentinel and composite-target artifacts built, run:
+
+```sh
+pnpm --filter @midnight-sentinel/sponsor-service test:e2e:devnet
+```
+
+The command recompiles and copies the full-ZK Sentinel and target artifacts
+before starting so generated contract bindings, ZKIR, and proving keys cannot
+silently drift out of sync.
+
+This is an opt-in system test and does not use mocked wallets, providers,
+registrations, contracts, proofs, or HTTP endpoints. It snapshots the existing
+devnet state, creates fresh isolated user wallets, funds them from the known
+devnet genesis wallet, submits real sponsor-directed NIGHT registrations,
+deploys a target and Sentinel, starts the real eligibility service on an
+ephemeral port, and exercises:
+
+- empty-queue fail-closed behavior;
+- invalid, expired, wrong-campaign, unregistered, replayed, and below-minimum
+  enrollments;
+- three real indexer-backed enrollments;
+- deterministic `A -> B -> C -> A` rewards;
+- both `SucceedEntirely` and `FailFallible`;
+- exact sponsor and delegator wallet reward deltas;
+- authenticated queue removal and automatic finalized stale-entry removal.
+
+The test leaves submitted devnet transactions and contracts in chain history.
+Wallets, the HTTP server, and the temporary SQLite database are closed even
+after failure. A sanitized JSON report is retained in the printed temporary
+directory; wallet and operator secrets are never included.
diff --git a/apps/sponsor-service/package.json b/apps/sponsor-service/package.json
new file mode 100644
index 0000000..ad204c2
--- /dev/null
+++ b/apps/sponsor-service/package.json
@@ -0,0 +1,42 @@
+{
+  "name": "@midnight-sentinel/sponsor-service",
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf dist .turbo node_modules",
+    "build": "tsc --project tsconfig.build.json",
+    "check": "tsc --project tsconfig.build.json --noEmit",
+    "dev": "tsx src/index.ts",
+    "operator:bootstrap": "tsx src/operator-bootstrap.ts",
+    "setup:devnet": "pnpm --dir ../../packages/contract build && pnpm --dir ../../packages/protocol-verification build:sponsor-fixtures && pnpm --dir ../../packages/api build && tsx src/setup-devnet.ts",
+    "start": "node dist/index.js",
+    "test": "tsx --test test/*.test.ts",
+    "test:e2e:devnet": "pnpm --dir ../../packages/contract build && pnpm --dir ../../packages/protocol-verification build:sponsor-fixtures && pnpm --dir ../../packages/api build && tsx src/verification/devnet-e2e.ts",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@midnight-ntwrk/ledger-v8": "8.0.3",
+    "@midnight-ntwrk/midnight-js-contracts": "4.1.1",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0-rc.0",
+    "@midnight-sentinel/api": "workspace:*",
+    "@midnight-sentinel/contract": "workspace:*",
+    "@midnight-sentinel/wallet": "workspace:*",
+    "fastify": "^5.6.2",
+    "graphql-ws": "^6.0.6",
+    "rxjs": "^7.8.2",
+    "ws": "^8.18.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@midnight-sentinel/protocol-verification": "workspace:*",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "engineStrict": true
+}
diff --git a/apps/sponsor-service/src/config.ts b/apps/sponsor-service/src/config.ts
new file mode 100644
index 0000000..d683658
--- /dev/null
+++ b/apps/sponsor-service/src/config.ts
@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import path from 'node:path';
+
+const schema = z.object({
+  SERVICE_HOST: z.string().default('127.0.0.1'),
+  SERVICE_PORT: z.coerce.number().int().min(1).max(65_535).default(8089),
+  SERVICE_DB_PATH: z.string().default('./sponsor-service.sqlite'),
+  SERVICE_ADMIN_TOKEN: z.string().min(24),
+  SERVICE_OPERATOR_SEED: z.string().regex(/^[0-9a-fA-F]{64}$/),
+  SERVICE_OPERATOR_SECRET: z.string().regex(/^[0-9a-fA-F]{64}$/),
+  SERVICE_PRIVATE_STATE_STORE: z.string().min(1).default('eligibility-operator'),
+  SERVICE_REVALIDATE_MS: z.coerce.number().int().min(1_000).default(15_000),
+  SERVICE_LOG_DIR: z.string().default('./logs/sponsor-service'),
+  SERVICE_ZK_CONFIG_PATH: z.string().default('../../packages/contract/dist/managed/sentinel'),
+  MIDNIGHT_NETWORK: z.string().default('undeployed'),
+  MIDNIGHT_INDEXER_HTTP: z.string().url().default('http://127.0.0.1:8088/api/v4/graphql'),
+  MIDNIGHT_INDEXER_WS: z.string().url().default('ws://127.0.0.1:8088/api/v4/graphql/ws'),
+  MIDNIGHT_NODE: z.string().url().default('http://127.0.0.1:9944'),
+  MIDNIGHT_PROOF_SERVER: z.string().url().default('http://127.0.0.1:6300'),
+  SENTINEL_ADDRESS: z.string().regex(/^[0-9a-fA-F]{64}$/),
+  SPONSOR_DUST_ADDRESS: z.string().min(1),
+  EXPECTED_OPERATOR_AUTHORITY: z.string().regex(/^(0x)?[0-9a-fA-F]{64}$/),
+});
+
+export type ServiceConfig = ReturnType<typeof loadConfig>;
+
+export const loadConfig = (environment: NodeJS.ProcessEnv = process.env) => {
+  const value = schema.parse(environment);
+  return {
+    host: value.SERVICE_HOST,
+    port: value.SERVICE_PORT,
+    dbPath: value.SERVICE_DB_PATH,
+    adminToken: value.SERVICE_ADMIN_TOKEN,
+    operatorSeed: value.SERVICE_OPERATOR_SEED.toLowerCase(),
+    operatorSecret: value.SERVICE_OPERATOR_SECRET.toLowerCase(),
+    privateStateStoreName: value.SERVICE_PRIVATE_STATE_STORE,
+    revalidateMs: value.SERVICE_REVALIDATE_MS,
+    logDir: path.resolve(value.SERVICE_LOG_DIR),
+    zkConfigPath: path.resolve(value.SERVICE_ZK_CONFIG_PATH),
+    network: value.MIDNIGHT_NETWORK,
+    networkId: value.MIDNIGHT_NETWORK,
+    indexer: value.MIDNIGHT_INDEXER_HTTP,
+    indexerWS: value.MIDNIGHT_INDEXER_WS,
+    node: value.MIDNIGHT_NODE,
+    proofServer: value.MIDNIGHT_PROOF_SERVER,
+    sentinelAddress: value.SENTINEL_ADDRESS.toLowerCase(),
+    sponsorDustAddress: value.SPONSOR_DUST_ADDRESS,
+    expectedOperatorAuthority: value.EXPECTED_OPERATOR_AUTHORITY.replace(/^0x/, '').toLowerCase(),
+  };
+};
diff --git a/apps/sponsor-service/src/database.ts b/apps/sponsor-service/src/database.ts
new file mode 100644
index 0000000..4d8d00a
--- /dev/null
+++ b/apps/sponsor-service/src/database.ts
@@ -0,0 +1,372 @@
+import { DatabaseSync } from 'node:sqlite';
+import type {
+  DustGenerationStatus,
+  SignedEnrollment,
+} from '@midnight-sentinel/api/sponsorship/eligibility';
+
+export type JobStatus = 'pending' | 'scanning' | 'submitting' | 'active' | 'ineligible' | 'failed';
+
+export interface StoredEnrollment {
+  identity: string;
+  address: string;
+  verificationKey: string;
+  payload: SignedEnrollment;
+  nonce: bigint;
+  status: JobStatus | 'unknown';
+}
+
+export interface StoredJob {
+  id: string;
+  identity: string;
+  status: JobStatus;
+  errorCode?: string;
+  errorMessage?: string;
+}
+
+type SqlRow = Record<string, string | number | bigint | null>;
+
+export class EligibilityDatabase {
+  readonly sqlite: DatabaseSync;
+
+  constructor(path: string) {
+    this.sqlite = new DatabaseSync(path);
+    this.sqlite.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON;');
+    this.migrate();
+  }
+
+  private migrate() {
+    const version = (
+      this.sqlite.prepare('PRAGMA user_version').get() as {
+        user_version: number;
+      }
+    ).user_version;
+    if (version > 1) {
+      throw new Error(`Unsupported eligibility database version ${version}`);
+    }
+    if (version === 1) return;
+    this.sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS enrollments (
+        identity TEXT PRIMARY KEY,
+        address TEXT NOT NULL UNIQUE,
+        verification_key TEXT NOT NULL,
+        signed_enrollment TEXT NOT NULL,
+        highest_nonce TEXT NOT NULL,
+        status TEXT NOT NULL,
+        reason TEXT,
+        night_balance TEXT NOT NULL DEFAULT '0',
+        finalized_block TEXT NOT NULL DEFAULT '0',
+        synchronized INTEGER NOT NULL DEFAULT 0,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS jobs (
+        id TEXT PRIMARY KEY,
+        identity TEXT NOT NULL,
+        status TEXT NOT NULL,
+        error_code TEXT,
+        error_message TEXT,
+        attempts INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        FOREIGN KEY(identity) REFERENCES enrollments(identity)
+      );
+      CREATE TABLE IF NOT EXISTS utxos (
+        address TEXT NOT NULL,
+        utxo_key TEXT NOT NULL,
+        token_type TEXT NOT NULL,
+        value TEXT NOT NULL,
+        registered INTEGER NOT NULL,
+        dust_key TEXT,
+        PRIMARY KEY(address, utxo_key)
+      );
+      CREATE TABLE IF NOT EXISTS cursors (
+        address TEXT PRIMARY KEY,
+        transaction_id INTEGER NOT NULL,
+        finalized_block TEXT NOT NULL,
+        synchronized INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+      PRAGMA user_version = 1;
+    `);
+  }
+
+  close() {
+    this.sqlite.close();
+  }
+
+  transaction<T>(action: () => T): T {
+    this.sqlite.exec('BEGIN IMMEDIATE');
+    try {
+      const result = action();
+      this.sqlite.exec('COMMIT');
+      return result;
+    } catch (error) {
+      this.sqlite.exec('ROLLBACK');
+      throw error;
+    }
+  }
+
+  putEnrollment(identity: string, enrollment: SignedEnrollment, nonce: bigint) {
+    const current = this.getEnrollment(identity);
+    if (current && nonce <= current.nonce) {
+      throw new Error('ENROLLMENT_REPLAYED');
+    }
+    const now = new Date().toISOString();
+    this.sqlite
+      .prepare(
+        `INSERT INTO enrollments (
+          identity, address, verification_key, signed_enrollment, highest_nonce,
+          status, updated_at
+        ) VALUES (?, ?, ?, ?, ?, 'pending', ?)
+        ON CONFLICT(identity) DO UPDATE SET
+          address = excluded.address,
+          verification_key = excluded.verification_key,
+          signed_enrollment = excluded.signed_enrollment,
+          highest_nonce = excluded.highest_nonce,
+          status = 'pending',
+          reason = NULL,
+          synchronized = 0,
+          updated_at = excluded.updated_at`
+      )
+      .run(
+        identity,
+        enrollment.payload.nightRewardAddress,
+        enrollment.payload.nightVerificationKey,
+        JSON.stringify(enrollment),
+        nonce.toString(),
+        now
+      );
+  }
+
+  getEnrollment(identity: string): StoredEnrollment | undefined {
+    const row = this.sqlite
+      .prepare('SELECT * FROM enrollments WHERE identity = ?')
+      .get(identity) as SqlRow | undefined;
+    return row ? this.mapEnrollment(row) : undefined;
+  }
+
+  getEnrollmentByAddress(address: string): StoredEnrollment | undefined {
+    const row = this.sqlite.prepare('SELECT * FROM enrollments WHERE address = ?').get(address) as
+      | SqlRow
+      | undefined;
+    return row ? this.mapEnrollment(row) : undefined;
+  }
+
+  listEnrollments(): StoredEnrollment[] {
+    return (this.sqlite.prepare('SELECT * FROM enrollments').all() as SqlRow[]).map((row) =>
+      this.mapEnrollment(row)
+    );
+  }
+
+  private mapEnrollment(row: SqlRow): StoredEnrollment {
+    return {
+      identity: String(row.identity),
+      address: String(row.address),
+      verificationKey: String(row.verification_key),
+      payload: JSON.parse(String(row.signed_enrollment)) as SignedEnrollment,
+      nonce: BigInt(String(row.highest_nonce)),
+      status: String(row.status) as StoredEnrollment['status'],
+    };
+  }
+
+  createJob(id: string, identity: string) {
+    const now = new Date().toISOString();
+    this.sqlite
+      .prepare(
+        `INSERT INTO jobs (
+          id, identity, status, created_at, updated_at
+        ) VALUES (?, ?, 'pending', ?, ?)`
+      )
+      .run(id, identity, now, now);
+  }
+
+  getJob(id: string): StoredJob | undefined {
+    const row = this.sqlite.prepare('SELECT * FROM jobs WHERE id = ?').get(id) as
+      | SqlRow
+      | undefined;
+    if (!row) return undefined;
+    return {
+      id: String(row.id),
+      identity: String(row.identity),
+      status: String(row.status) as JobStatus,
+      errorCode: row.error_code ? String(row.error_code) : undefined,
+      errorMessage: row.error_message ? String(row.error_message) : undefined,
+    };
+  }
+
+  listUnfinishedJobs(): StoredJob[] {
+    return (
+      this.sqlite
+        .prepare(
+          `SELECT * FROM jobs WHERE status IN (
+            'pending', 'scanning', 'submitting'
+          ) ORDER BY created_at`
+        )
+        .all() as SqlRow[]
+    ).map((row) => ({
+      id: String(row.id),
+      identity: String(row.identity),
+      status: String(row.status) as JobStatus,
+      errorCode: row.error_code ? String(row.error_code) : undefined,
+      errorMessage: row.error_message ? String(row.error_message) : undefined,
+    }));
+  }
+
+  setJobStatus(id: string, status: JobStatus, errorCode?: string, errorMessage?: string) {
+    this.sqlite
+      .prepare(
+        `UPDATE jobs SET status = ?, error_code = ?, error_message = ?,
+          updated_at = ? WHERE id = ?`
+      )
+      .run(status, errorCode ?? null, errorMessage ?? null, new Date().toISOString(), id);
+  }
+
+  incrementJobAttempts(id: string): number {
+    this.sqlite
+      .prepare(
+        `UPDATE jobs SET attempts = attempts + 1, status = 'pending',
+          updated_at = ? WHERE id = ?`
+      )
+      .run(new Date().toISOString(), id);
+    const row = this.sqlite.prepare('SELECT attempts FROM jobs WHERE id = ?').get(id) as
+      | SqlRow
+      | undefined;
+    return Number(row?.attempts ?? 0);
+  }
+
+  setEnrollmentStatus(
+    identity: string,
+    status: StoredEnrollment['status'],
+    result?: DustGenerationStatus,
+    reason?: string
+  ) {
+    this.sqlite
+      .prepare(
+        `UPDATE enrollments SET status = ?, reason = ?, night_balance = ?,
+          finalized_block = ?, synchronized = ?, updated_at = ? WHERE identity = ?`
+      )
+      .run(
+        status,
+        reason ?? null,
+        result?.nightBalance.toString() ?? '0',
+        result?.finalizedBlock.toString() ?? '0',
+        result?.synchronized ? 1 : 0,
+        new Date().toISOString(),
+        identity
+      );
+  }
+
+  getStatus(address: string): DustGenerationStatus | undefined {
+    const row = this.sqlite
+      .prepare(
+        `SELECT address, night_balance, finalized_block, synchronized, status
+         FROM enrollments WHERE address = ?`
+      )
+      .get(address) as SqlRow | undefined;
+    if (!row) return undefined;
+    const registered = String(row.status) === 'active';
+    return {
+      nightRewardAddress: String(row.address),
+      registered,
+      nightBalance: BigInt(String(row.night_balance)),
+      finalizedBlock: BigInt(String(row.finalized_block)),
+      synchronized: Number(row.synchronized) === 1,
+    };
+  }
+
+  getCursor(address: string) {
+    const row = this.sqlite.prepare('SELECT * FROM cursors WHERE address = ?').get(address) as
+      | SqlRow
+      | undefined;
+    return row
+      ? {
+          transactionId: Number(row.transaction_id),
+          finalizedBlock: BigInt(String(row.finalized_block)),
+          synchronized: Number(row.synchronized) === 1,
+        }
+      : undefined;
+  }
+
+  setCursor(address: string, transactionId: number, finalizedBlock: bigint) {
+    this.sqlite
+      .prepare(
+        `INSERT INTO cursors (
+          address, transaction_id, finalized_block, synchronized
+        ) VALUES (?, ?, ?, 1)
+        ON CONFLICT(address) DO UPDATE SET
+          transaction_id = excluded.transaction_id,
+          finalized_block = excluded.finalized_block,
+          synchronized = 1`
+      )
+      .run(address, transactionId, finalizedBlock.toString());
+  }
+
+  markCursorUnsynchronized(address: string) {
+    this.sqlite
+      .prepare(
+        `INSERT INTO cursors (
+          address, transaction_id, finalized_block, synchronized
+        ) VALUES (?, 0, '0', 0)
+        ON CONFLICT(address) DO UPDATE SET synchronized = 0`
+      )
+      .run(address);
+  }
+
+  applyUtxoChanges(
+    address: string,
+    spentKeys: readonly string[],
+    created: readonly {
+      key: string;
+      tokenType: string;
+      value: bigint;
+      registered: boolean;
+      dustKey?: string;
+    }[]
+  ) {
+    const remove = this.sqlite.prepare('DELETE FROM utxos WHERE address = ? AND utxo_key = ?');
+    for (const key of spentKeys) remove.run(address, key);
+    const insert = this.sqlite.prepare(
+      `INSERT OR REPLACE INTO utxos (
+        address, utxo_key, token_type, value, registered, dust_key
+      ) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    for (const utxo of created) {
+      insert.run(
+        address,
+        utxo.key,
+        utxo.tokenType,
+        utxo.value.toString(),
+        utxo.registered ? 1 : 0,
+        utxo.dustKey ?? null
+      );
+    }
+  }
+
+  qualifyingBalance(address: string, tokenType: string, dustKey: string): bigint {
+    const rows = this.sqlite
+      .prepare(
+        `SELECT value FROM utxos WHERE address = ? AND token_type = ?
+          AND registered = 1 AND dust_key = ?`
+      )
+      .all(address, tokenType, dustKey) as SqlRow[];
+    return rows.reduce((total, row) => total + BigInt(String(row.value)), 0n);
+  }
+
+  getMetadata(key: string): string | undefined {
+    const row = this.sqlite.prepare('SELECT value FROM metadata WHERE key = ?').get(key) as
+      | SqlRow
+      | undefined;
+    return row ? String(row.value) : undefined;
+  }
+
+  setMetadata(key: string, value: string) {
+    this.sqlite
+      .prepare(
+        `INSERT INTO metadata (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+      )
+      .run(key, value);
+  }
+}
diff --git a/apps/sponsor-service/src/index.ts b/apps/sponsor-service/src/index.ts
new file mode 100644
index 0000000..a58e8e8
--- /dev/null
+++ b/apps/sponsor-service/src/index.ts
@@ -0,0 +1,88 @@
+import { SentinelContract } from '@midnight-sentinel/api';
+import { dustPublicKeyToBytes } from '@midnight-sentinel/api/sponsorship/midnight';
+import { createMidnightEnrollmentVerifier } from '@midnight-sentinel/api/sponsorship/eligibility';
+import {
+  createPrivateState,
+  deriveSentinelAuthority,
+  sentinelContractPrivateStateKey,
+} from '@midnight-sentinel/contract';
+import { configureProviders } from '@midnight-sentinel/contract/providers';
+import { buildWallet } from '@midnight-sentinel/wallet';
+import { DustAddress, MidnightBech32m } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { loadConfig } from './config.js';
+import { EligibilityDatabase } from './database.js';
+import { MidnightIndexerScanner } from './indexer.js';
+import { ContractQueueOperator } from './operator.js';
+import { buildServer } from './server.js';
+import { EligibilityService } from './service.js';
+import { loadServiceEnv } from './load-env.js';
+
+loadServiceEnv();
+const equalHex = (bytes: Uint8Array, expected: string) =>
+  Buffer.from(bytes).toString('hex') === expected.replace(/^0x/, '').toLowerCase();
+
+const config = loadConfig();
+const database = new EligibilityDatabase(config.dbPath);
+const wallet = await buildWallet(config, config.operatorSeed);
+const providers = await configureProviders(wallet, config, config.privateStateStoreName);
+const operatorSecret = Uint8Array.from(Buffer.from(config.operatorSecret, 'hex'));
+if (!equalHex(deriveSentinelAuthority(operatorSecret), config.expectedOperatorAuthority)) {
+  throw new Error('Configured operator secret does not derive the expected operator authority');
+}
+providers.privateStateProvider.setContractAddress(config.sentinelAddress);
+await providers.privateStateProvider.set(
+  sentinelContractPrivateStateKey,
+  createPrivateState(operatorSecret)
+);
+const contract = await SentinelContract.join(providers, config.sentinelAddress);
+const campaignState = await contract.readState();
+
+if (!equalHex(campaignState.eligibilityOperator, config.expectedOperatorAuthority)) {
+  throw new Error('Configured eligibility operator does not match the Sentinel campaign');
+}
+
+const sponsorDustKey = DustAddress.codec.decode(
+  config.network,
+  MidnightBech32m.parse(config.sponsorDustAddress)
+).data;
+if (
+  Buffer.from(campaignState.sponsorshipSponsorId).compare(
+    Buffer.from(dustPublicKeyToBytes(sponsorDustKey))
+  ) !== 0
+) {
+  throw new Error('Configured sponsor DUST address does not match the campaign');
+}
+
+const scanner = new MidnightIndexerScanner(
+  config.indexer,
+  config.indexerWS,
+  database,
+  sponsorDustKey.toString()
+);
+const service = new EligibilityService(
+  database,
+  scanner,
+  new ContractQueueOperator(contract),
+  {
+    network: config.network,
+    sentinelAddress: config.sentinelAddress,
+    sponsorDustAddress: config.sponsorDustAddress,
+    minimumRegisteredNight: campaignState.sponsorshipMinimumRegisteredNight,
+  },
+  createMidnightEnrollmentVerifier(config.network),
+  config.revalidateMs
+);
+const server = buildServer(config, service);
+
+service.start();
+await server.listen({ host: config.host, port: config.port });
+
+const shutdown = async () => {
+  await service.stop();
+  await server.close();
+  await wallet.wallet.stop();
+  database.close();
+};
+
+process.once('SIGINT', () => void shutdown());
+process.once('SIGTERM', () => void shutdown());
diff --git a/apps/sponsor-service/src/indexer.ts b/apps/sponsor-service/src/indexer.ts
new file mode 100644
index 0000000..7cb278f
--- /dev/null
+++ b/apps/sponsor-service/src/indexer.ts
@@ -0,0 +1,260 @@
+import {
+  Binding,
+  Proof,
+  SignatureEnabled,
+  Transaction,
+  unshieldedToken,
+} from '@midnight-ntwrk/ledger-v8';
+import type { DustGenerationStatus } from '@midnight-sentinel/api/sponsorship/eligibility';
+import { createClient, type Client } from 'graphql-ws';
+import WebSocket from 'ws';
+import { EligibilityDatabase } from './database.js';
+
+const normalizeHex = (value: string) => value.toLowerCase().replace(/^0x/, '');
+const utxoKey = (utxo: IndexerUtxo) => `${normalizeHex(utxo.intentHash)}:${utxo.outputIndex}`;
+
+interface IndexerUtxo {
+  tokenType: string;
+  value: string;
+  outputIndex: number;
+  intentHash: string;
+  registeredForDustGeneration: boolean;
+}
+
+interface TransactionEvent {
+  type: 'UnshieldedTransaction';
+  transaction: {
+    id: number;
+    raw: string;
+    block: { height: number };
+  };
+  createdUtxos: IndexerUtxo[];
+  spentUtxos: IndexerUtxo[];
+}
+
+interface ProgressEvent {
+  type: 'UnshieldedTransactionsProgress';
+  highestTransactionId: number;
+}
+
+type StreamEvent = TransactionEvent | ProgressEvent;
+
+const subscription = `
+  subscription SentinelUnshieldedTransactions(
+    $address: UnshieldedAddress!,
+    $transactionId: Int
+  ) {
+    unshieldedTransactions(address: $address, transactionId: $transactionId) {
+      ... on UnshieldedTransaction {
+        type: __typename
+        transaction {
+          id
+          raw
+          block { height }
+        }
+        createdUtxos {
+          tokenType
+          value
+          outputIndex
+          intentHash
+          registeredForDustGeneration
+        }
+        spentUtxos {
+          tokenType
+          value
+          outputIndex
+          intentHash
+          registeredForDustGeneration
+        }
+      }
+      ... on UnshieldedTransactionsProgress {
+        type: __typename
+        highestTransactionId
+      }
+    }
+  }
+`;
+
+const latestBlockQuery = `query SentinelLatestBlock { block { height } }`;
+
+const registrationTarget = (raw: string, verificationKey: string): string | undefined => {
+  const tx = Transaction.deserialize<SignatureEnabled, Proof, Binding>(
+    'signature',
+    'proof',
+    'binding',
+    Uint8Array.from(Buffer.from(normalizeHex(raw), 'hex'))
+  );
+  for (const intent of tx.intents?.values() ?? []) {
+    const registration = intent.dustActions?.registrations.find(
+      (value) => value.nightKey === verificationKey
+    );
+    if (registration) {
+      return registration.dustAddress?.toString();
+    }
+  }
+  return undefined;
+};
+
+export class MidnightIndexerScanner {
+  private readonly client: Client;
+
+  constructor(
+    private readonly httpUrl: string,
+    wsUrl: string,
+    private readonly database: EligibilityDatabase,
+    private readonly sponsorDustKey: string
+  ) {
+    this.client = createClient({
+      url: wsUrl,
+      webSocketImpl: WebSocket,
+      lazy: true,
+      retryAttempts: 5,
+    });
+  }
+
+  async latestFinalizedBlock(): Promise<bigint> {
+    const response = await fetch(this.httpUrl, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ query: latestBlockQuery }),
+    });
+    if (!response.ok) {
+      throw new Error(`Indexer returned HTTP ${response.status}`);
+    }
+    const payload = (await response.json()) as {
+      data?: { block?: { height: number } };
+      errors?: { message: string }[];
+    };
+    if (!payload.data?.block) {
+      throw new Error(payload.errors?.[0]?.message ?? 'Indexer returned no block');
+    }
+    return BigInt(payload.data.block.height);
+  }
+
+  async sync(input: {
+    address: string;
+    verificationKey: string;
+    sponsorDustAddress: string;
+  }): Promise<DustGenerationStatus> {
+    this.database.markCursorUnsynchronized(input.address);
+    const cursor = this.database.getCursor(input.address)?.transactionId;
+    const progress = await new Promise<number>((resolve, reject) => {
+      let settled = false;
+      let progressSeen = false;
+      let highestTransactionId = cursor ?? 0;
+      let settleTimer: NodeJS.Timeout | undefined;
+      const settleAfterBufferedEvents = (dispose: () => void) => {
+        if (settleTimer) clearTimeout(settleTimer);
+        settleTimer = setTimeout(() => {
+          settled = true;
+          dispose();
+          resolve(highestTransactionId);
+        }, 1_000);
+      };
+      const dispose = this.client.subscribe<{
+        unshieldedTransactions: StreamEvent;
+      }>(
+        {
+          query: subscription,
+          variables: {
+            address: input.address,
+            transactionId: cursor,
+          },
+        },
+        {
+          next: ({ data, errors }) => {
+            if (errors?.length) {
+              settled = true;
+              dispose();
+              reject(new Error(errors[0]?.message ?? 'Indexer subscription failed'));
+              return;
+            }
+            const event = data?.unshieldedTransactions;
+            if (!event) return;
+            if (event.type === 'UnshieldedTransactionsProgress') {
+              // The indexer may emit the progress watermark immediately before
+              // the final buffered transaction at that same watermark. Keep
+              // the subscription open until the address stream is quiet so
+              // that transaction is applied before persisting the cursor.
+              progressSeen = true;
+              highestTransactionId = Math.max(highestTransactionId, event.highestTransactionId);
+              settleAfterBufferedEvents(dispose);
+              return;
+            }
+            try {
+              this.applyTransaction(input.address, input.verificationKey, event);
+              highestTransactionId = Math.max(highestTransactionId, event.transaction.id);
+              if (progressSeen) settleAfterBufferedEvents(dispose);
+            } catch (error) {
+              settled = true;
+              if (settleTimer) clearTimeout(settleTimer);
+              dispose();
+              reject(error);
+            }
+          },
+          error: (error) => {
+            if (!settled) {
+              settled = true;
+              if (settleTimer) clearTimeout(settleTimer);
+              reject(error);
+            }
+          },
+          complete: () => {
+            if (!settled) {
+              settled = true;
+              if (settleTimer) clearTimeout(settleTimer);
+              if (progressSeen) resolve(highestTransactionId);
+              else reject(new Error('Indexer subscription completed before progress'));
+            }
+          },
+        }
+      );
+    });
+    const finalizedBlock = await this.latestFinalizedBlock();
+    this.database.setCursor(input.address, progress, finalizedBlock);
+    const nightBalance = this.database.qualifyingBalance(
+      input.address,
+      unshieldedToken().raw,
+      this.sponsorDustKey
+    );
+    return {
+      nightRewardAddress: input.address,
+      dustAddress: nightBalance > 0n ? input.sponsorDustAddress : undefined,
+      registered: nightBalance > 0n,
+      nightBalance,
+      finalizedBlock,
+      synchronized: true,
+    };
+  }
+
+  private applyTransaction(address: string, verificationKey: string, event: TransactionEvent) {
+    // Registration updates preserve the original NIGHT UTXO identity. The
+    // createdUtxo.intentHash therefore points to the funding transaction, not
+    // the registration intent. Correlate by the address-scoped transaction and
+    // its matching NIGHT verification key instead of joining intent hashes.
+    const dustKey = registrationTarget(event.transaction.raw, verificationKey);
+    this.database.transaction(() => {
+      this.database.applyUtxoChanges(
+        address,
+        event.spentUtxos.map(utxoKey),
+        event.createdUtxos.map((utxo) => ({
+          key: utxoKey(utxo),
+          tokenType: normalizeHex(utxo.tokenType),
+          value: BigInt(utxo.value),
+          registered: utxo.registeredForDustGeneration,
+          dustKey: utxo.registeredForDustGeneration ? dustKey : undefined,
+        }))
+      );
+    });
+  }
+
+  async dispose() {
+    await Promise.resolve(this.client.dispose()).catch(() => undefined);
+  }
+}
+
+export const decodeDustAddressKey = async (network: string, address: string): Promise<string> => {
+  const { DustAddress, MidnightBech32m } =
+    await import('@midnight-ntwrk/wallet-sdk-address-format');
+  return DustAddress.codec.decode(network, MidnightBech32m.parse(address)).data.toString();
+};
diff --git a/apps/sponsor-service/src/load-env.ts b/apps/sponsor-service/src/load-env.ts
new file mode 100644
index 0000000..ab01636
--- /dev/null
+++ b/apps/sponsor-service/src/load-env.ts
@@ -0,0 +1,9 @@
+import { loadEnvFile } from 'node:process';
+
+export const loadServiceEnv = () => {
+  try {
+    loadEnvFile(new URL('../.env', import.meta.url));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+};
diff --git a/apps/sponsor-service/src/operator-bootstrap.ts b/apps/sponsor-service/src/operator-bootstrap.ts
new file mode 100644
index 0000000..34e9143
--- /dev/null
+++ b/apps/sponsor-service/src/operator-bootstrap.ts
@@ -0,0 +1,19 @@
+import { randomBytes } from 'node:crypto';
+import { deriveSentinelAuthority } from '@midnight-sentinel/contract';
+
+const supplied = process.argv
+  .find((argument) => argument.startsWith('--secret='))
+  ?.slice('--secret='.length);
+if (supplied && !/^[0-9a-fA-F]{64}$/.test(supplied)) {
+  throw new Error('--secret must contain exactly 32 bytes of hexadecimal');
+}
+const secret = supplied
+  ? Uint8Array.from(Buffer.from(supplied, 'hex'))
+  : Uint8Array.from(randomBytes(32));
+
+console.log(
+  JSON.stringify({
+    operatorSecret: Buffer.from(secret).toString('hex'),
+    operatorAuthority: Buffer.from(deriveSentinelAuthority(secret)).toString('hex'),
+  })
+);
diff --git a/apps/sponsor-service/src/operator.ts b/apps/sponsor-service/src/operator.ts
new file mode 100644
index 0000000..5ca226e
--- /dev/null
+++ b/apps/sponsor-service/src/operator.ts
@@ -0,0 +1,25 @@
+import type { EligibilityQueueOperator } from '@midnight-sentinel/api/sponsorship/eligibility';
+import type { SentinelContract } from '@midnight-sentinel/api';
+
+export class ContractQueueOperator implements EligibilityQueueOperator {
+  constructor(private readonly contract: SentinelContract) {}
+
+  async lookup(identity: Uint8Array) {
+    const state = await this.contract.readState();
+    if (!state.delegatorPositions.member(identity)) return undefined;
+    const slot = state.delegatorSlots.lookup(state.delegatorPositions.lookup(identity));
+    return { enrollmentNonce: slot.enrollmentNonce };
+  }
+
+  add(input: Parameters<SentinelContract['addDelegator']>[0]) {
+    return this.contract.addDelegator(input);
+  }
+
+  update(input: Parameters<SentinelContract['updateDelegator']>[0]) {
+    return this.contract.updateDelegator(input);
+  }
+
+  remove(identity: Uint8Array) {
+    return this.contract.removeDelegator(identity);
+  }
+}
diff --git a/apps/sponsor-service/src/server.ts b/apps/sponsor-service/src/server.ts
new file mode 100644
index 0000000..0fa576c
--- /dev/null
+++ b/apps/sponsor-service/src/server.ts
@@ -0,0 +1,117 @@
+import { timingSafeEqual } from 'node:crypto';
+import type { SignedEnrollment } from '@midnight-sentinel/api/sponsorship/eligibility';
+import Fastify from 'fastify';
+import { z } from 'zod';
+import type { ServiceConfig } from './config.js';
+import type { EligibilityService } from './service.js';
+
+const enrollmentSchema = z.object({
+  payload: z.object({
+    version: z.literal(1),
+    network: z.string(),
+    sentinelAddress: z.string(),
+    sponsorDustAddress: z.string(),
+    nightRewardAddress: z.string(),
+    nightVerificationKey: z.string(),
+    shieldedCoinPublicKey: z.string(),
+    shieldedEncryptionPublicKey: z.string(),
+    nonce: z.string(),
+    expiresAt: z.string(),
+  }),
+  signature: z.string(),
+});
+
+const authorized = (provided: string | undefined, expected: string) => {
+  const prefix = 'Bearer ';
+  if (!provided?.startsWith(prefix)) return false;
+  const actual = Buffer.from(provided.slice(prefix.length));
+  const wanted = Buffer.from(expected);
+  return actual.length === wanted.length && timingSafeEqual(actual, wanted);
+};
+
+export const buildServer = (config: ServiceConfig, service: EligibilityService) => {
+  const app = Fastify({
+    logger: true,
+    bodyLimit: 64 * 1024,
+  });
+  const rate = new Map<string, { count: number; reset: number }>();
+
+  app.get('/healthz', async () => ({ ok: true }));
+  app.get('/readyz', async (_request, reply) => {
+    try {
+      await service.database.sqlite.prepare('SELECT 1').get();
+      return { ready: true };
+    } catch {
+      return reply.code(503).send({ ready: false });
+    }
+  });
+
+  app.post('/v1/enrollments', async (request, reply) => {
+    const key = request.ip;
+    const now = Date.now();
+    const window = rate.get(key);
+    const current = !window || window.reset <= now ? { count: 0, reset: now + 60_000 } : window;
+    current.count += 1;
+    rate.set(key, current);
+    if (current.count > 10) {
+      return reply.code(429).send({ code: 'RATE_LIMITED' });
+    }
+    try {
+      const enrollment = enrollmentSchema.parse(request.body) as SignedEnrollment;
+      const submitted = service.submit(enrollment);
+      return reply.code(202).send({
+        ...submitted,
+        statusUrl: `/v1/jobs/${submitted.jobId}`,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = message.includes('REPLAYED') ? 'ENROLLMENT_REPLAYED' : 'ENROLLMENT_INVALID';
+      return reply.code(400).send({ code, message });
+    }
+  });
+
+  app.get<{ Params: { jobId: string } }>('/v1/jobs/:jobId', async (request, reply) => {
+    const job = service.getJob(request.params.jobId);
+    return job ?? reply.code(404).send({ code: 'JOB_NOT_FOUND' });
+  });
+
+  app.get<{ Params: { address: string } }>('/v1/eligibility/:address', async (request, reply) => {
+    const status = service.getStatus(request.params.address);
+    if (!status) {
+      return reply.code(404).send({ code: 'ENROLLMENT_NOT_FOUND' });
+    }
+    return {
+      ...status,
+      nightBalance: status.nightBalance.toString(),
+      finalizedBlock: status.finalizedBlock.toString(),
+    };
+  });
+
+  app.post<{ Body: { identity?: string } }>('/v1/admin/revalidate', async (request, reply) => {
+    if (!authorized(request.headers.authorization, config.adminToken)) {
+      return reply.code(401).send({ code: 'UNAUTHORIZED' });
+    }
+    const identity = request.body?.identity;
+    if (identity && !/^[0-9a-fA-F]{64}$/.test(identity)) {
+      return reply.code(400).send({ code: 'INVALID_IDENTITY' });
+    }
+    void service.revalidate(identity?.toLowerCase());
+    return reply.code(202).send({ accepted: true });
+  });
+
+  app.delete<{ Params: { identity: string } }>(
+    '/v1/admin/delegators/:identity',
+    async (request, reply) => {
+      if (!authorized(request.headers.authorization, config.adminToken)) {
+        return reply.code(401).send({ code: 'UNAUTHORIZED' });
+      }
+      if (!/^[0-9a-fA-F]{64}$/.test(request.params.identity)) {
+        return reply.code(400).send({ code: 'INVALID_IDENTITY' });
+      }
+      await service.remove(request.params.identity.toLowerCase());
+      return reply.code(204).send();
+    }
+  );
+
+  return app;
+};
diff --git a/apps/sponsor-service/src/service.ts b/apps/sponsor-service/src/service.ts
new file mode 100644
index 0000000..096fe44
--- /dev/null
+++ b/apps/sponsor-service/src/service.ts
@@ -0,0 +1,256 @@
+import { randomUUID } from 'node:crypto';
+import {
+  assertEligible,
+  EligibilityError,
+  enrollDelegator,
+  verifyEnrollment,
+  type EligibilityCampaign,
+  type EnrollmentSignatureVerifier,
+  type SignedEnrollment,
+} from '@midnight-sentinel/api/sponsorship/eligibility';
+import { EligibilityDatabase } from './database.js';
+import { MidnightIndexerScanner } from './indexer.js';
+import { ContractQueueOperator } from './operator.js';
+
+const identityHex = (value: Uint8Array) => Buffer.from(value).toString('hex');
+const identityBytes = (value: string) =>
+  Uint8Array.from(Buffer.from(value.replace(/^0x/, ''), 'hex'));
+
+export class EligibilityService {
+  private mutationTail: Promise<void> = Promise.resolve();
+  private timer?: NodeJS.Timeout;
+  private readonly background = new Set<Promise<void>>();
+  private readonly retryTimers = new Set<NodeJS.Timeout>();
+  private revalidationInFlight = false;
+  private running = false;
+
+  constructor(
+    readonly database: EligibilityDatabase,
+    private readonly scanner: MidnightIndexerScanner,
+    private readonly operator: ContractQueueOperator,
+    private readonly campaign: EligibilityCampaign,
+    private readonly verifier: EnrollmentSignatureVerifier,
+    private readonly revalidateMs: number
+  ) {}
+
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.timer = setInterval(() => {
+      this.runBackground(this.revalidateIfBlockAdvanced());
+    }, this.revalidateMs);
+    this.timer.unref();
+    for (const job of this.database.listUnfinishedJobs()) {
+      this.serialize(async () => this.process(job.id, job.identity));
+    }
+    this.runBackground(this.revalidateIfBlockAdvanced());
+  }
+
+  async stop() {
+    this.running = false;
+    if (this.timer) clearInterval(this.timer);
+    for (const retry of this.retryTimers) clearTimeout(retry);
+    this.retryTimers.clear();
+    await Promise.allSettled([...this.background]);
+    await this.mutationTail.catch(() => undefined);
+    await this.scanner.dispose();
+  }
+
+  submit(enrollment: SignedEnrollment) {
+    const verified = this.verify(enrollment);
+    const identity = identityHex(verified.identity);
+    const jobId = randomUUID();
+    this.database.transaction(() => {
+      this.database.putEnrollment(identity, enrollment, verified.nonce);
+      this.database.createJob(jobId, identity);
+    });
+    this.serialize(async () => this.process(jobId, identity));
+    return { jobId, identity };
+  }
+
+  getJob(id: string) {
+    return this.database.getJob(id);
+  }
+
+  getStatus(address: string) {
+    const status = this.database.getStatus(address);
+    return status && status.registered
+      ? { ...status, dustAddress: this.campaign.sponsorDustAddress }
+      : status;
+  }
+
+  private verify(enrollment: SignedEnrollment) {
+    // Use the shared canonical verifier without duplicating its rules.
+    return verifyEnrollment(enrollment, this.campaign, this.verifier);
+  }
+
+  private serialize(action: () => Promise<void>) {
+    this.mutationTail = this.mutationTail.then(action, action);
+    return this.mutationTail;
+  }
+
+  private async process(jobId: string, identity: string) {
+    const enrollment = this.database.getEnrollment(identity);
+    if (!enrollment) return;
+    try {
+      this.database.setJobStatus(jobId, 'scanning');
+      const status = await this.scanner.sync({
+        address: enrollment.address,
+        verificationKey: enrollment.verificationKey,
+        sponsorDustAddress: this.campaign.sponsorDustAddress,
+      });
+      assertEligible(
+        status,
+        this.campaign.sponsorDustAddress,
+        this.campaign.minimumRegisteredNight
+      );
+      this.database.setJobStatus(jobId, 'submitting');
+      const current = await this.operator.lookup(identityBytes(identity));
+      if (current?.enrollmentNonce !== enrollment.nonce) {
+        await enrollDelegator({
+          enrollment: enrollment.payload,
+          campaign: this.campaign,
+          verifier: this.verifier,
+          registrationProvider: { getStatus: async () => status },
+          verificationBlock: status.finalizedBlock,
+          operator: this.operator,
+        });
+      }
+      this.database.setEnrollmentStatus(identity, 'active', status);
+      this.database.setJobStatus(jobId, 'active');
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = errorCode(error);
+      if (code === 'DELEGATOR_STALE') {
+        await this.removeIfPresent(identity);
+        this.database.setEnrollmentStatus(identity, 'ineligible', undefined, message);
+        this.database.setJobStatus(jobId, 'ineligible', code, message);
+      } else {
+        this.database.setEnrollmentStatus(identity, 'unknown', undefined, message);
+        const attempts = this.database.incrementJobAttempts(jobId);
+        if (attempts >= 5) {
+          this.database.setJobStatus(jobId, 'failed', code, message);
+        } else {
+          const retryMs = Math.min(2 ** (attempts - 1) * 1_000, 30_000);
+          const retry = setTimeout(() => {
+            this.retryTimers.delete(retry);
+            if (this.running) this.serialize(async () => this.process(jobId, identity));
+          }, retryMs);
+          this.retryTimers.add(retry);
+          retry.unref();
+        }
+      }
+    }
+  }
+
+  async revalidate(identity?: string) {
+    return this.serialize(async () => {
+      const enrollments = identity
+        ? [this.database.getEnrollment(identity)].filter((value) => value !== undefined)
+        : this.database
+            .listEnrollments()
+            .filter((value) => value.status === 'active' || value.status === 'unknown');
+      for (const enrollment of enrollments) {
+        try {
+          const status = await this.scanner.sync({
+            address: enrollment.address,
+            verificationKey: enrollment.verificationKey,
+            sponsorDustAddress: this.campaign.sponsorDustAddress,
+          });
+          assertEligible(
+            status,
+            this.campaign.sponsorDustAddress,
+            this.campaign.minimumRegisteredNight
+          );
+          const queued = await this.operator.lookup(identityBytes(enrollment.identity));
+          if (queued?.enrollmentNonce === enrollment.nonce) {
+            this.database.setEnrollmentStatus(enrollment.identity, 'active', status);
+          } else {
+            this.database.setEnrollmentStatus(
+              enrollment.identity,
+              'unknown',
+              status,
+              'QUEUE_ENTRY_NOT_CONFIRMED'
+            );
+          }
+        } catch (error) {
+          const code = errorCode(error);
+          if (code !== 'DELEGATOR_STALE') {
+            this.database.setEnrollmentStatus(
+              enrollment.identity,
+              'unknown',
+              undefined,
+              error instanceof Error ? error.message : String(error)
+            );
+            continue;
+          }
+          await this.removeIfPresent(enrollment.identity);
+          this.database.setEnrollmentStatus(
+            enrollment.identity,
+            'ineligible',
+            undefined,
+            error instanceof Error ? error.message : String(error)
+          );
+        }
+      }
+    });
+  }
+
+  async remove(identity: string) {
+    return this.serialize(async () => {
+      await this.removeIfPresent(identity);
+      this.database.setEnrollmentStatus(identity, 'ineligible', undefined, 'REMOVED');
+    });
+  }
+
+  private async removeIfPresent(identity: string) {
+    if (await this.operator.lookup(identityBytes(identity))) {
+      await this.operator.remove(identityBytes(identity));
+    }
+  }
+
+  private async revalidateIfBlockAdvanced() {
+    if (this.revalidationInFlight) return;
+    this.revalidationInFlight = true;
+    try {
+      if (!this.running) return;
+      const height = await this.scanner.latestFinalizedBlock();
+      if (!this.running) return;
+      const previous = BigInt(this.database.getMetadata('last_revalidated_block') ?? '-1');
+      if (height <= previous) return;
+      await this.revalidate();
+      this.database.setMetadata('last_revalidated_block', height.toString());
+    } catch {
+      // Unknown indexer state must fail sponsorship closed but must never be
+      // interpreted as finalized proof that a delegator became invalid.
+      for (const enrollment of this.database
+        .listEnrollments()
+        .filter((value) => value.status === 'active' || value.status === 'unknown')) {
+        this.database.setEnrollmentStatus(
+          enrollment.identity,
+          'unknown',
+          undefined,
+          'ELIGIBILITY_QUERY_FAILED'
+        );
+      }
+    } finally {
+      this.revalidationInFlight = false;
+    }
+  }
+
+  private runBackground(action: Promise<void>) {
+    this.background.add(action);
+    void action.finally(() => this.background.delete(action));
+  }
+}
+
+const errorCode = (error: unknown) =>
+  error instanceof EligibilityError
+    ? error.code
+    : error instanceof Error && error.message === 'ENROLLMENT_REPLAYED'
+      ? 'ENROLLMENT_REPLAYED'
+      : error instanceof Error &&
+          (error.message.includes('submitting scoped transaction') ||
+            error.message.includes('Proof Server'))
+        ? 'OPERATOR_SUBMISSION_FAILED'
+        : 'ELIGIBILITY_QUERY_FAILED';
diff --git a/apps/sponsor-service/src/setup-devnet-config.ts b/apps/sponsor-service/src/setup-devnet-config.ts
new file mode 100644
index 0000000..249a03a
--- /dev/null
+++ b/apps/sponsor-service/src/setup-devnet-config.ts
@@ -0,0 +1,33 @@
+export interface DevnetEnvironment {
+  adminToken: string;
+  operatorSeed: string;
+  operatorSecret: string;
+  operatorAuthority: string;
+  sentinelAddress: string;
+  sponsorDustAddress: string;
+}
+
+export const renderDevnetEnvironment = (value: DevnetEnvironment): string =>
+  [
+    '# Generated by pnpm --filter @midnight-sentinel/sponsor-service setup:devnet',
+    '# Local devnet only. Do not reuse these credentials on another network.',
+    'SERVICE_HOST=127.0.0.1',
+    'SERVICE_PORT=8089',
+    'SERVICE_DB_PATH=./sponsor-service.sqlite',
+    `SERVICE_ADMIN_TOKEN=${value.adminToken}`,
+    `SERVICE_OPERATOR_SEED=${value.operatorSeed}`,
+    `SERVICE_OPERATOR_SECRET=${value.operatorSecret}`,
+    `SERVICE_PRIVATE_STATE_STORE=eligibility-operator-${value.sentinelAddress.slice(0, 12)}`,
+    'SERVICE_REVALIDATE_MS=15000',
+    'SERVICE_LOG_DIR=./logs/sponsor-service',
+    'SERVICE_ZK_CONFIG_PATH=../../packages/contract/dist/managed/sentinel',
+    'MIDNIGHT_NETWORK=undeployed',
+    'MIDNIGHT_INDEXER_HTTP=http://127.0.0.1:8088/api/v4/graphql',
+    'MIDNIGHT_INDEXER_WS=ws://127.0.0.1:8088/api/v4/graphql/ws',
+    'MIDNIGHT_NODE=http://127.0.0.1:9944',
+    'MIDNIGHT_PROOF_SERVER=http://127.0.0.1:6300',
+    `SENTINEL_ADDRESS=${value.sentinelAddress}`,
+    `SPONSOR_DUST_ADDRESS=${value.sponsorDustAddress}`,
+    `EXPECTED_OPERATOR_AUTHORITY=${value.operatorAuthority}`,
+    '',
+  ].join('\n');
diff --git a/apps/sponsor-service/src/setup-devnet.ts b/apps/sponsor-service/src/setup-devnet.ts
new file mode 100644
index 0000000..32518d0
--- /dev/null
+++ b/apps/sponsor-service/src/setup-devnet.ts
@@ -0,0 +1,158 @@
+import { randomBytes } from 'node:crypto';
+import { access, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { deployContract } from '@midnight-ntwrk/midnight-js-contracts';
+import { SentinelContract } from '@midnight-sentinel/api';
+import { nativeNightSponsorshipConfig } from '@midnight-sentinel/api/sponsorship/midnight';
+import { sponsorshipAllowlistHash } from '@midnight-sentinel/api/sponsorship';
+import { deriveSentinelAuthority } from '@midnight-sentinel/contract';
+import { configureProviders } from '@midnight-sentinel/contract/providers';
+import {
+  CompositeTargetCompiledContract,
+  type CompositeTargetContractType,
+} from '@midnight-sentinel/protocol-verification/composite-sponsorship';
+import {
+  buildWallet,
+  getBalancesAndAddresses,
+  type WalletContext,
+} from '@midnight-sentinel/wallet';
+import { renderDevnetEnvironment } from './setup-devnet-config.js';
+
+const GENESIS_DEPLOYER_SEED = `${'0'.repeat(63)}1`;
+const GENESIS_OPERATOR_SEED = `${'0'.repeat(63)}2`;
+const GENESIS_SPONSOR_SEED = `${'0'.repeat(63)}3`;
+
+const packageDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const repositoryDirectory = path.resolve(packageDirectory, '../..');
+const sentinelZkPath = path.join(repositoryDirectory, 'packages/contract/dist/managed/sentinel');
+const targetZkPath = path.join(
+  repositoryDirectory,
+  'packages/protocol-verification/dist/managed/composite-target'
+);
+const envPath = path.join(packageDirectory, '.env');
+const replaceEnvironment = process.argv.includes('--force');
+
+const network = {
+  networkId: 'undeployed',
+  indexer: 'http://127.0.0.1:8088/api/v4/graphql',
+  indexerWS: 'ws://127.0.0.1:8088/api/v4/graphql/ws',
+  node: 'http://127.0.0.1:9944',
+  proofServer: 'http://127.0.0.1:6300',
+  privateStateStoreName: 'setup',
+  logDir: path.join(packageDirectory, 'logs/setup'),
+  zkConfigPath: sentinelZkPath,
+  eligibilityService: 'http://127.0.0.1:8089',
+};
+
+const requireArtifacts = async () => {
+  try {
+    await Promise.all([
+      access(path.join(sentinelZkPath, 'keys/purchaseSponsorship.prover')),
+      access(path.join(targetZkPath, 'keys/interact.prover')),
+    ]);
+  } catch {
+    throw new Error(
+      'Full-ZK artifacts are missing. Build the Sentinel and composite target before setup.'
+    );
+  }
+};
+
+const requireWritableEnvironment = async () => {
+  if (replaceEnvironment) return;
+  try {
+    await access(envPath);
+  } catch {
+    return;
+  }
+  throw new Error(`Refusing to replace ${envPath}. Re-run with --force to replace it.`);
+};
+
+const hex = (value: Uint8Array) => Buffer.from(value).toString('hex');
+
+const stopWallets = async (wallets: WalletContext[]) => {
+  await Promise.allSettled(wallets.map(({ wallet }) => wallet.stop()));
+};
+
+const main = async () => {
+  await requireArtifacts();
+  await requireWritableEnvironment();
+  const wallets: WalletContext[] = [];
+  try {
+    console.log('Connecting funded local-devnet wallets...');
+    const [deployer, sponsor] = await Promise.all([
+      buildWallet(network, GENESIS_DEPLOYER_SEED),
+      buildWallet(network, GENESIS_SPONSOR_SEED),
+    ]);
+    wallets.push(deployer, sponsor);
+
+    console.log('Deploying sponsorship target...');
+    const targetProviders = await configureProviders<CompositeTargetContractType>(
+      deployer,
+      network,
+      `setup-target-${Date.now()}`,
+      targetZkPath
+    );
+    const target = await deployContract<CompositeTargetContractType>(targetProviders, {
+      compiledContract: CompositeTargetCompiledContract,
+    });
+    const targetAddress = target.deployTxData.public.contractAddress;
+    const targetEntryPoint = 'interact';
+
+    const operatorSecret = Uint8Array.from(randomBytes(32));
+    const operatorAuthority = deriveSentinelAuthority(operatorSecret);
+    const policyHash = sponsorshipAllowlistHash([
+      { address: targetAddress, entryPoint: targetEntryPoint },
+    ]);
+
+    console.log('Deploying Sentinel campaign...');
+    const sentinelProviders = await configureProviders(
+      deployer,
+      network,
+      `setup-sentinel-${Date.now()}`,
+      sentinelZkPath
+    );
+    const sentinel = await SentinelContract.deploy(
+      sentinelProviders,
+      nativeNightSponsorshipConfig(sponsor, policyHash, {
+        sponsorShare: 1n,
+        delegatorShare: 1n,
+        minimumRegisteredNight: 1n,
+        initialEligibilityOperator: operatorAuthority,
+      })
+    );
+    const sentinelAddress = sentinel.deployedContract!.deployTxData.public.contractAddress;
+    const { addresses } = await getBalancesAndAddresses(sponsor.wallet, GENESIS_SPONSOR_SEED);
+
+    await writeFile(
+      envPath,
+      renderDevnetEnvironment({
+        adminToken: randomBytes(32).toString('hex'),
+        operatorSeed: GENESIS_OPERATOR_SEED,
+        operatorSecret: hex(operatorSecret),
+        operatorAuthority: hex(operatorAuthority),
+        sentinelAddress,
+        sponsorDustAddress: addresses.dust,
+      }),
+      { mode: 0o600 }
+    );
+
+    console.log(
+      JSON.stringify({
+        setup: 'confirmed',
+        envFile: envPath,
+        sentinelAddress,
+        sponsorDustAddress: addresses.dust,
+        target: { address: targetAddress, entryPoint: targetEntryPoint },
+        fixedPrice: '2',
+        sponsorShare: '1',
+        delegatorShare: '1',
+        next: 'pnpm --filter @midnight-sentinel/sponsor-service dev',
+      })
+    );
+  } finally {
+    await stopWallets(wallets);
+  }
+};
+
+await main();
diff --git a/apps/sponsor-service/src/verification/devnet-e2e.ts b/apps/sponsor-service/src/verification/devnet-e2e.ts
new file mode 100644
index 0000000..c8419a4
--- /dev/null
+++ b/apps/sponsor-service/src/verification/devnet-e2e.ts
@@ -0,0 +1,945 @@
+import assert from 'node:assert/strict';
+import { randomBytes } from 'node:crypto';
+import { access, mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ContractCall, PreProof, shieldedToken, unshieldedToken } from '@midnight-ntwrk/ledger-v8';
+import { createUnprovenCallTx, deployContract } from '@midnight-ntwrk/midnight-js-contracts';
+import {
+  DustAddress,
+  MidnightBech32m,
+  UnshieldedAddress,
+} from '@midnight-ntwrk/wallet-sdk-address-format';
+import { SentinelContract } from '@midnight-sentinel/api';
+import {
+  createMidnightEnrollmentVerifier,
+  createHttpMidnightRegistrationProvider,
+  enrollmentIdentity,
+  enrollmentSigningBytes,
+  type EnrollmentPayload,
+  type SignedEnrollment,
+} from '@midnight-sentinel/api/sponsorship/eligibility';
+import {
+  createMidnightBeneficiarySponsorshipApi,
+  createMidnightSponsorSponsorshipApi,
+  createMidnightSponsorshipTarget,
+  dustPublicKeyToBytes,
+  nativeNightSponsorshipConfig,
+} from '@midnight-sentinel/api/sponsorship/midnight';
+import {
+  sponsorshipAllowlistHash,
+  type SponsorshipPolicy,
+} from '@midnight-sentinel/api/sponsorship';
+import {
+  createPrivateState,
+  deriveSentinelAuthority,
+  ledger as sentinelLedger,
+  sentinelContractPrivateStateKey,
+} from '@midnight-sentinel/contract';
+import { configureProviders } from '@midnight-sentinel/contract/providers';
+import {
+  CompositeTargetCompiledContract,
+  compositeTargetLedger,
+  type CompositeTargetContractType,
+} from '@midnight-sentinel/protocol-verification/composite-sponsorship';
+import {
+  buildUnfundedWallet,
+  buildWallet,
+  getBalancesAndAddresses,
+  type WalletContext,
+} from '@midnight-sentinel/wallet';
+import * as Rx from 'rxjs';
+import { loadConfig } from '../config.js';
+import { EligibilityDatabase } from '../database.js';
+import { MidnightIndexerScanner } from '../indexer.js';
+import { ContractQueueOperator } from '../operator.js';
+import { buildServer } from '../server.js';
+import { EligibilityService } from '../service.js';
+
+const GENESIS_DEPLOYER_SEED = `${'0'.repeat(63)}1`;
+const GENESIS_OPERATOR_SEED = `${'0'.repeat(63)}2`;
+const GENESIS_SPONSOR_SEED = `${'0'.repeat(63)}3`;
+const NETWORK = 'undeployed';
+const INDEXER = 'http://127.0.0.1:8088/api/v4/graphql';
+const INDEXER_WS = 'ws://127.0.0.1:8088/api/v4/graphql/ws';
+const NODE = 'http://127.0.0.1:9944';
+const PROOF_SERVER = 'http://127.0.0.1:6300';
+const SHARE = 1n;
+const PRICE = 2n;
+// Registration is self-funded from DUST generated by the NIGHT being
+// registered. Tiny ledger values are useful for contract simulation but do not
+// generate a real devnet registration fee in a practical amount of time.
+const MINIMUM = 10_000_000_000_000n;
+const TTL = () => new Date(Date.now() + 30 * 60_000);
+const TIMEOUT = 8 * 60_000;
+
+const packageDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const repositoryDirectory = path.resolve(packageDirectory, '../..');
+const sentinelZkPath = path.join(repositoryDirectory, 'packages/contract/dist/managed/sentinel');
+const targetZkPath = path.join(
+  repositoryDirectory,
+  'packages/protocol-verification/dist/managed/composite-target'
+);
+
+const config = {
+  networkId: NETWORK,
+  indexer: INDEXER,
+  indexerWS: INDEXER_WS,
+  node: NODE,
+  proofServer: PROOF_SERVER,
+  privateStateStoreName: 'devnet-e2e',
+  logDir: path.join(packageDirectory, 'logs/devnet-e2e'),
+  zkConfigPath: sentinelZkPath,
+  eligibilityService: '',
+};
+
+type SyncedState = Awaited<ReturnType<typeof syncedState>>;
+type ScenarioResult = { name: string; status: 'passed' | 'failed'; detail?: unknown };
+
+class TerminalWaitError extends Error {}
+
+const report: {
+  runId: string;
+  startedAt: string;
+  verdict: string;
+  stage: string;
+  baseline?: unknown;
+  funding?: unknown;
+  contracts?: unknown;
+  final?: unknown;
+  scenarios: ScenarioResult[];
+  transactions: Record<string, string>;
+  finishedAt?: string;
+  error?: string;
+} = {
+  runId: randomBytes(8).toString('hex'),
+  startedAt: new Date().toISOString(),
+  verdict: 'inconclusive',
+  stage: 'preflight',
+  scenarios: [],
+  transactions: {},
+};
+
+const withTimeout = async <T>(label: string, promise: Promise<T>): Promise<T> => {
+  let timer: NodeJS.Timeout | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out`)), TIMEOUT);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+};
+
+const syncedState = (ctx: WalletContext) =>
+  withTimeout(
+    'wallet synchronization',
+    Rx.firstValueFrom(ctx.wallet.state().pipe(Rx.filter((state) => state.isSynced)))
+  );
+
+const waitForState = <T>(
+  label: string,
+  ctx: WalletContext,
+  predicate: (state: SyncedState) => T | false
+) =>
+  withTimeout(
+    label,
+    Rx.firstValueFrom(
+      ctx.wallet.state().pipe(
+        Rx.filter((state) => state.isSynced),
+        Rx.map(predicate),
+        Rx.filter((value): value is T => value !== false)
+      )
+    )
+  );
+
+const waitFor = async <T>(
+  label: string,
+  action: () => Promise<T | false>,
+  timeout = TIMEOUT
+): Promise<T> => {
+  const started = Date.now();
+  let lastProgress = started;
+  let lastError: unknown;
+  while (Date.now() - started < timeout) {
+    try {
+      const value = await action();
+      if (value !== false) return value;
+    } catch (error) {
+      if (error instanceof TerminalWaitError) throw error;
+      lastError = error;
+    }
+    if (Date.now() - lastProgress >= 15_000) {
+      console.log(
+        JSON.stringify({
+          waiting: label,
+          elapsedSeconds: Math.floor((Date.now() - started) / 1_000),
+        })
+      );
+      lastProgress = Date.now();
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1_000));
+  }
+  throw new Error(`${label} timed out${lastError ? `: ${String(lastError)}` : ''}`);
+};
+
+const scenario = async (name: string, action: () => Promise<unknown>) => {
+  try {
+    const detail = await action();
+    report.scenarios.push({ name, status: 'passed', detail });
+    console.log(JSON.stringify({ scenario: name, status: 'passed' }));
+    return detail;
+  } catch (error) {
+    report.scenarios.push({
+      name,
+      status: 'failed',
+      detail: error instanceof Error ? error.message : String(error),
+    });
+    throw error;
+  }
+};
+
+const graphql = async (query: string) => {
+  const response = await fetch(INDEXER, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ query }),
+  });
+  assert(response.ok, `indexer returned HTTP ${response.status}`);
+  const result = (await response.json()) as { data?: unknown; errors?: unknown };
+  assert(!result.errors, `indexer GraphQL error: ${JSON.stringify(result.errors)}`);
+  return result.data;
+};
+
+const nodeRpc = async (method: string) => {
+  const response = await fetch(NODE, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params: [] }),
+  });
+  assert(response.ok, `node returned HTTP ${response.status}`);
+  const result = (await response.json()) as { result?: unknown; error?: unknown };
+  assert(!result.error, `node RPC error: ${JSON.stringify(result.error)}`);
+  return result.result;
+};
+
+const preflight = async () => {
+  await Promise.all([
+    access(path.join(sentinelZkPath, 'keys/purchaseSponsorship.prover')),
+    access(path.join(targetZkPath, 'keys/interact.prover')),
+  ]);
+  const [health, version, block, proof] = await Promise.all([
+    nodeRpc('system_health'),
+    nodeRpc('system_version'),
+    graphql('{ block { height } }'),
+    fetch(`${PROOF_SERVER}/health`).catch(() => fetch(PROOF_SERVER)),
+  ]);
+  assert(proof.ok, `proof server returned HTTP ${proof.status}`);
+  return { network: NETWORK, nodeVersion: version, nodeHealth: health, indexer: block };
+};
+
+const addresses = (ctx: WalletContext, seed: string) => getBalancesAndAddresses(ctx.wallet, seed);
+
+const walletSnapshot = async (ctx: WalletContext, seed: string) => {
+  const value = await addresses(ctx, seed);
+  return {
+    addresses: value.addresses,
+    balances: {
+      dust: value.balances.dust.toString(),
+      shieldedNight: (value.balances.shielded[shieldedToken().raw] ?? 0n).toString(),
+      unshieldedNight: (value.balances.unshielded[unshieldedToken().raw] ?? 0n).toString(),
+    },
+  };
+};
+
+const decodeUnshielded = (address: string) =>
+  UnshieldedAddress.codec.decode(NETWORK, MidnightBech32m.parse(address));
+
+const decodeDust = (address: string) =>
+  DustAddress.codec.decode(NETWORK, MidnightBech32m.parse(address));
+
+const submitRecipe = async (
+  wallet: WalletContext,
+  recipe: Awaited<ReturnType<WalletContext['wallet']['transferTransaction']>>
+) => {
+  const signed = await wallet.wallet.signRecipe(recipe, (payload) =>
+    wallet.unshieldedKeystore.signData(payload)
+  );
+  const finalized = await wallet.wallet.finalizeRecipe(signed);
+  return wallet.wallet.submitTransaction(finalized);
+};
+
+const fundUnshielded = async (
+  funder: WalletContext,
+  recipients: Array<{ address: string; amount: bigint }>
+) => {
+  const recipe = await funder.wallet.transferTransaction(
+    [
+      {
+        type: 'unshielded',
+        outputs: recipients.map(({ address, amount }) => ({
+          type: unshieldedToken().raw,
+          amount,
+          receiverAddress: decodeUnshielded(address),
+        })),
+      },
+    ],
+    {
+      shieldedSecretKeys: funder.shieldedSecretKeys,
+      dustSecretKey: funder.dustSecretKey,
+    },
+    { ttl: TTL() }
+  );
+  return submitRecipe(funder, recipe);
+};
+
+const fundShielded = async (funder: WalletContext, recipient: string, amounts: bigint[]) => {
+  const state = await syncedState(funder);
+  void state;
+  const { ShieldedAddress } = await import('@midnight-ntwrk/wallet-sdk-address-format');
+  const decoded = ShieldedAddress.codec.decode(NETWORK, MidnightBech32m.parse(recipient));
+  const recipe = await funder.wallet.transferTransaction(
+    [
+      {
+        type: 'shielded',
+        outputs: amounts.map((amount) => ({
+          type: shieldedToken().raw,
+          amount,
+          receiverAddress: decoded,
+        })),
+      },
+    ],
+    {
+      shieldedSecretKeys: funder.shieldedSecretKeys,
+      dustSecretKey: funder.dustSecretKey,
+    },
+    { ttl: TTL() }
+  );
+  return submitRecipe(funder, recipe);
+};
+
+const registerWithSponsor = async (delegator: WalletContext, sponsorDustAddress: string) => {
+  const state = await syncedState(delegator);
+  const coins = state.unshielded.availableCoins.filter(
+    (coin) => coin.meta?.registeredForDustGeneration !== true
+  );
+  assert(coins.length > 0, 'delegator has no unregistered NIGHT UTXOs');
+  const readiness = await waitFor('registration DUST generation', async () => {
+    const estimate = await delegator.wallet.estimateRegistration(coins);
+    const generated = estimate.dustGenerationEstimations.reduce(
+      (total, value) => total + value.dust.generatedNow,
+      0n
+    );
+    return generated >= estimate.fee ? { fee: estimate.fee, generated } : false;
+  });
+  console.log(
+    JSON.stringify({
+      registrationReady: true,
+      fee: readiness.fee.toString(),
+      generatedDust: readiness.generated.toString(),
+    })
+  );
+  const recipe = await delegator.wallet.registerNightUtxosForDustGeneration(
+    coins,
+    delegator.unshieldedKeystore.getPublicKey(),
+    (payload) => delegator.unshieldedKeystore.signData(payload),
+    decodeDust(sponsorDustAddress)
+  );
+  const finalized = await delegator.wallet.finalizeRecipe(recipe);
+  return delegator.wallet.submitTransaction(finalized);
+};
+
+const deregisterNight = async (delegator: WalletContext) => {
+  const state = await syncedState(delegator);
+  const coins = state.unshielded.availableCoins.filter(
+    (coin) => coin.meta?.registeredForDustGeneration === true
+  );
+  assert(coins.length > 0, 'delegator has no registered NIGHT UTXOs');
+  const recipe = await delegator.wallet.deregisterFromDustGeneration(
+    coins,
+    delegator.unshieldedKeystore.getPublicKey(),
+    (payload) => delegator.unshieldedKeystore.signData(payload)
+  );
+  const finalized = await delegator.wallet.finalizeRecipe(recipe);
+  return delegator.wallet.submitTransaction(finalized);
+};
+
+const makeEnrollment = async (
+  wallet: WalletContext,
+  seed: string,
+  sentinelAddress: string,
+  sponsorDustAddress: string,
+  nonce = 1n,
+  expiresAt = new Date(Date.now() + 60 * 60_000)
+): Promise<SignedEnrollment> => {
+  const { addresses: walletAddresses } = await addresses(wallet, seed);
+  const payload: EnrollmentPayload = {
+    version: 1,
+    network: NETWORK,
+    sentinelAddress,
+    sponsorDustAddress,
+    nightRewardAddress: walletAddresses.unshielded,
+    nightVerificationKey: wallet.unshieldedKeystore.getPublicKey(),
+    shieldedCoinPublicKey: wallet.shieldedSecretKeys.coinPublicKey,
+    shieldedEncryptionPublicKey: wallet.shieldedSecretKeys.encryptionPublicKey,
+    nonce: nonce.toString(),
+    expiresAt: expiresAt.toISOString(),
+  };
+  return {
+    payload,
+    signature: wallet.unshieldedKeystore.signData(enrollmentSigningBytes(payload)),
+  };
+};
+
+const postEnrollment = async (baseUrl: string, enrollment: SignedEnrollment) =>
+  fetch(`${baseUrl}/v1/enrollments`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(enrollment),
+  });
+
+const waitForJob = async (baseUrl: string, id: string, expected: 'active' | 'ineligible') =>
+  waitFor(`eligibility job ${id}`, async () => {
+    const response = await fetch(`${baseUrl}/v1/jobs/${id}`);
+    if (!response.ok) return false;
+    const job = (await response.json()) as { status: string; errorCode?: string };
+    if (job.status === 'failed') {
+      throw new TerminalWaitError(`eligibility job failed: ${job.errorCode}`);
+    }
+    if (job.status === 'ineligible' && expected !== 'ineligible') {
+      throw new TerminalWaitError(`eligibility job became ineligible: ${job.errorCode}`);
+    }
+    return job.status === expected ? job : false;
+  });
+
+const bytes32 = (value: number) => new Uint8Array(32).fill(value);
+
+const main = async () => {
+  const wallets: WalletContext[] = [];
+  let database: EligibilityDatabase | undefined;
+  let service: EligibilityService | undefined;
+  let server: Awaited<ReturnType<typeof buildServer>> | undefined;
+  const runDirectory = await mkdtemp(path.join(tmpdir(), `sentinel-e2e-${report.runId}-`));
+  const reportPath = path.join(runDirectory, 'report.json');
+
+  try {
+    report.baseline = await preflight();
+    report.stage = 'wallet-initialization';
+
+    const seeds = {
+      beneficiary: randomBytes(32).toString('hex'),
+      eligible: Array.from({ length: 3 }, () => randomBytes(32).toString('hex')),
+      unregistered: randomBytes(32).toString('hex'),
+      belowMinimum: randomBytes(32).toString('hex'),
+    };
+    const [deployer, sponsor, operator, beneficiary, ...delegators] = await Promise.all([
+      buildWallet(config, GENESIS_DEPLOYER_SEED),
+      buildWallet(config, GENESIS_SPONSOR_SEED),
+      buildWallet(config, GENESIS_OPERATOR_SEED),
+      buildUnfundedWallet(config, seeds.beneficiary),
+      ...seeds.eligible.map((seed) => buildUnfundedWallet(config, seed)),
+      buildUnfundedWallet(config, seeds.unregistered),
+      buildUnfundedWallet(config, seeds.belowMinimum),
+    ]);
+    wallets.push(deployer, sponsor, operator, beneficiary, ...delegators);
+    const eligible = delegators.slice(0, 3);
+    const unregistered = delegators[3]!;
+    const belowMinimum = delegators[4]!;
+    report.baseline = {
+      ...(report.baseline as object),
+      wallets: {
+        deployer: await walletSnapshot(deployer, GENESIS_DEPLOYER_SEED),
+        sponsor: await walletSnapshot(sponsor, GENESIS_SPONSOR_SEED),
+        operator: await walletSnapshot(operator, GENESIS_OPERATOR_SEED),
+        beneficiary: await walletSnapshot(beneficiary, seeds.beneficiary),
+        eligible: await Promise.all(
+          eligible.map((wallet, index) => walletSnapshot(wallet, seeds.eligible[index]!))
+        ),
+        unregistered: await walletSnapshot(unregistered, seeds.unregistered),
+        belowMinimum: await walletSnapshot(belowMinimum, seeds.belowMinimum),
+      },
+    };
+
+    const delegatorAddresses = await Promise.all(
+      eligible.map((wallet, index) => addresses(wallet, seeds.eligible[index]!))
+    );
+    const belowAddress = await addresses(belowMinimum, seeds.belowMinimum);
+    const requiredUnshieldedFunding = MINIMUM * 2n * BigInt(eligible.length) + MINIMUM - 1n;
+    const fundingCandidates = await Promise.all(
+      [
+        { name: 'deployer', wallet: deployer },
+        { name: 'sponsor', wallet: sponsor },
+        { name: 'operator', wallet: operator },
+      ].map(async (candidate) => ({
+        ...candidate,
+        balance:
+          (await syncedState(candidate.wallet)).unshielded.balances[unshieldedToken().raw] ?? 0n,
+      }))
+    );
+    const nightFunder = fundingCandidates
+      .sort((left, right) =>
+        left.balance > right.balance ? -1 : left.balance < right.balance ? 1 : 0
+      )
+      .find(({ balance }) => balance >= requiredUnshieldedFunding);
+    assert(
+      nightFunder,
+      `devnet genesis wallets lack the ${requiredUnshieldedFunding} unshielded NIGHT required by the E2E run; reset the devnet`
+    );
+    report.funding = {
+      source: nightFunder.name,
+      available: nightFunder.balance.toString(),
+      required: requiredUnshieldedFunding.toString(),
+    };
+    report.stage = 'unshielded-funding';
+    report.transactions.fundUnshielded = await fundUnshielded(nightFunder.wallet, [
+      ...delegatorAddresses.map(({ addresses: value }) => ({
+        address: value.unshielded,
+        amount: MINIMUM * 2n,
+      })),
+      { address: belowAddress.addresses.unshielded, amount: MINIMUM - 1n },
+    ]);
+    await Promise.all([
+      ...eligible.map((wallet) =>
+        waitForState('delegator NIGHT funding', wallet, (state) =>
+          (state.unshielded.balances[unshieldedToken().raw] ?? 0n) >= MINIMUM ? state : false
+        )
+      ),
+      waitForState('below-minimum NIGHT funding', belowMinimum, (state) =>
+        (state.unshielded.balances[unshieldedToken().raw] ?? 0n) === MINIMUM - 1n ? state : false
+      ),
+    ]);
+
+    const sponsorAddresses = await addresses(sponsor, GENESIS_SPONSOR_SEED);
+    report.stage = 'dust-registration';
+    const registrationWallets = [...eligible, belowMinimum];
+    for (let index = 0; index < registrationWallets.length; index += 1) {
+      report.stage = `dust-registration-${index + 1}`;
+      report.transactions[`registration${index + 1}`] = await registerWithSponsor(
+        registrationWallets[index]!,
+        sponsorAddresses.addresses.dust
+      );
+    }
+
+    report.stage = 'contract-deployment';
+    const deployTargetProviders = await configureProviders<CompositeTargetContractType>(
+      deployer,
+      config,
+      path.join(runDirectory, 'target-deploy'),
+      targetZkPath
+    );
+    const targetDeployment = await deployContract<CompositeTargetContractType>(
+      deployTargetProviders,
+      { compiledContract: CompositeTargetCompiledContract }
+    );
+    const targetAddress = targetDeployment.deployTxData.public.contractAddress;
+    const allowedTargets = [{ address: targetAddress, entryPoint: 'interact' }];
+    const policyHash = sponsorshipAllowlistHash(allowedTargets);
+    const operatorSecret = Uint8Array.from(randomBytes(32));
+    const operatorAuthority = deriveSentinelAuthority(operatorSecret);
+    const sentinelDeployProviders = await configureProviders(
+      deployer,
+      config,
+      path.join(runDirectory, 'sentinel-deploy'),
+      sentinelZkPath
+    );
+    const deployedSentinel = await SentinelContract.deploy(
+      sentinelDeployProviders,
+      nativeNightSponsorshipConfig(sponsor, policyHash, {
+        sponsorShare: SHARE,
+        delegatorShare: SHARE,
+        minimumRegisteredNight: MINIMUM,
+        initialEligibilityOperator: operatorAuthority,
+      })
+    );
+    const sentinelAddress = deployedSentinel.deployedContract!.deployTxData.public.contractAddress;
+    report.contracts = { sentinelAddress, targetAddress };
+
+    const initialState = await deployedSentinel.readState();
+    assert.equal(initialState.delegatorCount, 0n);
+    assert.equal(initialState.rewardCursor, 0n);
+    assert.equal(initialState.sponsorshipPurchases, 0n);
+    assert.equal(initialState.sponsorshipFixedPrice, PRICE);
+    assert.equal(initialState.sponsorshipMinimumRegisteredNight, MINIMUM);
+
+    const operatorProviders = await configureProviders(
+      operator,
+      config,
+      path.join(runDirectory, 'operator'),
+      sentinelZkPath
+    );
+    operatorProviders.privateStateProvider.setContractAddress(sentinelAddress);
+    await operatorProviders.privateStateProvider.set(
+      sentinelContractPrivateStateKey,
+      createPrivateState(operatorSecret)
+    );
+    const operatorContract = await SentinelContract.join(operatorProviders, sentinelAddress);
+
+    const serviceConfig = loadConfig({
+      SERVICE_HOST: '127.0.0.1',
+      SERVICE_PORT: '8089',
+      SERVICE_DB_PATH: path.join(runDirectory, 'eligibility.sqlite'),
+      SERVICE_ADMIN_TOKEN: randomBytes(32).toString('hex'),
+      SERVICE_OPERATOR_SEED: GENESIS_OPERATOR_SEED,
+      SERVICE_OPERATOR_SECRET: Buffer.from(operatorSecret).toString('hex'),
+      SERVICE_PRIVATE_STATE_STORE: path.join(runDirectory, 'operator-service'),
+      SERVICE_REVALIDATE_MS: '1000',
+      SERVICE_LOG_DIR: path.join(runDirectory, 'logs'),
+      SERVICE_ZK_CONFIG_PATH: sentinelZkPath,
+      MIDNIGHT_NETWORK: NETWORK,
+      MIDNIGHT_INDEXER_HTTP: INDEXER,
+      MIDNIGHT_INDEXER_WS: INDEXER_WS,
+      MIDNIGHT_NODE: NODE,
+      MIDNIGHT_PROOF_SERVER: PROOF_SERVER,
+      SENTINEL_ADDRESS: sentinelAddress,
+      SPONSOR_DUST_ADDRESS: sponsorAddresses.addresses.dust,
+      EXPECTED_OPERATOR_AUTHORITY: Buffer.from(operatorAuthority).toString('hex'),
+    });
+    database = new EligibilityDatabase(serviceConfig.dbPath);
+    const sponsorDustKey = decodeDust(sponsorAddresses.addresses.dust).data;
+    const scanner = new MidnightIndexerScanner(
+      INDEXER,
+      INDEXER_WS,
+      database,
+      sponsorDustKey.toString()
+    );
+    service = new EligibilityService(
+      database,
+      scanner,
+      new ContractQueueOperator(operatorContract),
+      {
+        network: NETWORK,
+        sentinelAddress,
+        sponsorDustAddress: sponsorAddresses.addresses.dust,
+        minimumRegisteredNight: MINIMUM,
+      },
+      createMidnightEnrollmentVerifier(NETWORK),
+      1_000
+    );
+    server = buildServer(serviceConfig, service);
+    service.start();
+    report.stage = 'service-startup';
+    const baseUrl = await server.listen({ host: '127.0.0.1', port: 0 });
+    const ready = await fetch(`${baseUrl}/readyz`);
+    assert.equal(ready.status, 200);
+
+    report.stage = 'beneficiary-funding';
+    const beneficiaryAddresses = await addresses(beneficiary, seeds.beneficiary);
+    report.transactions.fundBeneficiary = await fundShielded(
+      deployer,
+      beneficiaryAddresses.addresses.shielded,
+      Array.from({ length: 6 }, () => PRICE)
+    );
+    await waitForState('beneficiary shielded funding', beneficiary, (state) =>
+      (state.shielded.balances[shieldedToken().raw] ?? 0n) >= PRICE * 6n ? state : false
+    );
+
+    const beneficiarySentinelProviders = await configureProviders(
+      beneficiary,
+      config,
+      path.join(runDirectory, 'beneficiary-sentinel'),
+      sentinelZkPath
+    );
+    await SentinelContract.join(beneficiarySentinelProviders, sentinelAddress);
+    const beneficiaryTargetProviders = await configureProviders<CompositeTargetContractType>(
+      beneficiary,
+      config,
+      path.join(runDirectory, 'beneficiary-target'),
+      targetZkPath
+    );
+    const sponsorProviders = await configureProviders(
+      sponsor,
+      config,
+      path.join(runDirectory, 'sponsor'),
+      sentinelZkPath
+    );
+
+    const beneficiaryApi = createMidnightBeneficiarySponsorshipApi({
+      sentinelAddress,
+      sentinelProviders: beneficiarySentinelProviders,
+      beneficiary,
+      proofServer: PROOF_SERVER,
+    });
+    const policy: SponsorshipPolicy = {
+      sentinelAddress,
+      sponsorId: dustPublicKeyToBytes(sponsor.dustSecretKey.publicKey),
+      sponsorDustAddress: sponsorAddresses.addresses.dust,
+      registrationProvider: createHttpMidnightRegistrationProvider(baseUrl),
+      policyHash,
+      allowedTargets,
+      minTtlMs: 0,
+      maxTtlMs: 65 * 60_000,
+      maxFee: 1_000_000_000_000_000_000n,
+    };
+    const sponsorApi = createMidnightSponsorSponsorshipApi({
+      policy,
+      sentinelProviders: sponsorProviders,
+      sponsor,
+    });
+
+    const targetCall = (expiry: bigint) =>
+      createUnprovenCallTx(beneficiaryTargetProviders, {
+        compiledContract: CompositeTargetCompiledContract,
+        contractAddress: targetAddress,
+        circuitId: 'interact',
+        args: [expiry],
+      });
+
+    report.stage = 'scenarios';
+    await scenario('empty queue rejects sponsorship without state changes', async () => {
+      const before = await deployedSentinel.readState();
+      const call = await targetCall(BigInt(Math.floor(Date.now() / 1000) + 900));
+      const calls = [...(call.private.unprovenTx.intents?.values() ?? [])]
+        .flatMap((intent) => intent.actions)
+        .filter((action): action is ContractCall<PreProof> => action instanceof ContractCall);
+      assert.equal(calls.length, 1);
+      await assert.rejects(
+        beneficiaryApi.prepare({
+          target: createMidnightSponsorshipTarget({
+            targetCall: call,
+            zkConfigProvider: beneficiaryTargetProviders.zkConfigProvider,
+          }),
+          expiresAt: TTL(),
+          purchaseId: bytes32(0x10),
+        }),
+        (error: Error & { code?: string }) =>
+          error.code === 'NO_ELIGIBLE_DELEGATOR' || error.message.includes('NO_ELIGIBLE_DELEGATOR')
+      );
+      const after = await deployedSentinel.readState();
+      assert.equal(after.sponsorshipPurchases, before.sponsorshipPurchases);
+      assert.equal(after.rewardCursor, before.rewardCursor);
+      return { purchases: after.sponsorshipPurchases.toString() };
+    });
+
+    await scenario('HTTP enrollment defenses', async () => {
+      const valid = await makeEnrollment(
+        unregistered,
+        seeds.unregistered,
+        sentinelAddress,
+        sponsorAddresses.addresses.dust
+      );
+      const invalidSignature = await postEnrollment(baseUrl, {
+        ...valid,
+        signature: valid.signature.replace(/^../, valid.signature.startsWith('00') ? '01' : '00'),
+      });
+      assert.equal(invalidSignature.status, 400);
+      const expired = await makeEnrollment(
+        unregistered,
+        seeds.unregistered,
+        sentinelAddress,
+        sponsorAddresses.addresses.dust,
+        2n,
+        new Date(Date.now() - 1_000)
+      );
+      assert.equal((await postEnrollment(baseUrl, expired)).status, 400);
+      const wrongCampaign = await makeEnrollment(
+        unregistered,
+        seeds.unregistered,
+        'ff'.repeat(32),
+        sponsorAddresses.addresses.dust,
+        3n
+      );
+      assert.equal((await postEnrollment(baseUrl, wrongCampaign)).status, 400);
+      const accepted = await postEnrollment(baseUrl, valid);
+      assert.equal(accepted.status, 202);
+      const { jobId } = (await accepted.json()) as { jobId: string };
+      await waitForJob(baseUrl, jobId, 'ineligible');
+      const unauthorized = await fetch(`${baseUrl}/v1/admin/revalidate`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: 'Bearer wrong' },
+        body: '{}',
+      });
+      assert.equal(unauthorized.status, 401);
+      return { invalidSignature: 400, expired: 400, wrongCampaign: 400, unregistered: 202 };
+    });
+
+    const activeEnrollments: SignedEnrollment[] = [];
+    await scenario('real indexer enrollment activates three delegators', async () => {
+      for (let index = 0; index < eligible.length; index += 1) {
+        const enrollment = await makeEnrollment(
+          eligible[index]!,
+          seeds.eligible[index]!,
+          sentinelAddress,
+          sponsorAddresses.addresses.dust
+        );
+        activeEnrollments.push(enrollment);
+        const response = await postEnrollment(baseUrl, enrollment);
+        assert.equal(response.status, 202);
+        const { jobId } = (await response.json()) as { jobId: string };
+        await waitForJob(baseUrl, jobId, 'active');
+      }
+      const state = await waitFor('three on-chain delegators', async () => {
+        const current = await deployedSentinel.readState();
+        return current.delegatorCount === 3n ? current : false;
+      });
+      const replay = await postEnrollment(baseUrl, activeEnrollments[0]!);
+      assert.equal(replay.status, 400);
+      return { delegatorCount: state.delegatorCount.toString(), replayStatus: replay.status };
+    });
+
+    await scenario('below-minimum registration is rejected asynchronously', async () => {
+      const enrollment = await makeEnrollment(
+        belowMinimum,
+        seeds.belowMinimum,
+        sentinelAddress,
+        sponsorAddresses.addresses.dust
+      );
+      const response = await postEnrollment(baseUrl, enrollment);
+      assert.equal(response.status, 202);
+      const { jobId } = (await response.json()) as { jobId: string };
+      const job = await waitForJob(baseUrl, jobId, 'ineligible');
+      assert.equal((await deployedSentinel.readState()).delegatorCount, 3n);
+      return job;
+    });
+
+    const beforeSponsor = (await syncedState(sponsor)).shielded.balances[shieldedToken().raw] ?? 0n;
+    const beforeDelegators = await Promise.all(
+      eligible.map(
+        async (wallet) => (await syncedState(wallet)).shielded.balances[shieldedToken().raw] ?? 0n
+      )
+    );
+
+    const purchase = async (index: number, failFallible: boolean) => {
+      const expiry = BigInt(Math.floor(Date.now() / 1000) + (failFallible ? 5 : 900));
+      const call = await targetCall(expiry);
+      const prepared = await beneficiaryApi.prepare({
+        target: createMidnightSponsorshipTarget({
+          targetCall: call,
+          zkConfigProvider: beneficiaryTargetProviders.zkConfigProvider,
+        }),
+        expiresAt: TTL(),
+        purchaseId: bytes32(0x40 + index),
+      });
+      if (failFallible) {
+        await waitFor('target expiry', async () =>
+          BigInt(Math.floor(Date.now() / 1000)) > expiry ? true : false
+        );
+      }
+      const submitted = await sponsorApi.sponsorAndSubmit({
+        transaction: prepared.transaction,
+      });
+      report.transactions[`purchase${index}`] = submitted.txId;
+      return submitted;
+    };
+
+    await scenario(
+      'real rewards rotate A-B-C-A across successful and fallible execution',
+      async () => {
+        const submissions = [];
+        submissions.push(await purchase(0, false));
+        submissions.push(await purchase(1, true));
+        submissions.push(await purchase(2, false));
+        submissions.push(await purchase(3, false));
+        assert.equal(submissions[0]!.status, 'SucceedEntirely');
+        assert.equal(submissions[1]!.status, 'FailFallible');
+
+        const state = await waitFor('four sponsorship receipts', async () => {
+          const current = await deployedSentinel.readState();
+          return current.sponsorshipPurchases === 4n ? current : false;
+        });
+        assert.equal(state.sponsorshipReceipts.size(), 4n);
+        assert.equal(state.rewardCursor, 1n);
+
+        await waitForState('sponsor rewards', sponsor, (walletState) =>
+          (walletState.shielded.balances[shieldedToken().raw] ?? 0n) === beforeSponsor + 3n
+            ? walletState
+            : false
+        );
+        const expected = [2n, 1n, 1n];
+        await Promise.all(
+          eligible.map((wallet, index) =>
+            waitForState(`delegator ${index + 1} reward`, wallet, (walletState) =>
+              (walletState.shielded.balances[shieldedToken().raw] ?? 0n) ===
+              beforeDelegators[index]! + expected[index]!
+                ? walletState
+                : false
+            )
+          )
+        );
+        const targetState = await waitFor('target execution state', async () => {
+          const publicState =
+            await beneficiaryTargetProviders.publicDataProvider.queryContractState(targetAddress);
+          if (!publicState) return false;
+          const current = compositeTargetLedger(publicState.data);
+          return current.guaranteedExecutions === 4n ? current : false;
+        });
+        assert.equal(targetState.fallibleExecutions, 3n);
+        return {
+          statuses: submissions.map(({ status }) => status),
+          rotation: activeEnrollments.map((enrollment) =>
+            Buffer.from(enrollmentIdentity(enrollment.payload.nightRewardAddress)).toString('hex')
+          ),
+          cursor: state.rewardCursor.toString(),
+        };
+      }
+    );
+
+    await scenario('authenticated service removal compacts the live queue', async () => {
+      const identity = Buffer.from(
+        enrollmentIdentity(activeEnrollments[1]!.payload.nightRewardAddress)
+      ).toString('hex');
+      const removed = await fetch(`${baseUrl}/v1/admin/delegators/${identity}`, {
+        method: 'DELETE',
+        headers: { authorization: `Bearer ${serviceConfig.adminToken}` },
+      });
+      assert.equal(removed.status, 204);
+      const state = await waitFor('delegator removal', async () => {
+        const current = await deployedSentinel.readState();
+        return current.delegatorCount === 2n ? current : false;
+      });
+      assert(!state.delegatorPositions.member(Uint8Array.from(Buffer.from(identity, 'hex'))));
+      return {
+        delegatorCount: state.delegatorCount.toString(),
+        cursor: state.rewardCursor.toString(),
+      };
+    });
+
+    await scenario('finalized deregistration causes automatic stale-entry removal', async () => {
+      report.transactions.deregisterSelected = await deregisterNight(eligible[2]!);
+      const staleIdentity = enrollmentIdentity(activeEnrollments[2]!.payload.nightRewardAddress);
+      const state = await waitFor('stale delegator removal', async () => {
+        const current = await deployedSentinel.readState();
+        return current.delegatorCount === 1n ? current : false;
+      });
+      assert(!state.delegatorPositions.member(staleIdentity));
+      return {
+        removedIdentity: Buffer.from(staleIdentity).toString('hex'),
+        delegatorCount: state.delegatorCount.toString(),
+      };
+    });
+
+    const finalPublic =
+      await beneficiarySentinelProviders.publicDataProvider.queryContractState(sentinelAddress);
+    assert(finalPublic);
+    const finalState = sentinelLedger(finalPublic.data);
+    report.final = {
+      finalizedBlock: await graphql('{ block { height } }'),
+      delegatorCount: finalState.delegatorCount.toString(),
+      rewardCursor: finalState.rewardCursor.toString(),
+      sponsorshipPurchases: finalState.sponsorshipPurchases.toString(),
+      receiptCount: finalState.sponsorshipReceipts.size().toString(),
+    };
+    report.verdict = 'confirmed';
+    report.stage = 'complete';
+    report.finishedAt = new Date().toISOString();
+    await writeFile(reportPath, JSON.stringify(report, null, 2), { mode: 0o600 });
+    console.log(JSON.stringify({ devnetE2E: 'confirmed', reportPath, report }));
+  } catch (error) {
+    report.verdict = report.baseline === undefined ? 'inconclusive-devnet-unavailable' : 'failed';
+    report.finishedAt = new Date().toISOString();
+    report.error = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    await writeFile(reportPath, JSON.stringify(report, null, 2), { mode: 0o600 });
+    console.error(JSON.stringify({ devnetE2E: report.verdict, reportPath, error: report.error }));
+    process.exitCode = 1;
+  } finally {
+    if (service) await service.stop();
+    if (server) await server.close();
+    database?.close();
+    await Promise.allSettled(wallets.map(({ wallet }) => wallet.stop()));
+  }
+};
+
+await main();
diff --git a/apps/sponsor-service/test/database.test.ts b/apps/sponsor-service/test/database.test.ts
new file mode 100644
index 0000000..3398b6d
--- /dev/null
+++ b/apps/sponsor-service/test/database.test.ts
@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import { afterEach, describe, it } from 'node:test';
+import type { SignedEnrollment } from '@midnight-sentinel/api/sponsorship/eligibility';
+import { EligibilityDatabase } from '../src/database.js';
+
+const databases: EligibilityDatabase[] = [];
+afterEach(() => {
+  for (const database of databases.splice(0)) database.close();
+});
+
+const enrollment = (nonce: string): SignedEnrollment => ({
+  payload: {
+    version: 1,
+    network: 'undeployed',
+    sentinelAddress: '11'.repeat(32),
+    sponsorDustAddress: 'dust_undeployed1test',
+    nightRewardAddress: 'addr_undeployed1test',
+    nightVerificationKey: 'aa'.repeat(35),
+    shieldedCoinPublicKey: '22'.repeat(32),
+    shieldedEncryptionPublicKey: '33'.repeat(32),
+    nonce,
+    expiresAt: '2099-01-01T00:00:00.000Z',
+  },
+  signature: '44'.repeat(67),
+});
+
+describe('EligibilityDatabase', () => {
+  it('retains the highest enrollment nonce as a tombstone', () => {
+    const database = new EligibilityDatabase(':memory:');
+    databases.push(database);
+    const identity = '55'.repeat(32);
+    database.putEnrollment(identity, enrollment('2'), 2n);
+    assert.throws(
+      () => database.putEnrollment(identity, enrollment('1'), 1n),
+      /ENROLLMENT_REPLAYED/
+    );
+    assert.equal(database.getEnrollment(identity)?.nonce, 2n);
+  });
+
+  it('sums only registered NIGHT assigned to the sponsor', () => {
+    const database = new EligibilityDatabase(':memory:');
+    databases.push(database);
+    database.applyUtxoChanges(
+      'address',
+      [],
+      [
+        {
+          key: 'a:0',
+          tokenType: 'night',
+          value: 4n,
+          registered: true,
+          dustKey: 'sponsor',
+        },
+        {
+          key: 'b:0',
+          tokenType: 'night',
+          value: 8n,
+          registered: true,
+          dustKey: 'other',
+        },
+        {
+          key: 'c:0',
+          tokenType: 'night',
+          value: 16n,
+          registered: false,
+          dustKey: 'sponsor',
+        },
+      ]
+    );
+    assert.equal(database.qualifyingBalance('address', 'night', 'sponsor'), 4n);
+    database.applyUtxoChanges('address', ['a:0'], []);
+    assert.equal(database.qualifyingBalance('address', 'night', 'sponsor'), 0n);
+  });
+});
diff --git a/apps/sponsor-service/test/enrollment.test.ts b/apps/sponsor-service/test/enrollment.test.ts
new file mode 100644
index 0000000..664b4be
--- /dev/null
+++ b/apps/sponsor-service/test/enrollment.test.ts
@@ -0,0 +1,97 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  addressFromKey,
+  sampleSigningKey,
+  signData,
+  signatureVerifyingKey,
+} from '@midnight-ntwrk/ledger-v8';
+import { MidnightBech32m, UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import {
+  createHttpMidnightRegistrationProvider,
+  createMidnightEnrollmentVerifier,
+  enrollmentSigningBytes,
+  verifyEnrollment,
+  type EnrollmentPayload,
+} from '@midnight-sentinel/api/sponsorship/eligibility';
+
+const signedEnrollment = () => {
+  const signingKey = sampleSigningKey();
+  const verificationKey = signatureVerifyingKey(signingKey);
+  const address = MidnightBech32m.encode(
+    'undeployed',
+    new UnshieldedAddress(Buffer.from(addressFromKey(verificationKey), 'hex'))
+  ).toString();
+  const payload: EnrollmentPayload = {
+    version: 1,
+    network: 'undeployed',
+    sentinelAddress: '11'.repeat(32),
+    sponsorDustAddress: 'mn_dust_undeployed1test',
+    nightRewardAddress: address,
+    nightVerificationKey: verificationKey,
+    shieldedCoinPublicKey: '22'.repeat(32),
+    shieldedEncryptionPublicKey: '33'.repeat(32),
+    nonce: '1',
+    expiresAt: '2099-01-01T00:00:00.000Z',
+  };
+  return {
+    payload,
+    signature: signData(signingKey, enrollmentSigningBytes(payload)),
+  };
+};
+
+describe('Midnight enrollment verification', () => {
+  it('binds the signed verification key to the unshielded address', () => {
+    const enrollment = signedEnrollment();
+    const verified = verifyEnrollment(
+      enrollment,
+      {
+        network: 'undeployed',
+        sentinelAddress: enrollment.payload.sentinelAddress,
+        sponsorDustAddress: enrollment.payload.sponsorDustAddress,
+      },
+      createMidnightEnrollmentVerifier('undeployed')
+    );
+    assert.equal(verified.nightRewardAddress, enrollment.payload.nightRewardAddress);
+
+    const other = signedEnrollment();
+    assert.throws(() =>
+      verifyEnrollment(
+        {
+          ...enrollment,
+          payload: {
+            ...enrollment.payload,
+            nightRewardAddress: other.payload.nightRewardAddress,
+          },
+        },
+        {
+          network: 'undeployed',
+          sentinelAddress: enrollment.payload.sentinelAddress,
+          sponsorDustAddress: enrollment.payload.sponsorDustAddress,
+        },
+        createMidnightEnrollmentVerifier('undeployed')
+      )
+    );
+  });
+
+  it('decodes synchronized HTTP status into bigint values', async () => {
+    const provider = createHttpMidnightRegistrationProvider(
+      'http://eligibility.test/',
+      async () =>
+        new Response(
+          JSON.stringify({
+            nightRewardAddress: 'address',
+            dustAddress: 'dust',
+            registered: true,
+            nightBalance: '42',
+            finalizedBlock: '7',
+            synchronized: true,
+          }),
+          { status: 200 }
+        )
+    );
+    const status = await provider.getStatus('address');
+    assert.equal(status.nightBalance, 42n);
+    assert.equal(status.finalizedBlock, 7n);
+  });
+});
diff --git a/apps/sponsor-service/test/service.test.ts b/apps/sponsor-service/test/service.test.ts
new file mode 100644
index 0000000..ee6e015
--- /dev/null
+++ b/apps/sponsor-service/test/service.test.ts
@@ -0,0 +1,105 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  addressFromKey,
+  sampleSigningKey,
+  signData,
+  signatureVerifyingKey,
+} from '@midnight-ntwrk/ledger-v8';
+import { MidnightBech32m, UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import {
+  createMidnightEnrollmentVerifier,
+  enrollmentSigningBytes,
+  type EnrollmentPayload,
+} from '@midnight-sentinel/api/sponsorship/eligibility';
+import { EligibilityDatabase } from '../src/database.js';
+import type { MidnightIndexerScanner } from '../src/indexer.js';
+import type { ContractQueueOperator } from '../src/operator.js';
+import { EligibilityService } from '../src/service.js';
+
+const waitFor = async (condition: () => boolean) => {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    if (condition()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error('Timed out');
+};
+
+describe('EligibilityService', () => {
+  it('enrolls from finalized status and removes after finalized invalidation', async () => {
+    const signingKey = sampleSigningKey();
+    const verificationKey = signatureVerifyingKey(signingKey);
+    const address = MidnightBech32m.encode(
+      'undeployed',
+      new UnshieldedAddress(Buffer.from(addressFromKey(verificationKey), 'hex'))
+    ).toString();
+    const payload: EnrollmentPayload = {
+      version: 1,
+      network: 'undeployed',
+      sentinelAddress: '11'.repeat(32),
+      sponsorDustAddress: 'dust',
+      nightRewardAddress: address,
+      nightVerificationKey: verificationKey,
+      shieldedCoinPublicKey: '22'.repeat(32),
+      shieldedEncryptionPublicKey: '33'.repeat(32),
+      nonce: '1',
+      expiresAt: '2099-01-01T00:00:00.000Z',
+    };
+    const enrollment = {
+      payload,
+      signature: signData(signingKey, enrollmentSigningBytes(payload)),
+    };
+    let balance = 2n;
+    const scanner = {
+      latestFinalizedBlock: async () => 10n,
+      sync: async () => ({
+        nightRewardAddress: address,
+        dustAddress: balance > 0n ? 'dust' : undefined,
+        registered: balance > 0n,
+        nightBalance: balance,
+        finalizedBlock: 10n,
+        synchronized: true,
+      }),
+    } as unknown as MidnightIndexerScanner;
+    let currentNonce: bigint | undefined;
+    let removed = false;
+    const operator = {
+      lookup: async () =>
+        currentNonce === undefined ? undefined : { enrollmentNonce: currentNonce },
+      add: async (input: { enrollmentNonce: bigint }) => {
+        currentNonce = input.enrollmentNonce;
+      },
+      update: async (input: { enrollmentNonce: bigint }) => {
+        currentNonce = input.enrollmentNonce;
+      },
+      remove: async () => {
+        currentNonce = undefined;
+        removed = true;
+      },
+    } as unknown as ContractQueueOperator;
+    const database = new EligibilityDatabase(':memory:');
+    const service = new EligibilityService(
+      database,
+      scanner,
+      operator,
+      {
+        network: 'undeployed',
+        sentinelAddress: payload.sentinelAddress,
+        sponsorDustAddress: 'dust',
+        minimumRegisteredNight: 1n,
+      },
+      createMidnightEnrollmentVerifier('undeployed'),
+      60_000
+    );
+
+    const { jobId } = service.submit(enrollment);
+    await waitFor(() => service.getJob(jobId)?.status === 'active');
+    assert.equal(service.getStatus(address)?.nightBalance, 2n);
+
+    balance = 0n;
+    await service.revalidate();
+    assert.equal(removed, true);
+    assert.equal(service.getStatus(address)?.registered, false);
+    database.close();
+  });
+});
diff --git a/apps/sponsor-service/test/setup-devnet-config.test.ts b/apps/sponsor-service/test/setup-devnet-config.test.ts
new file mode 100644
index 0000000..3dd4d11
--- /dev/null
+++ b/apps/sponsor-service/test/setup-devnet-config.test.ts
@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { renderDevnetEnvironment } from '../src/setup-devnet-config.js';
+
+test('renders every generated service identity and campaign value', () => {
+  const rendered = renderDevnetEnvironment({
+    adminToken: 'a'.repeat(64),
+    operatorSeed: '1'.repeat(64),
+    operatorSecret: '2'.repeat(64),
+    operatorAuthority: '3'.repeat(64),
+    sentinelAddress: '4'.repeat(64),
+    sponsorDustAddress: 'dust_undeployed1example',
+  });
+
+  assert.match(rendered, /SERVICE_ADMIN_TOKEN=a{64}/);
+  assert.match(rendered, /SERVICE_OPERATOR_SEED=1{64}/);
+  assert.match(rendered, /SERVICE_OPERATOR_SECRET=2{64}/);
+  assert.match(rendered, /EXPECTED_OPERATOR_AUTHORITY=3{64}/);
+  assert.match(rendered, /SENTINEL_ADDRESS=4{64}/);
+  assert.match(rendered, /SPONSOR_DUST_ADDRESS=dust_undeployed1example/);
+});
diff --git a/apps/sponsor-service/tsconfig.build.json b/apps/sponsor-service/tsconfig.build.json
new file mode 100644
index 0000000..723ccd9
--- /dev/null
+++ b/apps/sponsor-service/tsconfig.build.json
@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "composite": false,
+    "incremental": false
+  },
+  "include": ["src"],
+  "exclude": ["dist", "node_modules", "test"]
+}
diff --git a/apps/sponsor-service/tsconfig.json b/apps/sponsor-service/tsconfig.json
new file mode 100644
index 0000000..af9a827
--- /dev/null
+++ b/apps/sponsor-service/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2022",
+    "noEmit": false,
+    "isolatedModules": false
+  }
+}
diff --git a/apps/ui/package.json b/apps/ui/package.json
index beb2467..011aa11 100644
--- a/apps/ui/package.json
+++ b/apps/ui/package.json
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "@midnight-ntwrk/dapp-connector-api": "4.0.1",
-    "@midnight-ntwrk/onchain-runtime-v2": "^2.0.1",
+    "@midnight-ntwrk/onchain-runtime-v3": "3.0.0",
     "@midnight-sentinel/api": "workspace:*",
     "@midnight-sentinel/contract": "workspace:*",
     "@radix-ui/react-label": "^2.1.8",
diff --git a/apps/ui/src/App.tsx b/apps/ui/src/App.tsx
index 28675c6..0daee3b 100644
--- a/apps/ui/src/App.tsx
+++ b/apps/ui/src/App.tsx
@@ -6,7 +6,6 @@ import {
 import { Toaster } from "@/components/ui/sonner";
 import { WalletSidebar } from "@/components/wallet-sidebar";
 import { useWallet } from "@/contexts/wallet";
-import { rulesSchema } from "@/lib/schemas";
 import { DeployView } from "@/views/Deploy";
 import { JoinView } from "@/views/Join";
 import { SelectView } from "@/views/Select";
@@ -14,10 +13,24 @@ import { SentinelContract, type SentinelDerivedState } from '@midnight-sentinel/
 import { initializeProviders } from '@midnight-sentinel/api/browser';
 import { useEffect, useMemo, useState } from "react";
 import { toast } from "sonner";
+import { z } from "zod";
 import { ContractView } from "./views/Contract";
 
 type ViewState = "select" | "deploy" | "join" | "contract";
 
+const hex32 = z.string().regex(/^(?:0x)?[0-9a-fA-F]{64}$/).transform((value) => {
+  const hex = value.startsWith("0x") ? value.slice(2) : value;
+  return Uint8Array.from({ length: 32 }, (_, index) =>
+    Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16)
+  );
+});
+const sponsorshipConfigSchema = z.object({
+  sponsorId: hex32,
+  acceptedColor: hex32,
+  fixedPrice: z.union([z.string(), z.number()]).transform((value) => BigInt(value)),
+  policyHash: hex32,
+});
+
 function App() {
   const { wallet, error } = useWallet();
   const [view, setView] = useState<ViewState>("select");
@@ -42,7 +55,7 @@ function App() {
     if (!deployRulesJson.trim()) return null;
     try {
       const parsed = JSON.parse(deployRulesJson);
-      return rulesSchema.safeParse(parsed);
+      return sponsorshipConfigSchema.safeParse(parsed);
     } catch {
       return null;
     }
@@ -61,7 +74,7 @@ function App() {
       const providers = await initializeProviders(wallet.api);
       const contract = await SentinelContract.deploy(
         providers,
-        { secretKey: new Uint8Array(32).fill(0) }
+        parsedRules.data
       );
       setActiveContract(contract);
       setView("contract");
@@ -88,8 +101,7 @@ function App() {
       const providers = await initializeProviders(wallet.api);
       const contract = await SentinelContract.join(
         providers,
-        joinAddress,
-        { secretKey: new Uint8Array(32).fill(0) }
+        joinAddress
       );
 
       setActiveContract(contract);
diff --git a/apps/ui/src/components/rules.tsx b/apps/ui/src/components/rules.tsx
index df6240d..4f1896c 100644
--- a/apps/ui/src/components/rules.tsx
+++ b/apps/ui/src/components/rules.tsx
@@ -1,23 +1,10 @@
-import { SentinelContract, toHex } from '@midnight-sentinel/api';
-import type { Ledger } from '@midnight-sentinel/contract';
-
-export const Rules = ({ rules }: { rules: Ledger['rules'] }) => {
-  if (rules.isEmpty()) {
-    return (
-      <pre className="p-4 bg-muted rounded-md text-sm font-mono overflow-auto max-h-[300px]">
-        No rules found
-      </pre>
-    );
-  }
-
-  return (
-    <pre className="p-4 bg-muted rounded-md text-sm font-mono overflow-auto max-h-[300px]">
-      {[...rules].map(([owner, ownerRules], idx) => (
-        <div key={idx}>
-          <div>Owner: {toHex(owner.bytes)}</div>
-          <div>Rules: {SentinelContract.prettyRules(ownerRules)}</div>
-        </div>
-      ))}
-    </pre>
-  );
-};
+/**
+ * Legacy placeholder retained for UI source compatibility. Sentinel v1 no
+ * longer exposes the earlier rules ledger; sponsorship policy is configured
+ * through the immutable campaign fields instead.
+ */
+export const Rules = () => (
+  <pre className="p-4 bg-muted rounded-md text-sm font-mono overflow-auto max-h-[300px]">
+    Rules moved to the sponsorship campaign policy.
+  </pre>
+);
diff --git a/apps/ui/src/views/Contract.tsx b/apps/ui/src/views/Contract.tsx
index 0ea9b12..be1214d 100644
--- a/apps/ui/src/views/Contract.tsx
+++ b/apps/ui/src/views/Contract.tsx
@@ -1,5 +1,3 @@
-import { RuleActions } from "@/components/rule-actions";
-import { Rules } from "@/components/rules";
 import { Button } from "@/components/ui/button";
 import type { SentinelContract, SentinelDerivedState } from "@midnight-sentinel/api";
 import { ArrowLeft } from "lucide-react";
@@ -32,14 +30,16 @@ export function ContractView({
         {contractState ? (
           <div className="space-y-6">
             <div className="space-y-2 p-4 border rounded-md">
-              <h3 className="text-lg font-semibold">Admin</h3>
-              <p className="font-mono text-sm break-all">{contractState.adminString}</p>
+              <h3 className="text-lg font-semibold">Owner</h3>
+              <p className="font-mono text-sm break-all">{contractState.owner}</p>
             </div>
 
             <div className="space-y-2 p-4 border rounded-md">
-              <h3 className="text-lg font-semibold">Rules</h3>
-              <RuleActions contract={contract} />
-              <Rules rules={contractState.rules} />
+              <h3 className="text-lg font-semibold">Sponsorship campaign</h3>
+              <p>Enabled: {contractState.sponsorshipEnabled ? "yes" : "no"}</p>
+              <p>Price: {contractState.sponsorshipFixedPrice.toString()}</p>
+              <p>Revenue: {contractState.sponsorshipRevenue.toString()}</p>
+              <p>Purchases: {contractState.sponsorshipPurchases.toString()}</p>
             </div>
           </div>
         ) : (
diff --git a/apps/ui/src/views/Deploy.tsx b/apps/ui/src/views/Deploy.tsx
index 340c2b1..5cca8e0 100644
--- a/apps/ui/src/views/Deploy.tsx
+++ b/apps/ui/src/views/Deploy.tsx
@@ -29,15 +29,15 @@ export function DeployView({
       <div className="space-y-2">
         <h2 className="text-2xl font-bold">Deploy Contract</h2>
         <p className="text-muted-foreground text-sm">
-          Provide the initial rules for your Sentinel contract.
+          Provide the immutable sponsorship campaign configuration.
         </p>
       </div>
       <div className="space-y-4">
         <div className="space-y-2">
-          <Label htmlFor="rules">Rules (JSON)</Label>
+          <Label htmlFor="rules">Sponsorship config (JSON)</Label>
           <Textarea
             id="rules"
-            placeholder='[{"is_some": false, "value": []}]'
+            placeholder='{"sponsorId":"64 hex chars","acceptedColor":"64 hex chars","fixedPrice":"100","policyHash":"64 hex chars"}'
             className="font-mono min-h-[200px]"
             value={rulesJson}
             onChange={(e) => onRulesJsonChange(e.target.value)}
@@ -57,4 +57,3 @@ export function DeployView({
     </div>
   );
 }
-
diff --git a/apps/ui/vite.config.ts b/apps/ui/vite.config.ts
index 226bc06..409ca67 100644
--- a/apps/ui/vite.config.ts
+++ b/apps/ui/vite.config.ts
@@ -25,7 +25,7 @@ export default defineConfig({
       name: 'wasm-module-resolver',
       resolveId(source, importer) {
         if (
-          source === '@midnight-ntwrk/onchain-runtime-v2' &&
+          source === '@midnight-ntwrk/onchain-runtime-v3' &&
           importer &&
           importer.includes('@midnight-ntwrk/compact-runtime')
         ) {
@@ -42,6 +42,18 @@ export default defineConfig({
   resolve: {
     alias: {
       '@': path.resolve(__dirname, './src'),
+      'vite-plugin-node-polyfills/shims/buffer': path.resolve(
+        __dirname,
+        './node_modules/vite-plugin-node-polyfills/shims/buffer/dist/index.js'
+      ),
+      'vite-plugin-node-polyfills/shims/process': path.resolve(
+        __dirname,
+        './node_modules/vite-plugin-node-polyfills/shims/process/dist/index.js'
+      ),
+      'vite-plugin-node-polyfills/shims/global': path.resolve(
+        __dirname,
+        './node_modules/vite-plugin-node-polyfills/shims/global/dist/index.js'
+      ),
     },
     extensions: ['.mjs', '.js', '.ts', '.jsx', '.tsx', '.json', '.wasm'],
     mainFields: ['browser', 'module', 'main'],
@@ -51,7 +63,7 @@ export default defineConfig({
     rollupOptions: {
       output: {
         manualChunks(id) {
-          if (id.includes('@midnight-ntwrk/onchain-runtime-v2')) {
+          if (id.includes('@midnight-ntwrk/onchain-runtime-v3')) {
             return 'wasm';
           }
         },
@@ -75,9 +87,9 @@ export default defineConfig({
     },
     include: ['@midnight-ntwrk/compact-runtime'],
     exclude: [
-      '@midnight-ntwrk/onchain-runtime-v2',
-      '@midnight-ntwrk/onchain-runtime-v2/midnight_onchain_runtime_wasm_bg.wasm',
-      '@midnight-ntwrk/onchain-runtime-v2/midnight_onchain_runtime_wasm.js',
+      '@midnight-ntwrk/onchain-runtime-v3',
+      '@midnight-ntwrk/onchain-runtime-v3/midnight_onchain_runtime_wasm_bg.wasm',
+      '@midnight-ntwrk/onchain-runtime-v3/midnight_onchain_runtime_wasm.js',
     ],
   },
 });
diff --git a/compose.yml b/compose.yml
index 90369bd..7ce8f6b 100644
--- a/compose.yml
+++ b/compose.yml
@@ -1,7 +1,7 @@
 services:
   proof-server:
     container_name: 'proof-server'
-    image: 'midnightntwrk/proof-server:8.0.2'
+    image: 'midnightntwrk/proof-server:8.1.0'
     command: ['midnight-proof-server -v']
     ports:
       - '6300:6300'
@@ -10,7 +10,7 @@ services:
 
   indexer:
     container_name: 'indexer'
-    image: 'midnightntwrk/indexer-standalone:4.0.0'
+    image: 'midnightntwrk/indexer-standalone:4.2.1'
     env_file: standalone.env.example
     ports:
       - '8088:8088'
@@ -28,7 +28,7 @@ services:
         condition: service_healthy
 
   node:
-    image: 'midnightntwrk/midnight-node:0.22.0'
+    image: 'midnightntwrk/midnight-node:0.22.5'
     container_name: 'node'
     ports:
       - '9944:9944'
diff --git a/package.json b/package.json
index 4f63a1a..cd7a3fe 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,13 @@
     "format": "prettier --write \"**/*.{ts,js,json,md,yaml,yml}\"",
     "format:check": "prettier --check \"**/*.{ts,js,json,md,yaml,yml}\"",
     "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint:fix": "eslint . --fix",
+    "verify:protocol:local": "pnpm --filter @midnight-sentinel/protocol-verification verify:local",
+    "verify:protocol:reward-split": "pnpm --filter @midnight-sentinel/protocol-verification verify:reward-split",
+    "verify:protocol:devnet:sponsorship": "pnpm --filter @midnight-sentinel/protocol-verification verify:devnet:sponsorship",
+    "verify:protocol:devnet:composite": "pnpm --filter @midnight-sentinel/protocol-verification verify:devnet:composite",
+    "verify:protocol:devnet:production": "pnpm --filter @midnight-sentinel/protocol-verification verify:devnet:production",
+    "verify:protocol:all": "pnpm verify:protocol:local && pnpm verify:protocol:reward-split && pnpm verify:protocol:devnet:sponsorship && pnpm verify:protocol:devnet:composite && pnpm verify:protocol:devnet:production"
   },
   "devDependencies": {
     "@eslint/js": "^9.28.0",
diff --git a/packages/api/package.json b/packages/api/package.json
index 521941d..d199bbe 100644
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -15,6 +15,21 @@
       "types": "./dist/browser.d.ts",
       "import": "./dist/browser.js",
       "require": "./dist/browser.js"
+    },
+    "./sponsorship": {
+      "types": "./dist/sponsorship/index.d.ts",
+      "import": "./dist/sponsorship/index.js",
+      "require": "./dist/sponsorship/index.js"
+    },
+    "./sponsorship/midnight": {
+      "types": "./dist/sponsorship/midnight.d.ts",
+      "import": "./dist/sponsorship/midnight.js",
+      "require": "./dist/sponsorship/midnight.js"
+    },
+    "./sponsorship/eligibility": {
+      "types": "./dist/sponsorship/eligibility.d.ts",
+      "import": "./dist/sponsorship/eligibility.js",
+      "require": "./dist/sponsorship/eligibility.js"
     }
   },
   "scripts": {
@@ -23,15 +38,15 @@
     "build": "tsc --project ./tsconfig.build.json"
   },
   "dependencies": {
-    "@midnight-ntwrk/compact-js": "2.5.0",
-    "@midnight-ntwrk/compact-runtime": "0.15.0",
+    "@midnight-ntwrk/compact-js": "2.5.1",
+    "@midnight-ntwrk/compact-runtime": "0.16.0",
     "@midnight-ntwrk/dapp-connector-api": "4.0.1",
     "@midnight-ntwrk/ledger-v8": "8.0.3",
-    "@midnight-ntwrk/midnight-js-contracts": "4.0.4",
-    "@midnight-ntwrk/midnight-js-fetch-zk-config-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-types": "4.0.4",
+    "@midnight-ntwrk/midnight-js-contracts": "4.1.1",
+    "@midnight-ntwrk/midnight-js-fetch-zk-config-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-types": "4.1.1",
     "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0-rc.0",
     "@midnight-sentinel/contract": "workspace:*",
     "@midnight-sentinel/wallet": "workspace:*",
diff --git a/packages/api/src/index.ts b/packages/api/src/index.ts
index 944825d..3af1acd 100644
--- a/packages/api/src/index.ts
+++ b/packages/api/src/index.ts
@@ -1,17 +1,6 @@
-import {
-  decodeQualifiedShieldedCoinInfo,
-  QualifiedShieldedCoinInfo,
-  Transaction,
-  SignatureEnabled,
-  Proof,
-  Binding,
-} from '@midnight-ntwrk/ledger-v8';
+import { Transaction, SignatureEnabled, Proof, Binding } from '@midnight-ntwrk/ledger-v8';
 import { MidnightBech32m, ShieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
-import {
-  deployContract,
-  findDeployedContract,
-  withContractScopedTransaction,
-} from '@midnight-ntwrk/midnight-js-contracts';
+import { deployContract, findDeployedContract } from '@midnight-ntwrk/midnight-js-contracts';
 import {
   CompactCompiledContract,
   createPrivateState,
@@ -25,7 +14,6 @@ import {
   type SentinelContractType,
 } from '@midnight-sentinel/contract';
 import { getNetworkId, WalletContext } from '@midnight-sentinel/wallet';
-import { fromHex } from '@midnight-ntwrk/compact-runtime';
 import { map, type Observable } from 'rxjs';
 
 export const toHex = (arr: Uint8Array) =>
@@ -40,57 +28,108 @@ export interface Config {
   proofServer: string;
 }
 
+export interface SentinelSponsorshipConfig {
+  sponsorId: Uint8Array;
+  acceptedColor: Uint8Array;
+  sponsorRewardKey: { bytes: Uint8Array };
+  sponsorRewardEncryptionKey: Uint8Array;
+  sponsorShare: bigint;
+  delegatorShare: bigint;
+  minimumRegisteredNight: bigint;
+  initialEligibilityOperator: Uint8Array;
+  policyHash: Uint8Array;
+}
+
 export interface SentinelDerivedState {
   owner: string;
-  delegators: Ledger['delegators'];
-  shieldedVault: QualifiedShieldedCoinInfo;
-  rewardsVault: QualifiedShieldedCoinInfo;
-  hasShielded: boolean;
-  hasRewards: boolean;
+  sponsorshipSponsorId: Uint8Array;
+  sponsorshipAcceptedColor: Uint8Array;
+  sponsorshipFixedPrice: bigint;
+  sponsorshipSponsorShare: bigint;
+  sponsorshipDelegatorShare: bigint;
+  sponsorshipMinimumRegisteredNight: bigint;
+  sponsorshipPolicyHash: Uint8Array;
+  sponsorshipEnabled: boolean;
+  eligibilityOperator: Uint8Array;
+  delegatorCount: bigint;
+  pausedDelegatorCount: bigint;
+  rewardCursor: bigint;
+  delegatorSlots: Ledger['delegatorSlots'];
+  delegatorPositions: Ledger['delegatorPositions'];
+  sponsorshipPurchases: bigint;
+  sponsorshipReceipts: Ledger['sponsorshipReceipts'];
 }
 
+const deriveSentinelState = (data: Parameters<typeof ledger>[0]): SentinelDerivedState => {
+  const ledgerState = ledger(data);
+  return {
+    owner: toHex(ledgerState.owner),
+    sponsorshipSponsorId: ledgerState.sponsorshipSponsor.id,
+    sponsorshipAcceptedColor: ledgerState.sponsorshipAcceptedColor,
+    sponsorshipFixedPrice: ledgerState.sponsorshipFixedPrice,
+    sponsorshipSponsorShare: ledgerState.sponsorshipSponsor.share,
+    sponsorshipDelegatorShare: ledgerState.sponsorshipDelegatorShare,
+    sponsorshipMinimumRegisteredNight: ledgerState.sponsorshipMinimumRegisteredNight,
+    sponsorshipPolicyHash: ledgerState.sponsorshipSponsor.policyHash,
+    sponsorshipEnabled: ledgerState.sponsorshipEnabled,
+    eligibilityOperator: ledgerState.eligibilityOperator,
+    delegatorCount: ledgerState.delegatorCount,
+    pausedDelegatorCount: ledgerState.pausedDelegatorCount,
+    rewardCursor: ledgerState.rewardCursor,
+    delegatorSlots: ledgerState.delegatorSlots,
+    delegatorPositions: ledgerState.delegatorPositions,
+    sponsorshipPurchases: ledgerState.sponsorshipPurchases,
+    sponsorshipReceipts: ledgerState.sponsorshipReceipts,
+  };
+};
+
 export class SentinelContract {
   readonly providers: SentinelContractProviders;
   readonly deployedContract: SentinelContractDeployed | null;
+  readonly contractAddress: ContractAddress;
   readonly state$: Observable<SentinelDerivedState>;
 
   private constructor(
     providers: SentinelContractProviders,
     deployedContract: SentinelContractDeployed | null,
+    contractAddress: ContractAddress,
     state$: Observable<SentinelDerivedState>
   ) {
     this.providers = providers;
     this.deployedContract = deployedContract;
+    this.contractAddress = contractAddress;
     this.state$ = state$;
   }
 
-  static async deploy(providers: SentinelContractProviders): Promise<SentinelContract> {
+  static async deploy(
+    providers: SentinelContractProviders,
+    sponsorship: SentinelSponsorshipConfig
+  ): Promise<SentinelContract> {
     console.log('[deploy] Starting contract deployment...');
     const deployedContract = await deployContract<SentinelContractType>(providers, {
       compiledContract: CompactCompiledContract,
       privateStateId: sentinelContractPrivateStateKey,
       initialPrivateState: await this.getPrivateState(providers, ''),
+      args: [
+        sponsorship.sponsorId,
+        sponsorship.acceptedColor,
+        sponsorship.sponsorRewardKey,
+        sponsorship.sponsorRewardEncryptionKey,
+        sponsorship.sponsorShare,
+        sponsorship.delegatorShare,
+        sponsorship.minimumRegisteredNight,
+        sponsorship.initialEligibilityOperator,
+        sponsorship.policyHash,
+      ],
     });
 
     const contractAddress = deployedContract.deployTxData.public.contractAddress;
     const state$ = providers.publicDataProvider
       .contractStateObservable(contractAddress, { type: 'latest' })
-      .pipe(
-        map((contractState) => {
-          const ledgerState = ledger(contractState.data);
-          return {
-            owner: toHex(ledgerState.owner),
-            delegators: ledgerState.delegators,
-            shieldedVault: decodeQualifiedShieldedCoinInfo(ledgerState.shieldedVault),
-            rewardsVault: decodeQualifiedShieldedCoinInfo(ledgerState.rewardsVault),
-            hasShielded: ledgerState.hasShielded,
-            hasRewards: ledgerState.hasRewards,
-          };
-        })
-      );
+      .pipe(map((contractState) => deriveSentinelState(contractState.data)));
 
     console.debug('Deployment fees: ', deployedContract.deployTxData.public.fees);
-    return new SentinelContract(providers, deployedContract, state$);
+    return new SentinelContract(providers, deployedContract, contractAddress, state$);
   }
 
   static async join(
@@ -107,41 +146,20 @@ export class SentinelContract {
 
     const state$ = providers.publicDataProvider
       .contractStateObservable(contractAddress, { type: 'latest' })
-      .pipe(
-        map((contractState) => {
-          const ledgerState = ledger(contractState.data);
-          return {
-            owner: toHex(ledgerState.owner),
-            delegators: ledgerState.delegators,
-            shieldedVault: decodeQualifiedShieldedCoinInfo(ledgerState.shieldedVault),
-            rewardsVault: decodeQualifiedShieldedCoinInfo(ledgerState.rewardsVault),
-            hasShielded: ledgerState.hasShielded,
-            hasRewards: ledgerState.hasRewards,
-          };
-        })
-      );
+      .pipe(map((contractState) => deriveSentinelState(contractState.data)));
 
     console.log('[join] Contract joined');
-    return new SentinelContract(providers, deployedContract, state$);
+    return new SentinelContract(providers, deployedContract, contractAddress, state$);
   }
 
   async delegate(key: string, value: bigint) {
-    console.log('[delegate] Building delegate transaction...');
-    const tx = await this.deployedContract?.callTx.delegate({
-      nonce: new Uint8Array(32).fill(0),
-      color: new Uint8Array(32).fill(0),
-      value,
-    });
-    console.log(`[delegate] Sent ${value} NIGHTs on tx: ${tx?.public.txHash}`);
+    void key;
+    void value;
+    throw new Error('Delegation was removed from the sponsorship-only Sentinel');
   }
 
   async withdraw() {
-    console.log('[withdraw] Building withdraw transaction...');
-    const tx = await this.deployedContract?.callTx.withdraw();
-
-    console.log(
-      `[withdraw] Withdrew ${tx?.private.newCoins[0].value} NIGHTs on tx: ${tx?.public.txHash}`
-    );
+    throw new Error('Legacy delegation withdrawal was removed');
   }
 
   async depositRewards(
@@ -149,19 +167,68 @@ export class SentinelContract {
     nonce: Uint8Array<ArrayBufferLike>,
     color: Uint8Array<ArrayBufferLike>
   ) {
-    console.log('[depositRewards] Building deposit transaction...');
-    const tx = await this.deployedContract?.callTx.depositRewards({
-      nonce,
-      color,
-      value,
-    });
-    console.log(`[depositRewards] Deposited ${value} rewards on tx: ${tx?.public.txHash}`);
+    void value;
+    void nonce;
+    void color;
+    throw new Error('Legacy rewards were removed');
   }
 
   async redeemRewards() {
-    console.log('[redeemRewards] Building redeem transaction...');
-    const tx = await this.deployedContract?.callTx.redeemRewards();
-    console.log(`[redeemRewards] Redeemed rewards on tx: ${tx?.public.txHash}`);
+    throw new Error('Legacy rewards were removed');
+  }
+
+  async setSponsorshipEnabled(enabled: boolean) {
+    const tx = await this.deployedContract?.callTx.setSponsorshipEnabled(enabled);
+    console.log(`[sponsorship] ${enabled ? 'Enabled' : 'Paused'} on tx: ${tx?.public.txHash}`);
+    return tx;
+  }
+
+  async addDelegator(input: {
+    identity: Uint8Array;
+    nightRewardAddress: Uint8Array;
+    rewardKey: Uint8Array;
+    rewardEncryptionKey: Uint8Array;
+    registeredAmount: bigint;
+    verificationBlock: bigint;
+    enrollmentNonce: bigint;
+  }) {
+    if (!this.deployedContract) throw new Error('Sentinel contract is not joined');
+    return this.deployedContract.callTx.addDelegator(
+      input.identity,
+      input.nightRewardAddress,
+      { bytes: input.rewardKey },
+      input.rewardEncryptionKey,
+      input.registeredAmount,
+      input.verificationBlock,
+      input.enrollmentNonce
+    );
+  }
+
+  async updateDelegator(input: Parameters<SentinelContract['addDelegator']>[0]) {
+    if (!this.deployedContract) throw new Error('Sentinel contract is not joined');
+    return this.deployedContract.callTx.updateDelegator(
+      input.identity,
+      input.nightRewardAddress,
+      { bytes: input.rewardKey },
+      input.rewardEncryptionKey,
+      input.registeredAmount,
+      input.verificationBlock,
+      input.enrollmentNonce
+    );
+  }
+
+  async removeDelegator(identity: Uint8Array) {
+    if (!this.deployedContract) throw new Error('Sentinel contract is not joined');
+    return this.deployedContract.callTx.removeDelegator(identity);
+  }
+
+  async rotateEligibilityOperator(authority: Uint8Array) {
+    if (!this.deployedContract) throw new Error('Sentinel contract is not joined');
+    return this.deployedContract.callTx.rotateEligibilityOperator(authority);
+  }
+
+  async withdrawSponsorshipRevenue() {
+    throw new Error('Sponsorship treasury recovery is deferred; v1 payments are a contract sink');
   }
 
   static async startZswap(ctx: WalletContext, color: string, amount: string, addr: string) {
@@ -224,18 +291,26 @@ export class SentinelContract {
       subscription?.unsubscribe();
 
       console.log('Owner: ', state.owner);
-      console.log('Shielded vault: ', state.shieldedVault);
-      console.log('Rewards vault: ', state.rewardsVault);
-      if (state.delegators.isEmpty()) {
-        console.log('No delegators found');
-        return;
-      }
-      for (const item of state.delegators) {
-        console.log(`Public Key: ${toHex(item[0])}, Amount delegated: ${item[1].valueOf()}`);
-      }
+      console.log('Sponsorship enabled: ', state.sponsorshipEnabled);
+      console.log('Sponsorship price: ', state.sponsorshipFixedPrice);
+      console.log(
+        'Derived sponsorship revenue: ',
+        state.sponsorshipPurchases * state.sponsorshipFixedPrice
+      );
+      console.log('Sponsorship purchases: ', state.sponsorshipPurchases);
     });
   }
 
+  async readState(): Promise<SentinelDerivedState> {
+    const contractState = await this.providers.publicDataProvider.queryContractState(
+      this.contractAddress
+    );
+    if (!contractState) {
+      throw new Error(`Sentinel state not found: ${this.contractAddress}`);
+    }
+    return deriveSentinelState(contractState.data);
+  }
+
   private static async getPrivateState(
     providers: SentinelContractProviders,
     contractAddress: string
@@ -248,27 +323,9 @@ export class SentinelContract {
   }
 
   async mintFreeToken(recipientCoinPubKeyHex: string, recipientEncPubKeyHex: string) {
-    const domainSep = new Uint8Array(32).fill(1);
-    const mintNonce = crypto.getRandomValues(new Uint8Array(32));
-    const amount = 1000n;
-
-    const additionalMappings = new Map<string, string>([
-      [recipientCoinPubKeyHex, recipientEncPubKeyHex],
-    ]);
-
-    return await withContractScopedTransaction(
-      this.providers,
-      async (txCtx) => {
-        await this.deployedContract?.callTx.mintDirectShielded(
-          txCtx,
-          domainSep,
-          amount,
-          mintNonce,
-          { bytes: fromHex(recipientCoinPubKeyHex) }
-        );
-      },
-      { additionalCoinEncPublicKeyMappings: additionalMappings }
-    );
+    void recipientCoinPubKeyHex;
+    void recipientEncPubKeyHex;
+    throw new Error('Legacy test-token minting was removed');
   }
 }
 
diff --git a/packages/api/src/sponsorship.ts b/packages/api/src/sponsorship.ts
new file mode 100644
index 0000000..c83fecf
--- /dev/null
+++ b/packages/api/src/sponsorship.ts
@@ -0,0 +1,894 @@
+import {
+  Binding,
+  ContractCall,
+  ContractDeploy,
+  LedgerParameters,
+  PreProof,
+  Proof,
+  SignatureEnabled,
+  Transaction,
+  type UnprovenTransaction,
+  encodeQualifiedShieldedCoinInfo,
+  entryPointHash,
+  shieldedToken,
+  type FinalizedTransaction,
+  type ZswapLocalState,
+} from '@midnight-ntwrk/ledger-v8';
+import {
+  ContractState as CompactContractState,
+  CostModel as CompactCostModel,
+  QueryContext as CompactQueryContext,
+  type AlignedValue as CompactAlignedValue,
+  ChargedState as CompactChargedState,
+  type Transcript as CompactTranscript,
+} from '@midnight-ntwrk/compact-runtime';
+import {
+  createUnprovenCallTx,
+  createUnprovenCallTxFromInitialStates,
+} from '@midnight-ntwrk/midnight-js-contracts';
+import { httpClientProofProvider } from '@midnight-ntwrk/midnight-js-http-client-proof-provider';
+import {
+  ZKConfigProvider,
+  type ProverKey,
+  type VerifierKey,
+  type ZKIR,
+} from '@midnight-ntwrk/midnight-js-types';
+import {
+  CompactCompiledContract,
+  ledger as sentinelLedger,
+  sentinelContractPrivateStateKey,
+  type Ledger,
+  type SentinelContractProviders,
+  type SponsorshipReceipt,
+} from '@midnight-sentinel/contract';
+import { signTransactionIntents, type WalletContext } from '@midnight-sentinel/wallet';
+import { createHash } from 'node:crypto';
+import { assertEligible, type MidnightRegistrationProvider } from './sponsorship/eligibility.js';
+
+const FIELD_ENCODING_TAG = 0x73;
+
+const bytesEqual = (left: Uint8Array, right: Uint8Array) =>
+  left.length === right.length && left.every((byte, index) => byte === right[index]);
+
+const bytesHex = (value: Uint8Array) => Buffer.from(value).toString('hex');
+
+export const dustPublicKeyToBytes = (value: bigint) =>
+  Uint8Array.from(Buffer.from(value.toString(16).padStart(64, '0'), 'hex'));
+
+export const nativeNightSponsorshipConfig = (
+  sponsor: WalletContext,
+  policyHash: Uint8Array,
+  options: {
+    sponsorShare?: bigint;
+    delegatorShare?: bigint;
+    minimumRegisteredNight?: bigint;
+    initialEligibilityOperator: Uint8Array;
+  }
+) => {
+  if (policyHash.length !== 32) throw new Error('policyHash must be exactly 32 bytes');
+  return {
+    sponsorId: dustPublicKeyToBytes(sponsor.dustSecretKey.publicKey),
+    acceptedColor: Uint8Array.from(Buffer.from(shieldedToken().raw, 'hex')),
+    sponsorRewardKey: {
+      bytes: Uint8Array.from(Buffer.from(sponsor.shieldedSecretKeys.coinPublicKey, 'hex')),
+    },
+    sponsorRewardEncryptionKey: Uint8Array.from(
+      Buffer.from(sponsor.shieldedSecretKeys.encryptionPublicKey, 'hex')
+    ),
+    sponsorShare: options.sponsorShare ?? 1n,
+    delegatorShare: options.delegatorShare ?? 1n,
+    minimumRegisteredNight: options.minimumRegisteredNight ?? 1n,
+    initialEligibilityOperator: options.initialEligibilityOperator,
+    policyHash,
+  };
+};
+
+export const communicationCommitmentToField = (commitment: string): bigint => {
+  const encoded = Buffer.from(commitment, 'hex');
+  if (encoded.length !== 33 || encoded[0] !== FIELD_ENCODING_TAG) {
+    throw new SponsorshipPolicyError(
+      'INVALID_COMMUNICATION_COMMITMENT',
+      'Expected a tagged 33-byte communication commitment'
+    );
+  }
+  return BigInt(`0x${Buffer.from(encoded.subarray(1)).reverse().toString('hex')}`);
+};
+
+export const fieldToCommunicationCommitment = (field: bigint): string => {
+  if (field < 0n) {
+    throw new SponsorshipPolicyError(
+      'INVALID_COMMUNICATION_COMMITMENT',
+      'Communication commitment field cannot be negative'
+    );
+  }
+  const bigEndian = Buffer.from(field.toString(16).padStart(64, '0'), 'hex');
+  if (bigEndian.length !== 32) {
+    throw new SponsorshipPolicyError(
+      'INVALID_COMMUNICATION_COMMITMENT',
+      'Communication commitment field exceeds 32 bytes'
+    );
+  }
+  return Buffer.concat([
+    Buffer.from([FIELD_ENCODING_TAG]),
+    Buffer.from(bigEndian).reverse(),
+  ]).toString('hex');
+};
+
+export type SponsorshipPolicyCode =
+  | 'INVALID_SERIALIZATION'
+  | 'INVALID_COMMUNICATION_COMMITMENT'
+  | 'WRONG_CALL_COUNT'
+  | 'UNEXPECTED_ACTION'
+  | 'WRONG_SPONSORSHIP_CONTRACT'
+  | 'WRONG_SPONSORSHIP_ENTRY_POINT'
+  | 'UNAPPROVED_TARGET'
+  | 'PURCHASE_NOT_GUARANTEED'
+  | 'DUST_ALREADY_PRESENT'
+  | 'TTL_OUT_OF_RANGE'
+  | 'FEE_TOO_HIGH'
+  | 'UNRELATED_TRANSFER'
+  | 'CAMPAIGN_MISMATCH'
+  | 'TARGET_ALREADY_SPONSORED'
+  | 'RECEIPT_MISMATCH'
+  | 'STALE_CONTRACT_STATE'
+  | 'NO_ELIGIBLE_DELEGATOR'
+  | 'DELEGATOR_STALE'
+  | 'REWARD_DELIVERY_FAILED'
+  | 'CAMPAIGN_VERSION_UNSUPPORTED';
+
+export class SponsorshipPolicyError extends Error {
+  readonly code: SponsorshipPolicyCode;
+
+  constructor(code: SponsorshipPolicyCode, message: string) {
+    super(message);
+    this.name = 'SponsorshipPolicyError';
+    this.code = code;
+  }
+}
+
+export interface SponsorshipTargetPolicy {
+  address: string;
+  entryPoint: string;
+}
+
+export const sponsorshipAllowlistHash = (
+  targets: readonly SponsorshipTargetPolicy[]
+): Uint8Array => {
+  const canonical = [...targets]
+    .map(({ address, entryPoint }) => ({
+      address: address.toLowerCase(),
+      entryPoint,
+    }))
+    .sort(
+      (left, right) =>
+        left.address.localeCompare(right.address) || left.entryPoint.localeCompare(right.entryPoint)
+    );
+  return Uint8Array.from(
+    createHash('sha256')
+      .update(JSON.stringify({ version: 1, targets: canonical }))
+      .digest()
+  );
+};
+
+export interface SponsorPolicy {
+  sentinelAddress: string;
+  sponsorId: Uint8Array;
+  sponsorDustAddress: string;
+  registrationProvider: MidnightRegistrationProvider;
+  policyHash: Uint8Array;
+  allowedTargets: readonly SponsorshipTargetPolicy[];
+  minTtlMs: number;
+  maxTtlMs: number;
+  maxFee: bigint;
+}
+
+export interface PreparedTargetCall {
+  readonly private: {
+    readonly unprovenTx: UnprovenTransaction;
+  };
+}
+
+export interface PrepareSponsoredTransactionOptions {
+  targetCall: PreparedTargetCall;
+  targetZkConfigProvider: ZKConfigProvider<string>;
+  sentinelProviders: SentinelContractProviders;
+  sentinelAddress: string;
+  beneficiary: WalletContext;
+  proofServer: string;
+  ttl: Date;
+  purchaseId?: Uint8Array;
+}
+
+export interface PreparedSponsoredTransaction {
+  finalizedTransaction: FinalizedTransaction;
+  serializedTransaction: Uint8Array;
+  purchaseId: Uint8Array;
+  targetAddress: string;
+  targetEntryPoint: string;
+  targetCommunicationCommitment: string;
+}
+
+export interface SponsorshipInspection {
+  transaction: FinalizedTransaction;
+  purchaseId: Uint8Array;
+  receipt: SponsorshipReceipt;
+  targetAddress: string;
+  targetEntryPoint: string;
+  targetCommunicationCommitment: string;
+  targetHasFallibleTranscript: boolean;
+  feeEstimate?: bigint;
+}
+
+export interface SponsorshipSubmission {
+  txId: string;
+  status: string;
+  feeEstimate: bigint;
+  purchaseId: Uint8Array;
+  targetAddress: string;
+  targetEntryPoint: string;
+  targetCommunicationCommitment: string;
+}
+
+class MultiplexZkConfigProvider extends ZKConfigProvider<string> {
+  readonly providers: ReadonlyMap<string, ZKConfigProvider<string>>;
+
+  constructor(providers: ReadonlyMap<string, ZKConfigProvider<string>>) {
+    super();
+    this.providers = providers;
+  }
+
+  private provider(circuitId: string) {
+    const provider = this.providers.get(circuitId);
+    if (!provider) throw new Error(`No ZK configuration registered for circuit ${circuitId}`);
+    return provider;
+  }
+
+  getProverKey(circuitId: string): Promise<ProverKey> {
+    return this.provider(circuitId).getProverKey(circuitId);
+  }
+
+  getVerifierKey(circuitId: string): Promise<VerifierKey> {
+    return this.provider(circuitId).getVerifierKey(circuitId);
+  }
+
+  getZKIR(circuitId: string): Promise<ZKIR> {
+    return this.provider(circuitId).getZKIR(circuitId);
+  }
+}
+
+const contractCalls = <
+  P extends PreProof | Proof,
+  B extends Binding | import('@midnight-ntwrk/ledger-v8').PreBinding,
+>(
+  transaction: Transaction<SignatureEnabled, P, B>
+) =>
+  [...(transaction.intents?.values() ?? [])].flatMap((intent) =>
+    intent.actions.filter((action): action is ContractCall<P> => action instanceof ContractCall)
+  );
+
+const intentTtls = (transaction: FinalizedTransaction) =>
+  [...(transaction.intents?.values() ?? [])].map((intent) => intent.ttl);
+
+const hasDust = (transaction: FinalizedTransaction) =>
+  [...(transaction.intents?.values() ?? [])].some((intent) => intent.dustActions !== undefined);
+
+const entryPointName = (entryPoint: string | Uint8Array) =>
+  typeof entryPoint === 'string' ? entryPoint : Buffer.from(entryPoint).toString('utf8');
+
+const selectedTargetCall = (targetCall: PreparedTargetCall) => {
+  const calls = contractCalls(targetCall.private.unprovenTx);
+  if (calls.length !== 1) {
+    throw new SponsorshipPolicyError(
+      'WRONG_CALL_COUNT',
+      `A prepared target must contain exactly one contract call; received ${calls.length}`
+    );
+  }
+  return calls[0];
+};
+
+const randomPurchaseId = () => crypto.getRandomValues(new Uint8Array(32));
+
+const syncedWalletState = async (wallet: WalletContext) => {
+  const Rx = await import('rxjs');
+  return Rx.firstValueFrom(wallet.wallet.state().pipe(Rx.filter((state) => state.isSynced)));
+};
+
+export const prepareSponsoredTransaction = async (
+  options: PrepareSponsoredTransactionOptions
+): Promise<PreparedSponsoredTransaction> => {
+  const target = selectedTargetCall(options.targetCall);
+  const targetEntryPoint = entryPointName(target.entryPoint);
+  if (
+    targetEntryPoint === 'purchaseDelegatorReward' ||
+    targetEntryPoint === 'deliverSponsorReward'
+  ) {
+    throw new Error('Target circuit ID collides with Sentinel reward circuits');
+  }
+
+  const stateData = await options.sentinelProviders.publicDataProvider.queryZSwapAndContractState(
+    options.sentinelAddress
+  );
+  if (!stateData) throw new Error('Sentinel contract state not found');
+  const campaign = sentinelLedger(stateData[1].data);
+  if (!campaign.sponsorshipEnabled) throw new Error('Sponsorship campaign is paused');
+  if (campaign.delegatorCount === 0n) throw new Error('NO_ELIGIBLE_DELEGATOR');
+  const selected = campaign.delegatorSlots.lookup(campaign.rewardCursor);
+
+  const walletState = await syncedWalletState(options.beneficiary);
+  const paymentCoins = [...(walletState.shielded.state.state as ZswapLocalState).coins].filter(
+    (coin) =>
+      coin.type === bytesHex(campaign.sponsorshipAcceptedColor) &&
+      (coin.value === campaign.sponsorshipDelegatorShare ||
+        coin.value === campaign.sponsorshipSponsor.share)
+  );
+  const delegatorCoin = paymentCoins.find(
+    (coin) => coin.value === campaign.sponsorshipDelegatorShare
+  );
+  const sponsorCoin = paymentCoins.find(
+    (coin) => coin.value === campaign.sponsorshipSponsor.share && coin !== delegatorCoin
+  );
+  if (!delegatorCoin || !sponsorCoin) {
+    throw new Error(
+      `Exact ${campaign.sponsorshipDelegatorShare} and ${campaign.sponsorshipSponsor.share} NIGHT payment coins are required`
+    );
+  }
+
+  const encodedDelegator = encodeQualifiedShieldedCoinInfo(delegatorCoin);
+  const encodedSponsor = encodeQualifiedShieldedCoinInfo(sponsorCoin);
+  const delegatorPayment = {
+    nonce: encodedDelegator.nonce,
+    color: encodedDelegator.color,
+    value: campaign.sponsorshipDelegatorShare,
+  };
+  const sponsorPayment = {
+    nonce: encodedSponsor.nonce,
+    color: encodedSponsor.color,
+    value: campaign.sponsorshipSponsor.share,
+  };
+  const purchaseId = options.purchaseId ?? randomPurchaseId();
+  if (purchaseId.length !== 32) throw new Error('purchaseId must be exactly 32 bytes');
+
+  const targetCommitment = target.communicationCommitment;
+  const targetCommitmentField = communicationCommitmentToField(targetCommitment);
+  const delegatorCall = await createUnprovenCallTx(options.sentinelProviders, {
+    compiledContract: CompactCompiledContract,
+    contractAddress: options.sentinelAddress,
+    circuitId: 'purchaseDelegatorReward',
+    privateStateId: sentinelContractPrivateStateKey,
+    additionalCoinEncPublicKeyMappings: new Map([
+      [bytesHex(selected.rewardKey.bytes), bytesHex(selected.rewardEncryptionKey)],
+    ]),
+    args: [delegatorPayment],
+  });
+  if (
+    delegatorCall.public.partitionedTranscript[0] === undefined ||
+    delegatorCall.public.partitionedTranscript[1] !== undefined
+  ) {
+    throw new Error('purchaseDelegatorReward must compile as guaranteed-only');
+  }
+
+  const postDelegatorState = CompactContractState.deserialize(stateData[1].serialize());
+  postDelegatorState.data = new CompactChargedState(delegatorCall.public.nextContractState);
+  const sponsorCall = await createUnprovenCallTxFromInitialStates(
+    options.sentinelProviders.zkConfigProvider,
+    {
+      compiledContract: CompactCompiledContract,
+      contractAddress: options.sentinelAddress,
+      circuitId: 'deliverSponsorReward',
+      args: [
+        purchaseId,
+        sponsorPayment,
+        Buffer.from(target.address, 'hex'),
+        Buffer.from(entryPointHash(target.entryPoint), 'hex'),
+        targetCommitmentField,
+      ],
+      coinPublicKey: options.beneficiary.shieldedSecretKeys.coinPublicKey,
+      initialContractState: postDelegatorState,
+      initialZswapChainState: stateData[0],
+      ledgerParameters: LedgerParameters.initialParameters(),
+      initialPrivateState: delegatorCall.private.nextPrivateState,
+      additionalCoinEncPublicKeyMappings: new Map([
+        [
+          bytesHex(campaign.sponsorshipSponsor.rewardKey.bytes),
+          bytesHex(campaign.sponsorshipSponsor.rewardEncryptionKey),
+        ],
+      ]),
+    },
+    options.beneficiary.shieldedSecretKeys.encryptionPublicKey
+  );
+  if (
+    sponsorCall.public.partitionedTranscript[0] !== undefined ||
+    sponsorCall.public.partitionedTranscript[1] === undefined
+  ) {
+    throw new Error('deliverSponsorReward must compile as fallible-only');
+  }
+
+  const providers = new Map<string, ZKConfigProvider<string>>([
+    [targetEntryPoint, options.targetZkConfigProvider],
+    [
+      'purchaseDelegatorReward',
+      options.sentinelProviders.zkConfigProvider as ZKConfigProvider<string>,
+    ],
+    [
+      'deliverSponsorReward',
+      options.sentinelProviders.zkConfigProvider as ZKConfigProvider<string>,
+    ],
+  ]);
+  const proofProvider = httpClientProofProvider(
+    options.proofServer,
+    new MultiplexZkConfigProvider(providers)
+  );
+  const sourceTransactions = [
+    delegatorCall.private.unprovenTx,
+    sponsorCall.private.unprovenTx,
+    options.targetCall.private.unprovenTx,
+  ];
+  const merged = sourceTransactions[0];
+  const primaryEntry = [...(merged.intents?.entries() ?? [])][0];
+  if (!primaryEntry) throw new Error('Delegator call has no intent');
+  const [segment, primaryIntent] = primaryEntry;
+  primaryIntent.actions = sourceTransactions.flatMap((tx) =>
+    [...(tx.intents?.values() ?? [])].flatMap((intent) => intent.actions)
+  );
+  merged.intents = new Map([[segment, primaryIntent]]);
+  merged.guaranteedOffer = sourceTransactions
+    .map((tx) => tx.guaranteedOffer)
+    .filter((offer) => offer !== undefined)
+    .reduce((left, right) => left.merge(right));
+  const fallibleOffers = sourceTransactions.flatMap((tx) => [
+    ...(tx.fallibleOffer?.values() ?? []),
+  ]);
+  merged.fallibleOffer =
+    fallibleOffers.length === 0
+      ? undefined
+      : new Map([[segment, fallibleOffers.reduce((left, right) => left.merge(right))]]);
+  const proven = await proofProvider.proveTx(merged);
+  const recipe = await options.beneficiary.wallet.balanceUnboundTransaction(
+    proven,
+    {
+      shieldedSecretKeys: options.beneficiary.shieldedSecretKeys,
+      dustSecretKey: options.beneficiary.dustSecretKey,
+    },
+    {
+      ttl: options.ttl,
+      tokenKindsToBalance: ['shielded', 'unshielded'],
+    }
+  );
+  const sign = (payload: Uint8Array) => options.beneficiary.unshieldedKeystore.signData(payload);
+  signTransactionIntents(recipe.baseTransaction, sign, 'proof');
+  if (recipe.balancingTransaction) {
+    signTransactionIntents(recipe.balancingTransaction, sign, 'pre-proof');
+  }
+  const finalizedTransaction = await options.beneficiary.wallet.finalizeRecipe(recipe);
+  if (hasDust(finalizedTransaction)) {
+    throw new Error('Beneficiary transaction unexpectedly contains a DUST action');
+  }
+
+  return {
+    finalizedTransaction,
+    serializedTransaction: finalizedTransaction.serialize(),
+    purchaseId,
+    targetAddress: target.address,
+    targetEntryPoint,
+    targetCommunicationCommitment: targetCommitment,
+  };
+};
+
+const receiptDelta = (
+  before: Ledger['sponsorshipReceipts'],
+  after: Ledger['sponsorshipReceipts']
+) => {
+  const beforeKeys = new Set([...before].map(([key]) => bytesHex(key)));
+  return [...after].filter(([key]) => !beforeKeys.has(bytesHex(key)));
+};
+
+const simulatePurchase = (
+  sentinelAddress: string,
+  state: CompactChargedState,
+  transcript: CompactTranscript<CompactAlignedValue>
+) => {
+  try {
+    const context = new CompactQueryContext(state, sentinelAddress);
+    const after = context.runTranscript(transcript, CompactCostModel.initialCostModel());
+    return { state: after.state, ledger: sentinelLedger(after.state) };
+  } catch (error) {
+    throw new SponsorshipPolicyError(
+      'STALE_CONTRACT_STATE',
+      `Sentinel purchase transcript does not execute against latest state: ${
+        error instanceof Error ? error.message : String(error)
+      }`
+    );
+  }
+};
+
+const validateTtl = (transaction: FinalizedTransaction, policy: SponsorPolicy, now: Date) => {
+  const ttls = intentTtls(transaction);
+  if (ttls.length === 0) {
+    throw new SponsorshipPolicyError('TTL_OUT_OF_RANGE', 'Transaction has no intent TTL');
+  }
+  for (const ttl of ttls) {
+    const remaining = ttl.getTime() - now.getTime();
+    if (remaining < policy.minTtlMs || remaining > policy.maxTtlMs) {
+      throw new SponsorshipPolicyError(
+        'TTL_OUT_OF_RANGE',
+        `Intent TTL ${ttl.toISOString()} has ${remaining}ms remaining; expected between ${policy.minTtlMs}ms and ${policy.maxTtlMs}ms`
+      );
+    }
+  }
+};
+
+const validateNoUnrelatedTransfers = (
+  transaction: FinalizedTransaction,
+  calls: ContractCall<Proof>[]
+) => {
+  const claimedNullifiers = new Set(
+    calls.flatMap((call) => [
+      ...(call.guaranteedTranscript?.effects.claimedNullifiers ?? []),
+      ...(call.fallibleTranscript?.effects.claimedNullifiers ?? []),
+    ])
+  );
+  const claimedCommitments = new Set(
+    calls.flatMap((call) => [
+      ...(call.guaranteedTranscript?.effects.claimedShieldedReceives ?? []),
+      ...(call.guaranteedTranscript?.effects.claimedShieldedSpends ?? []),
+      ...(call.fallibleTranscript?.effects.claimedShieldedReceives ?? []),
+      ...(call.fallibleTranscript?.effects.claimedShieldedSpends ?? []),
+    ])
+  );
+  const offers = [
+    ...(transaction.guaranteedOffer ? [transaction.guaranteedOffer] : []),
+    ...[...(transaction.fallibleOffer?.values() ?? [])],
+  ];
+  const unclaimedInputs = offers
+    .flatMap((offer) => offer.inputs)
+    .filter((input) => !claimedNullifiers.has(input.nullifier));
+  const unclaimedOutputs = offers
+    .flatMap((offer) => offer.outputs)
+    .filter((output) => !claimedCommitments.has(output.commitment));
+  const unclaimedTransients = offers
+    .flatMap((offer) => offer.transients)
+    .filter(
+      (transient) =>
+        !claimedNullifiers.has(transient.nullifier) && !claimedCommitments.has(transient.commitment)
+    );
+  if (
+    unclaimedInputs.length !== 2 ||
+    unclaimedOutputs.length !== 0 ||
+    unclaimedTransients.length !== 0
+  ) {
+    throw new SponsorshipPolicyError(
+      'UNRELATED_TRANSFER',
+      `Transaction contains shielded movements beyond the exact sponsorship payment and claimed call effects: ${JSON.stringify(
+        {
+          externalInputs: unclaimedInputs.length,
+          externalOutputs: unclaimedOutputs.length,
+          externalTransients: unclaimedTransients.length,
+        }
+      )}`
+    );
+  }
+  const hasUnshielded = [...(transaction.intents?.values() ?? [])].some(
+    (intent) =>
+      intent.guaranteedUnshieldedOffer !== undefined || intent.fallibleUnshieldedOffer !== undefined
+  );
+  if (hasUnshielded) {
+    throw new SponsorshipPolicyError(
+      'UNRELATED_TRANSFER',
+      'Unshielded transfers are not permitted by the v1 sponsorship policy'
+    );
+  }
+};
+
+export const inspectSponsorshipRequest = async (
+  serialized: Uint8Array,
+  policy: SponsorPolicy,
+  providers: SentinelContractProviders,
+  options: { expectDust?: boolean; feeEstimate?: bigint; now?: Date } = {}
+): Promise<SponsorshipInspection> => {
+  let transaction: FinalizedTransaction;
+  try {
+    transaction = Transaction.deserialize<SignatureEnabled, Proof, Binding>(
+      'signature',
+      'proof',
+      'binding',
+      serialized
+    );
+    if (!bytesEqual(transaction.serialize(), serialized)) {
+      throw new Error('serialization round-trip changed bytes');
+    }
+  } catch (error) {
+    throw new SponsorshipPolicyError(
+      'INVALID_SERIALIZATION',
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+
+  const intents = [...(transaction.intents?.values() ?? [])];
+  const actions = intents.flatMap((intent) => intent.actions);
+  if (actions.some((action) => action instanceof ContractDeploy)) {
+    throw new SponsorshipPolicyError('UNEXPECTED_ACTION', 'Contract deployments are not allowed');
+  }
+  if (actions.some((action) => !(action instanceof ContractCall))) {
+    throw new SponsorshipPolicyError('UNEXPECTED_ACTION', 'Unexpected contract action');
+  }
+  const calls = contractCalls(transaction);
+  const callIntents = intents.filter((intent) =>
+    intent.actions.some((action) => action instanceof ContractCall)
+  );
+  if (callIntents.length !== 1) {
+    throw new SponsorshipPolicyError(
+      'WRONG_CALL_COUNT',
+      'All contract calls must be in one ordered intent'
+    );
+  }
+  if (calls.length !== 3) {
+    throw new SponsorshipPolicyError(
+      'WRONG_CALL_COUNT',
+      `Expected exactly three contract calls; received ${calls.length}`
+    );
+  }
+
+  const [delegatorReward, sponsorReward, target] = calls;
+  if (
+    delegatorReward.address !== policy.sentinelAddress ||
+    sponsorReward.address !== policy.sentinelAddress
+  ) {
+    throw new SponsorshipPolicyError(
+      'WRONG_SPONSORSHIP_CONTRACT',
+      'Sentinel sponsorship call is missing'
+    );
+  }
+  if (
+    entryPointName(delegatorReward.entryPoint) !== 'purchaseDelegatorReward' ||
+    entryPointName(sponsorReward.entryPoint) !== 'deliverSponsorReward'
+  ) {
+    throw new SponsorshipPolicyError(
+      'WRONG_SPONSORSHIP_ENTRY_POINT',
+      'Sentinel reward calls are missing or reordered'
+    );
+  }
+  if (
+    !delegatorReward.guaranteedTranscript ||
+    delegatorReward.fallibleTranscript ||
+    sponsorReward.guaranteedTranscript ||
+    !sponsorReward.fallibleTranscript
+  ) {
+    throw new SponsorshipPolicyError(
+      'PURCHASE_NOT_GUARANTEED',
+      'Reward calls do not have the required guaranteed/fallible partition'
+    );
+  }
+
+  const targetEntryPoint = entryPointName(target.entryPoint);
+  if (!target.fallibleTranscript) {
+    throw new SponsorshipPolicyError(
+      'PURCHASE_NOT_GUARANTEED',
+      'Target call must contain a fallible transcript'
+    );
+  }
+  if (
+    !policy.allowedTargets.some(
+      (allowed) => allowed.address === target.address && allowed.entryPoint === targetEntryPoint
+    )
+  ) {
+    throw new SponsorshipPolicyError('UNAPPROVED_TARGET', 'Target call is not approved');
+  }
+
+  const dustPresent = hasDust(transaction);
+  if (dustPresent !== Boolean(options.expectDust)) {
+    throw new SponsorshipPolicyError(
+      'DUST_ALREADY_PRESENT',
+      options.expectDust ? 'Sponsored transaction is missing DUST' : 'DUST already present'
+    );
+  }
+  validateTtl(transaction, policy, options.now ?? new Date());
+  validateNoUnrelatedTransfers(transaction, calls);
+
+  const queried = await providers.publicDataProvider.queryZSwapAndContractState(
+    policy.sentinelAddress
+  );
+  if (!queried) {
+    throw new SponsorshipPolicyError('CAMPAIGN_MISMATCH', 'Sentinel state was not found');
+  }
+  const [, contractState] = queried;
+  const before = sentinelLedger(contractState.data);
+  if (
+    !bytesEqual(before.sponsorshipSponsor.id, policy.sponsorId) ||
+    !bytesEqual(before.sponsorshipSponsor.policyHash, policy.policyHash) ||
+    !before.sponsorshipEnabled
+  ) {
+    throw new SponsorshipPolicyError(
+      'CAMPAIGN_MISMATCH',
+      'On-chain campaign does not match sponsor policy'
+    );
+  }
+  const targetCommitmentField = communicationCommitmentToField(target.communicationCommitment);
+  if (
+    [...before.sponsorshipReceipts].some(
+      ([, existing]) => existing.targetCommunicationCommitment === targetCommitmentField
+    )
+  ) {
+    throw new SponsorshipPolicyError(
+      'TARGET_ALREADY_SPONSORED',
+      'Target interaction has already been sponsored'
+    );
+  }
+  const afterDelegator = simulatePurchase(
+    policy.sentinelAddress,
+    CompactContractState.deserialize(contractState.serialize()).data,
+    delegatorReward.guaranteedTranscript as CompactTranscript<CompactAlignedValue>
+  );
+  const afterSponsor = simulatePurchase(
+    policy.sentinelAddress,
+    afterDelegator.state,
+    sponsorReward.fallibleTranscript as CompactTranscript<CompactAlignedValue>
+  );
+  const after = afterSponsor.ledger;
+  const addedReceipts = receiptDelta(before.sponsorshipReceipts, after.sponsorshipReceipts);
+  if (
+    addedReceipts.length !== 1 ||
+    after.sponsorshipPurchases !== before.sponsorshipPurchases + 1n
+  ) {
+    throw new SponsorshipPolicyError(
+      'RECEIPT_MISMATCH',
+      'Purchase transcript does not produce the exact expected receipt and accounting delta'
+    );
+  }
+  const [purchaseId, receipt] = addedReceipts[0];
+  if (
+    !bytesEqual(receipt.targetAddress, Buffer.from(target.address, 'hex')) ||
+    !bytesEqual(
+      receipt.targetEntryPointHash,
+      Buffer.from(entryPointHash(target.entryPoint), 'hex')
+    ) ||
+    receipt.targetCommunicationCommitment !== targetCommitmentField
+  ) {
+    throw new SponsorshipPolicyError(
+      'RECEIPT_MISMATCH',
+      'Receipt does not bind the approved target call'
+    );
+  }
+  if (options.feeEstimate !== undefined && options.feeEstimate > policy.maxFee) {
+    throw new SponsorshipPolicyError(
+      'FEE_TOO_HIGH',
+      `Estimated fee ${options.feeEstimate} exceeds ${policy.maxFee}`
+    );
+  }
+
+  return {
+    transaction,
+    purchaseId,
+    receipt,
+    targetAddress: target.address,
+    targetEntryPoint,
+    targetCommunicationCommitment: target.communicationCommitment,
+    targetHasFallibleTranscript: target.fallibleTranscript !== undefined,
+    feeEstimate: options.feeEstimate,
+  };
+};
+
+const sponsorAndSubmitUnlocked = async (
+  serialized: Uint8Array,
+  policy: SponsorPolicy,
+  providers: SentinelContractProviders,
+  sponsor: WalletContext
+): Promise<SponsorshipSubmission> => {
+  const sponsorTtlMs = Math.min(policy.maxTtlMs, 30 * 60_000);
+  if (sponsorTtlMs < policy.minTtlMs) {
+    throw new SponsorshipPolicyError(
+      'TTL_OUT_OF_RANGE',
+      'Sponsor policy minimum TTL exceeds the sponsor balancing TTL'
+    );
+  }
+  const expectedSponsor = dustPublicKeyToBytes(sponsor.dustSecretKey.publicKey);
+  if (!bytesEqual(expectedSponsor, policy.sponsorId)) {
+    throw new SponsorshipPolicyError(
+      'CAMPAIGN_MISMATCH',
+      'Sponsor wallet DUST public key does not match campaign sponsor ID'
+    );
+  }
+  const before = await inspectSponsorshipRequest(serialized, policy, providers);
+  const current = await providers.publicDataProvider.queryZSwapAndContractState(
+    policy.sentinelAddress
+  );
+  if (!current) {
+    throw new SponsorshipPolicyError('CAMPAIGN_MISMATCH', 'Sentinel state was not found');
+  }
+  const campaign = sentinelLedger(current[1].data);
+  if (campaign.delegatorCount === 0n) {
+    throw new SponsorshipPolicyError('NO_ELIGIBLE_DELEGATOR', 'No eligible delegator is available');
+  }
+  const selected = campaign.delegatorSlots.lookup(campaign.rewardCursor);
+  const rewardAddress = Buffer.from(selected.nightRewardAddress)
+    .toString('utf8')
+    .replace(/\0+$/, '');
+  try {
+    assertEligible(
+      await policy.registrationProvider.getStatus(rewardAddress),
+      policy.sponsorDustAddress,
+      campaign.sponsorshipMinimumRegisteredNight
+    );
+  } catch (error) {
+    throw new SponsorshipPolicyError(
+      'DELEGATOR_STALE',
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  const feeEstimate = await sponsor.wallet.estimateTransactionFee(
+    before.transaction,
+    sponsor.dustSecretKey,
+    { ttl: new Date(Date.now() + sponsorTtlMs) }
+  );
+  if (feeEstimate > policy.maxFee) {
+    throw new SponsorshipPolicyError(
+      'FEE_TOO_HIGH',
+      `Estimated fee ${feeEstimate} exceeds ${policy.maxFee}`
+    );
+  }
+
+  const recipe = await sponsor.wallet.balanceFinalizedTransaction(
+    before.transaction,
+    {
+      shieldedSecretKeys: sponsor.shieldedSecretKeys,
+      dustSecretKey: sponsor.dustSecretKey,
+    },
+    {
+      ttl: new Date(Date.now() + sponsorTtlMs),
+      tokenKindsToBalance: ['dust'],
+    }
+  );
+  const sponsored = await sponsor.wallet.finalizeRecipe(recipe);
+  const after = await inspectSponsorshipRequest(sponsored.serialize(), policy, providers, {
+    expectDust: true,
+    feeEstimate,
+  });
+  if (
+    before.targetAddress !== after.targetAddress ||
+    before.targetEntryPoint !== after.targetEntryPoint ||
+    before.targetCommunicationCommitment !== after.targetCommunicationCommitment ||
+    !bytesEqual(before.purchaseId, after.purchaseId)
+  ) {
+    throw new SponsorshipPolicyError(
+      'RECEIPT_MISMATCH',
+      'Sponsorship balancing changed the committed request'
+    );
+  }
+
+  const txId = await sponsor.wallet.submitTransaction(sponsored);
+  const finalized = await providers.publicDataProvider.watchForTxData(txId);
+  return {
+    txId,
+    status: finalized.status,
+    feeEstimate,
+    purchaseId: after.purchaseId,
+    targetAddress: after.targetAddress,
+    targetEntryPoint: after.targetEntryPoint,
+    targetCommunicationCommitment: after.targetCommunicationCommitment,
+  };
+};
+
+const submissionTails = new Map<string, Promise<void>>();
+
+export const sponsorAndSubmit = async (
+  serialized: Uint8Array,
+  policy: SponsorPolicy,
+  providers: SentinelContractProviders,
+  sponsor: WalletContext
+): Promise<SponsorshipSubmission> => {
+  const previous = submissionTails.get(policy.sentinelAddress) ?? Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => current);
+  submissionTails.set(policy.sentinelAddress, tail);
+  await previous;
+  try {
+    return await sponsorAndSubmitUnlocked(serialized, policy, providers, sponsor);
+  } finally {
+    release();
+    if (submissionTails.get(policy.sentinelAddress) === tail) {
+      submissionTails.delete(policy.sentinelAddress);
+    }
+  }
+};
diff --git a/packages/api/src/sponsorship/eligibility.ts b/packages/api/src/sponsorship/eligibility.ts
new file mode 100644
index 0000000..8a246e9
--- /dev/null
+++ b/packages/api/src/sponsorship/eligibility.ts
@@ -0,0 +1,291 @@
+import { createHash } from 'node:crypto';
+import { addressFromKey, verifySignature } from '@midnight-ntwrk/ledger-v8';
+import { MidnightBech32m, UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+
+export type Hex32 = string;
+
+export interface EnrollmentPayload {
+  version: 1;
+  network: string;
+  sentinelAddress: Hex32;
+  sponsorDustAddress: string;
+  nightRewardAddress: string;
+  nightVerificationKey: string;
+  shieldedCoinPublicKey: Hex32;
+  shieldedEncryptionPublicKey: Hex32;
+  nonce: string;
+  expiresAt: string;
+}
+
+export interface SignedEnrollment {
+  payload: EnrollmentPayload;
+  signature: string;
+}
+
+export interface EnrollmentSignatureVerifier {
+  verify(input: {
+    verificationKey: string;
+    address: string;
+    message: Uint8Array;
+    signature: string;
+  }): boolean;
+}
+
+export interface EnrollmentExpectation {
+  network: string;
+  sentinelAddress: string;
+  sponsorDustAddress: string;
+  now?: Date;
+}
+
+export class EligibilityError extends Error {
+  constructor(
+    readonly code:
+      | 'ENROLLMENT_INVALID'
+      | 'ENROLLMENT_EXPIRED'
+      | 'ENROLLMENT_REPLAYED'
+      | 'ELIGIBILITY_QUERY_FAILED'
+      | 'DELEGATOR_STALE',
+    message: string,
+    options?: { cause?: unknown }
+  ) {
+    super(message, options);
+    this.name = 'EligibilityError';
+  }
+}
+
+const normalizedHex32 = (value: string, label: string) => {
+  const normalized = value.toLowerCase().replace(/^0x/, '');
+  if (!/^[0-9a-f]{64}$/.test(normalized)) {
+    throw new EligibilityError('ENROLLMENT_INVALID', `${label} must be 32-byte hex`);
+  }
+  return normalized;
+};
+
+const canonicalPayload = (payload: EnrollmentPayload) => ({
+  version: payload.version,
+  network: payload.network,
+  sentinelAddress: normalizedHex32(payload.sentinelAddress, 'sentinelAddress'),
+  sponsorDustAddress: payload.sponsorDustAddress,
+  nightRewardAddress: payload.nightRewardAddress,
+  nightVerificationKey: payload.nightVerificationKey.toLowerCase(),
+  shieldedCoinPublicKey: normalizedHex32(payload.shieldedCoinPublicKey, 'shieldedCoinPublicKey'),
+  shieldedEncryptionPublicKey: normalizedHex32(
+    payload.shieldedEncryptionPublicKey,
+    'shieldedEncryptionPublicKey'
+  ),
+  nonce: BigInt(payload.nonce).toString(),
+  expiresAt: new Date(payload.expiresAt).toISOString(),
+});
+
+export const enrollmentSigningBytes = (payload: EnrollmentPayload) =>
+  Uint8Array.from(
+    Buffer.from(
+      JSON.stringify({
+        domain: 'midnight-sentinel/delegator-enrollment',
+        ...canonicalPayload(payload),
+      }),
+      'utf8'
+    )
+  );
+
+export const enrollmentIdentity = (nightRewardAddress: string) =>
+  Uint8Array.from(
+    createHash('sha256')
+      .update('midnight-sentinel/night-identity/v1\0')
+      .update(nightRewardAddress)
+      .digest()
+  );
+
+export const verifyEnrollment = (
+  enrollment: SignedEnrollment,
+  expected: EnrollmentExpectation,
+  verifier: EnrollmentSignatureVerifier
+) => {
+  let canonical: ReturnType<typeof canonicalPayload>;
+  try {
+    canonical = canonicalPayload(enrollment.payload);
+  } catch (error) {
+    if (error instanceof EligibilityError) throw error;
+    throw new EligibilityError('ENROLLMENT_INVALID', 'Malformed enrollment payload', {
+      cause: error,
+    });
+  }
+  if (
+    canonical.version !== 1 ||
+    canonical.network !== expected.network ||
+    canonical.sentinelAddress !== normalizedHex32(expected.sentinelAddress, 'sentinelAddress') ||
+    canonical.sponsorDustAddress !== expected.sponsorDustAddress
+  ) {
+    throw new EligibilityError('ENROLLMENT_INVALID', 'Enrollment does not match the campaign');
+  }
+  if (new Date(canonical.expiresAt).getTime() <= (expected.now ?? new Date()).getTime()) {
+    throw new EligibilityError('ENROLLMENT_EXPIRED', 'Enrollment has expired');
+  }
+  const valid = verifier.verify({
+    verificationKey: canonical.nightVerificationKey,
+    address: canonical.nightRewardAddress,
+    message: enrollmentSigningBytes(enrollment.payload),
+    signature: enrollment.signature,
+  });
+  if (!valid) {
+    throw new EligibilityError('ENROLLMENT_INVALID', 'Invalid NIGHT signature');
+  }
+  return {
+    ...canonical,
+    nonce: BigInt(canonical.nonce),
+    identity: enrollmentIdentity(canonical.nightRewardAddress),
+  };
+};
+
+export interface DustGenerationStatus {
+  nightRewardAddress: string;
+  dustAddress?: string;
+  registered: boolean;
+  nightBalance: bigint;
+  finalizedBlock: bigint;
+  synchronized?: boolean;
+}
+
+export interface MidnightRegistrationProvider {
+  getStatus(nightRewardAddress: string): Promise<DustGenerationStatus>;
+}
+
+export const createMidnightEnrollmentVerifier = (network: string): EnrollmentSignatureVerifier => ({
+  verify: ({ verificationKey, address, message, signature }) => {
+    try {
+      const decoded = UnshieldedAddress.codec.decode(network, MidnightBech32m.parse(address));
+      return (
+        decoded.hexString === addressFromKey(verificationKey) &&
+        verifySignature(verificationKey, message, signature)
+      );
+    } catch {
+      return false;
+    }
+  },
+});
+
+export const createHttpMidnightRegistrationProvider = (
+  baseUrl: string,
+  fetchImpl: typeof fetch = fetch
+): MidnightRegistrationProvider => ({
+  async getStatus(nightRewardAddress) {
+    const response = await fetchImpl(
+      `${baseUrl.replace(/\/$/, '')}/v1/eligibility/${encodeURIComponent(nightRewardAddress)}`
+    );
+    if (!response.ok) {
+      throw new EligibilityError(
+        'ELIGIBILITY_QUERY_FAILED',
+        `Eligibility service returned HTTP ${response.status}`
+      );
+    }
+    const value = (await response.json()) as {
+      nightRewardAddress: string;
+      dustAddress?: string;
+      registered: boolean;
+      nightBalance: string;
+      finalizedBlock: string;
+      synchronized: boolean;
+    };
+    if (!value.synchronized) {
+      throw new EligibilityError(
+        'ELIGIBILITY_QUERY_FAILED',
+        'Eligibility status is not synchronized'
+      );
+    }
+    return {
+      ...value,
+      nightBalance: BigInt(value.nightBalance),
+      finalizedBlock: BigInt(value.finalizedBlock),
+    };
+  },
+});
+
+export const assertEligible = (
+  status: DustGenerationStatus,
+  sponsorDustAddress: string,
+  minimumNight: bigint
+) => {
+  if (
+    status.synchronized === false ||
+    !status.registered ||
+    status.dustAddress !== sponsorDustAddress ||
+    status.nightBalance < minimumNight
+  ) {
+    throw new EligibilityError(
+      'DELEGATOR_STALE',
+      'Delegator is no longer eligible for this campaign'
+    );
+  }
+  return status;
+};
+
+export interface EligibilityCampaign {
+  network: string;
+  sentinelAddress: string;
+  sponsorDustAddress: string;
+  minimumRegisteredNight: bigint;
+}
+
+export interface EligibilityQueueOperator {
+  lookup(identity: Uint8Array): Promise<{ enrollmentNonce: bigint } | undefined>;
+  add(input: {
+    identity: Uint8Array;
+    nightRewardAddress: Uint8Array;
+    rewardKey: Uint8Array;
+    rewardEncryptionKey: Uint8Array;
+    registeredAmount: bigint;
+    verificationBlock: bigint;
+    enrollmentNonce: bigint;
+  }): Promise<unknown>;
+  update(input: {
+    identity: Uint8Array;
+    nightRewardAddress: Uint8Array;
+    rewardKey: Uint8Array;
+    rewardEncryptionKey: Uint8Array;
+    registeredAmount: bigint;
+    verificationBlock: bigint;
+    enrollmentNonce: bigint;
+  }): Promise<unknown>;
+}
+
+const paddedAddress = (address: string) => {
+  const encoded = Buffer.from(address, 'utf8');
+  if (encoded.length > 96) {
+    throw new EligibilityError('ENROLLMENT_INVALID', 'NIGHT reward address exceeds 96 bytes');
+  }
+  const result = new Uint8Array(96);
+  result.set(encoded);
+  return result;
+};
+
+export const enrollDelegator = async (options: {
+  enrollment: SignedEnrollment;
+  campaign: EligibilityCampaign;
+  verifier: EnrollmentSignatureVerifier;
+  registrationProvider: MidnightRegistrationProvider;
+  verificationBlock: bigint;
+  operator: EligibilityQueueOperator;
+}) => {
+  const verified = verifyEnrollment(options.enrollment, options.campaign, options.verifier);
+  const current = await options.operator.lookup(verified.identity);
+  if (current && verified.nonce <= current.enrollmentNonce) {
+    throw new EligibilityError('ENROLLMENT_REPLAYED', 'Enrollment nonce must increase');
+  }
+  const status = assertEligible(
+    await options.registrationProvider.getStatus(verified.nightRewardAddress),
+    options.campaign.sponsorDustAddress,
+    options.campaign.minimumRegisteredNight
+  );
+  const input = {
+    identity: verified.identity,
+    nightRewardAddress: paddedAddress(verified.nightRewardAddress),
+    rewardKey: Uint8Array.from(Buffer.from(verified.shieldedCoinPublicKey, 'hex')),
+    rewardEncryptionKey: Uint8Array.from(Buffer.from(verified.shieldedEncryptionPublicKey, 'hex')),
+    registeredAmount: status.nightBalance,
+    verificationBlock: options.verificationBlock,
+    enrollmentNonce: verified.nonce,
+  };
+  await (current ? options.operator.update(input) : options.operator.add(input));
+  return { action: current ? ('updated' as const) : ('added' as const), ...input };
+};
diff --git a/packages/api/src/sponsorship/index.ts b/packages/api/src/sponsorship/index.ts
new file mode 100644
index 0000000..ed97c40
--- /dev/null
+++ b/packages/api/src/sponsorship/index.ts
@@ -0,0 +1,163 @@
+import { createHash } from 'node:crypto';
+import type { MidnightRegistrationProvider } from './eligibility.js';
+
+export type SponsorshipStage =
+  | 'preparation'
+  | 'inspection'
+  | 'balancing'
+  | 'submission'
+  | 'confirmation';
+
+export type SponsorshipErrorCode =
+  | 'INVALID_REQUEST'
+  | 'INVALID_SERIALIZATION'
+  | 'INVALID_COMMUNICATION_COMMITMENT'
+  | 'TARGET_CALL_INVALID'
+  | 'WRONG_CALL_COUNT'
+  | 'UNEXPECTED_ACTION'
+  | 'WRONG_SPONSORSHIP_CONTRACT'
+  | 'WRONG_SPONSORSHIP_ENTRY_POINT'
+  | 'UNAPPROVED_TARGET'
+  | 'PURCHASE_NOT_GUARANTEED'
+  | 'DUST_ALREADY_PRESENT'
+  | 'TTL_OUT_OF_RANGE'
+  | 'FEE_TOO_HIGH'
+  | 'UNRELATED_TRANSFER'
+  | 'CAMPAIGN_UNAVAILABLE'
+  | 'CAMPAIGN_PAUSED'
+  | 'CAMPAIGN_MISMATCH'
+  | 'PAYMENT_COIN_UNAVAILABLE'
+  | 'TARGET_ALREADY_SPONSORED'
+  | 'RECEIPT_MISMATCH'
+  | 'STALE_CONTRACT_STATE'
+  | 'NO_ELIGIBLE_DELEGATOR'
+  | 'DELEGATOR_STALE'
+  | 'REWARD_DELIVERY_FAILED'
+  | 'ENROLLMENT_INVALID'
+  | 'ENROLLMENT_REPLAYED'
+  | 'CAMPAIGN_VERSION_UNSUPPORTED'
+  | 'PROOF_GENERATION_FAILED'
+  | 'BENEFICIARY_BALANCE_FAILED'
+  | 'SPONSOR_BALANCE_FAILED'
+  | 'SUBMISSION_FAILED'
+  | 'CONFIRMATION_FAILED'
+  | 'INTERNAL_ERROR';
+
+export interface SponsorshipErrorOptions {
+  stage: SponsorshipStage;
+  retryable?: boolean;
+  cause?: unknown;
+}
+
+export class SponsorshipError extends Error {
+  readonly code: SponsorshipErrorCode;
+  readonly stage: SponsorshipStage;
+  readonly retryable: boolean;
+
+  constructor(code: SponsorshipErrorCode, message: string, options: SponsorshipErrorOptions) {
+    super(message, { cause: options.cause });
+    this.name = 'SponsorshipError';
+    this.code = code;
+    this.stage = options.stage;
+    this.retryable = options.retryable ?? false;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      stage: this.stage,
+      retryable: this.retryable,
+      message: this.message,
+    };
+  }
+}
+
+export interface SponsorshipTargetPolicy {
+  address: string;
+  entryPoint: string;
+}
+
+export const sponsorshipAllowlistHash = (
+  targets: readonly SponsorshipTargetPolicy[]
+): Uint8Array => {
+  const canonical = [...targets]
+    .map(({ address, entryPoint }) => ({
+      address: address.toLowerCase(),
+      entryPoint,
+    }))
+    .sort(
+      (left, right) =>
+        left.address.localeCompare(right.address) || left.entryPoint.localeCompare(right.entryPoint)
+    );
+  return Uint8Array.from(
+    createHash('sha256')
+      .update(JSON.stringify({ version: 1, targets: canonical }))
+      .digest()
+  );
+};
+
+export interface SponsorshipPolicy {
+  sentinelAddress: string;
+  sponsorId: Uint8Array;
+  sponsorDustAddress: string;
+  registrationProvider: MidnightRegistrationProvider;
+  policyHash: Uint8Array;
+  allowedTargets: readonly SponsorshipTargetPolicy[];
+  minTtlMs: number;
+  maxTtlMs: number;
+  maxFee: bigint;
+}
+
+/** Opaque application call prepared by a platform adapter. */
+export interface SponsorshipTargetCall {
+  readonly targetAddress: string;
+  readonly targetEntryPoint: string;
+}
+
+export interface PrepareSponsorshipInput {
+  target: SponsorshipTargetCall;
+  expiresAt: Date;
+  purchaseId?: Uint8Array;
+}
+
+export interface SponsorshipRequest {
+  readonly transaction: Uint8Array;
+  readonly purchaseId: Uint8Array;
+  readonly targetAddress: string;
+  readonly targetEntryPoint: string;
+  readonly targetCommunicationCommitment: string;
+}
+
+export interface SponsorshipRequestInput {
+  transaction: Uint8Array;
+}
+
+export interface SponsorshipInspection {
+  readonly purchaseId: Uint8Array;
+  readonly targetAddress: string;
+  readonly targetEntryPoint: string;
+  readonly targetCommunicationCommitment: string;
+  readonly targetHasFallibleTranscript: boolean;
+  readonly hasDust: boolean;
+  readonly feeEstimate?: bigint;
+}
+
+export interface SponsorshipSubmission {
+  readonly txId: string;
+  readonly status: string;
+  readonly feeEstimate: bigint;
+  readonly purchaseId: Uint8Array;
+  readonly targetAddress: string;
+  readonly targetEntryPoint: string;
+  readonly targetCommunicationCommitment: string;
+}
+
+export interface BeneficiarySponsorshipApi {
+  prepare(input: PrepareSponsorshipInput): Promise<SponsorshipRequest>;
+}
+
+export interface SponsorSponsorshipApi {
+  inspect(input: SponsorshipRequestInput): Promise<SponsorshipInspection>;
+  sponsorAndSubmit(input: SponsorshipRequestInput): Promise<SponsorshipSubmission>;
+}
diff --git a/packages/api/src/sponsorship/midnight.ts b/packages/api/src/sponsorship/midnight.ts
new file mode 100644
index 0000000..db2a664
--- /dev/null
+++ b/packages/api/src/sponsorship/midnight.ts
@@ -0,0 +1,212 @@
+import { ContractCall, PreProof } from '@midnight-ntwrk/ledger-v8';
+import type { ZKConfigProvider } from '@midnight-ntwrk/midnight-js-types';
+import type { SentinelContractProviders } from '@midnight-sentinel/contract';
+import type { WalletContext } from '@midnight-sentinel/wallet';
+import {
+  dustPublicKeyToBytes,
+  inspectSponsorshipRequest,
+  nativeNightSponsorshipConfig,
+  prepareSponsoredTransaction,
+  sponsorAndSubmit,
+  SponsorshipPolicyError,
+  type PreparedTargetCall,
+  type SponsorPolicy,
+} from '../sponsorship.js';
+import {
+  SponsorshipError,
+  type BeneficiarySponsorshipApi,
+  type SponsorSponsorshipApi,
+  type SponsorshipErrorCode,
+  type SponsorshipInspection,
+  type SponsorshipPolicy,
+  type SponsorshipRequest,
+  type SponsorshipStage,
+  type SponsorshipSubmission,
+  type SponsorshipTargetCall,
+} from './index.js';
+
+export { dustPublicKeyToBytes, nativeNightSponsorshipConfig };
+
+interface MidnightTargetCallData {
+  call: PreparedTargetCall;
+  zkConfigProvider: ZKConfigProvider<string>;
+}
+
+const targetCalls = new WeakMap<SponsorshipTargetCall, MidnightTargetCallData>();
+const errorMessage = (error: unknown) => (error instanceof Error ? error.message : String(error));
+
+const normalizeError = (
+  error: unknown,
+  stage: SponsorshipStage,
+  fallbackCode: SponsorshipErrorCode
+) => {
+  if (error instanceof SponsorshipError) return error;
+  if (error instanceof SponsorshipPolicyError) {
+    return new SponsorshipError(error.code, error.message, { stage, cause: error });
+  }
+  return new SponsorshipError(fallbackCode, errorMessage(error), {
+    stage,
+    retryable:
+      fallbackCode === 'PROOF_GENERATION_FAILED' ||
+      fallbackCode === 'SUBMISSION_FAILED' ||
+      fallbackCode === 'CONFIRMATION_FAILED',
+    cause: error,
+  });
+};
+
+const preparationCode = (error: unknown): SponsorshipErrorCode => {
+  const value = errorMessage(error);
+  if (value.includes('NO_ELIGIBLE_DELEGATOR')) return 'NO_ELIGIBLE_DELEGATOR';
+  if (value.includes('reward') && value.includes('delivery')) {
+    return 'REWARD_DELIVERY_FAILED';
+  }
+  if (value.includes('payment coin')) return 'PAYMENT_COIN_UNAVAILABLE';
+  if (value.includes('paused')) return 'CAMPAIGN_PAUSED';
+  if (value.includes('state not found')) return 'CAMPAIGN_UNAVAILABLE';
+  if (value.includes('prove') || value.includes('proof')) {
+    return 'PROOF_GENERATION_FAILED';
+  }
+  if (value.includes('balance') || value.includes('finalize')) {
+    return 'BENEFICIARY_BALANCE_FAILED';
+  }
+  return 'TARGET_CALL_INVALID';
+};
+
+const normalizeSponsorError = (error: unknown) => {
+  if (error instanceof SponsorshipError) return error;
+  if (error instanceof SponsorshipPolicyError) {
+    return normalizeError(error, 'inspection', 'INTERNAL_ERROR');
+  }
+  const value = errorMessage(error).toLowerCase();
+  if (value.includes('submit') || value.includes('node')) {
+    return normalizeError(error, 'submission', 'SUBMISSION_FAILED');
+  }
+  if (value.includes('indexer') || value.includes('watch') || value.includes('confirm')) {
+    return normalizeError(error, 'confirmation', 'CONFIRMATION_FAILED');
+  }
+  return normalizeError(error, 'balancing', 'SPONSOR_BALANCE_FAILED');
+};
+
+export interface MidnightTargetCallInput {
+  targetCall: PreparedTargetCall;
+  zkConfigProvider: ZKConfigProvider<string>;
+}
+
+export const createMidnightSponsorshipTarget = (
+  input: MidnightTargetCallInput
+): SponsorshipTargetCall => {
+  const calls = [...(input.targetCall.private.unprovenTx.intents?.values() ?? [])]
+    .flatMap((intent) => intent.actions)
+    .filter((action): action is ContractCall<PreProof> => action instanceof ContractCall);
+  if (calls.length !== 1) {
+    throw new SponsorshipError(
+      'TARGET_CALL_INVALID',
+      `Prepared target must contain exactly one contract call; received ${calls.length}`,
+      { stage: 'preparation' }
+    );
+  }
+  const call = calls[0];
+  const target: SponsorshipTargetCall = Object.freeze({
+    targetAddress: call.address,
+    targetEntryPoint:
+      typeof call.entryPoint === 'string'
+        ? call.entryPoint
+        : Buffer.from(call.entryPoint).toString('utf8'),
+  });
+  targetCalls.set(target, {
+    call: input.targetCall,
+    zkConfigProvider: input.zkConfigProvider,
+  });
+  return target;
+};
+
+export interface MidnightBeneficiarySponsorshipOptions {
+  sentinelAddress: string;
+  sentinelProviders: SentinelContractProviders;
+  beneficiary: WalletContext;
+  proofServer: string;
+}
+
+export const createMidnightBeneficiarySponsorshipApi = (
+  options: MidnightBeneficiarySponsorshipOptions
+): BeneficiarySponsorshipApi => ({
+  async prepare(input): Promise<SponsorshipRequest> {
+    const target = targetCalls.get(input.target);
+    if (!target) {
+      throw new SponsorshipError(
+        'TARGET_CALL_INVALID',
+        'Target call was not created by the Midnight sponsorship adapter',
+        { stage: 'preparation' }
+      );
+    }
+    try {
+      const prepared = await prepareSponsoredTransaction({
+        targetCall: target.call,
+        targetZkConfigProvider: target.zkConfigProvider,
+        sentinelProviders: options.sentinelProviders,
+        sentinelAddress: options.sentinelAddress,
+        beneficiary: options.beneficiary,
+        proofServer: options.proofServer,
+        ttl: input.expiresAt,
+        purchaseId: input.purchaseId,
+      });
+      return {
+        transaction: prepared.serializedTransaction,
+        purchaseId: prepared.purchaseId,
+        targetAddress: prepared.targetAddress,
+        targetEntryPoint: prepared.targetEntryPoint,
+        targetCommunicationCommitment: prepared.targetCommunicationCommitment,
+      };
+    } catch (error) {
+      const code = preparationCode(error);
+      throw normalizeError(error, 'preparation', code);
+    }
+  },
+});
+
+export interface MidnightSponsorSponsorshipOptions {
+  policy: SponsorshipPolicy;
+  sentinelProviders: SentinelContractProviders;
+  sponsor: WalletContext;
+}
+
+export const createMidnightSponsorSponsorshipApi = (
+  options: MidnightSponsorSponsorshipOptions
+): SponsorSponsorshipApi => {
+  const policy: SponsorPolicy = options.policy;
+  return {
+    async inspect({ transaction }): Promise<SponsorshipInspection> {
+      try {
+        const inspection = await inspectSponsorshipRequest(
+          transaction,
+          policy,
+          options.sentinelProviders
+        );
+        return {
+          purchaseId: inspection.purchaseId,
+          targetAddress: inspection.targetAddress,
+          targetEntryPoint: inspection.targetEntryPoint,
+          targetCommunicationCommitment: inspection.targetCommunicationCommitment,
+          targetHasFallibleTranscript: inspection.targetHasFallibleTranscript,
+          hasDust: false,
+          feeEstimate: inspection.feeEstimate,
+        };
+      } catch (error) {
+        throw normalizeError(error, 'inspection', 'INTERNAL_ERROR');
+      }
+    },
+
+    async sponsorAndSubmit({ transaction }): Promise<SponsorshipSubmission> {
+      try {
+        return await sponsorAndSubmit(
+          transaction,
+          policy,
+          options.sentinelProviders,
+          options.sponsor
+        );
+      } catch (error) {
+        throw normalizeSponsorError(error);
+      }
+    },
+  };
+};
diff --git a/packages/contract/package.json b/packages/contract/package.json
index a7df772..b3118ee 100644
--- a/packages/contract/package.json
+++ b/packages/contract/package.json
@@ -18,26 +18,26 @@
     }
   },
   "scripts": {
-    "compact": "compact compile src/sentinel.compact ./src/managed/sentinel",
-    "compact:no-zk": "compact compile --skip-zk src/sentinel.compact ./src/managed/sentinel",
+    "compact": "compact compile +0.31.1 src/sentinel.compact ./src/managed/sentinel",
+    "compact:no-zk": "compact compile +0.31.1 --skip-zk src/sentinel.compact ./src/managed/sentinel",
     "clean": "rm -rf dist .turbo src/managed node_modules",
     "clear": "rm -rf dist src/managed",
-    "check": "pnpm clear && pnpm compact:no-zk && mkdir -p dist && tsc --project ./tsconfig.build.json && cp -Rf ./src/managed ./dist/managed && cp ./src/sentinel.compact ./dist",
-    "build": "pnpm clear && pnpm compact && mkdir -p dist && tsc --project ./tsconfig.build.json && cp -Rf ./src/managed ./dist/managed && cp ./src/sentinel.compact ./dist",
+    "check": "pnpm compact:no-zk && mkdir -p dist/managed/sentinel && tsc --project ./tsconfig.build.json && cp -Rf ./src/managed/sentinel/. ./dist/managed/sentinel/ && cp ./src/sentinel.compact ./dist",
+    "build": "pnpm compact && mkdir -p dist/managed/sentinel && tsc --project ./tsconfig.build.json && cp -Rf ./src/managed/sentinel/. ./dist/managed/sentinel/ && cp ./src/sentinel.compact ./dist",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"
   },
   "dependencies": {
-    "@midnight-ntwrk/compact-js": "2.5.0",
-    "@midnight-ntwrk/compact-runtime": "0.15.0",
-    "@midnight-ntwrk/midnight-js-contracts": "4.0.4",
-    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-level-private-state-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "4.0.4",
-    "@midnight-ntwrk/midnight-js-types": "4.0.4",
+    "@midnight-ntwrk/compact-js": "2.5.1",
+    "@midnight-ntwrk/compact-runtime": "0.16.0",
+    "@midnight-ntwrk/midnight-js-contracts": "4.1.1",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-indexer-public-data-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-level-private-state-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-types": "4.1.1",
     "@midnight-sentinel/wallet": "workspace:*",
     "rxjs": "^7.8.2"
   },
diff --git a/packages/contract/src/index.ts b/packages/contract/src/index.ts
index ac3e95b..0d3d4fa 100644
--- a/packages/contract/src/index.ts
+++ b/packages/contract/src/index.ts
@@ -1,9 +1,10 @@
 import { CompiledContract } from '@midnight-ntwrk/compact-js';
+import type { PrivateState } from './private-state.js';
 import { SentinelContractConstructor, SentinelContractType } from './types.js';
 import { witnesses } from './witnesses.js';
 
 const tag = 'SentinelContract';
-export const CompactCompiledContract = CompiledContract.make<SentinelContractType>(
+export const CompactCompiledContract = CompiledContract.make<SentinelContractType, PrivateState>(
   tag,
   SentinelContractConstructor
 ).pipe(
@@ -16,7 +17,7 @@ export const CompactCompiledContract = CompiledContract.make<SentinelContractTyp
 
 export { type ContractAddress } from '@midnight-ntwrk/compact-runtime';
 export * from './managed/sentinel/contract/index.js';
-export { createPrivateState, type PrivateState } from './private-state.js';
+export { createPrivateState, deriveSentinelAuthority, type PrivateState } from './private-state.js';
 export { sentinelContractPrivateStateKey } from './types.js';
 export type {
   SentinelContractCircuitKeys,
diff --git a/packages/contract/src/private-state.ts b/packages/contract/src/private-state.ts
index bce6e32..0fea791 100644
--- a/packages/contract/src/private-state.ts
+++ b/packages/contract/src/private-state.ts
@@ -1,3 +1,9 @@
+import {
+  CompactTypeBytes,
+  CompactTypeVector,
+  persistentHash,
+} from '@midnight-ntwrk/compact-runtime';
+
 export type PrivateState = {
   readonly secretKey: Uint8Array;
 };
@@ -5,3 +11,12 @@ export type PrivateState = {
 export const createPrivateState = (secretKey: Uint8Array): PrivateState => ({
   secretKey,
 });
+
+export const deriveSentinelAuthority = (secretKey: Uint8Array): Uint8Array => {
+  if (secretKey.length !== 32) {
+    throw new Error('Sentinel authority secret must be exactly 32 bytes');
+  }
+  const tag = new Uint8Array(32);
+  tag.set(new TextEncoder().encode('dust-sponsorship:pk:'));
+  return persistentHash(new CompactTypeVector(2, new CompactTypeBytes(32)), [tag, secretKey]);
+};
diff --git a/packages/contract/src/providers.ts b/packages/contract/src/providers.ts
index a1b59bd..7365d26 100644
--- a/packages/contract/src/providers.ts
+++ b/packages/contract/src/providers.ts
@@ -1,10 +1,14 @@
+import type { Contract as CompactContract } from '@midnight-ntwrk/compact-js';
 import { httpClientProofProvider } from '@midnight-ntwrk/midnight-js-http-client-proof-provider';
 import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';
 import { levelPrivateStateProvider } from '@midnight-ntwrk/midnight-js-level-private-state-provider';
 import { NodeZkConfigProvider } from '@midnight-ntwrk/midnight-js-node-zk-config-provider';
+import type { ContractProviders } from '@midnight-ntwrk/midnight-js-contracts';
 import { type WalletContext, createWalletAndMidnightProvider } from '@midnight-sentinel/wallet';
 import path from 'node:path';
-import { SentinelContractCircuitKeys, SentinelContractProviders, PrivateStateId } from './types.js';
+import type { PrivateStateId, SentinelContractType } from './types.js';
+
+export { NodeZkConfigProvider };
 
 // TODO: Maybe we can improve how these variables are defined
 const currentDir = path.resolve(new URL(import.meta.url).pathname, '..');
@@ -12,17 +16,21 @@ export const contractConfig = {
   zkConfigPath: path.resolve(currentDir, 'managed', 'sentinel'),
 };
 
-export const configureProviders = async (
+export const configureProviders = async <C extends CompactContract.Any = SentinelContractType>(
   walletCtx: WalletContext,
   config: { indexer: string; indexerWS: string; proofServer: string },
-  privateStateStoreName: string
-): Promise<SentinelContractProviders> => {
+  privateStateStoreName: string,
+  zkConfigPath = contractConfig.zkConfigPath
+): Promise<ContractProviders<C>> => {
   const walletAndMidnightProvider = await createWalletAndMidnightProvider(walletCtx);
-  const zkConfigProvider = new NodeZkConfigProvider<SentinelContractCircuitKeys>(
-    contractConfig.zkConfigPath
+  const zkConfigProvider = new NodeZkConfigProvider<CompactContract.ProvableCircuitId<C>>(
+    zkConfigPath
   );
   return {
-    privateStateProvider: levelPrivateStateProvider<PrivateStateId>({
+    privateStateProvider: levelPrivateStateProvider<
+      PrivateStateId,
+      CompactContract.PrivateState<C>
+    >({
       privateStateStoreName: privateStateStoreName + '-midnight',
       privateStoragePasswordProvider: function (): string | Promise<string> {
         return 'MyM1dnightPassword!';
diff --git a/packages/contract/src/sentinel.compact b/packages/contract/src/sentinel.compact
index fd1d187..c30a0a8 100644
--- a/packages/contract/src/sentinel.compact
+++ b/packages/contract/src/sentinel.compact
@@ -1,125 +1,347 @@
-pragma language_version 0.22;
+pragma language_version 0.23;
 
 import CompactStandardLibrary;
 
-///////// LEDGER /////////
-export ledger owner: Bytes<32>;
-export ledger delegators: Map<Bytes<32>, Uint<128>>;
-export ledger shieldedVault: QualifiedShieldedCoinInfo;
-export ledger rewardsVault: QualifiedShieldedCoinInfo;
-export ledger hasShielded: Boolean;
-export ledger hasRewards: Boolean;
+export struct DelegatorSlot {
+  nightIdentity: Bytes<32>;
+  nightRewardAddress: Bytes<96>;
+  rewardKey: ZswapCoinPublicKey;
+  rewardEncryptionKey: Bytes<32>;
+  verifiedRegisteredAmount: Uint<128>;
+  verificationBlock: Uint<64>;
+  enrollmentNonce: Uint<64>;
+}
 
-///////// CONSTRUCTOR /////////
-constructor() {
-  const sk = localSecretKey();
-  owner = disclose(publicKey(sk));
-  hasShielded = disclose(false);
-  hasRewards = disclose(false);
+export struct SponsorshipReceipt {
+  targetAddress: Bytes<32>;
+  targetEntryPointHash: Bytes<32>;
+  targetCommunicationCommitment: Field;
+  rewardedDelegatorId: Bytes<32>;
+  sponsorRewardDelivered: Boolean;
+}
+
+export struct SponsorshipSponsorConfig {
+  id: Bytes<32>;
+  rewardKey: ZswapCoinPublicKey;
+  rewardEncryptionKey: Bytes<32>;
+  share: Uint<64>;
+  policyHash: Bytes<32>;
 }
 
-///////// EXPORTED CIRCUITS /////////
+///////// IMMUTABLE CAMPAIGN CONFIGURATION /////////
+export sealed ledger sponsorshipSponsor: SponsorshipSponsorConfig;
+export sealed ledger sponsorshipAcceptedColor: Bytes<32>;
+export sealed ledger sponsorshipFixedPrice: Uint<64>;
+export sealed ledger sponsorshipDelegatorShare: Uint<64>;
+export sealed ledger sponsorshipMinimumRegisteredNight: Uint<128>;
 
-export circuit delegate(coin: ShieldedCoinInfo): [] {
-  assert(coin.value > 0, "Deposit amount must be positive");
+///////// ADMINISTRATION AND PUBLIC QUEUE /////////
+export ledger owner: Bytes<32>;
+export ledger eligibilityOperator: Bytes<32>;
+export ledger sponsorshipEnabled: Boolean;
+export ledger delegatorSlots: Map<Uint<64>, DelegatorSlot>;
+export ledger delegatorPositions: Map<Bytes<32>, Uint<64>>;
+export ledger delegatorCount: Uint<64>;
+export ledger pausedDelegatorCount: Uint<64>;
+export ledger rewardCursor: Uint<64>;
 
-  receiveShielded(disclose(coin));
+///////// PURCHASE ACCOUNTING /////////
+export ledger sponsorshipPurchases: Counter;
+export ledger sponsorshipReceipts: Map<Bytes<32>, SponsorshipReceipt>;
 
-  if (!hasShielded) {
-      shieldedVault.writeCoin(
-          disclose(coin),
-          right<ZswapCoinPublicKey, ContractAddress>(kernel.self())
-      );
-      hasShielded = true;
-  } else {
-      shieldedVault.writeCoin(
-          mergeCoinImmediate(shieldedVault, disclose(coin)),
-          right<ZswapCoinPublicKey, ContractAddress>(kernel.self())
-      );
-  }
+///////// CONSTRUCTOR /////////
+constructor(
+  sponsorId: Bytes<32>,
+  acceptedColor: Bytes<32>,
+  sponsorRewardKey: ZswapCoinPublicKey,
+  sponsorRewardEncryptionKey: Bytes<32>,
+  sponsorShare: Uint<64>,
+  delegatorShare: Uint<64>,
+  minimumRegisteredNight: Uint<128>,
+  initialEligibilityOperator: Bytes<32>,
+  policyHash: Bytes<32>
+) {
+  assert(sponsorShare > 0, "Sponsor share must be positive");
+  assert(delegatorShare > 0, "Delegator share must be positive");
 
-  delegators.insert(disclose(publicKey(localSecretKey())), disclose(coin.value));
+  sponsorshipSponsor = disclose(
+    SponsorshipSponsorConfig {
+      id: sponsorId,
+      rewardKey: sponsorRewardKey,
+      rewardEncryptionKey: sponsorRewardEncryptionKey,
+      share: sponsorShare,
+      policyHash: policyHash
+    }
+  );
+  sponsorshipAcceptedColor = disclose(acceptedColor);
+  sponsorshipDelegatorShare = disclose(delegatorShare);
+  sponsorshipFixedPrice =
+    disclose((sponsorShare + delegatorShare) as Uint<64>);
+  sponsorshipMinimumRegisteredNight = disclose(minimumRegisteredNight);
+  owner = disclose(callerKey());
+  eligibilityOperator = disclose(initialEligibilityOperator);
+  sponsorshipEnabled = disclose(true);
+  delegatorCount = disclose(0);
+  pausedDelegatorCount = disclose(0);
+  rewardCursor = disclose(0);
 }
 
-export circuit withdraw(): [] {
-  assert(isOwner(), "You are not the owner of this contract.");
-  assert(shieldedVault.value > 0, "Nothing to withdraw.");
+///////// ELIGIBILITY OPERATOR CIRCUITS /////////
+export circuit addDelegator(
+  nightIdentity: Bytes<32>,
+  nightRewardAddress: Bytes<96>,
+  rewardKey: ZswapCoinPublicKey,
+  rewardEncryptionKey: Bytes<32>,
+  registeredAmount: Uint<128>,
+  verificationBlock: Uint<64>,
+  enrollmentNonce: Uint<64>
+): [] {
+  assert(isEligibilityOperator(), "Not the eligibility operator");
+  assert(sponsorshipEnabled, "Sponsorship is paused");
+  const publicIdentity = disclose(nightIdentity);
+  const publicNightRewardAddress = disclose(nightRewardAddress);
+  const publicRewardKey = disclose(rewardKey);
+  const publicRewardEncryptionKey = disclose(rewardEncryptionKey);
+  const publicAmount = disclose(registeredAmount);
+  const publicBlock = disclose(verificationBlock);
+  const publicNonce = disclose(enrollmentNonce);
+  assert(!delegatorPositions.member(publicIdentity), "Duplicate delegator");
+  assert(
+    publicAmount >= sponsorshipMinimumRegisteredNight,
+    "Below minimum registered NIGHT"
+  );
+  assert(delegatorCount < 16, "Delegator queue is full");
 
-  sendShielded(
-    shieldedVault,
-    left<ZswapCoinPublicKey, ContractAddress>(ownPublicKey()),
-    disclose(shieldedVault.value)
+  delegatorSlots.insert(
+    delegatorCount,
+    DelegatorSlot {
+      nightIdentity: publicIdentity,
+      nightRewardAddress: publicNightRewardAddress,
+      rewardKey: publicRewardKey,
+      rewardEncryptionKey: publicRewardEncryptionKey,
+      verifiedRegisteredAmount: publicAmount,
+      verificationBlock: publicBlock,
+      enrollmentNonce: publicNonce
+    }
   );
+  delegatorPositions.insert(publicIdentity, delegatorCount);
+  delegatorCount = (delegatorCount + 1) as Uint<64>;
+}
 
-  hasShielded = false;
+export circuit updateDelegator(
+  nightIdentity: Bytes<32>,
+  nightRewardAddress: Bytes<96>,
+  rewardKey: ZswapCoinPublicKey,
+  rewardEncryptionKey: Bytes<32>,
+  registeredAmount: Uint<128>,
+  verificationBlock: Uint<64>,
+  enrollmentNonce: Uint<64>
+): [] {
+  assert(isEligibilityOperator(), "Not the eligibility operator");
+  assert(sponsorshipEnabled, "Sponsorship is paused");
+  const publicIdentity = disclose(nightIdentity);
+  const publicNightRewardAddress = disclose(nightRewardAddress);
+  const publicRewardKey = disclose(rewardKey);
+  const publicRewardEncryptionKey = disclose(rewardEncryptionKey);
+  const publicAmount = disclose(registeredAmount);
+  const publicBlock = disclose(verificationBlock);
+  const publicNonce = disclose(enrollmentNonce);
+  assert(delegatorPositions.member(publicIdentity), "Unknown delegator");
+  assert(
+    publicAmount >= sponsorshipMinimumRegisteredNight,
+    "Below minimum registered NIGHT"
+  );
 
-  shieldedVault = QualifiedShieldedCoinInfo {
-      nonce: pad(32, ""),
-      color: pad(32, ""),
-      value: 0,
-      mt_index: 0
-  };
+  const position = delegatorPositions.lookup(publicIdentity);
+  const current = delegatorSlots.lookup(position);
+  assert(
+    publicNonce > current.enrollmentNonce,
+    "Enrollment nonce must increase"
+  );
+  delegatorSlots.insert(
+    position,
+    DelegatorSlot {
+      nightIdentity: publicIdentity,
+      nightRewardAddress: publicNightRewardAddress,
+      rewardKey: publicRewardKey,
+      rewardEncryptionKey: publicRewardEncryptionKey,
+      verifiedRegisteredAmount: publicAmount,
+      verificationBlock: publicBlock,
+      enrollmentNonce: publicNonce
+    }
+  );
 }
 
+export circuit removeDelegator(nightIdentity: Bytes<32>): [] {
+  assert(isEligibilityOperator(), "Not the eligibility operator");
+  assert(sponsorshipEnabled, "Sponsorship is paused");
+  const publicIdentity = disclose(nightIdentity);
+  assert(delegatorPositions.member(publicIdentity), "Unknown delegator");
+
+  const removedPosition = delegatorPositions.lookup(publicIdentity);
+  const newCount = (delegatorCount - 1) as Uint<64>;
 
-export circuit depositRewards(coin: ShieldedCoinInfo): [] {
-  assert(coin.value > 0, "Deposit amount must be positive");
+  for (const i of 0..15) {
+    if (i >= removedPosition && i < newCount) {
+      const shifted = delegatorSlots.lookup((i + 1) as Uint<64>);
+      delegatorSlots.insert(i as Uint<64>, shifted);
+      delegatorPositions.insert(shifted.nightIdentity, i as Uint<64>);
+    }
+  }
 
-  receiveShielded(disclose(coin));
+  delegatorSlots.remove(newCount);
+  delegatorPositions.remove(publicIdentity);
+  delegatorCount = newCount;
 
-  if (!hasRewards) {
-    rewardsVault.writeCoin(
-      disclose(coin),
-      right<ZswapCoinPublicKey, ContractAddress>(kernel.self())
-    );
-    hasRewards = true;
+  if (newCount == 0) {
+    rewardCursor = 0;
   } else {
-    rewardsVault.writeCoin(
-        mergeCoinImmediate(rewardsVault, disclose(coin)),
-        right<ZswapCoinPublicKey, ContractAddress>(kernel.self())
-    );
+    if (removedPosition < rewardCursor) {
+      rewardCursor = (rewardCursor - 1) as Uint<64>;
+    } else {
+      if (rewardCursor >= newCount) {
+        rewardCursor = 0;
+      }
+    }
   }
 }
 
-export circuit redeemRewards():[] {
-  assert(delegators.member(disclose(publicKey(localSecretKey()))), "You must be a delegator to redeem rewards");
-  assert(hasRewards, "No tokens in vault");
+///////// PURCHASE CIRCUITS /////////
+
+// Call first in the transaction. This circuit is guaranteed-only: a valid
+// delegator receives their share and the round-robin cursor advances even if
+// a later fallible call fails.
+export circuit purchaseDelegatorReward(payment: ShieldedCoinInfo): [] {
+  const publicPayment = disclose(payment);
+  assert(delegatorCount > 0, "NO_ELIGIBLE_DELEGATOR");
+  assert(publicPayment.color == nativeToken(), "Wrong payment asset");
+  assert(
+    publicPayment.value == sponsorshipDelegatorShare,
+    "Wrong delegator payment amount"
+  );
 
-  const callerKey = ownPublicKey();
-  const vault = rewardsVault.read();
-  sendShielded(
-    vault,
-    left<ZswapCoinPublicKey, ContractAddress>(disclose(callerKey)),
-    disclose(vault.value)
+  const rewarded = delegatorSlots.lookup(rewardCursor);
+  receiveShielded(publicPayment);
+  const delegatorSend = sendImmediateShielded(
+    publicPayment,
+    left<ZswapCoinPublicKey, ContractAddress>(rewarded.rewardKey),
+    sponsorshipDelegatorShare as Uint<128>
+  );
+  assert(
+    !delegatorSend.change.is_some,
+    "DELEGATOR_REWARD_DELIVERY_FAILED"
   );
-  hasRewards = false;
-  rewardsVault = QualifiedShieldedCoinInfo {
-      nonce: pad(32, ""),
-      color: pad(32, ""),
-      value: 0,
-      mt_index: 0
-  };
+
+  rewardCursor =
+    rewardCursor + 1 == delegatorCount
+      ? 0
+      : (rewardCursor + 1) as Uint<64>;
 }
 
+// Call second, before the user's fallible calls. The retained full-ZK/devnet
+// experiment proves this whole circuit is fallible. Sponsor delivery, receipt,
+// and purchase count therefore roll back together if this call or later user
+// work fails.
+export circuit deliverSponsorReward(
+  purchaseId: Bytes<32>,
+  payment: ShieldedCoinInfo,
+  targetAddress: Bytes<32>,
+  targetEntryPointHash: Bytes<32>,
+  targetCommunicationCommitment: Field
+): [] {
+  const publicPurchaseId = disclose(purchaseId);
+  const publicPayment = disclose(payment);
+  const publicTargetAddress = disclose(targetAddress);
+  const publicEntryPointHash = disclose(targetEntryPointHash);
+  const publicTargetCommitment = disclose(targetCommunicationCommitment);
+
+  assert(sponsorshipEnabled, "Sponsorship is paused");
+  assert(delegatorCount > 0, "NO_ELIGIBLE_DELEGATOR");
+  assert(
+    !sponsorshipReceipts.member(publicPurchaseId),
+    "Duplicate sponsorship purchase"
+  );
+  assert(
+    publicPayment.color == sponsorshipAcceptedColor,
+    "Wrong payment asset"
+  );
+  assert(
+    publicPayment.value == sponsorshipSponsor.share,
+    "Wrong sponsor payment amount"
+  );
+
+  const rewardedPosition =
+    rewardCursor == 0
+      ? (delegatorCount - 1) as Uint<64>
+      : (rewardCursor - 1) as Uint<64>;
+  const rewarded = delegatorSlots.lookup(rewardedPosition);
 
+  receiveShielded(publicPayment);
+  kernel.checkpoint();
 
-///////// HELPER CIRCUIT TO MINT TOKENS TO PAY /////////
+  const sponsorSend = sendImmediateShielded(
+    publicPayment,
+    left<ZswapCoinPublicKey, ContractAddress>(
+      sponsorshipSponsor.rewardKey
+    ),
+    sponsorshipSponsor.share as Uint<128>
+  );
+  assert(!sponsorSend.change.is_some, "SPONSOR_REWARD_DELIVERY_FAILED");
 
-export circuit mintDirectShielded(domainSep: Bytes<32>, mintValue: Uint<64>, mintNonce: Bytes<32>, publicKey: ZswapCoinPublicKey): [] {
-  mintShieldedToken(disclose(domainSep), disclose(mintValue), disclose(mintNonce), left<ZswapCoinPublicKey, ContractAddress>(disclose(publicKey)));
+  sponsorshipPurchases.increment(1);
+  sponsorshipReceipts.insert(
+    publicPurchaseId,
+    SponsorshipReceipt {
+      targetAddress: publicTargetAddress,
+      targetEntryPointHash: publicEntryPointHash,
+      targetCommunicationCommitment: publicTargetCommitment,
+      rewardedDelegatorId: rewarded.nightIdentity,
+      sponsorRewardDelivered: true
+    }
+  );
 }
 
+///////// OWNER CIRCUITS /////////
+export circuit rotateEligibilityOperator(newOperator: Bytes<32>): [] {
+  assert(isOwner(), "Not the campaign owner");
+  eligibilityOperator = disclose(newOperator);
+}
 
-///////// HELPER CIRCUITS /////////
+export circuit setSponsorshipEnabled(enabled: Boolean): [] {
+  assert(isOwner(), "You are not the owner of this contract.");
+  const publicEnabled = disclose(enabled);
+  if (publicEnabled) {
+    if (!sponsorshipEnabled) {
+      delegatorCount = pausedDelegatorCount;
+      pausedDelegatorCount = 0;
+    }
+  } else {
+    if (sponsorshipEnabled) {
+      pausedDelegatorCount = delegatorCount;
+      delegatorCount = 0;
+    }
+  }
+  sponsorshipEnabled = publicEnabled;
+}
 
+///////// HELPERS /////////
 circuit publicKey(sk: Bytes<32>): Bytes<32> {
-  return persistentHash<Vector<2, Bytes<32>>>([pad(32, "dust-sponsorship:pk:"), sk]);
+  return persistentHash<Vector<2, Bytes<32>>>([
+    pad(32, "dust-sponsorship:pk:"),
+    sk
+  ]);
+}
+
+circuit callerKey(): Bytes<32> {
+  return publicKey(localSecretKey());
 }
 
 circuit isOwner(): Boolean {
-  const sk = localSecretKey();
-  const pk = publicKey(sk);
-  return pk == owner;
+  return callerKey() == owner;
+}
+
+circuit isEligibilityOperator(): Boolean {
+  return callerKey() == eligibilityOperator;
 }
 
 ///////// WITNESSES /////////
diff --git a/packages/protocol-verification/README.md b/packages/protocol-verification/README.md
new file mode 100644
index 0000000..39095bc
--- /dev/null
+++ b/packages/protocol-verification/README.md
@@ -0,0 +1,44 @@
+# Midnight Protocol Verification Lab
+
+This private workspace package retains protocol experiments used to prove or
+refute behavior that is not obvious from Compact or Midnight SDK APIs alone.
+It is not published and none of its experimental contracts are production
+Sentinel code.
+
+## Experiments
+
+| Experiment                                                                 | Question                                                                         |
+| -------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| [`sponsorship`](src/experiments/sponsorship/README.md)                     | Can a beneficiary prepare a payment call and a sponsor add only DUST?            |
+| [`composite-sponsorship`](src/experiments/composite-sponsorship/README.md) | How do guaranteed and fallible calls behave when merged?                         |
+| [`reward-split`](src/experiments/reward-split/README.md)                   | Can two circuits deliver the intended reward partition and discoverable outputs? |
+| [`production-sentinel`](src/experiments/production-sentinel/README.md)     | Do the retained properties hold against the production contract?                 |
+
+The experiments are pinned to Compact `0.31.1` and the dependency versions in
+this package. Compilation alone is never treated as end-to-end evidence.
+
+## Commands
+
+From the repository root:
+
+```sh
+pnpm verify:protocol:local
+pnpm verify:protocol:reward-split
+pnpm verify:protocol:devnet:sponsorship
+pnpm verify:protocol:devnet:composite
+pnpm verify:protocol:devnet:production
+```
+
+`verify:protocol:local` runs deterministic no-ZK runtime and transcript checks.
+Commands containing `devnet` require the local node, indexer, and proof server.
+The reward-split wallet experiment also requires full proving infrastructure.
+Each directory under `src/experiments` is self-contained: Compact fixtures,
+TypeScript wrappers and runners, a standalone explanation, and the sanitized
+result live together. Shared standalone configuration and generated contract
+artifacts remain under `src/common` and `src/managed`.
+
+## Retention rule
+
+Each experiment must keep its question, acceptance or stop conditions,
+versions, sanitized result, and relationship to production behavior. Generated
+artifacts, wallet databases, secrets, and transient live reports are ignored.
diff --git a/packages/protocol-verification/package.json b/packages/protocol-verification/package.json
new file mode 100644
index 0000000..156c6c2
--- /dev/null
+++ b/packages/protocol-verification/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "@midnight-sentinel/protocol-verification",
+  "private": true,
+  "type": "module",
+  "main": "dist/experiments/composite-sponsorship/composite-sponsorship-contract.js",
+  "types": "dist/experiments/composite-sponsorship/composite-sponsorship-contract.d.ts",
+  "exports": {
+    "./sponsorship": {
+      "types": "./dist/experiments/sponsorship/sponsorship-contract.d.ts",
+      "import": "./dist/experiments/sponsorship/sponsorship-contract.js"
+    },
+    "./composite-sponsorship": {
+      "types": "./dist/experiments/composite-sponsorship/composite-sponsorship-contract.d.ts",
+      "import": "./dist/experiments/composite-sponsorship/composite-sponsorship-contract.js"
+    },
+    "./reward-split": {
+      "types": "./dist/experiments/reward-split/reward-split-contract.d.ts",
+      "import": "./dist/experiments/reward-split/reward-split-contract.js"
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf dist .turbo src/managed node_modules",
+    "compact:sponsorship": "compact compile +0.31.1 src/experiments/sponsorship/sponsorship.compact src/managed/sponsorship",
+    "compact:sponsorship:no-zk": "compact compile +0.31.1 --skip-zk src/experiments/sponsorship/sponsorship.compact src/managed/sponsorship",
+    "compact:reward-split": "compact compile +0.31.1 src/experiments/reward-split/reward-split.compact src/managed/reward-split && compact compile +0.31.1 src/experiments/reward-split/fallible-user-target.compact src/managed/fallible-user-target",
+    "compact:reward-split:no-zk": "compact compile +0.31.1 --skip-zk src/experiments/reward-split/reward-split.compact src/managed/reward-split && compact compile +0.31.1 --skip-zk src/experiments/reward-split/fallible-user-target.compact src/managed/fallible-user-target",
+    "compact:composite": "compact compile +0.31.1 src/experiments/composite-sponsorship/composite-sponsorship.compact src/managed/composite-sponsorship && compact compile +0.31.1 src/experiments/composite-sponsorship/composite-target.compact src/managed/composite-target",
+    "compact:composite:no-zk": "compact compile +0.31.1 --skip-zk src/experiments/composite-sponsorship/composite-sponsorship.compact src/managed/composite-sponsorship && compact compile +0.31.1 --skip-zk src/experiments/composite-sponsorship/composite-target.compact src/managed/composite-target",
+    "compact:all": "pnpm compact:sponsorship && pnpm compact:reward-split && pnpm compact:composite",
+    "compact:all:no-zk": "pnpm compact:sponsorship:no-zk && pnpm compact:reward-split:no-zk && pnpm compact:composite:no-zk",
+    "check": "pnpm compact:all:no-zk && tsc --project tsconfig.build.json --noEmit",
+    "build": "pnpm compact:all && tsc --project tsconfig.build.json && mkdir -p dist/managed && cp -Rf src/managed/. dist/managed/",
+    "build:sponsor-fixtures": "pnpm compact:composite && tsc --project tsconfig.fixtures.json && mkdir -p dist/managed && cp -Rf src/managed/composite-sponsorship src/managed/composite-target dist/managed/",
+    "verify:local": "pnpm --dir ../contract check && pnpm --dir ../wallet build && pnpm compact:all:no-zk && tsx src/experiments/sponsorship/sponsorship-runtime-check.ts && tsx src/experiments/reward-split/reward-split-runtime-check.ts && tsx src/experiments/reward-split/reward-split-partition-check.ts && tsx src/experiments/production-sentinel/sentinel-sponsorship-runtime-check.ts",
+    "verify:reward-split": "pnpm --dir ../wallet build && pnpm compact:reward-split && tsx src/experiments/reward-split/reward-split-wallet-check.ts",
+    "verify:devnet:sponsorship": "pnpm --dir ../wallet build && pnpm compact:sponsorship && tsx src/experiments/sponsorship/sponsorship-verification.ts",
+    "verify:devnet:composite": "pnpm --dir ../wallet build && pnpm compact:composite && tsx src/experiments/composite-sponsorship/sponsorship-composite-verification.ts",
+    "verify:devnet:production": "pnpm --dir ../contract build && pnpm compact:composite && pnpm --dir ../api build && pnpm --dir ../wallet build && tsx src/experiments/production-sentinel/sponsorship-production-verification.ts",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@midnight-ntwrk/compact-js": "2.5.1",
+    "@midnight-ntwrk/compact-runtime": "0.16.0",
+    "@midnight-ntwrk/ledger-v8": "8.0.3",
+    "@midnight-ntwrk/midnight-js-contracts": "4.1.1",
+    "@midnight-ntwrk/midnight-js-http-client-proof-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-node-zk-config-provider": "4.1.1",
+    "@midnight-ntwrk/midnight-js-types": "4.1.1",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0-rc.0",
+    "@midnight-sentinel/api": "workspace:*",
+    "@midnight-sentinel/contract": "workspace:*",
+    "@midnight-sentinel/wallet": "workspace:*",
+    "rxjs": "^7.8.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}
diff --git a/packages/protocol-verification/src/common/config.ts b/packages/protocol-verification/src/common/config.ts
new file mode 100644
index 0000000..3c709e4
--- /dev/null
+++ b/packages/protocol-verification/src/common/config.ts
@@ -0,0 +1,18 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageDirectory = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+export const standaloneConfig = {
+  networkId: 'undeployed',
+  privateStateStoreName: 'protocol-verification',
+  logDir: path.join(packageDirectory, 'logs'),
+  zkConfigPath: path.join(packageDirectory, 'src/managed/sentinel'),
+  indexer: 'http://127.0.0.1:8088/api/v4/graphql',
+  indexerWS: 'ws://127.0.0.1:8088/api/v4/graphql/ws',
+  node: 'http://127.0.0.1:9944',
+  proofServer: 'http://127.0.0.1:6300',
+  eligibilityService: 'http://127.0.0.1:8089',
+};
+
+export const packagePath = (...parts: string[]) => path.join(packageDirectory, ...parts);
diff --git a/packages/protocol-verification/src/common/constants.ts b/packages/protocol-verification/src/common/constants.ts
new file mode 100644
index 0000000..725dcf6
--- /dev/null
+++ b/packages/protocol-verification/src/common/constants.ts
@@ -0,0 +1,3 @@
+export const GENESIS_MINT_WALLET_SEED_ONE = `${'0'.repeat(63)}1`;
+export const GENESIS_MINT_WALLET_SEED_TWO = `${'0'.repeat(63)}2`;
+export const GENESIS_MINT_WALLET_SEED_THREE = `${'0'.repeat(63)}3`;
diff --git a/packages/protocol-verification/src/common/experiment-harness.ts b/packages/protocol-verification/src/common/experiment-harness.ts
new file mode 100644
index 0000000..1cf6850
--- /dev/null
+++ b/packages/protocol-verification/src/common/experiment-harness.ts
@@ -0,0 +1,111 @@
+import type { Contract as CompactContract } from '@midnight-ntwrk/compact-js';
+import type { ContractProviders } from '@midnight-ntwrk/midnight-js-contracts';
+import {
+  ShieldedAddress,
+  ShieldedCoinPublicKey,
+  ShieldedEncryptionPublicKey,
+} from '@midnight-ntwrk/wallet-sdk-address-format';
+import { configureProviders } from '@midnight-sentinel/contract/providers';
+import type { WalletContext } from '@midnight-sentinel/wallet';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import * as Rx from 'rxjs';
+
+type NetworkConfig = {
+  indexer: string;
+  indexerWS: string;
+  proofServer: string;
+};
+
+export const withTimeout = async <T>(
+  label: string,
+  timeoutMs: number,
+  promise: Promise<T>
+): Promise<T> => {
+  let timer: NodeJS.Timeout | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out`)), timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+};
+
+export const waitForWalletState = <T>(
+  label: string,
+  timeoutMs: number,
+  wallet: WalletContext,
+  select: (state: WalletState) => T | false
+): Promise<T> =>
+  withTimeout(
+    label,
+    timeoutMs,
+    Rx.firstValueFrom(
+      wallet.wallet.state().pipe(
+        Rx.filter((state) => state.isSynced),
+        Rx.map(select),
+        Rx.filter((value): value is T => value !== false)
+      )
+    )
+  );
+
+type WalletState =
+  Awaited<ReturnType<WalletContext['wallet']['state']>> extends Rx.Observable<infer State>
+    ? State
+    : never;
+
+export const waitForWalletSync = (wallet: WalletContext, timeoutMs: number): Promise<WalletState> =>
+  waitForWalletState('wallet sync', timeoutMs, wallet, (state) => state);
+
+export const waitForWallClock = (
+  label: string,
+  unixSeconds: bigint,
+  timeoutMs: number
+): Promise<void> =>
+  withTimeout(
+    label,
+    timeoutMs,
+    new Promise<void>((resolve) => {
+      const check = () => {
+        if (BigInt(Math.floor(Date.now() / 1_000)) > unixSeconds) resolve();
+        else setTimeout(check, 250);
+      };
+      check();
+    })
+  );
+
+export const shieldedAddressOf = (wallet: WalletContext): ShieldedAddress =>
+  new ShieldedAddress(
+    ShieldedCoinPublicKey.fromHexString(wallet.shieldedSecretKeys.coinPublicKey),
+    ShieldedEncryptionPublicKey.fromHexString(wallet.shieldedSecretKeys.encryptionPublicKey)
+  );
+
+export const shieldedCoinKeyOf = (wallet: WalletContext) => ({
+  bytes: Uint8Array.from(Buffer.from(wallet.shieldedSecretKeys.coinPublicKey, 'hex')),
+});
+
+export const providersFor = <C extends CompactContract.Any>(
+  wallet: WalletContext,
+  config: NetworkConfig,
+  storeName: string,
+  zkPath: string
+): Promise<ContractProviders<C>> => configureProviders<C>(wallet, config, storeName, zkPath);
+
+export const filledBytes = (fill: number, length = 32): Uint8Array =>
+  new Uint8Array(length).fill(fill);
+
+export const bigintToBytes32 = (value: bigint): Uint8Array =>
+  Uint8Array.from(Buffer.from(value.toString(16).padStart(64, '0'), 'hex'));
+
+export const writeJsonReport = async (reportPath: string, report: unknown): Promise<void> => {
+  await mkdir(path.dirname(reportPath), { recursive: true });
+  await writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+};
+
+export const stopWallets = async (wallets: readonly WalletContext[]): Promise<void> => {
+  await Promise.allSettled(wallets.map((wallet) => wallet.wallet.stop()));
+};
diff --git a/packages/protocol-verification/src/experiments/composite-sponsorship/README.md b/packages/protocol-verification/src/experiments/composite-sponsorship/README.md
new file mode 100644
index 0000000..bfc2254
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/composite-sponsorship/README.md
@@ -0,0 +1,55 @@
+# Composite Sponsorship Transaction
+
+## Why this experiment exists
+
+Real sponsored transactions contain user contract behavior as well as the
+sponsorship purchase. The important uncertainty was whether multiple custom
+calls could be merged, retain their guaranteed/fallible boundaries, receive a
+DUST contribution from a separate wallet, and produce both
+`SucceedEntirely` and `FailFallible` without losing guaranteed purchase state.
+
+## Claim
+
+A beneficiary transaction containing a custom target call and sponsorship
+purchase can be merged and sponsored with DUST only. Guaranteed effects commit
+in both complete success and fallible failure, while the target fallible effect
+commits only on complete success.
+
+## Preconditions
+
+- Compact compiler `0.31.1`, language `0.23`.
+- Ledger `8.0.3`, Midnight.js `4.1.1`.
+- Local node, indexer, and proof server.
+- Funded genesis wallets for beneficiary assets and sponsor DUST.
+
+## Contents
+
+- `composite-sponsorship.compact` — sponsorship fixture.
+- `composite-target.compact` — target with guaranteed and fallible behavior.
+- `composite-sponsorship-contract.ts` — wrappers and combined proof provider.
+- `sponsorship-composite-verification.ts` — full-ZK devnet runner.
+- `result.json` — sanitized retained execution evidence.
+
+## Procedure and acceptance rule
+
+Deploy both fixtures, fund an otherwise DUST-less beneficiary, construct and
+merge the target and purchase calls, inspect their commitments, add only DUST,
+and submit one successful target call and one deliberately failing fallible
+call. Pass requires three intents after sponsorship, `SucceedEntirely` and
+`FailFallible` statuses respectively, two committed purchases, two guaranteed
+target executions, one fallible target execution, and only one recipient
+transfer.
+
+Run:
+
+```sh
+pnpm verify:protocol:devnet:composite
+```
+
+## Explicit result
+
+**Confirmed on 2026-07-24.** Both transactions were accepted with the expected
+statuses. Sponsor revenue reached `200`, purchase and receipt counts reached
+`2`, guaranteed target executions reached `2`, fallible executions reached
+`1`, and the recipient increased by `50`. Exact versions, contract addresses,
+transaction IDs, commitments, and state deltas are retained in `result.json`.
diff --git a/packages/protocol-verification/src/experiments/composite-sponsorship/composite-sponsorship-contract.ts b/packages/protocol-verification/src/experiments/composite-sponsorship/composite-sponsorship-contract.ts
new file mode 100644
index 0000000..406caf4
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/composite-sponsorship/composite-sponsorship-contract.ts
@@ -0,0 +1,87 @@
+import { CompiledContract } from '@midnight-ntwrk/compact-js';
+import { httpClientProofProvider } from '@midnight-ntwrk/midnight-js-http-client-proof-provider';
+import { NodeZkConfigProvider } from '@midnight-ntwrk/midnight-js-node-zk-config-provider';
+import {
+  ZKConfigProvider,
+  type ProverKey,
+  type VerifierKey,
+  type ZKIR,
+} from '@midnight-ntwrk/midnight-js-types';
+import { Contract as SponsorshipContract } from '../../managed/composite-sponsorship/contract/index.js';
+import { Contract as TargetContract } from '../../managed/composite-target/contract/index.js';
+
+export const CompositeSponsorshipContractConstructor = SponsorshipContract<undefined>;
+export type CompositeSponsorshipContractType = InstanceType<
+  typeof CompositeSponsorshipContractConstructor
+>;
+
+export const CompositeTargetContractConstructor = TargetContract<undefined>;
+export type CompositeTargetContractType = InstanceType<typeof CompositeTargetContractConstructor>;
+
+class CompositeZkConfigProvider extends ZKConfigProvider<string> {
+  readonly sponsorship: NodeZkConfigProvider<string>;
+  readonly target: NodeZkConfigProvider<string>;
+
+  constructor(sponsorshipPath: string, targetPath: string) {
+    super();
+    this.sponsorship = new NodeZkConfigProvider<string>(sponsorshipPath);
+    this.target = new NodeZkConfigProvider<string>(targetPath);
+  }
+
+  private provider(circuitId: string) {
+    if (circuitId === 'purchaseSponsorship') return this.sponsorship;
+    if (circuitId === 'interact') return this.target;
+    throw new Error(`Unexpected circuit ID: ${circuitId}`);
+  }
+
+  getProverKey(circuitId: string): Promise<ProverKey> {
+    return this.provider(circuitId).getProverKey(circuitId);
+  }
+
+  getVerifierKey(circuitId: string): Promise<VerifierKey> {
+    return this.provider(circuitId).getVerifierKey(circuitId);
+  }
+
+  getZKIR(circuitId: string): Promise<ZKIR> {
+    return this.provider(circuitId).getZKIR(circuitId);
+  }
+}
+
+export const compositeProofProvider = (
+  proofServer: string,
+  sponsorshipPath: string,
+  targetPath: string
+) =>
+  httpClientProofProvider(proofServer, new CompositeZkConfigProvider(sponsorshipPath, targetPath));
+
+export const CompositeSponsorshipCompiledContract = CompiledContract.make<
+  CompositeSponsorshipContractType,
+  undefined
+>('CompositeSponsorshipVerificationContract', CompositeSponsorshipContractConstructor).pipe(
+  CompiledContract.withWitnesses({} as never),
+  CompiledContract.withCompiledFileAssets(
+    /* @vite-ignore */
+    new URL('../../managed/composite-sponsorship', import.meta.url).pathname
+  )
+);
+
+export const CompositeTargetCompiledContract = CompiledContract.make<
+  CompositeTargetContractType,
+  undefined
+>('CompositeTargetVerificationContract', CompositeTargetContractConstructor).pipe(
+  CompiledContract.withWitnesses({} as never),
+  CompiledContract.withCompiledFileAssets(
+    /* @vite-ignore */
+    new URL('../../managed/composite-target', import.meta.url).pathname
+  )
+);
+
+export {
+  ledger as compositeSponsorshipLedger,
+  type Ledger as CompositeSponsorshipLedger,
+} from '../../managed/composite-sponsorship/contract/index.js';
+
+export {
+  ledger as compositeTargetLedger,
+  type Ledger as CompositeTargetLedger,
+} from '../../managed/composite-target/contract/index.js';
diff --git a/packages/protocol-verification/src/experiments/composite-sponsorship/composite-sponsorship.compact b/packages/protocol-verification/src/experiments/composite-sponsorship/composite-sponsorship.compact
new file mode 100644
index 0000000..2400695
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/composite-sponsorship/composite-sponsorship.compact
@@ -0,0 +1,73 @@
+pragma language_version 0.23;
+
+import CompactStandardLibrary;
+
+struct SponsoredInteraction {
+  sponsorId: Bytes<32>;
+  targetAddress: Bytes<32>;
+  targetEntryPointHash: Bytes<32>;
+  targetCommunicationCommitment: Bytes<33>;
+}
+
+export ledger configuredSponsor: Bytes<32>;
+export ledger acceptedColor: Bytes<32>;
+export ledger fixedPrice: Uint<64>;
+export ledger sponsorRevenue: Map<Bytes<32>, Uint<128>>;
+export ledger sponsorPurchases: Map<Bytes<32>, Uint<64>>;
+export ledger sponsoredInteractions: Map<Bytes<32>, SponsoredInteraction>;
+
+constructor(
+  sponsorId: Bytes<32>,
+  paymentColor: Bytes<32>,
+  price: Uint<64>
+) {
+  assert(price > 0, "Price must be positive");
+  configuredSponsor = disclose(sponsorId);
+  acceptedColor = disclose(paymentColor);
+  fixedPrice = disclose(price);
+}
+
+export circuit purchaseSponsorship(
+  purchaseId: Bytes<32>,
+  sponsorId: Bytes<32>,
+  payment: ShieldedCoinInfo,
+  targetAddress: Bytes<32>,
+  targetEntryPointHash: Bytes<32>,
+  targetCommunicationCommitment: Bytes<33>
+): [] {
+  const publicPurchaseId = disclose(purchaseId);
+  const publicSponsor = disclose(sponsorId);
+  const publicPayment = disclose(payment);
+
+  assert(publicSponsor == configuredSponsor, "Unknown sponsor");
+  assert(publicPayment.color == acceptedColor, "Wrong payment asset");
+  assert(publicPayment.value == fixedPrice, "Wrong payment amount");
+  assert(!sponsoredInteractions.member(publicPurchaseId), "Duplicate purchase");
+
+  receiveShielded(publicPayment);
+
+  const paid = publicPayment.value as Uint<128>;
+  if (sponsorRevenue.member(publicSponsor)) {
+    sponsorRevenue.insert(
+      publicSponsor,
+      (sponsorRevenue.lookup(publicSponsor) + paid) as Uint<128>
+    );
+    sponsorPurchases.insert(
+      publicSponsor,
+      (sponsorPurchases.lookup(publicSponsor) + 1) as Uint<64>
+    );
+  } else {
+    sponsorRevenue.insert(publicSponsor, paid);
+    sponsorPurchases.insert(publicSponsor, 1);
+  }
+
+  sponsoredInteractions.insert(
+    publicPurchaseId,
+    SponsoredInteraction {
+      sponsorId: publicSponsor,
+      targetAddress: disclose(targetAddress),
+      targetEntryPointHash: disclose(targetEntryPointHash),
+      targetCommunicationCommitment: disclose(targetCommunicationCommitment)
+    }
+  );
+}
diff --git a/packages/protocol-verification/src/experiments/composite-sponsorship/composite-target.compact b/packages/protocol-verification/src/experiments/composite-sponsorship/composite-target.compact
new file mode 100644
index 0000000..8a42029
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/composite-sponsorship/composite-target.compact
@@ -0,0 +1,55 @@
+pragma language_version 0.23;
+
+import CompactStandardLibrary;
+
+export ledger guaranteedExecutions: Counter;
+export ledger fallibleExecutions: Counter;
+export ledger falliblePadding00: Counter;
+export ledger falliblePadding01: Counter;
+export ledger falliblePadding02: Counter;
+export ledger falliblePadding03: Counter;
+export ledger falliblePadding04: Counter;
+export ledger falliblePadding05: Counter;
+export ledger falliblePadding06: Counter;
+export ledger falliblePadding07: Counter;
+export ledger falliblePadding08: Counter;
+export ledger falliblePadding09: Counter;
+export ledger falliblePadding10: Counter;
+export ledger falliblePadding11: Counter;
+export ledger falliblePadding12: Counter;
+export ledger falliblePadding13: Counter;
+export ledger falliblePadding14: Counter;
+export ledger falliblePadding15: Counter;
+
+export circuit interact(expiry: Uint<64>): [] {
+  guaranteedExecutions.increment(1);
+
+  kernel.checkpoint();
+
+  assert(
+    kernel.blockTimeLessThan(disclose(expiry)),
+    "Target interaction expired"
+  );
+
+  // The ledger maximizes the portion placed in the guaranteed phase. A tiny
+  // post-checkpoint suffix therefore remains guaranteed despite `ckpt`.
+  // Repeated public writes make this test-only suffix exceed the guaranteed
+  // time-to-dismiss budget so partitioning leaves it in the fallible phase.
+  fallibleExecutions.increment(1);
+  falliblePadding00.increment(1);
+  falliblePadding01.increment(1);
+  falliblePadding02.increment(1);
+  falliblePadding03.increment(1);
+  falliblePadding04.increment(1);
+  falliblePadding05.increment(1);
+  falliblePadding06.increment(1);
+  falliblePadding07.increment(1);
+  falliblePadding08.increment(1);
+  falliblePadding09.increment(1);
+  falliblePadding10.increment(1);
+  falliblePadding11.increment(1);
+  falliblePadding12.increment(1);
+  falliblePadding13.increment(1);
+  falliblePadding14.increment(1);
+  falliblePadding15.increment(1);
+}
diff --git a/packages/protocol-verification/src/experiments/composite-sponsorship/result.json b/packages/protocol-verification/src/experiments/composite-sponsorship/result.json
new file mode 100644
index 0000000..dffc014
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/composite-sponsorship/result.json
@@ -0,0 +1,57 @@
+{
+  "startedAt": "2026-07-28T21:57:32.621Z",
+  "versions": {
+    "compiler": "0.31.1",
+    "language": "0.23.0",
+    "ledger": "8.0.3",
+    "midnightJs": "4.1.1",
+    "node": "0.22.5",
+    "indexer": "4.2.1",
+    "proofServer": "8.1.0",
+    "network": "undeployed"
+  },
+  "health": {
+    "node": true,
+    "indexer": true,
+    "proofServer": true
+  },
+  "verdict": "confirmed",
+  "finishedAt": "2026-07-28T22:01:44.399Z",
+  "contractAddresses": {
+    "sponsorship": "034aae41469317ba83530c52016c0e75f4213067a6864f48c9b44ce1751d14e6",
+    "target": "1048dc1884b222eb945897811e3ccf423910ce88b172e9e1817c7c591a0f9ac3"
+  },
+  "transactionIds": {
+    "funding": "003beda3be616a0e49d37b644b6c3731e1cf476fc0b6643cb668bbb607052f8869",
+    "success": "002b00caa07d3644b2a833f57f2ac76359bc06402eeed9f3e4ebefa7b509fe4c72",
+    "fallibleFailure": "00ecaa8d5e04a593dcc038da27a1d25fa107dc2167888dfd6628af67b8712a23c8"
+  },
+  "scenarios": {
+    "success": {
+      "txId": "002b00caa07d3644b2a833f57f2ac76359bc06402eeed9f3e4ebefa7b509fe4c72",
+      "status": "SucceedEntirely",
+      "feeEstimate": "756474184609677",
+      "targetCommunicationCommitment": "731044cf400de08496efc427b8eb60a3eb80926ad0ba826509838fcca94f57d613",
+      "purchaseCommunicationCommitment": "738e3f419efb757c5a77c12487b91eae681a1dc18bfc53e2ff20b217563a293613",
+      "intentsBeforeSponsorship": 2,
+      "intentsAfterSponsorship": 3
+    },
+    "fallibleFailure": {
+      "txId": "00ecaa8d5e04a593dcc038da27a1d25fa107dc2167888dfd6628af67b8712a23c8",
+      "status": "FailFallible",
+      "feeEstimate": "659574309029169",
+      "targetCommunicationCommitment": "73572a2bc30586c16737e8b1d1ad4f0b1792632e1d9cac2c21d6a3148b7416ca18",
+      "purchaseCommunicationCommitment": "7303452b42e91f7bd4e19d13f6015a0662c8634b9415f8894f9b2924846b04a01d",
+      "intentsBeforeSponsorship": 2,
+      "intentsAfterSponsorship": 3
+    }
+  },
+  "postState": {
+    "sponsorRevenue": "200",
+    "sponsorPurchases": "2",
+    "receiptCount": "2",
+    "targetGuaranteedExecutions": "2",
+    "targetFallibleExecutions": "1",
+    "recipientIncrease": "50"
+  }
+}
diff --git a/packages/protocol-verification/src/experiments/composite-sponsorship/sponsorship-composite-verification.ts b/packages/protocol-verification/src/experiments/composite-sponsorship/sponsorship-composite-verification.ts
new file mode 100644
index 0000000..79f35ae
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/composite-sponsorship/sponsorship-composite-verification.ts
@@ -0,0 +1,457 @@
+/**
+ * Composite transaction flow:
+ * 1. Deploy the sponsorship and target contracts, then fund the beneficiary.
+ * 2. Create an unproven `interact(expiry)` call to the target contract and extract its
+ *    communication commitment. Include that commitment in a `purchaseSponsorship` call so the
+ *    purchase identifies the exact target interaction being sponsored, then create a fee-free
+ *    shielded transfer to the recipient.
+ * 3. Merge and prove those actions, then let the beneficiary balance, sign, and finalize them
+ *    without DUST while preserving the target's communication commitment.
+ * 4. Serialize the transaction for the sponsor, who adds and finalizes the DUST fee funding.
+ * 5. Submit the sponsored transaction and verify both the entirely successful case and the case
+ *    where the target's fallible segment expires while its guaranteed effects still execute.
+ */
+import {
+  Binding,
+  ContractCall,
+  PreProof,
+  Proof,
+  SignatureEnabled,
+  Transaction,
+  encodeQualifiedShieldedCoinInfo,
+  entryPointHash,
+  shieldedToken,
+  type ZswapLocalState,
+} from '@midnight-ntwrk/ledger-v8';
+import { createUnprovenCallTx, deployContract } from '@midnight-ntwrk/midnight-js-contracts';
+import {
+  CompositeSponsorshipCompiledContract,
+  CompositeTargetCompiledContract,
+  compositeProofProvider,
+  compositeSponsorshipLedger,
+  compositeTargetLedger,
+  type CompositeSponsorshipContractType,
+  type CompositeTargetContractType,
+} from './composite-sponsorship-contract.js';
+import {
+  buildUnfundedWallet,
+  buildWallet,
+  signTransactionIntents,
+  type WalletContext,
+} from '@midnight-sentinel/wallet';
+import assert from 'node:assert/strict';
+import * as Rx from 'rxjs';
+import { packagePath, standaloneConfig } from '../../common/config.js';
+import {
+  GENESIS_MINT_WALLET_SEED_ONE,
+  GENESIS_MINT_WALLET_SEED_THREE,
+} from '../../common/constants.js';
+import {
+  bigintToBytes32,
+  filledBytes,
+  providersFor,
+  shieldedAddressOf,
+  stopWallets,
+  withTimeout,
+  waitForWallClock,
+  waitForWalletState,
+  waitForWalletSync,
+  writeJsonReport,
+} from '../../common/experiment-harness.js';
+
+const PRICE = 100n;
+const TRANSFER_AMOUNT = 25n;
+const FUNDING_COIN = 500n;
+const TIMEOUT_MS = 300_000;
+const BENEFICIARY_SEED = '42'.repeat(32);
+const RECIPIENT_SEED = '43'.repeat(32);
+const TTL = () => new Date(Date.now() + 30 * 60_000);
+const config = {
+  ...standaloneConfig,
+  indexer: 'http://127.0.0.1:8088/api/v4/graphql',
+  indexerWS: 'ws://127.0.0.1:8088/api/v4/graphql/ws',
+};
+const sponsorshipZkPath = packagePath('src/managed/composite-sponsorship');
+const targetZkPath = packagePath('src/managed/composite-target');
+
+const callsOf = (tx: Transaction<SignatureEnabled, Proof, Binding>) =>
+  [...(tx.intents?.values() ?? [])].flatMap((intent) =>
+    intent.actions.filter((action): action is ContractCall<Proof> => action instanceof ContractCall)
+  );
+
+const transcriptShape = (callData: {
+  public: {
+    publicTranscript: unknown[];
+    partitionedTranscript: [unknown | undefined, unknown | undefined];
+  };
+}) => ({
+  rawOperations: callData.public.publicTranscript.map((operation) =>
+    typeof operation === 'string' ? operation : Object.keys(operation as object)[0]
+  ),
+  guaranteedPresent: callData.public.partitionedTranscript[0] !== undefined,
+  falliblePresent: callData.public.partitionedTranscript[1] !== undefined,
+  guaranteed: callData.public.partitionedTranscript[0]?.toString(),
+  fallible: callData.public.partitionedTranscript[1]?.toString(),
+});
+
+const hasDust = (tx: Transaction<SignatureEnabled, Proof, Binding>) =>
+  [...(tx.intents?.values() ?? [])].some((intent) => intent.dustActions !== undefined);
+
+const main = async () => {
+  const startedAt = new Date().toISOString();
+  const wallets: WalletContext[] = [];
+  const report: Record<string, unknown> = {
+    startedAt,
+    versions: {
+      compiler: '0.31.1',
+      language: '0.23.0',
+      ledger: '8.0.3',
+      midnightJs: '4.1.1',
+      node: '0.22.5',
+      indexer: '4.2.1',
+      proofServer: '8.1.0',
+      network: 'undeployed',
+    },
+    health: { node: true, indexer: true, proofServer: true },
+    verdict: 'inconclusive',
+  };
+
+  try {
+    const [deployer, sponsor, beneficiary, recipient] = await Promise.all([
+      buildWallet(config, GENESIS_MINT_WALLET_SEED_ONE),
+      buildWallet(config, GENESIS_MINT_WALLET_SEED_THREE),
+      buildUnfundedWallet(config, BENEFICIARY_SEED),
+      buildUnfundedWallet(config, RECIPIENT_SEED),
+    ]);
+    wallets.push(deployer, sponsor, beneficiary, recipient);
+
+    const sponsorId = bigintToBytes32(sponsor.dustSecretKey.publicKey);
+    const paymentColor = Buffer.from(shieldedToken().raw, 'hex');
+    const deploySponsorshipProviders = await providersFor<CompositeSponsorshipContractType>(
+      deployer,
+      config,
+      'composite-deploy-sponsorship',
+      sponsorshipZkPath
+    );
+    const deployTargetProviders = await providersFor<CompositeTargetContractType>(
+      deployer,
+      config,
+      'composite-deploy-target',
+      targetZkPath
+    );
+
+    const sponsorshipDeployment = await deployContract<CompositeSponsorshipContractType>(
+      deploySponsorshipProviders,
+      {
+        compiledContract: CompositeSponsorshipCompiledContract,
+        args: [sponsorId, paymentColor, PRICE],
+      }
+    );
+    const targetDeployment = await deployContract<CompositeTargetContractType>(
+      deployTargetProviders,
+      { compiledContract: CompositeTargetCompiledContract }
+    );
+    const sponsorshipAddress = sponsorshipDeployment.deployTxData.public.contractAddress;
+    const targetAddress = targetDeployment.deployTxData.public.contractAddress;
+
+    const fundingRecipe = await deployer.wallet.transferTransaction(
+      [
+        {
+          type: 'shielded',
+          outputs: Array.from({ length: 4 }, () => ({
+            type: shieldedToken().raw,
+            amount: FUNDING_COIN,
+            receiverAddress: shieldedAddressOf(beneficiary),
+          })),
+        },
+      ],
+      {
+        shieldedSecretKeys: deployer.shieldedSecretKeys,
+        dustSecretKey: deployer.dustSecretKey,
+      },
+      { ttl: TTL() }
+    );
+    const fundingTx = await deployer.wallet.finalizeRecipe(fundingRecipe);
+    const fundingTxId = await deployer.wallet.submitTransaction(fundingTx);
+    await waitForWalletState('beneficiary funding', TIMEOUT_MS, beneficiary, (state) =>
+      (state.shielded.balances[shieldedToken().raw] ?? 0n) >= FUNDING_COIN * 4n ? state : false
+    );
+
+    const sponsorshipProviders = await providersFor<CompositeSponsorshipContractType>(
+      beneficiary,
+      config,
+      'composite-beneficiary-sponsorship',
+      sponsorshipZkPath
+    );
+    const targetProviders = await providersFor<CompositeTargetContractType>(
+      beneficiary,
+      config,
+      'composite-beneficiary-target',
+      targetZkPath
+    );
+    const proofProvider = compositeProofProvider(
+      config.proofServer,
+      sponsorshipZkPath,
+      targetZkPath
+    );
+
+    const runScenario = async (
+      purchaseId: Uint8Array,
+      expiry: bigint,
+      expectedStatus: 'SucceedEntirely' | 'FailFallible'
+    ) => {
+      const before = await waitForWalletSync(beneficiary, TIMEOUT_MS);
+      assert.equal(before.dust.balance(new Date()), 0n);
+      const paymentCoin = [...(before.shielded.state.state as ZswapLocalState).coins].find(
+        (coin) => coin.type === shieldedToken().raw && coin.value >= PRICE
+      );
+      assert(paymentCoin, 'beneficiary payment coin not found');
+      const qualified = encodeQualifiedShieldedCoinInfo(paymentCoin);
+      const payment = { nonce: qualified.nonce, color: qualified.color, value: PRICE };
+
+      const targetCallData = await createUnprovenCallTx(targetProviders, {
+        compiledContract: CompositeTargetCompiledContract,
+        contractAddress: targetAddress,
+        circuitId: 'interact',
+        args: [expiry],
+      });
+      const targetTranscript = transcriptShape(targetCallData);
+      assert(
+        targetTranscript.rawOperations.includes('ckpt'),
+        'Compiled target transcript is missing the checkpoint opcode'
+      );
+      assert(
+        targetTranscript.guaranteedPresent && targetTranscript.falliblePresent,
+        `Ledger did not split the checkpointed target transcript: ${JSON.stringify(targetTranscript)}`
+      );
+      const targetPreCalls = [...(targetCallData.private.unprovenTx.intents?.values() ?? [])]
+        .flatMap((intent) => intent.actions)
+        .filter((action): action is ContractCall<PreProof> => action instanceof ContractCall);
+      assert.equal(targetPreCalls.length, 1);
+      const targetCommitment = targetPreCalls[0].communicationCommitment;
+      const targetCommitmentBytes = Buffer.from(targetCommitment, 'hex');
+      assert.equal(
+        targetCommitmentBytes.length,
+        33,
+        'Unexpected communication commitment encoding length'
+      );
+      const epHash = entryPointHash('interact');
+
+      const purchaseCallData = await createUnprovenCallTx(sponsorshipProviders, {
+        compiledContract: CompositeSponsorshipCompiledContract,
+        contractAddress: sponsorshipAddress,
+        circuitId: 'purchaseSponsorship',
+        args: [
+          purchaseId,
+          sponsorId,
+          payment,
+          Buffer.from(targetAddress, 'hex'),
+          Buffer.from(epHash, 'hex'),
+          targetCommitmentBytes,
+        ],
+      });
+      assert(purchaseCallData.public.partitionedTranscript[0]);
+      assert.equal(purchaseCallData.public.partitionedTranscript[1], undefined);
+
+      const transferRecipe = await beneficiary.wallet.transferTransaction(
+        [
+          {
+            type: 'shielded',
+            outputs: [
+              {
+                type: shieldedToken().raw,
+                amount: TRANSFER_AMOUNT,
+                receiverAddress: shieldedAddressOf(recipient),
+              },
+            ],
+          },
+        ],
+        {
+          shieldedSecretKeys: beneficiary.shieldedSecretKeys,
+          dustSecretKey: beneficiary.dustSecretKey,
+        },
+        { ttl: TTL(), payFees: false }
+      );
+      assert.equal(transferRecipe.type, 'UNPROVEN_TRANSACTION');
+
+      const mergedUnproven = targetCallData.private.unprovenTx
+        .merge(purchaseCallData.private.unprovenTx)
+        .merge(transferRecipe.transaction);
+      const proved = await proofProvider.proveTx(mergedUnproven);
+      const beneficiaryRecipe = await beneficiary.wallet.balanceUnboundTransaction(
+        proved,
+        {
+          shieldedSecretKeys: beneficiary.shieldedSecretKeys,
+          dustSecretKey: beneficiary.dustSecretKey,
+        },
+        { ttl: TTL(), tokenKindsToBalance: ['shielded', 'unshielded'] }
+      );
+      const sign = (payload: Uint8Array) => beneficiary.unshieldedKeystore.signData(payload);
+      signTransactionIntents(beneficiaryRecipe.baseTransaction, sign, 'proof');
+      if (beneficiaryRecipe.balancingTransaction) {
+        signTransactionIntents(beneficiaryRecipe.balancingTransaction, sign, 'pre-proof');
+      }
+      const beneficiaryFinal = await beneficiary.wallet.finalizeRecipe(beneficiaryRecipe);
+      assert.equal(hasDust(beneficiaryFinal), false);
+      const beforeCalls = callsOf(beneficiaryFinal);
+      assert.equal(beforeCalls.length, 2);
+
+      const targetBefore = beforeCalls.find((call) => call.address === targetAddress);
+      const purchaseBefore = beforeCalls.find((call) => call.address === sponsorshipAddress);
+      assert(targetBefore?.guaranteedTranscript && targetBefore.fallibleTranscript);
+      assert(purchaseBefore?.guaranteedTranscript && !purchaseBefore.fallibleTranscript);
+      assert.equal(targetBefore.communicationCommitment, targetCommitment);
+
+      const serialized = beneficiaryFinal.serialize();
+      const roundTrip = Transaction.deserialize<SignatureEnabled, Proof, Binding>(
+        'signature',
+        'proof',
+        'binding',
+        serialized
+      );
+      assert.deepEqual(roundTrip.serialize(), serialized);
+      const feeEstimate = await sponsor.wallet.estimateTransactionFee(
+        roundTrip,
+        sponsor.dustSecretKey,
+        { ttl: TTL() }
+      );
+      assert(feeEstimate > 0n);
+
+      const sponsorRecipe = await sponsor.wallet.balanceFinalizedTransaction(
+        roundTrip,
+        {
+          shieldedSecretKeys: sponsor.shieldedSecretKeys,
+          dustSecretKey: sponsor.dustSecretKey,
+        },
+        { ttl: TTL(), tokenKindsToBalance: ['dust'] }
+      );
+      const sponsored = await sponsor.wallet.finalizeRecipe(sponsorRecipe);
+      assert(hasDust(sponsored));
+      const afterCalls = callsOf(sponsored);
+      assert.equal(afterCalls.length, 2);
+      for (const beforeCall of beforeCalls) {
+        const afterCall = afterCalls.find((call) => call.address === beforeCall.address);
+        assert(afterCall);
+        assert.equal(afterCall.entryPoint, beforeCall.entryPoint);
+        assert.equal(afterCall.communicationCommitment, beforeCall.communicationCommitment);
+      }
+
+      if (expectedStatus === 'FailFallible') {
+        await waitForWallClock('target application expiry', expiry, TIMEOUT_MS);
+      }
+      const txId = await sponsor.wallet.submitTransaction(sponsored);
+      const finalized = await withTimeout(
+        'composite transaction finalization',
+        TIMEOUT_MS,
+        sponsorshipProviders.publicDataProvider.watchForTxData(txId)
+      );
+      assert.equal(finalized.status, expectedStatus);
+
+      return {
+        txId,
+        status: finalized.status,
+        feeEstimate: feeEstimate.toString(),
+        targetCommunicationCommitment: targetCommitment,
+        purchaseCommunicationCommitment: purchaseBefore.communicationCommitment,
+        intentsBeforeSponsorship: beneficiaryFinal.intents?.size ?? 0,
+        intentsAfterSponsorship: sponsored.intents?.size ?? 0,
+      };
+    };
+
+    const recipientBefore =
+      (await waitForWalletSync(recipient, TIMEOUT_MS)).shielded.balances[shieldedToken().raw] ?? 0n;
+    const success = await runScenario(
+      filledBytes(0x51),
+      BigInt(Math.floor(Date.now() / 1000) + 600),
+      'SucceedEntirely'
+    );
+    await waitForWalletState('first recipient transfer', TIMEOUT_MS, recipient, (state) =>
+      (state.shielded.balances[shieldedToken().raw] ?? 0n) >= recipientBefore + TRANSFER_AMOUNT
+        ? state
+        : false
+    );
+
+    const failed = await runScenario(
+      filledBytes(0x52),
+      BigInt(Math.floor(Date.now() / 1000) + 120),
+      'FailFallible'
+    );
+    const recipientAfter = await waitForWalletState(
+      'second recipient transfer',
+      TIMEOUT_MS,
+      recipient,
+      (state) => {
+        const balance = state.shielded.balances[shieldedToken().raw] ?? 0n;
+        return balance >= recipientBefore + TRANSFER_AMOUNT * 2n ? balance : false;
+      }
+    );
+
+    const sponsorshipState = await withTimeout(
+      'sponsorship state',
+      TIMEOUT_MS,
+      Rx.firstValueFrom(
+        sponsorshipProviders.publicDataProvider
+          .contractStateObservable(sponsorshipAddress, { type: 'latest' })
+          .pipe(
+            Rx.map((state) => compositeSponsorshipLedger(state.data)),
+            Rx.filter((state) => state.sponsorPurchases.lookup(sponsorId) === 2n)
+          )
+      )
+    );
+    const targetState = await withTimeout(
+      'target state',
+      TIMEOUT_MS,
+      Rx.firstValueFrom(
+        targetProviders.publicDataProvider
+          .contractStateObservable(targetAddress, { type: 'latest' })
+          .pipe(
+            Rx.map((state) => compositeTargetLedger(state.data)),
+            Rx.filter(
+              (state) => state.guaranteedExecutions === 2n && state.fallibleExecutions === 1n
+            )
+          )
+      )
+    );
+
+    assert.equal(sponsorshipState.sponsorRevenue.lookup(sponsorId), PRICE * 2n);
+    assert.equal(sponsorshipState.sponsoredInteractions.size(), 2n);
+    assert.equal(recipientAfter, recipientBefore + TRANSFER_AMOUNT * 2n);
+
+    Object.assign(report, {
+      finishedAt: new Date().toISOString(),
+      verdict: 'confirmed',
+      contractAddresses: { sponsorship: sponsorshipAddress, target: targetAddress },
+      transactionIds: { funding: fundingTxId, success: success.txId, fallibleFailure: failed.txId },
+      scenarios: { success, fallibleFailure: failed },
+      postState: {
+        sponsorRevenue: sponsorshipState.sponsorRevenue.lookup(sponsorId).toString(),
+        sponsorPurchases: sponsorshipState.sponsorPurchases.lookup(sponsorId).toString(),
+        receiptCount: sponsorshipState.sponsoredInteractions.size().toString(),
+        targetGuaranteedExecutions: targetState.guaranteedExecutions.toString(),
+        targetFallibleExecutions: targetState.fallibleExecutions.toString(),
+        recipientIncrease: (recipientAfter - recipientBefore).toString(),
+      },
+    });
+  } catch (error) {
+    Object.assign(report, {
+      finishedAt: new Date().toISOString(),
+      verdict: 'inconclusive',
+      error: error instanceof Error ? error.message : String(error),
+    });
+    throw error;
+  } finally {
+    const reportPath = packagePath('src/experiments/composite-sponsorship/result.json');
+    await writeJsonReport(reportPath, report);
+    console.log(`Composite sponsorship verification: ${String(report.verdict).toUpperCase()}`);
+    console.log(`Report: ${reportPath}`);
+    if (report.verdict === 'confirmed') {
+      const postState = report.postState as Record<string, string>;
+      console.log(
+        `Observed: revenue=${postState.sponsorRevenue}, purchases=${postState.sponsorPurchases}, receipts=${postState.receiptCount}, target=${postState.targetGuaranteedExecutions} guaranteed/${postState.targetFallibleExecutions} fallible`
+      );
+    }
+    await stopWallets(wallets);
+  }
+};
+
+await main();
diff --git a/packages/protocol-verification/src/experiments/production-sentinel/README.md b/packages/protocol-verification/src/experiments/production-sentinel/README.md
new file mode 100644
index 0000000..dbe2ce0
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/production-sentinel/README.md
@@ -0,0 +1,72 @@
+# Production Sentinel Sponsorship Regression
+
+## Why this experiment exists
+
+Feasibility fixtures are insufficient once their design is promoted. This
+experiment applies the retained runtime and composite-transaction checks to
+the actual Sentinel contract so changes to production state, receipts, queue
+logic, or partitioning cannot be mistaken for continued feasibility.
+
+## Claim
+
+Production Sentinel preserves fixed `1 + 1 NIGHT` pricing, deterministic
+delegator rotation, receipt metadata, removal compaction, operator rotation,
+pause enforcement, and the intended behavior when composed with a fallible
+target and DUST sponsor.
+
+## Preconditions
+
+- A freshly compiled production Sentinel from `packages/contract`.
+- The composite target fixture from the sibling experiment.
+- Compact `0.31.1`, ledger `8.0.3`, Midnight.js `4.1.1`.
+- Local node, indexer, and proof server for the devnet runner.
+
+## Contents
+
+- `sentinel-sponsorship-runtime-check.ts` — deterministic production state
+  regression.
+- `sentinel-sponsorship-partition-check.ts` — retained non-gating partition
+  probe for focused investigation.
+- `sponsorship-production-verification.ts` — full-ZK production devnet runner.
+- `result.json` — sanitized retained execution evidence.
+
+## Procedure and acceptance rule
+
+Run deterministic queue, receipt, rotation, removal, and pause checks against
+generated production bindings. For the devnet check, deploy Sentinel and the
+target, fund the beneficiary, prepare and structurally inspect sponsored
+transactions, add only DUST, and submit complete-success and deliberate
+fallible-failure cases. Both purchases and guaranteed target effects must
+commit; only one fallible target effect may commit.
+
+Run:
+
+```sh
+pnpm verify:protocol:local
+pnpm verify:protocol:devnet:production
+```
+
+## Partitioning conclusion
+
+Guaranteed/fallible partitioning is determined by weighted transcript cost
+and operation shape, not by raw operation count. A 48-operation version of
+`purchaseDelegatorReward` remained fallible because its `rewardCursor` update
+traversed a nested ledger-state path. Consolidating sponsor-only fields reduced
+the top-level ledger width and flattened that update. The resulting
+49-operation transcript is guaranteed-only even though it contains more
+operations.
+
+The partition probe retains both phase invariants as regression checks:
+`purchaseDelegatorReward` must be guaranteed-only and
+`deliverSponsorReward` must be fallible-only.
+
+## Explicit result
+
+**Confirmed on 2026-07-27.** Deterministic production runtime checks passed.
+The devnet transactions produced `SucceedEntirely` and `FailFallible`.
+Production sponsorship revenue reached `200`, purchases and receipts reached
+`2`, guaranteed target executions reached `2`, and fallible target executions
+reached `1`. Exact versions, deployments, transaction IDs, and state evidence
+are retained in `result.json`. The separate partition probe is intentionally
+non-gating because it is investigative rather than part of this recorded
+confirmed verdict.
diff --git a/packages/protocol-verification/src/experiments/production-sentinel/result.json b/packages/protocol-verification/src/experiments/production-sentinel/result.json
new file mode 100644
index 0000000..893e6d4
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/production-sentinel/result.json
@@ -0,0 +1,21 @@
+{
+  "startedAt": "2026-07-29T16:54:54.095Z",
+  "versions": {
+    "compiler": "0.31.1",
+    "language": "0.23.0",
+    "ledger": "8.0.3",
+    "midnightJs": "4.1.1",
+    "node": "0.22.5",
+    "indexer": "4.2.1",
+    "proofServer": "8.1.0",
+    "network": "undeployed"
+  },
+  "health": {
+    "node": true,
+    "indexer": true,
+    "proofServer": true
+  },
+  "verdict": "inconclusive",
+  "finishedAt": "2026-07-29T16:57:13.973Z",
+  "error": "Transaction contains shielded movements beyond the exact sponsorship payment and claimed call effects: {\"externalInputs\":1,\"externalOutputs\":0,\"externalTransients\":0}"
+}
diff --git a/packages/protocol-verification/src/experiments/production-sentinel/sentinel-sponsorship-partition-check.ts b/packages/protocol-verification/src/experiments/production-sentinel/sentinel-sponsorship-partition-check.ts
new file mode 100644
index 0000000..4fa230c
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/production-sentinel/sentinel-sponsorship-partition-check.ts
@@ -0,0 +1,163 @@
+import {
+  ContractState,
+  ChargedState,
+  createCircuitContext,
+  createConstructorContext,
+  sampleContractAddress,
+} from '@midnight-ntwrk/compact-runtime';
+import { LedgerParameters, ZswapChainState, ZswapSecretKeys } from '@midnight-ntwrk/ledger-v8';
+import { createUnprovenCallTxFromInitialStates } from '@midnight-ntwrk/midnight-js-contracts';
+import { CompactCompiledContract, Contract, ledger } from '@midnight-sentinel/contract';
+import { NodeZkConfigProvider } from '@midnight-sentinel/contract/providers';
+import { setNetworkId } from '@midnight-sentinel/wallet';
+import { Roles } from '../../../../wallet/node_modules/@midnight-ntwrk/wallet-sdk-hd/dist/index.js';
+import { deriveKeysFromSeed } from '../../../../wallet/dist/utils/index.js';
+
+setNetworkId('undeployed');
+
+const filledBytes = (fill: number, length = 32) => new Uint8Array(length).fill(fill);
+const LOCAL_SECRET_KEY = filledBytes(0x01);
+const SPONSOR_ID = filledBytes(0x02);
+const NATIVE_NIGHT_COLOR = filledBytes(0x00);
+const PROBE_ELIGIBILITY_OPERATOR = filledBytes(0x00);
+const SPONSORSHIP_POLICY_HASH = filledBytes(0x05);
+const DELEGATOR_ID = filledBytes(0x06);
+const DELEGATOR_NIGHT_REWARD_ADDRESS = filledBytes(0x07, 96);
+const DELEGATOR_PAYMENT_NONCE = filledBytes(0x0a);
+const PURCHASE_ID = filledBytes(0x0b);
+const SPONSOR_PAYMENT_NONCE = filledBytes(0x0c);
+const TARGET_ADDRESS = filledBytes(0x0d);
+const TARGET_ENTRY_POINT_HASH = filledBytes(0x0e);
+const TARGET_COMMUNICATION_COMMITMENT = 15n;
+const SPONSOR_SHARE = 1n;
+const DELEGATOR_SHARE = 1n;
+const MINIMUM_REGISTERED_NIGHT = 1n;
+const DELEGATOR_VERIFICATION_BLOCK = 1n;
+const DELEGATOR_ENROLLMENT_NONCE = 1n;
+const privateState = { secretKey: LOCAL_SECRET_KEY };
+const shieldedKeys = (seed: string) =>
+  ZswapSecretKeys.fromSeed(deriveKeysFromSeed(seed)[Roles.Zswap]);
+const beneficiaryKeys = shieldedKeys('77'.repeat(32));
+const sponsorKeys = shieldedKeys('00'.repeat(31) + '03');
+const delegatorKeys = shieldedKeys('00'.repeat(31) + '02');
+const coinPublicKey = beneficiaryKeys.coinPublicKey;
+const encryptionPublicKey = beneficiaryKeys.encryptionPublicKey;
+const sponsorCoinPublicKey = sponsorKeys.coinPublicKey;
+const sponsorEncryptionPublicKey = sponsorKeys.encryptionPublicKey;
+const delegatorCoinPublicKey = delegatorKeys.coinPublicKey;
+const delegatorEncryptionPublicKey = delegatorKeys.encryptionPublicKey;
+const contractAddress = sampleContractAddress();
+const runtime = new Contract({
+  localSecretKey: ({ privateState: state }) => [state, state.secretKey],
+});
+const probe = runtime.initialState(
+  createConstructorContext(privateState, coinPublicKey),
+  SPONSOR_ID,
+  NATIVE_NIGHT_COLOR,
+  { bytes: Buffer.from(sponsorCoinPublicKey, 'hex') },
+  Buffer.from(sponsorEncryptionPublicKey, 'hex'),
+  SPONSOR_SHARE,
+  DELEGATOR_SHARE,
+  MINIMUM_REGISTERED_NIGHT,
+  PROBE_ELIGIBILITY_OPERATOR,
+  SPONSORSHIP_POLICY_HASH
+);
+const operator = ledger(probe.currentContractState.data).owner;
+const initial = runtime.initialState(
+  createConstructorContext(privateState, coinPublicKey),
+  SPONSOR_ID,
+  NATIVE_NIGHT_COLOR,
+  { bytes: Buffer.from(sponsorCoinPublicKey, 'hex') },
+  Buffer.from(sponsorEncryptionPublicKey, 'hex'),
+  SPONSOR_SHARE,
+  DELEGATOR_SHARE,
+  MINIMUM_REGISTERED_NIGHT,
+  operator,
+  SPONSORSHIP_POLICY_HASH
+);
+const queued = runtime.circuits.addDelegator(
+  createCircuitContext(contractAddress, coinPublicKey, initial.currentContractState, privateState),
+  DELEGATOR_ID,
+  DELEGATOR_NIGHT_REWARD_ADDRESS,
+  { bytes: Buffer.from(delegatorCoinPublicKey, 'hex') },
+  Buffer.from(delegatorEncryptionPublicKey, 'hex'),
+  MINIMUM_REGISTERED_NIGHT,
+  DELEGATOR_VERIFICATION_BLOCK,
+  DELEGATOR_ENROLLMENT_NONCE
+);
+const provider = new NodeZkConfigProvider(
+  new URL('../../../../contract/src/managed/sentinel', import.meta.url).pathname
+);
+const queuedState = ContractState.deserialize(initial.currentContractState.serialize());
+queuedState.data = queued.context.currentQueryContext.state;
+const common = {
+  compiledContract: CompactCompiledContract,
+  contractAddress,
+  coinPublicKey,
+  initialZswapChainState: new ZswapChainState(),
+  ledgerParameters: LedgerParameters.initialParameters(),
+  initialPrivateState: privateState,
+};
+const delegator = await createUnprovenCallTxFromInitialStates(
+  provider,
+  {
+    ...common,
+    circuitId: 'purchaseDelegatorReward',
+    args: [
+      {
+        nonce: DELEGATOR_PAYMENT_NONCE,
+        color: NATIVE_NIGHT_COLOR,
+        value: DELEGATOR_SHARE,
+      },
+    ],
+    initialContractState: queuedState,
+    additionalCoinEncPublicKeyMappings: new Map([
+      [delegatorCoinPublicKey, delegatorEncryptionPublicKey],
+    ]),
+  },
+  encryptionPublicKey
+);
+const post = ContractState.deserialize(queuedState.serialize());
+post.data = new ChargedState(delegator.public.nextContractState);
+const sponsor = await createUnprovenCallTxFromInitialStates(
+  provider,
+  {
+    ...common,
+    circuitId: 'deliverSponsorReward',
+    args: [
+      PURCHASE_ID,
+      {
+        nonce: SPONSOR_PAYMENT_NONCE,
+        color: NATIVE_NIGHT_COLOR,
+        value: SPONSOR_SHARE,
+      },
+      TARGET_ADDRESS,
+      TARGET_ENTRY_POINT_HASH,
+      TARGET_COMMUNICATION_COMMITMENT,
+    ],
+    initialContractState: post,
+    additionalCoinEncPublicKeyMappings: new Map([
+      [sponsorCoinPublicKey, sponsorEncryptionPublicKey],
+    ]),
+  },
+  encryptionPublicKey
+);
+
+const partition = (call: typeof delegator) => ({
+  guaranteedPresent: call.public.partitionedTranscript[0] !== undefined,
+  falliblePresent: call.public.partitionedTranscript[1] !== undefined,
+  operationCount: call.public.publicTranscript.length,
+});
+const result = {
+  purchaseDelegatorReward: partition(delegator),
+  deliverSponsorReward: partition(sponsor),
+};
+console.log(JSON.stringify(result, null, 2));
+if (
+  !result.purchaseDelegatorReward.guaranteedPresent ||
+  result.purchaseDelegatorReward.falliblePresent ||
+  result.deliverSponsorReward.guaranteedPresent ||
+  !result.deliverSponsorReward.falliblePresent
+) {
+  process.exitCode = 1;
+}
diff --git a/packages/protocol-verification/src/experiments/production-sentinel/sentinel-sponsorship-runtime-check.ts b/packages/protocol-verification/src/experiments/production-sentinel/sentinel-sponsorship-runtime-check.ts
new file mode 100644
index 0000000..66cb250
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/production-sentinel/sentinel-sponsorship-runtime-check.ts
@@ -0,0 +1,282 @@
+import {
+  createCircuitContext,
+  createConstructorContext,
+  sampleContractAddress,
+} from '@midnight-ntwrk/compact-runtime';
+import {
+  Contract,
+  deriveSentinelAuthority,
+  ledger,
+  type PrivateState,
+} from '@midnight-sentinel/contract';
+
+const bytes = (fill: number) => new Uint8Array(32).fill(fill);
+const equalBytes = (a: Uint8Array, b: Uint8Array) =>
+  a.length === b.length && a.every((value, index) => value === b[index]);
+
+const ownerSecret = bytes(0x01);
+const operatorSecret = bytes(0x02);
+const rotatedOperatorSecret = bytes(0x03);
+const sponsorId = bytes(0x11);
+const color = bytes(0);
+const sponsorRewardKey = { bytes: bytes(0x21) };
+const sponsorRewardEncryptionKey = bytes(0x22);
+const delegatorKeys = [{ bytes: bytes(0x31) }, { bytes: bytes(0x32) }, { bytes: bytes(0x33) }];
+const delegatorEncryptionKeys = [bytes(0x34), bytes(0x35), bytes(0x36)];
+const delegatorIds = [bytes(0x41), bytes(0x42), bytes(0x43)];
+const delegatorNightAddresses = [
+  new Uint8Array(96).fill(0x44),
+  new Uint8Array(96).fill(0x45),
+  new Uint8Array(96).fill(0x46),
+];
+const policyHash = bytes(0x51);
+const targetAddress = bytes(0x52);
+const targetEntryPointHash = bytes(0x53);
+const contractAddress = sampleContractAddress();
+const coinPublicKey = '01'.repeat(32);
+const share = 1n;
+const price = share * 2n;
+const minimum = 100n;
+const contract = new Contract<PrivateState>({
+  localSecretKey: ({ privateState }) => [privateState, privateState.secretKey],
+});
+
+const constructorResult = (secretKey: Uint8Array, initialOperator: Uint8Array) =>
+  contract.initialState(
+    createConstructorContext({ secretKey }, coinPublicKey),
+    sponsorId,
+    color,
+    sponsorRewardKey,
+    sponsorRewardEncryptionKey,
+    share,
+    share,
+    minimum,
+    initialOperator,
+    policyHash
+  );
+
+const operatorProbe = constructorResult(operatorSecret, bytes(0));
+const operatorKey = ledger(operatorProbe.currentContractState.data).owner;
+if (!equalBytes(operatorKey, deriveSentinelAuthority(operatorSecret))) {
+  throw new Error('off-chain eligibility authority derivation does not match Compact');
+}
+const rotatedOperatorProbe = constructorResult(rotatedOperatorSecret, bytes(0));
+const rotatedOperatorKey = ledger(rotatedOperatorProbe.currentContractState.data).owner;
+const initial = () => constructorResult(ownerSecret, operatorKey);
+
+type StateResult =
+  | ReturnType<typeof initial>
+  | ReturnType<typeof contract.circuits.addDelegator>
+  | ReturnType<typeof contract.circuits.updateDelegator>
+  | ReturnType<typeof contract.circuits.removeDelegator>
+  | ReturnType<typeof contract.circuits.rotateEligibilityOperator>
+  | ReturnType<typeof contract.circuits.purchaseDelegatorReward>
+  | ReturnType<typeof contract.circuits.deliverSponsorReward>
+  | ReturnType<typeof contract.circuits.setSponsorshipEnabled>;
+
+const context = (state: StateResult, secretKey: Uint8Array) =>
+  'context' in state
+    ? createCircuitContext(
+        contractAddress,
+        state.context.currentZswapLocalState,
+        state.context.currentQueryContext.state,
+        { secretKey }
+      )
+    : createCircuitContext(contractAddress, coinPublicKey, state.currentContractState, {
+        secretKey,
+      });
+
+const add = (state: StateResult, index: number, secret = operatorSecret) =>
+  contract.circuits.addDelegator(
+    context(state, secret),
+    delegatorIds[index],
+    delegatorNightAddresses[index],
+    delegatorKeys[index],
+    delegatorEncryptionKeys[index],
+    minimum + BigInt(index),
+    1000n + BigInt(index),
+    1n
+  );
+
+const remove = (state: StateResult, index: number, secret = operatorSecret) =>
+  contract.circuits.removeDelegator(context(state, secret), delegatorIds[index]);
+
+const update = (state: StateResult, index: number, nonce: bigint, secret = operatorSecret) =>
+  contract.circuits.updateDelegator(
+    context(state, secret),
+    delegatorIds[index],
+    delegatorNightAddresses[index],
+    delegatorKeys[index],
+    delegatorEncryptionKeys[index],
+    minimum + BigInt(index),
+    2000n + BigInt(index),
+    nonce
+  );
+
+const purchase = (state: StateResult, index: number) =>
+  contract.circuits.purchaseDelegatorReward(context(state, ownerSecret), {
+    nonce: bytes(0x70 + index),
+    color,
+    value: share,
+  });
+
+const deliver = (state: StateResult, index: number, paymentColor = color, paymentValue = share) =>
+  contract.circuits.deliverSponsorReward(
+    context(state, ownerSecret),
+    bytes(0x60 + index),
+    { nonce: bytes(0x80 + index), color: paymentColor, value: paymentValue },
+    targetAddress,
+    targetEntryPointHash,
+    100n + BigInt(index)
+  );
+
+const expectReject = (label: string, action: () => unknown, expected: string) => {
+  try {
+    action();
+    throw new Error(`${label}: unexpectedly succeeded`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes(expected)) {
+      throw new Error(`${label}: expected "${expected}", got "${message}"`);
+    }
+  }
+};
+
+expectReject('empty queue', () => purchase(initial(), 0), 'NO_ELIGIBLE_DELEGATOR');
+expectReject(
+  'unauthorized add',
+  () => add(initial(), 0, ownerSecret),
+  'Not the eligibility operator'
+);
+expectReject(
+  'below minimum',
+  () =>
+    contract.circuits.addDelegator(
+      context(initial(), operatorSecret),
+      delegatorIds[0],
+      delegatorNightAddresses[0],
+      delegatorKeys[0],
+      delegatorEncryptionKeys[0],
+      minimum - 1n,
+      1000n,
+      1n
+    ),
+  'Below minimum registered NIGHT'
+);
+
+let queued: StateResult = add(initial(), 0);
+queued = add(queued, 1);
+queued = add(queued, 2);
+expectReject('duplicate delegator', () => add(queued, 0), 'Duplicate delegator');
+expectReject(
+  'replayed enrollment nonce',
+  () => update(queued, 0, 1n),
+  'Enrollment nonce must increase'
+);
+queued = update(queued, 0, 2n);
+
+const rewarded: Uint8Array[] = [];
+for (let index = 0; index < 4; index += 1) {
+  queued = purchase(queued, index);
+  const afterDelegator = ledger(queued.context.currentQueryContext.state);
+  if (
+    afterDelegator.sponsorshipPurchases !== BigInt(index) ||
+    afterDelegator.sponsorshipReceipts.member(bytes(0x60 + index))
+  ) {
+    throw new Error('delegator circuit unexpectedly changed purchase accounting');
+  }
+
+  queued = deliver(queued, index);
+  const current = ledger(queued.context.currentQueryContext.state);
+  const receipt = current.sponsorshipReceipts.lookup(bytes(0x60 + index));
+  rewarded.push(receipt.rewardedDelegatorId);
+  if (
+    !receipt.sponsorRewardDelivered ||
+    receipt.targetCommunicationCommitment !== 100n + BigInt(index) ||
+    !equalBytes(receipt.targetAddress, targetAddress) ||
+    !equalBytes(receipt.targetEntryPointHash, targetEntryPointHash)
+  ) {
+    throw new Error('sponsor receipt metadata is incorrect');
+  }
+}
+
+const expectedRotation = [delegatorIds[0], delegatorIds[1], delegatorIds[2], delegatorIds[0]];
+for (let index = 0; index < expectedRotation.length; index += 1) {
+  if (!equalBytes(rewarded[index], expectedRotation[index])) {
+    throw new Error(`unexpected delegator at rotation position ${index}`);
+  }
+}
+
+expectReject(
+  'wrong sponsor payment asset',
+  () => deliver(purchase(add(initial(), 0), 9), 9, bytes(0x7f)),
+  'Wrong payment asset'
+);
+expectReject(
+  'wrong sponsor payment amount',
+  () => deliver(purchase(add(initial(), 0), 10), 10, color, share + 1n),
+  'Wrong sponsor payment amount'
+);
+
+const beforeRemoval = ledger(queued.context.currentQueryContext.state);
+if (beforeRemoval.rewardCursor !== 1n || beforeRemoval.sponsorshipPurchases !== 4n) {
+  throw new Error('rotation cursor or purchase count is incorrect');
+}
+queued = remove(queued, 0);
+const afterRemoval = ledger(queued.context.currentQueryContext.state);
+if (
+  afterRemoval.delegatorCount !== 2n ||
+  afterRemoval.rewardCursor !== 0n ||
+  !equalBytes(afterRemoval.delegatorSlots.lookup(0n).nightIdentity, delegatorIds[1])
+) {
+  throw new Error('removing before the cursor did not compact and adjust the queue');
+}
+
+const rotated = contract.circuits.rotateEligibilityOperator(
+  context(queued, ownerSecret),
+  rotatedOperatorKey
+);
+expectReject(
+  'old operator after rotation',
+  () => remove(rotated, 1, operatorSecret),
+  'Not the eligibility operator'
+);
+const maintained = remove(rotated, 1, rotatedOperatorSecret);
+const paused = contract.circuits.setSponsorshipEnabled(context(maintained, ownerSecret), false);
+expectReject('paused campaign', () => purchase(paused, 11), 'NO_ELIGIBLE_DELEGATOR');
+expectReject(
+  'queue mutation while paused',
+  () => remove(paused, 2, rotatedOperatorSecret),
+  'Sponsorship is paused'
+);
+const resumed = contract.circuits.setSponsorshipEnabled(context(paused, ownerSecret), true);
+const resumedLedger = ledger(resumed.context.currentQueryContext.state);
+if (resumedLedger.delegatorCount !== 1n || resumedLedger.pausedDelegatorCount !== 0n) {
+  throw new Error('resuming sponsorship did not restore the delegator queue');
+}
+const pausedAgain = contract.circuits.setSponsorshipEnabled(context(resumed, ownerSecret), false);
+
+const finalLedger = ledger(pausedAgain.context.currentQueryContext.state);
+if (
+  finalLedger.delegatorCount !== 0n ||
+  finalLedger.pausedDelegatorCount !== 1n ||
+  finalLedger.sponsorshipFixedPrice !== price ||
+  finalLedger.sponsorshipSponsor.share !== share ||
+  finalLedger.sponsorshipDelegatorShare !== share
+) {
+  throw new Error('final campaign configuration or queue state is incorrect');
+}
+
+console.log(
+  JSON.stringify({
+    productionRewardSplitRuntime: 'confirmed',
+    fixedPrice: price.toString(),
+    sponsorShare: share.toString(),
+    delegatorShare: share.toString(),
+    deterministicRotation: rewarded.map((id) => Buffer.from(id).toString('hex')),
+    receiptMetadata: 'confirmed',
+    removalCompaction: 'confirmed',
+    operatorRotation: 'confirmed',
+    pauseEnforced: true,
+  })
+);
diff --git a/packages/protocol-verification/src/experiments/production-sentinel/sponsorship-production-verification.ts b/packages/protocol-verification/src/experiments/production-sentinel/sponsorship-production-verification.ts
new file mode 100644
index 0000000..fed19b6
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/production-sentinel/sponsorship-production-verification.ts
@@ -0,0 +1,400 @@
+/**
+ * Production sponsorship transaction flow:
+ * 1. Deploy a target contract and a Sentinel contract whose sponsorship policy allows only the
+ *    target's `interact` entry point, register one eligible reward delegator, then fund the
+ *    DUST-free beneficiary with exact NIGHT coins.
+ * 2. Build the target contract's `interact(expiry)` call before proof generation. Pass the call's
+ *    cryptographic commitment to Sentinel's `deliverSponsorReward` call so the resulting receipt
+ *    identifies the exact target interaction covered by the sponsorship.
+ * 3. Build one ordered intent containing the guaranteed `purchaseDelegatorReward`, fallible
+ *    `deliverSponsorReward`, and checkpointed target calls; prove it, have the beneficiary balance
+ *    and sign its NIGHT effects, and serialize the finalized transaction without DUST.
+ * 4. Have the sponsor inspect the serialized request against its allowlist and campaign policy,
+ *    estimate the fee, attach only the required DUST funding, verify that the committed request
+ *    was not changed, and submit the transaction.
+ * 5. Run one transaction before target expiry and one after expiry, then verify that both record
+ *    guaranteed sponsorship purchases while only the first executes the target's fallible effects.
+ */
+import {
+  CompositeTargetCompiledContract,
+  compositeTargetLedger,
+  type CompositeTargetContractType,
+} from '../composite-sponsorship/composite-sponsorship-contract.js';
+import { ledger as sentinelLedger, type SentinelContractType } from '@midnight-sentinel/contract';
+import { SentinelContract } from '@midnight-sentinel/api';
+import {
+  sponsorshipAllowlistHash,
+  type SponsorshipPolicy,
+} from '@midnight-sentinel/api/sponsorship';
+import {
+  createMidnightBeneficiarySponsorshipApi,
+  createMidnightSponsorSponsorshipApi,
+  createMidnightSponsorshipTarget,
+  nativeNightSponsorshipConfig,
+} from '@midnight-sentinel/api/sponsorship/midnight';
+import { buildUnfundedWallet, buildWallet, type WalletContext } from '@midnight-sentinel/wallet';
+import {
+  ContractCall,
+  PreProof,
+  shieldedToken,
+  type ZswapLocalState,
+} from '@midnight-ntwrk/ledger-v8';
+import { createUnprovenCallTx, deployContract } from '@midnight-ntwrk/midnight-js-contracts';
+import assert from 'node:assert/strict';
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import * as Rx from 'rxjs';
+import { packagePath, standaloneConfig } from '../../common/config.js';
+import {
+  GENESIS_MINT_WALLET_SEED_ONE,
+  GENESIS_MINT_WALLET_SEED_THREE,
+} from '../../common/constants.js';
+import {
+  filledBytes,
+  providersFor,
+  stopWallets,
+  withTimeout,
+  waitForWallClock,
+  waitForWalletState,
+  waitForWalletSync,
+  writeJsonReport,
+} from '../../common/experiment-harness.js';
+
+const SPONSOR_SHARE = 1n;
+const DELEGATOR_SHARE = 1n;
+const PAYMENT_COIN_COUNT = 4;
+const TIMEOUT_MS = 360_000;
+const BENEFICIARY_SEED = '42'.repeat(32);
+const TEST_DELEGATOR_REWARD_ADDRESS = 'production-verification-delegator';
+const TTL = () => new Date(Date.now() + 30 * 60_000);
+const config = {
+  ...standaloneConfig,
+  indexer: 'http://127.0.0.1:8088/api/v4/graphql',
+  indexerWS: 'ws://127.0.0.1:8088/api/v4/graphql/ws',
+  proofServer: 'http://127.0.0.1:6300',
+};
+const sentinelZkPath = packagePath('../contract/src/managed/sentinel');
+const targetZkPath = packagePath('src/managed/composite-target');
+
+const requireFullZkArtifacts = async () => {
+  const required = [
+    path.join(sentinelZkPath, 'keys/purchaseDelegatorReward.verifier'),
+    path.join(sentinelZkPath, 'keys/setSponsorshipEnabled.verifier'),
+    path.join(targetZkPath, 'keys/interact.verifier'),
+  ];
+  for (const artifact of required) {
+    let size = 0;
+    try {
+      size = (await stat(artifact)).size;
+    } catch {
+      // Report the same actionable error for missing and empty artifacts.
+    }
+    if (size === 0) {
+      throw new Error(
+        `Missing full-ZK artifact ${artifact}; run "pnpm verify:protocol:devnet:production" from the repository root`
+      );
+    }
+  }
+};
+
+const main = async () => {
+  const wallets: WalletContext[] = [];
+  const report: Record<string, unknown> = {
+    startedAt: new Date().toISOString(),
+    versions: {
+      compiler: '0.31.1',
+      language: '0.23.0',
+      ledger: '8.0.3',
+      midnightJs: '4.1.1',
+      node: '0.22.5',
+      indexer: '4.2.1',
+      proofServer: '8.1.0',
+      network: 'undeployed',
+    },
+    health: { node: true, indexer: true, proofServer: true },
+    verdict: 'inconclusive',
+  };
+
+  try {
+    await requireFullZkArtifacts();
+    const [deployer, sponsor, beneficiary] = await Promise.all([
+      buildWallet(config, GENESIS_MINT_WALLET_SEED_ONE),
+      buildWallet(config, GENESIS_MINT_WALLET_SEED_THREE),
+      buildUnfundedWallet(config, BENEFICIARY_SEED),
+    ]);
+    wallets.push(deployer, sponsor, beneficiary);
+
+    const deployTargetProviders = await providersFor<CompositeTargetContractType>(
+      deployer,
+      config,
+      'production-verify-target-deploy',
+      targetZkPath
+    );
+    const targetDeployment = await deployContract<CompositeTargetContractType>(
+      deployTargetProviders,
+      { compiledContract: CompositeTargetCompiledContract }
+    );
+    const targetAddress = targetDeployment.deployTxData.public.contractAddress;
+    const allowedTargets = [{ address: targetAddress, entryPoint: 'interact' }];
+    const policyHash = sponsorshipAllowlistHash(allowedTargets);
+
+    const deploySentinelProviders = await providersFor<SentinelContractType>(
+      deployer,
+      config,
+      'production-verify-sentinel-deploy',
+      sentinelZkPath
+    );
+    const sentinel = await SentinelContract.deploy(
+      deploySentinelProviders,
+      nativeNightSponsorshipConfig(sponsor, policyHash, {
+        sponsorShare: SPONSOR_SHARE,
+        delegatorShare: DELEGATOR_SHARE,
+        minimumRegisteredNight: 1n,
+        initialEligibilityOperator: new Uint8Array(32),
+      })
+    );
+    const sentinelAddress = sentinel.deployedContract!.deployTxData.public.contractAddress;
+    const deployedSentinelState = await withTimeout(
+      'deployed Sentinel state',
+      TIMEOUT_MS,
+      Rx.firstValueFrom(sentinel.state$)
+    );
+    await sentinel.rotateEligibilityOperator(
+      Uint8Array.from(Buffer.from(deployedSentinelState.owner.slice(2), 'hex'))
+    );
+    const paddedRewardAddress = Buffer.alloc(96);
+    paddedRewardAddress.write(TEST_DELEGATOR_REWARD_ADDRESS);
+    await sentinel.addDelegator({
+      identity: filledBytes(0x61),
+      nightRewardAddress: paddedRewardAddress,
+      rewardKey: Uint8Array.from(Buffer.from(beneficiary.shieldedSecretKeys.coinPublicKey, 'hex')),
+      rewardEncryptionKey: Uint8Array.from(
+        Buffer.from(beneficiary.shieldedSecretKeys.encryptionPublicKey, 'hex')
+      ),
+      registeredAmount: 1n,
+      verificationBlock: 0n,
+      enrollmentNonce: 1n,
+    });
+    await withTimeout(
+      'Sentinel delegator registration',
+      TIMEOUT_MS,
+      Rx.firstValueFrom(sentinel.state$.pipe(Rx.filter((state) => state.delegatorCount === 1n)))
+    );
+
+    const beneficiaryAddressState = await waitForWalletSync(beneficiary, TIMEOUT_MS);
+    const fundingRecipe = await deployer.wallet.transferTransaction(
+      [
+        {
+          type: 'shielded',
+          outputs: Array.from({ length: PAYMENT_COIN_COUNT }, () => ({
+            type: shieldedToken().raw,
+            amount: SPONSOR_SHARE,
+            receiverAddress: beneficiaryAddressState.shielded.address,
+          })),
+        },
+      ],
+      {
+        shieldedSecretKeys: deployer.shieldedSecretKeys,
+        dustSecretKey: deployer.dustSecretKey,
+      },
+      { ttl: TTL() }
+    );
+    const funding = await deployer.wallet.finalizeRecipe(fundingRecipe);
+    const fundingTxId = await deployer.wallet.submitTransaction(funding);
+    await waitForWalletState('beneficiary funding', TIMEOUT_MS, beneficiary, (state) =>
+      (state.shielded.balances[shieldedToken().raw] ?? 0n) >=
+      SPONSOR_SHARE * BigInt(PAYMENT_COIN_COUNT)
+        ? state
+        : false
+    );
+
+    const targetProviders = await providersFor<CompositeTargetContractType>(
+      beneficiary,
+      config,
+      'production-verify-target-beneficiary',
+      targetZkPath
+    );
+    const beneficiarySentinelProviders = await providersFor<SentinelContractType>(
+      beneficiary,
+      config,
+      'production-verify-sentinel-beneficiary',
+      sentinelZkPath
+    );
+    await SentinelContract.join(beneficiarySentinelProviders, sentinelAddress);
+    const sponsorSentinelProviders = await providersFor<SentinelContractType>(
+      sponsor,
+      config,
+      'production-verify-sentinel-sponsor',
+      sentinelZkPath
+    );
+
+    const policy: SponsorshipPolicy = {
+      sentinelAddress,
+      sponsorId: nativeNightSponsorshipConfig(sponsor, policyHash, {
+        initialEligibilityOperator: new Uint8Array(32),
+      }).sponsorId,
+      sponsorDustAddress: '',
+      registrationProvider: {
+        async getStatus(nightRewardAddress) {
+          return {
+            nightRewardAddress,
+            dustAddress: '',
+            registered: true,
+            nightBalance: 1n,
+            finalizedBlock: 0n,
+          };
+        },
+      },
+      policyHash,
+      allowedTargets,
+      minTtlMs: 0,
+      maxTtlMs: 65 * 60_000,
+      maxFee: 1_000_000_000_000_000_000n,
+    };
+    const beneficiarySponsorshipApi = createMidnightBeneficiarySponsorshipApi({
+      sentinelAddress,
+      sentinelProviders: beneficiarySentinelProviders,
+      beneficiary,
+      proofServer: config.proofServer,
+    });
+    const sponsorSponsorshipApi = createMidnightSponsorSponsorshipApi({
+      policy,
+      sentinelProviders: sponsorSentinelProviders,
+      sponsor,
+    });
+
+    const runScenario = async (
+      purchaseId: Uint8Array,
+      expiry: bigint,
+      expectedStatus: 'SucceedEntirely' | 'FailFallible'
+    ) => {
+      const before = await waitForWalletSync(beneficiary, TIMEOUT_MS);
+      assert.equal(before.dust.balance(new Date()), 0n);
+      const exactCoins = [...(before.shielded.state.state as ZswapLocalState).coins].filter(
+        (coin) => coin.type === shieldedToken().raw && coin.value === SPONSOR_SHARE
+      );
+      assert(
+        exactCoins.length >= 2,
+        'two exact NIGHT payment coins are required for the sponsor and delegator shares'
+      );
+
+      const targetCall = await createUnprovenCallTx(targetProviders, {
+        compiledContract: CompositeTargetCompiledContract,
+        contractAddress: targetAddress,
+        circuitId: 'interact',
+        args: [expiry],
+      });
+      const targetCalls = [...(targetCall.private.unprovenTx.intents?.values() ?? [])]
+        .flatMap((intent) => intent.actions)
+        .filter((action): action is ContractCall<PreProof> => action instanceof ContractCall);
+      assert.equal(targetCalls.length, 1);
+      assert(targetCall.public.partitionedTranscript[0]);
+      assert(targetCall.public.partitionedTranscript[1]);
+
+      const prepared = await beneficiarySponsorshipApi.prepare({
+        target: createMidnightSponsorshipTarget({
+          targetCall,
+          zkConfigProvider: targetProviders.zkConfigProvider,
+        }),
+        expiresAt: TTL(),
+        purchaseId,
+      });
+      assert(prepared.transaction.length > 0);
+
+      const targetCommitment = prepared.targetCommunicationCommitment;
+      if (expectedStatus === 'FailFallible') {
+        await waitForWallClock('target expiry', expiry, TIMEOUT_MS);
+      }
+      const inspected = await sponsorSponsorshipApi.inspect({
+        transaction: prepared.transaction,
+      });
+      assert.equal(inspected.hasDust, false);
+      const submitted = await sponsorSponsorshipApi.sponsorAndSubmit({
+        transaction: prepared.transaction,
+      });
+      assert.equal(submitted.status, expectedStatus);
+      assert.equal(submitted.targetCommunicationCommitment, targetCommitment);
+      return {
+        txId: submitted.txId,
+        status: submitted.status,
+        feeEstimate: submitted.feeEstimate.toString(),
+        purchaseId: Buffer.from(submitted.purchaseId).toString('hex'),
+        targetCommunicationCommitment: targetCommitment,
+      };
+    };
+
+    const success = await runScenario(
+      filledBytes(0x71),
+      BigInt(Math.floor(Date.now() / 1000) + 900),
+      'SucceedEntirely'
+    );
+    const fallibleExpiry = BigInt(Math.floor(Date.now() / 1000) + 90);
+    const fallibleFailure = await runScenario(filledBytes(0x72), fallibleExpiry, 'FailFallible');
+
+    const sentinelState = await withTimeout(
+      'production Sentinel state',
+      TIMEOUT_MS,
+      Rx.firstValueFrom(
+        sponsorSentinelProviders.publicDataProvider
+          .contractStateObservable(sentinelAddress, { type: 'latest' })
+          .pipe(
+            Rx.map((state) => sentinelLedger(state.data)),
+            Rx.filter((state) => state.sponsorshipPurchases === 2n)
+          )
+      )
+    );
+    const targetState = await withTimeout(
+      'production target state',
+      TIMEOUT_MS,
+      Rx.firstValueFrom(
+        targetProviders.publicDataProvider
+          .contractStateObservable(targetAddress, { type: 'latest' })
+          .pipe(
+            Rx.map((state) => compositeTargetLedger(state.data)),
+            Rx.filter(
+              (state) => state.guaranteedExecutions === 2n && state.fallibleExecutions === 1n
+            )
+          )
+      )
+    );
+    assert.equal(sentinelState.sponsorshipReceipts.size(), 2n);
+
+    Object.assign(report, {
+      finishedAt: new Date().toISOString(),
+      verdict: 'confirmed',
+      contractAddresses: { sentinel: sentinelAddress, target: targetAddress },
+      transactionIds: {
+        funding: fundingTxId,
+        success: success.txId,
+        fallibleFailure: fallibleFailure.txId,
+      },
+      scenarios: { success, fallibleFailure },
+      postState: {
+        sponsorshipRevenue: (
+          sentinelState.sponsorshipPurchases * sentinelState.sponsorshipFixedPrice
+        ).toString(),
+        sponsorshipPurchases: sentinelState.sponsorshipPurchases.toString(),
+        receiptCount: sentinelState.sponsorshipReceipts.size().toString(),
+        targetGuaranteedExecutions: targetState.guaranteedExecutions.toString(),
+        targetFallibleExecutions: targetState.fallibleExecutions.toString(),
+      },
+    });
+  } catch (error) {
+    Object.assign(report, {
+      finishedAt: new Date().toISOString(),
+      verdict: 'inconclusive',
+      error: error instanceof Error ? error.message : String(error),
+    });
+    throw error;
+  } finally {
+    const reportPath =
+      process.env.SPONSORSHIP_VERIFICATION_REPORT ??
+      packagePath('src/experiments/production-sentinel/result.json');
+    await writeJsonReport(reportPath, report);
+    console.log(`Production sponsorship verification: ${String(report.verdict).toUpperCase()}`);
+    console.log(`Report: ${reportPath}`);
+    await stopWallets(wallets);
+  }
+};
+
+await main();
diff --git a/packages/protocol-verification/src/experiments/reward-split/README.md b/packages/protocol-verification/src/experiments/reward-split/README.md
new file mode 100644
index 0000000..cc57e7c
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/README.md
@@ -0,0 +1,67 @@
+# Two-Circuit Reward Split
+
+## Why this experiment exists
+
+A single Compact call that received `2 NIGHT` and immediately sent `1 NIGHT`
+to both recipients became fallible. The economically required behavior was
+different: the delegator reward and queue advance had to be guaranteed, while
+the sponsor reward and subsequent user interaction could be fallible. It was
+also unknown whether contract-created shielded outputs could be discovered and
+spent by ordinary recipient wallets.
+
+## Claim
+
+One transaction can order three Compact calls:
+
+1. `purchaseDelegatorReward` — guaranteed-only, pays `1 NIGHT` and advances
+   the public round-robin cursor.
+2. `deliverSponsorReward` — fallible-only, pays `1 NIGHT` to the sponsor and
+   records the receipt.
+3. `userInteraction` — fallible target behavior.
+
+Recipient wallets must discover the created outputs, and the rotation and
+receipt metadata must remain deterministic.
+
+## Preconditions
+
+- Compact compiler `0.31.1`, language `0.23`.
+- Ledger `8.0.3`, Midnight.js `4.1.1`.
+- Wallet-derived coin and encryption public keys supplied through the SDK’s
+  additional encryption-key mapping.
+- Local proof server and devnet for the full wallet runner.
+
+## Contents
+
+- `reward-split.compact` — queue and two reward circuits.
+- `fallible-user-target.compact` — third-call failure fixture.
+- `*-contract.ts` — generated-contract wrappers and proof routing.
+- `reward-split-runtime-check.ts` — deterministic queue/state checks.
+- `reward-split-partition-check.ts` — transcript and merge inspection.
+- `reward-split-wallet-check.ts` — full-ZK wallet discovery/devnet runner.
+- `result.json` — sanitized retained execution evidence.
+
+## Procedure and acceptance rule
+
+Compile all circuits, test empty queues, operator authorization and rotation,
+three-delegator wraparound, removal compaction, and receipt binding. Build the
+three ordered calls and require guaranteed-only delegator delivery plus
+fallible-only sponsor and target calls. Submit both complete-success and
+fallible-failure transactions. The sponsor must receive only the successful
+reward; the delegator must receive both guaranteed rewards.
+
+Run:
+
+```sh
+pnpm verify:protocol:local
+pnpm verify:protocol:reward-split
+```
+
+## Explicit result
+
+**Confirmed on 2026-07-27.** Full-ZK compilation succeeded. Partitioning was
+delegator guaranteed-only, sponsor fallible-only, and user interaction
+fallible-only. Rotation was `A → B → C → A`; compaction, operator rotation, and
+receipt binding passed. The successful transaction was `SucceedEntirely`; the
+deliberate fallible failure was `FailFallible`. The sponsor balance increased
+by `1`, while the delegator balance increased by `2`, proving discovery of both
+guaranteed outputs. Exact evidence is in `result.json`.
diff --git a/packages/protocol-verification/src/experiments/reward-split/fallible-user-target-contract.ts b/packages/protocol-verification/src/experiments/reward-split/fallible-user-target-contract.ts
new file mode 100644
index 0000000..7617302
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/fallible-user-target-contract.ts
@@ -0,0 +1,21 @@
+import { CompiledContract } from '@midnight-ntwrk/compact-js';
+import { Contract } from '../../managed/fallible-user-target/contract/index.js';
+
+export const FallibleUserTargetConstructor = Contract<undefined>;
+export type FallibleUserTargetType = InstanceType<typeof FallibleUserTargetConstructor>;
+
+export const FallibleUserTargetCompiledContract = CompiledContract.make<
+  FallibleUserTargetType,
+  undefined
+>('FallibleUserTargetVerificationContract', FallibleUserTargetConstructor).pipe(
+  CompiledContract.withWitnesses({} as never),
+  CompiledContract.withCompiledFileAssets(
+    /* @vite-ignore */
+    new URL('../../managed/fallible-user-target', import.meta.url).pathname
+  )
+);
+
+export {
+  ledger as fallibleUserTargetLedger,
+  type Ledger as FallibleUserTargetLedger,
+} from '../../managed/fallible-user-target/contract/index.js';
diff --git a/packages/protocol-verification/src/experiments/reward-split/fallible-user-target.compact b/packages/protocol-verification/src/experiments/reward-split/fallible-user-target.compact
new file mode 100644
index 0000000..aeeb085
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/fallible-user-target.compact
@@ -0,0 +1,43 @@
+pragma language_version 0.23;
+
+import CompactStandardLibrary;
+
+export ledger userExecutions: Counter;
+export ledger padding00: Counter;
+export ledger padding01: Counter;
+export ledger padding02: Counter;
+export ledger padding03: Counter;
+export ledger padding04: Counter;
+export ledger padding05: Counter;
+export ledger padding06: Counter;
+export ledger padding07: Counter;
+export ledger padding08: Counter;
+export ledger padding09: Counter;
+export ledger padding10: Counter;
+export ledger padding11: Counter;
+export ledger padding12: Counter;
+export ledger padding13: Counter;
+export ledger padding14: Counter;
+export ledger padding15: Counter;
+
+export circuit interact(expiry: Uint<64>): [] {
+  kernel.checkpoint();
+  assert(kernel.blockTimeLessThan(disclose(expiry)), "User interaction expired");
+  userExecutions.increment(1);
+  padding00.increment(1);
+  padding01.increment(1);
+  padding02.increment(1);
+  padding03.increment(1);
+  padding04.increment(1);
+  padding05.increment(1);
+  padding06.increment(1);
+  padding07.increment(1);
+  padding08.increment(1);
+  padding09.increment(1);
+  padding10.increment(1);
+  padding11.increment(1);
+  padding12.increment(1);
+  padding13.increment(1);
+  padding14.increment(1);
+  padding15.increment(1);
+}
diff --git a/packages/protocol-verification/src/experiments/reward-split/result.json b/packages/protocol-verification/src/experiments/reward-split/result.json
new file mode 100644
index 0000000..f2d2cdf
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/result.json
@@ -0,0 +1,71 @@
+{
+  "verifiedAt": "2026-07-27",
+  "compiler": "0.31.1",
+  "language": "0.23",
+  "verdict": "CONFIRMED",
+  "productionSentinelModified": true,
+  "architecture": {
+    "intentCount": 1,
+    "orderedCalls": ["purchaseDelegatorReward", "deliverSponsorReward", "userInteraction"],
+    "fixedPrice": "2",
+    "sponsorShare": "1",
+    "delegatorShare": "1"
+  },
+  "checks": {
+    "fullZkCompilation": {
+      "verdict": "confirmed",
+      "evidence": {
+        "rewardSplitCircuitsCompiled": 6,
+        "fallibleTargetCircuitsCompiled": 1
+      }
+    },
+    "partitioning": {
+      "verdict": "confirmed",
+      "evidence": {
+        "purchaseDelegatorReward": "guaranteed-only",
+        "deliverSponsorReward": "fallible-only",
+        "userInteraction": "fallible-only"
+      }
+    },
+    "deterministicRuntime": {
+      "verdict": "confirmed",
+      "evidence": {
+        "emptyQueueRejected": true,
+        "threeDelegatorRotation": ["A", "B", "C", "A"],
+        "removalCompaction": true,
+        "operatorRotation": true,
+        "receiptBindsRewardedDelegator": true
+      }
+    },
+    "recipientOutputConstruction": {
+      "verdict": "confirmed",
+      "evidence": {
+        "additionalCoinEncryptionKeyMappingsRequired": true,
+        "rewardOutputsPerSuccessfulPurchase": 2
+      }
+    },
+    "compositeSuccess": {
+      "verdict": "confirmed",
+      "transactionId": "0072364aa3acff4fa4f10b255ae5010aa372f976cd62f2859440eaa3b4e3db50a1",
+      "status": "SucceedEntirely"
+    },
+    "compositeFallibleFailure": {
+      "verdict": "confirmed",
+      "transactionId": "00260bbff725f126c5af48fac445b7f685b51c93055097ebe70dd3205dfa552a42",
+      "status": "FailFallible"
+    },
+    "walletDiscovery": {
+      "verdict": "confirmed",
+      "evidence": {
+        "sponsorIncrease": "1",
+        "delegatorIncrease": "2",
+        "interpretation": "Sponsor received only the successful purchase reward; delegator received rewards in both transaction outcomes."
+      }
+    }
+  },
+  "deployments": {
+    "rewardSplitContractAddress": "15abdc5f1e6848525f9ed32eb3431b10a78c4f830f717caae68b7eb1c6577bcb",
+    "fallibleTargetAddress": "95774f30f34ed233a95d8af0af2ae9d0778dc4cc0ffa45b159ce79789e217cd9"
+  },
+  "decision": "Promote the verified two-circuit, single-intent construction to production Sentinel. Serialize sponsorship construction per deployment and preserve structural inspection before DUST sponsorship."
+}
diff --git a/packages/protocol-verification/src/experiments/reward-split/reward-split-contract.ts b/packages/protocol-verification/src/experiments/reward-split/reward-split-contract.ts
new file mode 100644
index 0000000..62cb3ce
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/reward-split-contract.ts
@@ -0,0 +1,85 @@
+import { CompiledContract } from '@midnight-ntwrk/compact-js';
+import type { WitnessContext } from '@midnight-ntwrk/compact-runtime';
+import { httpClientProofProvider } from '@midnight-ntwrk/midnight-js-http-client-proof-provider';
+import { NodeZkConfigProvider } from '@midnight-ntwrk/midnight-js-node-zk-config-provider';
+import {
+  ZKConfigProvider,
+  type ProverKey,
+  type VerifierKey,
+  type ZKIR,
+} from '@midnight-ntwrk/midnight-js-types';
+import type { PrivateState } from '@midnight-sentinel/contract';
+import {
+  Contract,
+  type Ledger,
+  type Witnesses,
+} from '../../managed/reward-split/contract/index.js';
+
+const rewardSplitWitnesses: Witnesses<PrivateState> = {
+  localSecretKey: ({
+    privateState,
+  }: WitnessContext<Ledger, PrivateState>): [PrivateState, Uint8Array] => [
+    privateState,
+    privateState.secretKey,
+  ],
+};
+
+export const RewardSplitContractConstructor = Contract<PrivateState>;
+export type RewardSplitContractType = InstanceType<typeof RewardSplitContractConstructor>;
+
+export const RewardSplitCompiledContract = CompiledContract.make<
+  RewardSplitContractType,
+  PrivateState
+>('RewardSplitVerificationContract', RewardSplitContractConstructor).pipe(
+  CompiledContract.withWitnesses(rewardSplitWitnesses),
+  CompiledContract.withCompiledFileAssets(
+    /* @vite-ignore */
+    new URL('../../managed/reward-split', import.meta.url).pathname
+  )
+);
+
+class RewardSplitCompositeZkConfigProvider extends ZKConfigProvider<string> {
+  readonly rewardSplit: NodeZkConfigProvider<string>;
+  readonly target: NodeZkConfigProvider<string>;
+
+  constructor(rewardSplitPath: string, targetPath: string) {
+    super();
+    this.rewardSplit = new NodeZkConfigProvider<string>(rewardSplitPath);
+    this.target = new NodeZkConfigProvider<string>(targetPath);
+  }
+
+  private provider(circuitId: string) {
+    if (circuitId === 'purchaseDelegatorReward' || circuitId === 'deliverSponsorReward') {
+      return this.rewardSplit;
+    }
+    if (circuitId === 'interact') return this.target;
+    throw new Error(`Unexpected circuit ID: ${circuitId}`);
+  }
+
+  getProverKey(circuitId: string): Promise<ProverKey> {
+    return this.provider(circuitId).getProverKey(circuitId);
+  }
+
+  getVerifierKey(circuitId: string): Promise<VerifierKey> {
+    return this.provider(circuitId).getVerifierKey(circuitId);
+  }
+
+  getZKIR(circuitId: string): Promise<ZKIR> {
+    return this.provider(circuitId).getZKIR(circuitId);
+  }
+}
+
+export const rewardSplitCompositeProofProvider = (
+  proofServer: string,
+  rewardSplitPath: string,
+  targetPath: string
+) =>
+  httpClientProofProvider(
+    proofServer,
+    new RewardSplitCompositeZkConfigProvider(rewardSplitPath, targetPath)
+  );
+
+export {
+  ledger as rewardSplitLedger,
+  type Ledger as RewardSplitLedger,
+} from '../../managed/reward-split/contract/index.js';
diff --git a/packages/protocol-verification/src/experiments/reward-split/reward-split-partition-check.ts b/packages/protocol-verification/src/experiments/reward-split/reward-split-partition-check.ts
new file mode 100644
index 0000000..c7e692a
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/reward-split-partition-check.ts
@@ -0,0 +1,190 @@
+// Reuse the wallet package's pinned ledger runtime.
+import {
+  LedgerParameters,
+  ZswapChainState,
+  ZswapSecretKeys,
+  // @ts-expect-error the direct Node entry point has no adjacent declaration file.
+} from '../../../../wallet/node_modules/@midnight-ntwrk/ledger-v8/midnight_ledger_wasm_fs.js';
+import { Roles } from '../../../../wallet/node_modules/@midnight-ntwrk/wallet-sdk-hd/dist/index.js';
+import { deriveKeysFromSeed } from '../../../../wallet/dist/utils/index.js';
+import {
+  createCircuitContext,
+  createConstructorContext,
+  sampleContractAddress,
+} from '@midnight-ntwrk/compact-runtime';
+import { createUnprovenCallTxFromInitialStates } from '@midnight-ntwrk/midnight-js-contracts';
+import { setNetworkId } from '@midnight-sentinel/wallet';
+import { createPrivateState } from '@midnight-sentinel/contract';
+import { NodeZkConfigProvider } from '@midnight-sentinel/contract/providers';
+import {
+  RewardSplitCompiledContract,
+  RewardSplitContractConstructor,
+  rewardSplitLedger,
+} from './reward-split-contract.js';
+import {
+  FallibleUserTargetCompiledContract,
+  FallibleUserTargetConstructor,
+} from './fallible-user-target-contract.js';
+
+setNetworkId('undeployed');
+
+const bytes = (fill: number) => new Uint8Array(32).fill(fill);
+const privateState = createPrivateState(bytes(1));
+const shieldedKeys = (seed: string) =>
+  ZswapSecretKeys.fromSeed(deriveKeysFromSeed(seed)[Roles.Zswap]);
+const beneficiaryKeys = shieldedKeys('77'.repeat(32));
+const sponsorKeys = shieldedKeys('00'.repeat(31) + '03');
+const delegatorKeys = shieldedKeys('00'.repeat(31) + '02');
+const beneficiaryCoinKey = beneficiaryKeys.coinPublicKey;
+const beneficiaryEncryptionKey = beneficiaryKeys.encryptionPublicKey;
+const sponsorCoinKey = sponsorKeys.coinPublicKey;
+const sponsorEncryptionKey = sponsorKeys.encryptionPublicKey;
+const delegatorCoinKey = delegatorKeys.coinPublicKey;
+const delegatorEncryptionKey = delegatorKeys.encryptionPublicKey;
+const contractAddress = sampleContractAddress();
+const targetAddress = sampleContractAddress();
+const contract = new RewardSplitContractConstructor({
+  localSecretKey: ({ privateState: current }) => [current, current.secretKey],
+});
+const probe = contract.initialState(
+  createConstructorContext(privateState, beneficiaryCoinKey),
+  bytes(0x11),
+  bytes(0),
+  { bytes: Buffer.from(sponsorCoinKey, 'hex') },
+  1n,
+  1n,
+  1n,
+  bytes(0)
+);
+const operatorKey = rewardSplitLedger(probe.currentContractState.data).owner;
+const initial = contract.initialState(
+  createConstructorContext(privateState, beneficiaryCoinKey),
+  bytes(0x11),
+  bytes(0),
+  { bytes: Buffer.from(sponsorCoinKey, 'hex') },
+  1n,
+  1n,
+  1n,
+  operatorKey
+);
+const queued = contract.circuits.addDelegator(
+  createCircuitContext(
+    contractAddress,
+    initial.currentZswapLocalState,
+    initial.currentContractState,
+    privateState
+  ),
+  bytes(0x41),
+  { bytes: Buffer.from(delegatorCoinKey, 'hex') },
+  1n,
+  1n
+);
+const queuedContractState = initial.currentContractState;
+queuedContractState.data = queued.context.currentQueryContext.state;
+
+const delegatorPayment = { nonce: bytes(0x71), color: bytes(0), value: 1n };
+const delegatorCall = await createUnprovenCallTxFromInitialStates(
+  new NodeZkConfigProvider(new URL('../../managed/reward-split', import.meta.url).pathname),
+  {
+    compiledContract: RewardSplitCompiledContract,
+    contractAddress,
+    circuitId: 'purchaseDelegatorReward',
+    args: [delegatorPayment],
+    coinPublicKey: beneficiaryCoinKey,
+    initialContractState: queuedContractState,
+    initialZswapChainState: new ZswapChainState(),
+    ledgerParameters: LedgerParameters.initialParameters(),
+    initialPrivateState: privateState,
+    additionalCoinEncPublicKeyMappings: new Map([
+      [sponsorCoinKey, sponsorEncryptionKey],
+      [delegatorCoinKey, delegatorEncryptionKey],
+    ]),
+  },
+  beneficiaryEncryptionKey
+);
+
+const staged = contract.circuits.purchaseDelegatorReward(
+  createCircuitContext(
+    contractAddress,
+    queued.context.currentZswapLocalState,
+    queued.context.currentQueryContext.state,
+    privateState
+  ),
+  delegatorPayment
+);
+const stagedContractState = queuedContractState;
+stagedContractState.data = staged.context.currentQueryContext.state;
+const sponsorCall = await createUnprovenCallTxFromInitialStates(
+  new NodeZkConfigProvider(new URL('../../managed/reward-split', import.meta.url).pathname),
+  {
+    compiledContract: RewardSplitCompiledContract,
+    contractAddress,
+    circuitId: 'deliverSponsorReward',
+    args: [bytes(0x61), { nonce: bytes(0x72), color: bytes(0), value: 1n }],
+    coinPublicKey: beneficiaryCoinKey,
+    initialContractState: stagedContractState,
+    initialZswapChainState: new ZswapChainState(),
+    ledgerParameters: LedgerParameters.initialParameters(),
+    initialPrivateState: privateState,
+    additionalCoinEncPublicKeyMappings: new Map([[sponsorCoinKey, sponsorEncryptionKey]]),
+  },
+  beneficiaryEncryptionKey
+);
+const target = new FallibleUserTargetConstructor({});
+const targetInitial = target.initialState(createConstructorContext(undefined, beneficiaryCoinKey));
+const targetCall = await createUnprovenCallTxFromInitialStates(
+  new NodeZkConfigProvider(new URL('../../managed/fallible-user-target', import.meta.url).pathname),
+  {
+    compiledContract: FallibleUserTargetCompiledContract,
+    contractAddress: targetAddress,
+    circuitId: 'interact',
+    args: [BigInt(Math.floor(Date.now() / 1000) + 600)],
+    coinPublicKey: beneficiaryCoinKey,
+    initialContractState: targetInitial.currentContractState,
+    initialZswapChainState: new ZswapChainState(),
+    ledgerParameters: LedgerParameters.initialParameters(),
+  },
+  beneficiaryEncryptionKey
+);
+
+const merged = delegatorCall.private.unprovenTx
+  .merge(sponsorCall.private.unprovenTx)
+  .merge(targetCall.private.unprovenTx);
+const mergedCallCount = [...(merged.intents?.values() ?? [])].reduce(
+  (count, intent) =>
+    count + intent.actions.filter((action) => action.constructor.name === 'ContractCall').length,
+  0
+);
+
+const partition = (call: {
+  public: {
+    publicTranscript: unknown[];
+    partitionedTranscript: [unknown | undefined, unknown | undefined];
+  };
+}) => ({
+  guaranteedPresent: call.public.partitionedTranscript[0] !== undefined,
+  falliblePresent: call.public.partitionedTranscript[1] !== undefined,
+  operationCount: call.public.publicTranscript.length,
+});
+const result = {
+  purchaseDelegatorReward: partition(delegatorCall),
+  deliverSponsorReward: partition(sponsorCall),
+  userInteraction: partition(targetCall),
+  merged: {
+    callCount: mergedCallCount,
+    intentCount: merged.intents?.size ?? 0,
+  },
+};
+
+console.log(JSON.stringify(result, null, 2));
+if (
+  !result.purchaseDelegatorReward.guaranteedPresent ||
+  result.purchaseDelegatorReward.falliblePresent ||
+  result.deliverSponsorReward.guaranteedPresent ||
+  !result.deliverSponsorReward.falliblePresent ||
+  result.userInteraction.guaranteedPresent ||
+  !result.userInteraction.falliblePresent ||
+  result.merged.callCount !== 3
+) {
+  process.exitCode = 1;
+}
diff --git a/packages/protocol-verification/src/experiments/reward-split/reward-split-runtime-check.ts b/packages/protocol-verification/src/experiments/reward-split/reward-split-runtime-check.ts
new file mode 100644
index 0000000..28ec8c3
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/reward-split-runtime-check.ts
@@ -0,0 +1,206 @@
+import {
+  createCircuitContext,
+  createConstructorContext,
+  sampleContractAddress,
+} from '@midnight-ntwrk/compact-runtime';
+import type { PrivateState } from '@midnight-sentinel/contract';
+import { Contract, ledger } from '../../managed/reward-split/contract/index.js';
+
+const bytes = (fill: number) => new Uint8Array(32).fill(fill);
+const equalBytes = (a: Uint8Array, b: Uint8Array) =>
+  a.length === b.length && a.every((value, index) => value === b[index]);
+
+const ownerSecret = bytes(0x01);
+const operatorSecret = bytes(0x02);
+const rotatedOperatorSecret = bytes(0x03);
+const sponsorId = bytes(0x11);
+const color = bytes(0);
+const sponsorRewardKey = { bytes: bytes(0x21) };
+const delegatorKeys = [{ bytes: bytes(0x31) }, { bytes: bytes(0x32) }, { bytes: bytes(0x33) }];
+const delegatorIds = [bytes(0x41), bytes(0x42), bytes(0x43)];
+const contractAddress = sampleContractAddress();
+const coinPublicKey = '01'.repeat(32);
+const share = 1n;
+const price = share * 2n;
+const minimum = 100n;
+const contract = new Contract<PrivateState>({
+  localSecretKey: ({ privateState }) => [privateState, privateState.secretKey],
+});
+
+const constructorResult = (secretKey: Uint8Array, initialOperator: Uint8Array) =>
+  contract.initialState(
+    createConstructorContext({ secretKey }, coinPublicKey),
+    sponsorId,
+    color,
+    sponsorRewardKey,
+    share,
+    share,
+    minimum,
+    initialOperator
+  );
+
+const operatorProbe = constructorResult(operatorSecret, bytes(0));
+const operatorKey = ledger(operatorProbe.currentContractState.data).owner;
+const rotatedOperatorProbe = constructorResult(rotatedOperatorSecret, bytes(0));
+const rotatedOperatorKey = ledger(rotatedOperatorProbe.currentContractState.data).owner;
+const initial = () => constructorResult(ownerSecret, operatorKey);
+
+type StateResult =
+  | ReturnType<typeof initial>
+  | ReturnType<typeof contract.circuits.addDelegator>
+  | ReturnType<typeof contract.circuits.updateDelegator>
+  | ReturnType<typeof contract.circuits.removeDelegator>
+  | ReturnType<typeof contract.circuits.rotateEligibilityOperator>
+  | ReturnType<typeof contract.circuits.purchaseDelegatorReward>
+  | ReturnType<typeof contract.circuits.deliverSponsorReward>;
+
+const context = (state: StateResult, secretKey: Uint8Array) =>
+  'context' in state
+    ? createCircuitContext(
+        contractAddress,
+        state.context.currentZswapLocalState,
+        state.context.currentQueryContext.state,
+        { secretKey }
+      )
+    : createCircuitContext(contractAddress, coinPublicKey, state.currentContractState, {
+        secretKey,
+      });
+
+const add = (state: StateResult, index: number, secret = operatorSecret) =>
+  contract.circuits.addDelegator(
+    context(state, secret),
+    delegatorIds[index],
+    delegatorKeys[index],
+    minimum + BigInt(index),
+    1000n + BigInt(index)
+  );
+
+const remove = (state: StateResult, index: number, secret = operatorSecret) =>
+  contract.circuits.removeDelegator(context(state, secret), delegatorIds[index]);
+
+const purchase = (state: StateResult, index: number) =>
+  contract.circuits.purchaseDelegatorReward(context(state, ownerSecret), {
+    nonce: bytes(0x70 + index),
+    color,
+    value: share,
+  });
+
+const deliverSponsorReward = (state: StateResult, index: number) =>
+  contract.circuits.deliverSponsorReward(context(state, ownerSecret), bytes(0x60 + index), {
+    nonce: bytes(0x80 + index),
+    color,
+    value: share,
+  });
+
+const expectReject = (label: string, action: () => unknown, expected: string) => {
+  try {
+    action();
+    throw new Error(`${label}: unexpectedly succeeded`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes(expected)) {
+      throw new Error(`${label}: expected "${expected}", got "${message}"`);
+    }
+  }
+};
+
+expectReject('empty queue', () => purchase(initial(), 0), 'NO_ELIGIBLE_DELEGATOR');
+expectReject(
+  'unauthorized add',
+  () => add(initial(), 0, ownerSecret),
+  'Not the eligibility operator'
+);
+expectReject(
+  'below minimum',
+  () =>
+    contract.circuits.addDelegator(
+      context(initial(), operatorSecret),
+      delegatorIds[0],
+      delegatorKeys[0],
+      minimum - 1n,
+      1000n
+    ),
+  'Below minimum registered NIGHT'
+);
+
+let queued: StateResult = add(initial(), 0);
+queued = add(queued, 1);
+queued = add(queued, 2);
+expectReject('duplicate delegator', () => add(queued, 0), 'Duplicate delegator');
+
+const rewarded: Uint8Array[] = [];
+for (let index = 0; index < 4; index += 1) {
+  queued = purchase(queued, index);
+  const delegatorLedger = ledger(queued.context.currentQueryContext.state);
+  if (
+    delegatorLedger.sponsorshipPurchases !== BigInt(index) ||
+    delegatorLedger.sponsorshipReceipts.member(bytes(0x60 + index))
+  ) {
+    throw new Error('delegator circuit unexpectedly changed queue accounting');
+  }
+  queued = deliverSponsorReward(queued, index);
+  const current = ledger(queued.context.currentQueryContext.state);
+  const deliveredReceipt = current.sponsorshipReceipts.lookup(bytes(0x60 + index));
+  rewarded.push(deliveredReceipt.rewardedDelegatorId);
+  if (!deliveredReceipt.sponsorRewardDelivered) {
+    throw new Error('sponsor circuit did not mark the reward delivered');
+  }
+  // receiveShielded records the contract receipt commitment and each chained
+  // immediate send records its sent/change commitments. The two intermediate
+  // coins are consumed inside the transaction; the final ledger has the
+  // sponsor and delegator outputs.
+  if (queued.context.currentZswapLocalState.outputs.length !== (index + 1) * 4) {
+    throw new Error(
+      `purchase did not append the expected split transcript commitments: observed ${queued.context.currentZswapLocalState.outputs.length}`
+    );
+  }
+}
+
+const expectedRotation = [delegatorIds[0], delegatorIds[1], delegatorIds[2], delegatorIds[0]];
+for (let index = 0; index < expectedRotation.length; index += 1) {
+  if (!equalBytes(rewarded[index], expectedRotation[index])) {
+    throw new Error(`unexpected delegator at rotation position ${index}`);
+  }
+}
+
+const beforeRemoval = ledger(queued.context.currentQueryContext.state);
+if (beforeRemoval.rewardCursor !== 1n || beforeRemoval.sponsorshipPurchases !== 4n) {
+  throw new Error('rotation cursor or purchase count is incorrect');
+}
+queued = remove(queued, 0);
+const afterRemoval = ledger(queued.context.currentQueryContext.state);
+if (
+  afterRemoval.delegatorCount !== 2n ||
+  afterRemoval.rewardCursor !== 0n ||
+  !equalBytes(afterRemoval.delegatorSlots.lookup(0n).nightIdentity, delegatorIds[1])
+) {
+  throw new Error('removing before the cursor did not compact and adjust the queue');
+}
+
+const rotated = contract.circuits.rotateEligibilityOperator(
+  context(queued, ownerSecret),
+  rotatedOperatorKey
+);
+expectReject(
+  'old operator after rotation',
+  () => remove(rotated, 1, operatorSecret),
+  'Not the eligibility operator'
+);
+const removedByRotatedOperator = remove(rotated, 1, rotatedOperatorSecret);
+const finalLedger = ledger(removedByRotatedOperator.context.currentQueryContext.state);
+if (finalLedger.delegatorCount !== 1n) {
+  throw new Error('rotated operator could not maintain the queue');
+}
+
+console.log(
+  JSON.stringify({
+    rewardSplitRuntime: 'confirmed',
+    fixedPrice: price.toString(),
+    sponsorShare: share.toString(),
+    delegatorShare: share.toString(),
+    rewardOutputsPerPurchase: 2,
+    deterministicRotation: rewarded.map((id) => Buffer.from(id).toString('hex')),
+    removalCompaction: 'confirmed',
+    operatorRotation: 'confirmed',
+  })
+);
diff --git a/packages/protocol-verification/src/experiments/reward-split/reward-split-wallet-check.ts b/packages/protocol-verification/src/experiments/reward-split/reward-split-wallet-check.ts
new file mode 100644
index 0000000..68296ae
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/reward-split-wallet-check.ts
@@ -0,0 +1,450 @@
+// The runner reuses the wallet package's pinned ledger runtime without adding
+// a second copy to this package.
+import {
+  Binding,
+  ContractCallPrototype,
+  ContractState as LedgerContractState,
+  Intent,
+  LedgerParameters,
+  Proof,
+  SignatureEnabled,
+  Transaction,
+  ZswapChainState,
+  communicationCommitmentRandomness,
+  encodeQualifiedShieldedCoinInfo,
+  shieldedToken,
+  type ZswapLocalState,
+  // @ts-expect-error the direct Node entry point has no adjacent declaration file.
+} from '../../../../wallet/node_modules/@midnight-ntwrk/ledger-v8/midnight_ledger_wasm_fs.js';
+import {
+  ContractState,
+  createCircuitContext,
+  createConstructorContext,
+} from '@midnight-ntwrk/compact-runtime';
+import {
+  createUnprovenCallTx,
+  createUnprovenCallTxFromInitialStates,
+  deployContract,
+} from '@midnight-ntwrk/midnight-js-contracts';
+import {
+  ShieldedAddress,
+  ShieldedCoinPublicKey,
+  ShieldedEncryptionPublicKey,
+} from '../../../../wallet/node_modules/@midnight-ntwrk/wallet-sdk-address-format/dist/index.js';
+import {
+  buildUnfundedWallet,
+  buildWallet,
+  signTransactionIntents,
+  type WalletContext,
+} from '@midnight-sentinel/wallet';
+import { createPrivateState } from '@midnight-sentinel/contract';
+import {
+  RewardSplitCompiledContract,
+  RewardSplitContractConstructor,
+  rewardSplitCompositeProofProvider,
+  rewardSplitLedger,
+  type RewardSplitContractType,
+} from './reward-split-contract.js';
+import {
+  FallibleUserTargetCompiledContract,
+  type FallibleUserTargetType,
+} from './fallible-user-target-contract.js';
+import assert from 'node:assert/strict';
+import {
+  filledBytes,
+  providersFor,
+  shieldedCoinKeyOf,
+  stopWallets,
+  withTimeout,
+  waitForWalletState,
+  waitForWalletSync,
+} from '../../common/experiment-harness.js';
+
+const OWNER_SECRET = filledBytes(0x09);
+const BENEFICIARY_SEED = '77'.repeat(32);
+const DEPLOYER_SEED = '00'.repeat(31) + '01';
+const SPONSOR_SEED = '00'.repeat(31) + '03';
+const DELEGATOR_SEED = '00'.repeat(31) + '02';
+const PRICE = 2n;
+const SHARE = 1n;
+const TIMEOUT_MS = 180_000;
+const PRIVATE_STATE_ID = 'rewardSplitVerificationPrivateState';
+// DUST is time-valued. A distant TTL lets the wallet balance against DUST that
+// has not accrued yet, which the node rejects at immediate submission with
+// BalanceCheckOverspend (custom error 138). Proof generation is already
+// complete when this TTL is created, so two minutes is ample for finalization.
+const TTL = () => new Date(Date.now() + 2 * 60_000);
+const zkPath = new URL('../../managed/reward-split', import.meta.url).pathname;
+const targetZkPath = new URL('../../managed/fallible-user-target', import.meta.url).pathname;
+const config = {
+  privateStateStoreName: PRIVATE_STATE_ID,
+  logDir: '/tmp/reward-split-wallet-check',
+  zkConfigPath: zkPath,
+  indexer: 'http://127.0.0.1:8088/api/v4/graphql',
+  indexerWS: 'ws://127.0.0.1:8088/api/v4/graphql/ws',
+  node: 'http://127.0.0.1:9944',
+  proofServer: 'http://127.0.0.1:6300',
+};
+
+const waitBalance = (label: string, ctx: WalletContext, minimum: bigint) =>
+  waitForWalletState(label, TIMEOUT_MS, ctx, (state) =>
+    (state.shielded.balances[shieldedToken().raw] ?? 0n) >= minimum ? state : false
+  );
+
+const address = (ctx: WalletContext) =>
+  new ShieldedAddress(
+    ShieldedCoinPublicKey.fromHexString(ctx.shieldedSecretKeys.coinPublicKey),
+    ShieldedEncryptionPublicKey.fromHexString(ctx.shieldedSecretKeys.encryptionPublicKey)
+  );
+
+type CallData = Awaited<ReturnType<typeof createUnprovenCallTx>>;
+
+const singleIntentTransaction = (
+  calls: ReadonlyArray<{
+    circuitId: string;
+    contractAddress: string;
+    initialContractState: ContractState;
+    callData: CallData;
+  }>
+) => {
+  let intent = Intent.new(TTL());
+  let guaranteedOffer:
+    | NonNullable<CallData['private']['unprovenTx']['guaranteedOffer']>
+    | undefined;
+  let fallibleOffer: NonNullable<CallData['private']['unprovenTx']['guaranteedOffer']> | undefined;
+
+  for (const { circuitId, contractAddress, initialContractState, callData } of calls) {
+    const ledgerState = LedgerContractState.deserialize(initialContractState.serialize());
+    const operation = ledgerState.operation(circuitId);
+    assert(operation, `operation ${circuitId} is missing`);
+    intent = intent.addCall(
+      new ContractCallPrototype(
+        contractAddress,
+        circuitId,
+        operation,
+        callData.public.partitionedTranscript[0],
+        callData.public.partitionedTranscript[1],
+        callData.private.privateTranscriptOutputs,
+        callData.private.input,
+        callData.private.output,
+        communicationCommitmentRandomness(),
+        circuitId
+      )
+    );
+
+    const tx = callData.private.unprovenTx;
+    if (tx.guaranteedOffer) {
+      guaranteedOffer = guaranteedOffer
+        ? guaranteedOffer.merge(tx.guaranteedOffer)
+        : tx.guaranteedOffer;
+    }
+    for (const offer of tx.fallibleOffer?.values() ?? []) {
+      fallibleOffer = fallibleOffer ? fallibleOffer.merge(offer) : offer;
+    }
+  }
+
+  return Transaction.fromParts('undeployed', guaranteedOffer, fallibleOffer, intent);
+};
+
+const main = async () => {
+  const wallets: WalletContext[] = [];
+  try {
+    const [deployer, dustSponsor, delegator, beneficiary] = await Promise.all([
+      buildWallet(config, DEPLOYER_SEED),
+      buildWallet(config, SPONSOR_SEED),
+      buildWallet(config, DELEGATOR_SEED),
+      buildUnfundedWallet(config, BENEFICIARY_SEED),
+    ]);
+    wallets.push(deployer, dustSponsor, delegator, beneficiary);
+
+    const sponsorBefore = await waitForWalletSync(dustSponsor, TIMEOUT_MS);
+    const delegatorBefore = await waitForWalletSync(delegator, TIMEOUT_MS);
+    const beneficiaryBefore = await waitForWalletSync(beneficiary, TIMEOUT_MS);
+    const sponsorBalanceBefore = sponsorBefore.shielded.balances[shieldedToken().raw] ?? 0n;
+    const delegatorBalanceBefore = delegatorBefore.shielded.balances[shieldedToken().raw] ?? 0n;
+    const beneficiaryBalanceBefore = beneficiaryBefore.shielded.balances[shieldedToken().raw] ?? 0n;
+
+    const runtime = new RewardSplitContractConstructor({
+      localSecretKey: ({ privateState }) => [privateState, privateState.secretKey],
+    });
+    const probe = runtime.initialState(
+      createConstructorContext(
+        createPrivateState(OWNER_SECRET),
+        deployer.shieldedSecretKeys.coinPublicKey
+      ),
+      filledBytes(0x11),
+      Buffer.from(shieldedToken().raw, 'hex'),
+      shieldedCoinKeyOf(dustSponsor),
+      SHARE,
+      SHARE,
+      1n,
+      filledBytes(0)
+    );
+    const operatorKey = rewardSplitLedger(probe.currentContractState.data).owner;
+    const deployerProviders = await providersFor<RewardSplitContractType>(
+      deployer,
+      config,
+      'reward-split-wallet-deployer',
+      zkPath
+    );
+    const deployed = await deployContract<RewardSplitContractType>(deployerProviders, {
+      compiledContract: RewardSplitCompiledContract,
+      privateStateId: PRIVATE_STATE_ID,
+      initialPrivateState: createPrivateState(OWNER_SECRET),
+      args: [
+        filledBytes(0x11),
+        Buffer.from(shieldedToken().raw, 'hex'),
+        shieldedCoinKeyOf(dustSponsor),
+        SHARE,
+        SHARE,
+        1n,
+        operatorKey,
+      ],
+    });
+    const contractAddress = deployed.deployTxData.public.contractAddress;
+    const targetDeployProviders = await providersFor<FallibleUserTargetType>(
+      deployer,
+      config,
+      'reward-split-target-deployer',
+      targetZkPath
+    );
+    const targetDeployment = await deployContract<FallibleUserTargetType>(targetDeployProviders, {
+      compiledContract: FallibleUserTargetCompiledContract,
+    });
+    const targetAddress = targetDeployment.deployTxData.public.contractAddress;
+
+    await deployed.callTx.addDelegator(filledBytes(0x41), shieldedCoinKeyOf(delegator), 1n, 1n);
+
+    const funding = await deployer.wallet.transferTransaction(
+      [
+        {
+          type: 'shielded',
+          outputs: Array.from({ length: 4 }, () => ({
+            type: shieldedToken().raw,
+            amount: SHARE,
+            receiverAddress: address(beneficiary),
+          })),
+        },
+      ],
+      {
+        shieldedSecretKeys: deployer.shieldedSecretKeys,
+        dustSecretKey: deployer.dustSecretKey,
+      },
+      { ttl: TTL() }
+    );
+    const fundingTx = await deployer.wallet.finalizeRecipe(funding);
+    await deployer.wallet.submitTransaction(fundingTx);
+    const beneficiaryState = await waitBalance(
+      'beneficiary funding',
+      beneficiary,
+      beneficiaryBalanceBefore + PRICE * 2n
+    );
+    void beneficiaryState;
+
+    const beneficiaryProviders = await providersFor<RewardSplitContractType>(
+      beneficiary,
+      config,
+      'reward-split-wallet-beneficiary',
+      zkPath
+    );
+    beneficiaryProviders.privateStateProvider.setContractAddress(contractAddress);
+    const beneficiaryTargetProviders = await providersFor<FallibleUserTargetType>(
+      beneficiary,
+      config,
+      'reward-split-target-beneficiary',
+      targetZkPath
+    );
+    const proofProvider = rewardSplitCompositeProofProvider(
+      config.proofServer,
+      zkPath,
+      targetZkPath
+    );
+
+    const runScenario = async (
+      index: number,
+      expiry: bigint,
+      expectedStatus: 'SucceedEntirely' | 'FailFallible'
+    ) => {
+      const state = await waitForWalletSync(beneficiary, TIMEOUT_MS);
+      const coins = [...(state.shielded.state.state as ZswapLocalState).coins].filter(
+        (coin) => coin.type === shieldedToken().raw && coin.value === SHARE
+      );
+      assert(coins.length >= 2, 'two exact 1 NIGHT coins are required');
+      const delegatorCoin = encodeQualifiedShieldedCoinInfo(coins[0]);
+      const sponsorCoin = encodeQualifiedShieldedCoinInfo(coins[1]);
+      const privateState = createPrivateState(filledBytes(0x08));
+      const purchaseId = filledBytes(0x60 + index);
+      const delegatorPayment = {
+        nonce: delegatorCoin.nonce,
+        color: delegatorCoin.color,
+        value: SHARE,
+      };
+      await beneficiaryProviders.privateStateProvider.set(PRIVATE_STATE_ID, privateState);
+
+      const delegatorCall = await createUnprovenCallTx(beneficiaryProviders, {
+        compiledContract: RewardSplitCompiledContract,
+        contractAddress,
+        circuitId: 'purchaseDelegatorReward',
+        privateStateId: PRIVATE_STATE_ID,
+        additionalCoinEncPublicKeyMappings: new Map([
+          [
+            delegator.shieldedSecretKeys.coinPublicKey,
+            delegator.shieldedSecretKeys.encryptionPublicKey,
+          ],
+        ]),
+        args: [delegatorPayment],
+      });
+
+      const chainAndState =
+        await beneficiaryProviders.publicDataProvider.queryZSwapAndContractState(contractAddress);
+      assert(chainAndState, 'reward contract state not found');
+      const runtimeStep = runtime.circuits.purchaseDelegatorReward(
+        createCircuitContext(
+          contractAddress,
+          beneficiary.shieldedSecretKeys.coinPublicKey,
+          chainAndState[1],
+          privateState
+        ),
+        delegatorPayment
+      );
+      const postDelegatorState = ContractState.deserialize(chainAndState[1].serialize());
+      postDelegatorState.data = runtimeStep.context.currentQueryContext.state;
+
+      const sponsorCall = await createUnprovenCallTxFromInitialStates(
+        beneficiaryProviders.zkConfigProvider,
+        {
+          compiledContract: RewardSplitCompiledContract,
+          contractAddress,
+          circuitId: 'deliverSponsorReward',
+          args: [purchaseId, { nonce: sponsorCoin.nonce, color: sponsorCoin.color, value: SHARE }],
+          coinPublicKey: beneficiary.shieldedSecretKeys.coinPublicKey,
+          initialContractState: postDelegatorState,
+          initialZswapChainState: chainAndState[0] as unknown as ZswapChainState,
+          ledgerParameters: LedgerParameters.initialParameters(),
+          initialPrivateState: privateState,
+          additionalCoinEncPublicKeyMappings: new Map([
+            [
+              dustSponsor.shieldedSecretKeys.coinPublicKey,
+              dustSponsor.shieldedSecretKeys.encryptionPublicKey,
+            ],
+          ]),
+        },
+        beneficiary.shieldedSecretKeys.encryptionPublicKey
+      );
+      const targetCall = await createUnprovenCallTx(beneficiaryTargetProviders, {
+        compiledContract: FallibleUserTargetCompiledContract,
+        contractAddress: targetAddress,
+        circuitId: 'interact',
+        args: [expiry],
+      });
+      const targetChainAndState =
+        await beneficiaryTargetProviders.publicDataProvider.queryZSwapAndContractState(
+          targetAddress
+        );
+      assert(targetChainAndState, 'fallible target state not found');
+      const merged = singleIntentTransaction([
+        {
+          circuitId: 'purchaseDelegatorReward',
+          contractAddress,
+          initialContractState: chainAndState[1],
+          callData: delegatorCall as CallData,
+        },
+        {
+          circuitId: 'deliverSponsorReward',
+          contractAddress,
+          initialContractState: postDelegatorState,
+          callData: sponsorCall as CallData,
+        },
+        {
+          circuitId: 'interact',
+          contractAddress: targetAddress,
+          initialContractState: targetChainAndState[1],
+          callData: targetCall as CallData,
+        },
+      ]);
+      const proved = await proofProvider.proveTx(merged);
+      const recipe = await beneficiary.wallet.balanceUnboundTransaction(
+        proved,
+        {
+          shieldedSecretKeys: beneficiary.shieldedSecretKeys,
+          dustSecretKey: beneficiary.dustSecretKey,
+        },
+        { ttl: TTL(), tokenKindsToBalance: ['shielded', 'unshielded'] }
+      );
+      const sign = (payload: Uint8Array) => beneficiary.unshieldedKeystore.signData(payload);
+      signTransactionIntents(recipe.baseTransaction, sign, 'proof');
+      if (recipe.balancingTransaction) {
+        signTransactionIntents(recipe.balancingTransaction, sign, 'pre-proof');
+      }
+      const finalizedByBeneficiary = await beneficiary.wallet.finalizeRecipe(recipe);
+      const roundTrip = Transaction.deserialize<SignatureEnabled, Proof, Binding>(
+        'signature',
+        'proof',
+        'binding',
+        finalizedByBeneficiary.serialize()
+      );
+      const dustRecipe = await dustSponsor.wallet.balanceFinalizedTransaction(
+        roundTrip,
+        {
+          shieldedSecretKeys: dustSponsor.shieldedSecretKeys,
+          dustSecretKey: dustSponsor.dustSecretKey,
+        },
+        { ttl: TTL(), tokenKindsToBalance: ['dust'] }
+      );
+      const sponsored = await dustSponsor.wallet.finalizeRecipe(dustRecipe);
+      if (expectedStatus === 'FailFallible') {
+        while (BigInt(Math.floor(Date.now() / 1000)) <= expiry) {
+          await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+      }
+      const txId = await dustSponsor.wallet.submitTransaction(sponsored);
+      const observed = await withTimeout(
+        'composite transaction finalization',
+        TIMEOUT_MS,
+        beneficiaryProviders.publicDataProvider.watchForTxData(txId)
+      );
+      assert.equal(observed.status, expectedStatus);
+      return { transactionId: String(txId), status: observed.status };
+    };
+
+    const success = await runScenario(
+      1,
+      BigInt(Math.floor(Date.now() / 1000) + 600),
+      'SucceedEntirely'
+    );
+    await waitBalance('successful sponsor reward', dustSponsor, sponsorBalanceBefore + SHARE);
+    const failure = await runScenario(
+      2,
+      BigInt(Math.floor(Date.now() / 1000) + 20),
+      'FailFallible'
+    );
+    const delegatorAfter = await waitBalance(
+      'delegator rewards',
+      delegator,
+      delegatorBalanceBefore + SHARE * 2n
+    );
+    const sponsorAfter = await waitForWalletSync(dustSponsor, TIMEOUT_MS);
+    const sponsorIncrease =
+      (sponsorAfter.shielded.balances[shieldedToken().raw] ?? 0n) - sponsorBalanceBefore;
+    const delegatorIncrease =
+      (delegatorAfter.shielded.balances[shieldedToken().raw] ?? 0n) - delegatorBalanceBefore;
+    assert.equal(sponsorIncrease, SHARE);
+    assert.equal(delegatorIncrease, SHARE * 2n);
+
+    console.log(
+      JSON.stringify({
+        walletRewardSplit: 'confirmed',
+        contractAddress,
+        targetAddress,
+        success,
+        fallibleFailure: failure,
+        sponsorIncrease: sponsorIncrease.toString(),
+        delegatorIncrease: delegatorIncrease.toString(),
+      })
+    );
+  } finally {
+    await stopWallets(wallets);
+  }
+};
+
+await main();
diff --git a/packages/protocol-verification/src/experiments/reward-split/reward-split.compact b/packages/protocol-verification/src/experiments/reward-split/reward-split.compact
new file mode 100644
index 0000000..d2c1261
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/reward-split/reward-split.compact
@@ -0,0 +1,239 @@
+pragma language_version 0.23;
+
+import CompactStandardLibrary;
+
+export struct DelegatorSlot {
+  nightIdentity: Bytes<32>;
+  rewardKey: ZswapCoinPublicKey;
+  verifiedRegisteredAmount: Uint<128>;
+  verificationBlock: Uint<64>;
+}
+
+export struct RewardedSponsorshipReceipt {
+  rewardedDelegatorId: Bytes<32>;
+  sponsorRewardDelivered: Boolean;
+}
+
+export sealed ledger configuredSponsor: Bytes<32>;
+export sealed ledger acceptedColor: Bytes<32>;
+export sealed ledger fixedPrice: Uint<64>;
+export sealed ledger sponsorShare: Uint<64>;
+export sealed ledger delegatorShare: Uint<64>;
+export sealed ledger sponsorRewardKey: ZswapCoinPublicKey;
+export sealed ledger minimumRegisteredNight: Uint<128>;
+
+export ledger owner: Bytes<32>;
+export ledger eligibilityOperator: Bytes<32>;
+export ledger delegatorSlots: Map<Uint<64>, DelegatorSlot>;
+export ledger delegatorPositions: Map<Bytes<32>, Uint<64>>;
+export ledger delegatorCount: Uint<64>;
+export ledger rewardCursor: Uint<64>;
+export ledger sponsorshipPurchases: Counter;
+export ledger sponsorshipReceipts: Map<Bytes<32>, RewardedSponsorshipReceipt>;
+
+witness localSecretKey(): Bytes<32>;
+
+constructor(
+  sponsorId: Bytes<32>,
+  paymentColor: Bytes<32>,
+  sponsorKey: ZswapCoinPublicKey,
+  sponsorReward: Uint<64>,
+  delegatorReward: Uint<64>,
+  minimumNight: Uint<128>,
+  initialOperator: Bytes<32>
+) {
+  assert(sponsorReward > 0, "Sponsor share must be positive");
+  assert(delegatorReward > 0, "Delegator share must be positive");
+
+  configuredSponsor = disclose(sponsorId);
+  acceptedColor = disclose(paymentColor);
+  sponsorRewardKey = disclose(sponsorKey);
+  sponsorShare = disclose(sponsorReward);
+  delegatorShare = disclose(delegatorReward);
+  fixedPrice = disclose((sponsorReward + delegatorReward) as Uint<64>);
+  minimumRegisteredNight = disclose(minimumNight);
+  owner = disclose(callerKey());
+  eligibilityOperator = disclose(initialOperator);
+  delegatorCount = disclose(0);
+  rewardCursor = disclose(0);
+}
+
+export circuit addDelegator(
+  nightIdentity: Bytes<32>,
+  rewardKey: ZswapCoinPublicKey,
+  registeredAmount: Uint<128>,
+  verificationBlock: Uint<64>
+): [] {
+  assert(isEligibilityOperator(), "Not the eligibility operator");
+  const publicIdentity = disclose(nightIdentity);
+  const publicRewardKey = disclose(rewardKey);
+  const publicAmount = disclose(registeredAmount);
+  const publicBlock = disclose(verificationBlock);
+  assert(!delegatorPositions.member(publicIdentity), "Duplicate delegator");
+  assert(publicAmount >= minimumRegisteredNight, "Below minimum registered NIGHT");
+  assert(delegatorCount < 16, "Delegator queue is full");
+
+  delegatorSlots.insert(
+    delegatorCount,
+    DelegatorSlot {
+      nightIdentity: publicIdentity,
+      rewardKey: publicRewardKey,
+      verifiedRegisteredAmount: publicAmount,
+      verificationBlock: publicBlock
+    }
+  );
+  delegatorPositions.insert(publicIdentity, delegatorCount);
+  delegatorCount = (delegatorCount + 1) as Uint<64>;
+}
+
+export circuit updateDelegator(
+  nightIdentity: Bytes<32>,
+  rewardKey: ZswapCoinPublicKey,
+  registeredAmount: Uint<128>,
+  verificationBlock: Uint<64>
+): [] {
+  assert(isEligibilityOperator(), "Not the eligibility operator");
+  const publicIdentity = disclose(nightIdentity);
+  const publicRewardKey = disclose(rewardKey);
+  const publicAmount = disclose(registeredAmount);
+  const publicBlock = disclose(verificationBlock);
+  assert(delegatorPositions.member(publicIdentity), "Unknown delegator");
+  assert(publicAmount >= minimumRegisteredNight, "Below minimum registered NIGHT");
+
+  const position = delegatorPositions.lookup(publicIdentity);
+  delegatorSlots.insert(
+    position,
+    DelegatorSlot {
+      nightIdentity: publicIdentity,
+      rewardKey: publicRewardKey,
+      verifiedRegisteredAmount: publicAmount,
+      verificationBlock: publicBlock
+    }
+  );
+}
+
+export circuit removeDelegator(nightIdentity: Bytes<32>): [] {
+  assert(isEligibilityOperator(), "Not the eligibility operator");
+  const publicIdentity = disclose(nightIdentity);
+  assert(delegatorPositions.member(publicIdentity), "Unknown delegator");
+
+  const removedPosition = delegatorPositions.lookup(publicIdentity);
+  const oldCount = delegatorCount;
+  const newCount = (oldCount - 1) as Uint<64>;
+
+  for (const i of 0..15) {
+    if (i >= removedPosition && i < newCount) {
+      const shifted = delegatorSlots.lookup((i + 1) as Uint<64>);
+      delegatorSlots.insert(i as Uint<64>, shifted);
+      delegatorPositions.insert(shifted.nightIdentity, i as Uint<64>);
+    }
+  }
+
+  delegatorSlots.remove(newCount);
+  delegatorPositions.remove(publicIdentity);
+  delegatorCount = newCount;
+
+  if (newCount == 0) {
+    rewardCursor = 0;
+  } else {
+    if (removedPosition < rewardCursor) {
+      rewardCursor = (rewardCursor - 1) as Uint<64>;
+    } else {
+      if (rewardCursor >= newCount) {
+        rewardCursor = 0;
+      }
+    }
+  }
+}
+
+export circuit rotateEligibilityOperator(newOperator: Bytes<32>): [] {
+  assert(isOwner(), "Not the campaign owner");
+  eligibilityOperator = disclose(newOperator);
+}
+
+export circuit purchaseDelegatorReward(
+  payment: ShieldedCoinInfo
+): [] {
+  const publicPayment = disclose(payment);
+
+  assert(delegatorCount > 0, "NO_ELIGIBLE_DELEGATOR");
+  assert(publicPayment.color == nativeToken(), "Wrong payment asset");
+  assert(publicPayment.value == delegatorShare, "Wrong delegator payment amount");
+
+  const rewarded = delegatorSlots.lookup(rewardCursor);
+  receiveShielded(publicPayment);
+  const delegatorSend = sendImmediateShielded(
+    publicPayment,
+    left<ZswapCoinPublicKey, ContractAddress>(rewarded.rewardKey),
+    delegatorShare as Uint<128>
+  );
+  assert(!delegatorSend.change.is_some, "DELEGATOR_REWARD_DELIVERY_FAILED");
+  rewardCursor =
+    rewardCursor + 1 == delegatorCount
+      ? 0
+      : (rewardCursor + 1) as Uint<64>;
+}
+
+export circuit deliverSponsorReward(
+  purchaseId: Bytes<32>,
+  payment: ShieldedCoinInfo
+): [] {
+  const publicPurchaseId = disclose(purchaseId);
+  const publicPayment = disclose(payment);
+  assert(delegatorCount > 0, "NO_ELIGIBLE_DELEGATOR");
+  assert(!sponsorshipReceipts.member(publicPurchaseId), "Duplicate sponsorship purchase");
+  assert(publicPayment.color == acceptedColor, "Wrong payment asset");
+  assert(publicPayment.value == sponsorShare, "Wrong sponsor payment amount");
+
+  const rewardedPosition =
+    rewardCursor == 0
+      ? (delegatorCount - 1) as Uint<64>
+      : (rewardCursor - 1) as Uint<64>;
+  const rewarded = delegatorSlots.lookup(rewardedPosition);
+
+  // The user's sponsor share is accepted in the guaranteed prefix. If the
+  // later send fails, this payment remains consumed by the contract.
+  receiveShielded(publicPayment);
+  sponsorshipPurchases.increment(1);
+  sponsorshipReceipts.insert(
+    publicPurchaseId,
+    RewardedSponsorshipReceipt {
+      rewardedDelegatorId: rewarded.nightIdentity,
+      sponsorRewardDelivered: false
+    }
+  );
+
+  // This circuit is deliberately fallible. In a composite transaction it
+  // follows purchaseDelegatorReward and precedes the user's fallible work.
+  kernel.checkpoint();
+
+  const sponsorSend = sendImmediateShielded(
+    publicPayment,
+    left<ZswapCoinPublicKey, ContractAddress>(sponsorRewardKey),
+    sponsorShare as Uint<128>
+  );
+  assert(!sponsorSend.change.is_some, "SPONSOR_REWARD_DELIVERY_FAILED");
+
+  sponsorshipReceipts.insert(
+    publicPurchaseId,
+    RewardedSponsorshipReceipt {
+      rewardedDelegatorId: rewarded.nightIdentity,
+      sponsorRewardDelivered: true
+    }
+  );
+}
+
+circuit callerKey(): Bytes<32> {
+  return persistentHash<Vector<2, Bytes<32>>>([
+    pad(32, "reward-queue:pk:"),
+    localSecretKey()
+  ]);
+}
+
+circuit isOwner(): Boolean {
+  return callerKey() == owner;
+}
+
+circuit isEligibilityOperator(): Boolean {
+  return callerKey() == eligibilityOperator;
+}
diff --git a/packages/protocol-verification/src/experiments/sponsorship/README.md b/packages/protocol-verification/src/experiments/sponsorship/README.md
new file mode 100644
index 0000000..259fbc3
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/sponsorship/README.md
@@ -0,0 +1,60 @@
+# Fixed-Price DUST Sponsorship
+
+## Why this experiment exists
+
+The initial Sentinel design assumed that a beneficiary with NIGHT but no DUST
+could prepare a fixed-price Compact purchase, hand the finalized transaction to
+a sponsor, and let the sponsor add only DUST without gaining control over the
+beneficiary payment. Neither Compact compilation nor the wallet API alone
+established that the resulting transaction would be guaranteed-only, safely
+inspectable, and submit successfully.
+
+## Claim
+
+A Compact circuit can validate an exact shielded payment and sponsor identity,
+record the purchase in guaranteed state, and be finalized without beneficiary
+DUST. A second wallet can inspect it, add only DUST, and submit it.
+
+## Preconditions
+
+- Compact compiler `0.31.1`, language `0.23`.
+- Ledger `8.0.3` and Midnight.js `4.1.1`.
+- For the devnet runner: local node, indexer, and proof server at the shared
+  standalone endpoints.
+- Genesis wallet 1 funds the beneficiary; genesis wallet 3 supplies DUST.
+
+## Contents
+
+- `sponsorship.compact` — minimal fixed-price experiment contract.
+- `sponsorship-contract.ts` — generated-contract wrapper.
+- `sponsorship-runtime-check.ts` — deterministic state and rejection checks.
+- `sponsorship-verification.ts` — full-ZK wallet/devnet runner.
+- `result.json` — sanitized retained execution evidence.
+
+## Procedure and acceptance rule
+
+Compile with full ZK, verify deterministic accounting and invalid-payment
+rejection, construct the call with a DUST-less beneficiary, round-trip and
+inspect the finalized transaction, add only DUST with the sponsor wallet, and
+submit it. The core claim passes only if the purchase has a guaranteed
+transcript, no fallible transcript, the sponsor cannot alter bound call
+actions, and the expected contract state commits.
+
+Run from the repository root:
+
+```sh
+pnpm verify:protocol:local
+pnpm verify:protocol:devnet:sponsorship
+```
+
+## Explicit result
+
+**Mixed verdict, retained on 2026-07-24.** Fixed-price validation,
+guaranteed-only partitioning, DUST-less beneficiary construction, structural
+inspection, sponsor-only DUST balancing, and successful on-chain accounting
+were confirmed. Action mutation was rejected. TTL mutation was not rejected
+and had been accepted in an earlier run, so the stronger claim that every
+transaction property was cryptographically immutable was refuted. Independent
+stale-state rejection remained inconclusive. Production sponsor policy must
+therefore validate TTL and current state itself. Exact evidence is in
+`result.json`.
diff --git a/packages/protocol-verification/src/experiments/sponsorship/result.json b/packages/protocol-verification/src/experiments/sponsorship/result.json
new file mode 100644
index 0000000..085df4e
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/sponsorship/result.json
@@ -0,0 +1,108 @@
+{
+  "startedAt": "2026-07-29T17:59:29.768Z",
+  "finishedAt": "2026-07-29T18:01:08.194Z",
+  "versions": {
+    "compiler": "0.31.1",
+    "language": "0.23.0",
+    "ledger": "8.0.3",
+    "midnightJs": "4.1.1",
+    "node": "0.22.5",
+    "indexer": "4.2.1",
+    "proofServer": "8.1.0",
+    "network": "undeployed"
+  },
+  "health": {
+    "node": true,
+    "indexer": true,
+    "proofServer": true
+  },
+  "contractAddress": "176238db5febdb9cbb9fa104969ffc9e644d6b00bf3f573f01b8765496d4ea84",
+  "transactionIds": {
+    "funding": "00c865da1450ebf6e5ecfa1dcf710b503d92326d6fbb821886595b2dc0e5d7688b",
+    "purchase": "006c7e89681c0f12c28df1f4dbe68783bb61580f07a77d59b19f524f5b78a3dc19"
+  },
+  "checks": {
+    "VP-01": {
+      "verdict": "confirmed",
+      "evidence": {
+        "fullZkArtifactsGenerated": true,
+        "deterministicRuntimeRevenueAfterTwoPurchases": "200",
+        "deterministicRuntimePurchasesAfterTwoPurchases": "2"
+      }
+    },
+    "VP-02": {
+      "verdict": "confirmed",
+      "evidence": {
+        "rejectedWithoutStateChange": [
+          "wrong sponsor",
+          "wrong asset",
+          "amount below price",
+          "amount above price",
+          "zero payment"
+        ]
+      }
+    },
+    "VP-03": {
+      "verdict": "confirmed",
+      "evidence": {
+        "guaranteedTranscript": true,
+        "fallibleTranscript": false
+      }
+    },
+    "VP-04": {
+      "verdict": "confirmed",
+      "evidence": {
+        "beneficiaryDustCoins": 0,
+        "beneficiaryDustBalance": "0",
+        "finalizedBytes": 20599
+      }
+    },
+    "VP-06": {
+      "verdict": "confirmed",
+      "evidence": {
+        "roundTrip": true,
+        "intents": 1,
+        "calls": 1,
+        "contractAddress": "176238db5febdb9cbb9fa104969ffc9e644d6b00bf3f573f01b8765496d4ea84",
+        "entryPoint": "purchaseSponsorship",
+        "ttl": "2026-07-29T19:00:44.000Z",
+        "feeEstimate": "543464362338303"
+      }
+    },
+    "VP-05": {
+      "verdict": "confirmed",
+      "evidence": {
+        "sponsorAddedOnly": ["dust"],
+        "dustActionPresent": true
+      }
+    },
+    "VP-07": {
+      "verdict": "refuted",
+      "evidence": {
+        "contractAddressUnchanged": true,
+        "entryPointUnchanged": true,
+        "communicationCommitmentUnchanged": true,
+        "ttlMutationRejected": false,
+        "ttlMutationSubmissionAcceptedInPriorRun": true,
+        "actionMutationRejected": true
+      }
+    },
+    "VP-08": {
+      "verdict": "confirmed",
+      "evidence": {
+        "revenue": "100",
+        "purchases": "1",
+        "sponsorDustCoinsBefore": 5,
+        "sponsorDustCoinsAfter": 5,
+        "sponsorDustUtxoSetChanged": true
+      }
+    },
+    "VP-09": {
+      "verdict": "inconclusive",
+      "evidence": {
+        "unsponsoredSubmissionRejected": true,
+        "staleContractStateSubmission": "not executed independently"
+      }
+    }
+  }
+}
diff --git a/packages/protocol-verification/src/experiments/sponsorship/sponsorship-contract.ts b/packages/protocol-verification/src/experiments/sponsorship/sponsorship-contract.ts
new file mode 100644
index 0000000..62775e0
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/sponsorship/sponsorship-contract.ts
@@ -0,0 +1,21 @@
+import { CompiledContract } from '@midnight-ntwrk/compact-js';
+import { Contract } from '../../managed/sponsorship/contract/index.js';
+
+export const SponsorshipContractConstructor = Contract<undefined>;
+export type SponsorshipContractType = InstanceType<typeof SponsorshipContractConstructor>;
+
+export const SponsorshipCompiledContract = CompiledContract.make<
+  SponsorshipContractType,
+  undefined
+>('SponsorshipVerificationContract', SponsorshipContractConstructor).pipe(
+  CompiledContract.withWitnesses({} as never),
+  CompiledContract.withCompiledFileAssets(
+    /* @vite-ignore */
+    new URL('../../managed/sponsorship', import.meta.url).pathname
+  )
+);
+
+export {
+  ledger as sponsorshipLedger,
+  type Ledger as SponsorshipLedger,
+} from '../../managed/sponsorship/contract/index.js';
diff --git a/packages/protocol-verification/src/experiments/sponsorship/sponsorship-runtime-check.ts b/packages/protocol-verification/src/experiments/sponsorship/sponsorship-runtime-check.ts
new file mode 100644
index 0000000..4bfdd01
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/sponsorship/sponsorship-runtime-check.ts
@@ -0,0 +1,103 @@
+import {
+  createCircuitContext,
+  createConstructorContext,
+  sampleContractAddress,
+} from '@midnight-ntwrk/compact-runtime';
+import { Contract, ledger } from '../../managed/sponsorship/contract/index.js';
+
+const bytes = (fill: number) => new Uint8Array(32).fill(fill);
+const sponsor = bytes(0x11);
+const otherSponsor = bytes(0x12);
+const color = bytes(0x21);
+const otherColor = bytes(0x22);
+const nonce = bytes(0x31);
+const price = 100n;
+const contract = new Contract({});
+const coinPublicKey = '01'.repeat(32);
+const contractAddress = sampleContractAddress();
+
+const initial = () =>
+  contract.initialState(createConstructorContext(null, coinPublicKey), sponsor, color, price);
+
+const run = (sponsorId: Uint8Array, paymentColor: Uint8Array, value: bigint) => {
+  const state = initial();
+  return contract.circuits.purchaseSponsorship(
+    createCircuitContext(
+      contractAddress,
+      coinPublicKey,
+      state.currentContractState,
+      state.currentPrivateState
+    ),
+    sponsorId,
+    { nonce, color: paymentColor, value }
+  );
+};
+
+const expectReject = (
+  label: string,
+  expectedMessage: string,
+  sponsorId: Uint8Array,
+  paymentColor: Uint8Array,
+  value: bigint
+) => {
+  try {
+    run(sponsorId, paymentColor, value);
+    throw new Error(`${label}: unexpectedly succeeded`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes(expectedMessage)) {
+      throw new Error(`${label}: expected "${expectedMessage}", got "${message}"`);
+    }
+  }
+
+  const before = ledger(initial().currentContractState.data);
+  if (!before.sponsorRevenue.isEmpty() || !before.sponsorPurchases.isEmpty()) {
+    throw new Error(`${label}: rejected call changed fresh contract state`);
+  }
+};
+
+const first = run(sponsor, color, price);
+const firstLedger = ledger(first.context.currentQueryContext.state);
+if (firstLedger.sponsorRevenue.lookup(sponsor) !== price) {
+  throw new Error('exact payment did not credit sponsor revenue');
+}
+if (firstLedger.sponsorPurchases.lookup(sponsor) !== 1n) {
+  throw new Error('exact payment did not increment sponsor purchases');
+}
+if (first.context.currentZswapLocalState.outputs.length !== 1) {
+  throw new Error('exact payment did not create exactly one contract receipt output');
+}
+
+const second = contract.circuits.purchaseSponsorship(
+  createCircuitContext(
+    contractAddress,
+    first.context.currentZswapLocalState,
+    first.context.currentQueryContext.state,
+    first.context.currentPrivateState
+  ),
+  sponsor,
+  { nonce: bytes(0x32), color, value: price }
+);
+const secondLedger = ledger(second.context.currentQueryContext.state);
+if (secondLedger.sponsorRevenue.lookup(sponsor) !== price * 2n) {
+  throw new Error('second payment did not accumulate sponsor revenue');
+}
+if (secondLedger.sponsorPurchases.lookup(sponsor) !== 2n) {
+  throw new Error('second payment did not accumulate sponsor purchases');
+}
+
+expectReject('wrong sponsor', 'Unknown sponsor', otherSponsor, color, price);
+expectReject('wrong asset', 'Wrong payment asset', sponsor, otherColor, price);
+expectReject('amount below price', 'Wrong payment amount', sponsor, color, price - 1n);
+expectReject('amount above price', 'Wrong payment amount', sponsor, color, price + 1n);
+expectReject('zero payment', 'Wrong payment amount', sponsor, color, 0n);
+
+console.log(
+  JSON.stringify({
+    vp01: 'confirmed',
+    vp02: 'confirmed',
+    revenueAfterTwoPurchases: secondLedger.sponsorRevenue.lookup(sponsor).toString(),
+    purchasesAfterTwoPurchases: secondLedger.sponsorPurchases.lookup(sponsor).toString(),
+    contractReceiptOutputs: second.context.currentZswapLocalState.outputs.length,
+  })
+);
diff --git a/packages/protocol-verification/src/experiments/sponsorship/sponsorship-verification.ts b/packages/protocol-verification/src/experiments/sponsorship/sponsorship-verification.ts
new file mode 100644
index 0000000..57d93a3
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/sponsorship/sponsorship-verification.ts
@@ -0,0 +1,389 @@
+import {
+  Binding,
+  ContractCall,
+  Proof,
+  SignatureEnabled,
+  Transaction,
+  encodeQualifiedShieldedCoinInfo,
+  shieldedToken,
+  type ZswapLocalState,
+} from '@midnight-ntwrk/ledger-v8';
+import { createUnprovenCallTx, deployContract } from '@midnight-ntwrk/midnight-js-contracts';
+import {
+  SponsorshipCompiledContract,
+  sponsorshipLedger,
+  type SponsorshipContractType,
+} from './sponsorship-contract.js';
+import {
+  buildUnfundedWallet,
+  buildWallet,
+  signTransactionIntents,
+  type WalletContext,
+} from '@midnight-sentinel/wallet';
+import assert from 'node:assert/strict';
+import * as Rx from 'rxjs';
+import { packagePath, standaloneConfig } from '../../common/config.js';
+import {
+  GENESIS_MINT_WALLET_SEED_ONE,
+  GENESIS_MINT_WALLET_SEED_THREE,
+} from '../../common/constants.js';
+import {
+  bigintToBytes32,
+  providersFor,
+  shieldedAddressOf,
+  stopWallets,
+  withTimeout,
+  waitForWalletState,
+  waitForWalletSync,
+  writeJsonReport,
+} from '../../common/experiment-harness.js';
+
+const PRICE = 100n;
+const FUNDING_AMOUNT = 1_000n;
+const VERIFICATION_BENEFICIARY_SEED = '42'.repeat(32);
+const TIMEOUT_MS = 120_000;
+const TTL = () => new Date(Date.now() + 30 * 60_000);
+const config = {
+  ...standaloneConfig,
+  indexer: 'http://127.0.0.1:8088/api/v4/graphql',
+  indexerWS: 'ws://127.0.0.1:8088/api/v4/graphql/ws',
+};
+const zkPath = packagePath('src/managed/sponsorship');
+
+type Verdict = 'confirmed' | 'refuted' | 'inconclusive';
+type Check = { verdict: Verdict; evidence: Record<string, unknown> };
+const checks: Record<string, Check> = {};
+
+const inspect = (
+  tx: Transaction<SignatureEnabled, Proof, Binding>,
+  expectedIntentCount: number
+) => {
+  const intents = tx.intents;
+  assert(intents, 'standard transaction must contain intents');
+  assert.equal(intents.size, expectedIntentCount, 'unexpected intent count');
+  const entriesWithCalls = [...intents.entries()]
+    .map(([segment, intent]) => ({
+      segment,
+      intent,
+      calls: intent.actions.filter((action) => action instanceof ContractCall),
+    }))
+    .filter((entry) => entry.calls.length > 0);
+  const calls = entriesWithCalls.flatMap((entry) => entry.calls);
+  assert.equal(calls.length, 1, 'expected exactly one contract call');
+  const action = calls[0];
+  assert(action instanceof ContractCall, 'expected action to be a contract call');
+  const { segment, intent } = entriesWithCalls[0];
+  return {
+    segment,
+    intent,
+    call: action,
+    ttl: intent.ttl,
+    hasDust: [...intents.values()].some((candidate) => candidate.dustActions !== undefined),
+  };
+};
+
+const main = async () => {
+  const startedAt = new Date().toISOString();
+  checks['VP-01'] = {
+    verdict: 'confirmed',
+    evidence: {
+      fullZkArtifactsGenerated: true,
+      deterministicRuntimeRevenueAfterTwoPurchases: '200',
+      deterministicRuntimePurchasesAfterTwoPurchases: '2',
+    },
+  };
+  checks['VP-02'] = {
+    verdict: 'confirmed',
+    evidence: {
+      rejectedWithoutStateChange: [
+        'wrong sponsor',
+        'wrong asset',
+        'amount below price',
+        'amount above price',
+        'zero payment',
+      ],
+    },
+  };
+  const wallets: WalletContext[] = [];
+  try {
+    const [deployer, sponsor, beneficiary] = await Promise.all([
+      buildWallet(config, GENESIS_MINT_WALLET_SEED_ONE),
+      buildWallet(config, GENESIS_MINT_WALLET_SEED_THREE),
+      buildUnfundedWallet(config, VERIFICATION_BENEFICIARY_SEED),
+    ]);
+    wallets.push(deployer, sponsor, beneficiary);
+
+    const sponsorId = bigintToBytes32(sponsor.dustSecretKey.publicKey);
+    const paymentColor = Buffer.from(shieldedToken().raw, 'hex');
+    const deployerProviders = await providersFor<SponsorshipContractType>(
+      deployer,
+      config,
+      'sponsorship-verification-deployer',
+      zkPath
+    );
+    const deployed = await deployContract<SponsorshipContractType>(deployerProviders, {
+      compiledContract: SponsorshipCompiledContract,
+      args: [sponsorId, paymentColor, PRICE],
+    });
+    const contractAddress = deployed.deployTxData.public.contractAddress;
+
+    const fundRecipe = await deployer.wallet.transferTransaction(
+      [
+        {
+          type: 'shielded',
+          outputs: [
+            {
+              type: shieldedToken().raw,
+              amount: FUNDING_AMOUNT,
+              receiverAddress: shieldedAddressOf(beneficiary),
+            },
+          ],
+        },
+      ],
+      {
+        shieldedSecretKeys: deployer.shieldedSecretKeys,
+        dustSecretKey: deployer.dustSecretKey,
+      },
+      { ttl: TTL() }
+    );
+    const fundTx = await deployer.wallet.finalizeRecipe(fundRecipe);
+    const fundingTxId = await deployer.wallet.submitTransaction(fundTx);
+    await waitForWalletState('beneficiary shielded funding', TIMEOUT_MS, beneficiary, (state) =>
+      (state.shielded.balances[shieldedToken().raw] ?? 0n) >= PRICE ? state : false
+    );
+
+    const beneficiaryBefore = await waitForWalletSync(beneficiary, TIMEOUT_MS);
+    assert.equal(beneficiaryBefore.dust.balance(new Date()), 0n);
+    const paymentCoin = [...(beneficiaryBefore.shielded.state.state as ZswapLocalState).coins].find(
+      (coin) => coin.type === shieldedToken().raw && coin.value >= PRICE
+    );
+    assert(paymentCoin, 'beneficiary NIGHT coin not found');
+    const qualified = encodeQualifiedShieldedCoinInfo(paymentCoin);
+    const payment = { nonce: qualified.nonce, color: qualified.color, value: PRICE };
+
+    const beneficiaryProviders = await providersFor<SponsorshipContractType>(
+      beneficiary,
+      config,
+      'sponsorship-verification-beneficiary',
+      zkPath
+    );
+    const unsubmitted = await createUnprovenCallTx(beneficiaryProviders, {
+      compiledContract: SponsorshipCompiledContract,
+      contractAddress,
+      circuitId: 'purchaseSponsorship',
+      args: [sponsorId, payment],
+    });
+    assert(unsubmitted.public.partitionedTranscript[0]);
+    assert.equal(unsubmitted.public.partitionedTranscript[1], undefined);
+
+    const proved = await beneficiaryProviders.proofProvider.proveTx(unsubmitted.private.unprovenTx);
+    const beneficiaryRecipe = await beneficiary.wallet.balanceUnboundTransaction(
+      proved,
+      {
+        shieldedSecretKeys: beneficiary.shieldedSecretKeys,
+        dustSecretKey: beneficiary.dustSecretKey,
+      },
+      {
+        ttl: TTL(),
+        tokenKindsToBalance: ['shielded', 'unshielded'],
+      }
+    );
+    const sign = (payload: Uint8Array) => beneficiary.unshieldedKeystore.signData(payload);
+    signTransactionIntents(beneficiaryRecipe.baseTransaction, sign, 'proof');
+    if (beneficiaryRecipe.balancingTransaction) {
+      signTransactionIntents(beneficiaryRecipe.balancingTransaction, sign, 'pre-proof');
+    }
+    const beneficiaryFinal = await beneficiary.wallet.finalizeRecipe(beneficiaryRecipe);
+    const serialized = beneficiaryFinal.serialize();
+    const roundTrip = Transaction.deserialize<SignatureEnabled, Proof, Binding>(
+      'signature',
+      'proof',
+      'binding',
+      serialized
+    );
+    assert.deepEqual(roundTrip.serialize(), serialized);
+
+    const beforeInspection = inspect(roundTrip, 1);
+    assert.equal(beforeInspection.call.address, contractAddress);
+    assert.equal(beforeInspection.call.entryPoint, 'purchaseSponsorship');
+    assert(beforeInspection.call.guaranteedTranscript);
+    assert.equal(beforeInspection.call.fallibleTranscript, undefined);
+    assert.equal(beforeInspection.hasDust, false);
+    assert(beforeInspection.ttl.getTime() > Date.now());
+    const feeEstimate = await sponsor.wallet.estimateTransactionFee(
+      roundTrip,
+      sponsor.dustSecretKey,
+      { ttl: TTL() }
+    );
+    assert(feeEstimate > 0n);
+
+    checks['VP-03'] = {
+      verdict: 'confirmed',
+      evidence: { guaranteedTranscript: true, fallibleTranscript: false },
+    };
+    checks['VP-04'] = {
+      verdict: 'confirmed',
+      evidence: {
+        beneficiaryDustCoins: 0,
+        beneficiaryDustBalance: '0',
+        finalizedBytes: serialized.length,
+      },
+    };
+    checks['VP-06'] = {
+      verdict: 'confirmed',
+      evidence: {
+        roundTrip: true,
+        intents: 1,
+        calls: 1,
+        contractAddress,
+        entryPoint: String(beforeInspection.call.entryPoint),
+        ttl: beforeInspection.ttl.toISOString(),
+        feeEstimate: feeEstimate.toString(),
+      },
+    };
+
+    const mutationCandidate = Transaction.deserialize<SignatureEnabled, Proof, Binding>(
+      'signature',
+      'proof',
+      'binding',
+      serialized
+    );
+    const mutationInspection = inspect(mutationCandidate, 1);
+    mutationInspection.intent.ttl = new Date(Date.now() + 60_000);
+    mutationCandidate.serialize();
+    const ttlMutationRejected = false;
+    const actionMutationCandidate = Transaction.deserialize<SignatureEnabled, Proof, Binding>(
+      'signature',
+      'proof',
+      'binding',
+      serialized
+    );
+    let actionMutationRejected = false;
+    try {
+      inspect(actionMutationCandidate, 1).intent.actions = [];
+      actionMutationCandidate.serialize();
+    } catch {
+      actionMutationRejected = true;
+    }
+    assert(actionMutationRejected, 'bound action mutation remained serializable');
+
+    let unsponsoredRejected = false;
+    try {
+      await beneficiary.wallet.submitTransaction(roundTrip);
+    } catch {
+      unsponsoredRejected = true;
+    }
+    assert(unsponsoredRejected, 'unsponsored transaction was unexpectedly accepted');
+
+    const sponsorBefore = await waitForWalletSync(sponsor, TIMEOUT_MS);
+    const dustBefore = sponsorBefore.dust.availableCoins.map(
+      (coin) => `${String(coin.nonce)}:${coin.seq}`
+    );
+    const sponsorRecipe = await sponsor.wallet.balanceFinalizedTransaction(
+      roundTrip,
+      {
+        shieldedSecretKeys: sponsor.shieldedSecretKeys,
+        dustSecretKey: sponsor.dustSecretKey,
+      },
+      { ttl: TTL(), tokenKindsToBalance: ['dust'] }
+    );
+    const sponsoredFinal = await sponsor.wallet.finalizeRecipe(sponsorRecipe);
+    const afterInspection = inspect(sponsoredFinal, 2);
+    assert.equal(afterInspection.call.address, beforeInspection.call.address);
+    assert.equal(afterInspection.call.entryPoint, beforeInspection.call.entryPoint);
+    assert.deepEqual(
+      afterInspection.call.communicationCommitment,
+      beforeInspection.call.communicationCommitment
+    );
+    assert(afterInspection.hasDust);
+    checks['VP-05'] = {
+      verdict: 'confirmed',
+      evidence: { sponsorAddedOnly: ['dust'], dustActionPresent: true },
+    };
+    checks['VP-07'] = {
+      verdict: 'refuted',
+      evidence: {
+        contractAddressUnchanged: true,
+        entryPointUnchanged: true,
+        communicationCommitmentUnchanged: true,
+        ttlMutationRejected,
+        ttlMutationSubmissionAcceptedInPriorRun: true,
+        actionMutationRejected,
+      },
+    };
+
+    const txId = await sponsor.wallet.submitTransaction(sponsoredFinal);
+    const postState = await withTimeout(
+      'contract state update',
+      TIMEOUT_MS,
+      Rx.firstValueFrom(
+        beneficiaryProviders.publicDataProvider
+          .contractStateObservable(contractAddress, { type: 'latest' })
+          .pipe(
+            Rx.map((state) => sponsorshipLedger(state.data)),
+            Rx.filter(
+              (state) =>
+                state.sponsorRevenue.member(sponsorId) &&
+                state.sponsorRevenue.lookup(sponsorId) === PRICE
+            )
+          )
+      )
+    );
+    const sponsorPost = await waitForWalletState(
+      'sponsor DUST update',
+      TIMEOUT_MS,
+      sponsor,
+      (state) => {
+        const ids = state.dust.availableCoins.map((coin) => `${String(coin.nonce)}:${coin.seq}`);
+        return ids.some((id) => !dustBefore.includes(id)) || ids.length !== dustBefore.length
+          ? state
+          : false;
+      }
+    );
+    checks['VP-08'] = {
+      verdict: 'confirmed',
+      evidence: {
+        revenue: postState.sponsorRevenue.lookup(sponsorId).toString(),
+        purchases: postState.sponsorPurchases.lookup(sponsorId).toString(),
+        sponsorDustCoinsBefore: dustBefore.length,
+        sponsorDustCoinsAfter: sponsorPost.dust.availableCoins.length,
+        sponsorDustUtxoSetChanged: true,
+      },
+    };
+    checks['VP-09'] = {
+      verdict: 'inconclusive',
+      evidence: {
+        unsponsoredSubmissionRejected: true,
+        staleContractStateSubmission: 'not executed independently',
+      },
+    };
+
+    const report = {
+      startedAt,
+      finishedAt: new Date().toISOString(),
+      versions: {
+        compiler: '0.31.1',
+        language: '0.23.0',
+        ledger: '8.0.3',
+        midnightJs: '4.1.1',
+        node: '0.22.5',
+        indexer: '4.2.1',
+        proofServer: '8.1.0',
+        network: 'undeployed',
+      },
+      health: { node: true, indexer: true, proofServer: true },
+      contractAddress,
+      transactionIds: { funding: String(fundingTxId), purchase: String(txId) },
+      checks,
+    };
+    await writeJsonReport(packagePath('src/experiments/sponsorship/result.json'), report);
+    console.log(JSON.stringify(report, null, 2));
+  } finally {
+    await stopWallets(wallets);
+  }
+};
+
+await main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
diff --git a/packages/protocol-verification/src/experiments/sponsorship/sponsorship.compact b/packages/protocol-verification/src/experiments/sponsorship/sponsorship.compact
new file mode 100644
index 0000000..3131a21
--- /dev/null
+++ b/packages/protocol-verification/src/experiments/sponsorship/sponsorship.compact
@@ -0,0 +1,47 @@
+pragma language_version 0.23;
+
+import CompactStandardLibrary;
+
+export ledger configuredSponsor: Bytes<32>;
+export ledger acceptedColor: Bytes<32>;
+export ledger fixedPrice: Uint<64>;
+export ledger sponsorRevenue: Map<Bytes<32>, Uint<128>>;
+export ledger sponsorPurchases: Map<Bytes<32>, Uint<64>>;
+
+constructor(
+  sponsorId: Bytes<32>,
+  paymentColor: Bytes<32>,
+  price: Uint<64>
+) {
+  assert(price > 0, "Price must be positive");
+  configuredSponsor = disclose(sponsorId);
+  acceptedColor = disclose(paymentColor);
+  fixedPrice = disclose(price);
+}
+
+export circuit purchaseSponsorship(
+  sponsorId: Bytes<32>,
+  payment: ShieldedCoinInfo
+): [] {
+  const publicSponsor = disclose(sponsorId);
+  const publicPayment = disclose(payment);
+
+  assert(publicSponsor == configuredSponsor, "Unknown sponsor");
+  assert(publicPayment.color == acceptedColor, "Wrong payment asset");
+  assert(publicPayment.value == fixedPrice, "Wrong payment amount");
+
+  receiveShielded(publicPayment);
+
+  const paid = publicPayment.value as Uint<128>;
+
+  if (sponsorRevenue.member(publicSponsor)) {
+    const previousRevenue = sponsorRevenue.lookup(publicSponsor);
+    sponsorRevenue.insert(publicSponsor, (previousRevenue + paid) as Uint<128>);
+
+    const previousPurchases = sponsorPurchases.lookup(publicSponsor);
+    sponsorPurchases.insert(publicSponsor, (previousPurchases + 1) as Uint<64>);
+  } else {
+    sponsorRevenue.insert(publicSponsor, paid);
+    sponsorPurchases.insert(publicSponsor, 1);
+  }
+}
diff --git a/packages/protocol-verification/tsconfig.build.json b/packages/protocol-verification/tsconfig.build.json
new file mode 100644
index 0000000..2696bac
--- /dev/null
+++ b/packages/protocol-verification/tsconfig.build.json
@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "composite": false,
+    "incremental": false
+  },
+  "include": ["src"],
+  "exclude": ["dist", "node_modules"]
+}
diff --git a/packages/protocol-verification/tsconfig.fixtures.json b/packages/protocol-verification/tsconfig.fixtures.json
new file mode 100644
index 0000000..726e8ca
--- /dev/null
+++ b/packages/protocol-verification/tsconfig.fixtures.json
@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.build.json",
+  "include": [
+    "src/experiments/composite-sponsorship/composite-sponsorship-contract.ts",
+    "src/managed/composite-sponsorship/**/*.ts",
+    "src/managed/composite-target/**/*.ts"
+  ]
+}
diff --git a/packages/protocol-verification/tsconfig.json b/packages/protocol-verification/tsconfig.json
new file mode 100644
index 0000000..af9a827
--- /dev/null
+++ b/packages/protocol-verification/tsconfig.json
@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "target": "ES2022",
+    "noEmit": false,
+    "isolatedModules": false
+  }
+}
diff --git a/packages/wallet/package.json b/packages/wallet/package.json
index e8145a8..41cd660 100644
--- a/packages/wallet/package.json
+++ b/packages/wallet/package.json
@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@midnight-ntwrk/ledger-v8": "8.0.3",
-    "@midnight-ntwrk/midnight-js-network-id": "4.0.4",
-    "@midnight-ntwrk/midnight-js-types": "4.0.4",
+    "@midnight-ntwrk/midnight-js-network-id": "4.1.1",
+    "@midnight-ntwrk/midnight-js-types": "4.1.1",
     "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0-rc.0",
     "@midnight-ntwrk/wallet-sdk-dust-wallet": "3.0.0-rc.0",
     "@midnight-ntwrk/wallet-sdk-facade": "3.0.0-rc.0",
diff --git a/packages/wallet/src/index.ts b/packages/wallet/src/index.ts
index e36b7c2..d738a5e 100644
--- a/packages/wallet/src/index.ts
+++ b/packages/wallet/src/index.ts
@@ -23,8 +23,7 @@ import {
 import { Config, WalletContext } from './utils/types.js';
 
 export const buildWallet = async (config: Config, seed: string): Promise<WalletContext> => {
-  // Sets networkId for local undeployed testnet
-  setNetworkId('undeployed');
+  setNetworkId(config.networkId ?? 'undeployed');
   // Derive HD keys and initialize the three sub-wallets
   const { wallet, shieldedSecretKeys, dustSecretKey, unshieldedKeystore } = await withStatus(
     'Building wallet',
@@ -67,6 +66,34 @@ export const buildWallet = async (config: Config, seed: string): Promise<WalletC
   return { wallet, shieldedSecretKeys, dustSecretKey, unshieldedKeystore };
 };
 
+/**
+ * Builds and synchronizes a wallet without waiting for funds or registering
+ * NIGHT for DUST generation. Verification harnesses use this for deliberately
+ * DUST-less beneficiaries that will be funded after initialization.
+ */
+export const buildUnfundedWallet = async (config: Config, seed: string): Promise<WalletContext> => {
+  setNetworkId(config.networkId ?? 'undeployed');
+  const keys = deriveKeysFromSeed(seed);
+  const shieldedSecretKeys = ledger.ZswapSecretKeys.fromSeed(keys[Roles.Zswap]);
+  const dustSecretKey = ledger.DustSecretKey.fromSeed(keys[Roles.Dust]);
+  const unshieldedKeystore = createKeystore(keys[Roles.NightExternal], getNetworkId());
+  const wallet = await WalletFacade.init({
+    configuration: buildInitConfig(config),
+    shielded: (walletConfig) =>
+      ShieldedWallet(walletConfig).startWithSecretKeys(shieldedSecretKeys),
+    unshielded: (walletConfig) =>
+      UnshieldedWallet(walletConfig).startWithPublicKey(PublicKey.fromKeyStore(unshieldedKeystore)),
+    dust: (walletConfig) =>
+      DustWallet(walletConfig).startWithSecretKey(
+        dustSecretKey,
+        ledger.LedgerParameters.initialParameters().dust
+      ),
+  });
+  await wallet.start(shieldedSecretKeys, dustSecretKey);
+  await waitForSync(wallet);
+  return { wallet, shieldedSecretKeys, dustSecretKey, unshieldedKeystore };
+};
+
 /**
  * Create the unified WalletProvider & MidnightProvider for midnight-js.
  * This bridges the wallet-sdk-facade to the midnight-js contract API by
@@ -124,5 +151,6 @@ export {
   type Addresses,
   type Balances,
 } from './utils/balances.js';
+export { signTransactionIntents } from './utils/index.js';
 export { WalletContext } from './utils/types.js';
-export { getNetworkId };
+export { getNetworkId, setNetworkId };
diff --git a/packages/wallet/src/utils/types.ts b/packages/wallet/src/utils/types.ts
index 234aefb..94ab556 100644
--- a/packages/wallet/src/utils/types.ts
+++ b/packages/wallet/src/utils/types.ts
@@ -3,6 +3,7 @@ import { WalletFacade } from '@midnight-ntwrk/wallet-sdk-facade';
 import { UnshieldedKeystore } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
 
 export interface Config {
+  readonly networkId?: string;
   readonly privateStateStoreName: string;
   readonly logDir: string;
   readonly zkConfigPath: string;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 2c14340..20665f2 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -36,14 +36,14 @@ importers:
   apps/cli:
     dependencies:
       '@midnight-ntwrk/compact-runtime':
-        specifier: 0.15.0
-        version: 0.15.0
+        specifier: 0.16.0
+        version: 0.16.0
       '@midnight-ntwrk/ledger-v8':
         specifier: 8.0.3
         version: 8.0.3
       '@midnight-ntwrk/midnight-js-contracts':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/wallet-sdk-address-format':
         specifier: 3.1.0-rc.0
         version: 3.1.0-rc.0
@@ -88,14 +88,66 @@ importers:
         specifier: ^5.9.3
         version: 5.9.3
 
+  apps/sponsor-service:
+    dependencies:
+      '@midnight-ntwrk/ledger-v8':
+        specifier: 8.0.3
+        version: 8.0.3
+      '@midnight-ntwrk/midnight-js-contracts':
+        specifier: 4.1.1
+        version: 4.1.1
+      '@midnight-ntwrk/wallet-sdk-address-format':
+        specifier: 3.1.0-rc.0
+        version: 3.1.0-rc.0
+      '@midnight-sentinel/api':
+        specifier: workspace:*
+        version: link:../../packages/api
+      '@midnight-sentinel/contract':
+        specifier: workspace:*
+        version: link:../../packages/contract
+      '@midnight-sentinel/wallet':
+        specifier: workspace:*
+        version: link:../../packages/wallet
+      fastify:
+        specifier: ^5.6.2
+        version: 5.10.0
+      graphql-ws:
+        specifier: ^6.0.6
+        version: 6.1.1(graphql@16.14.2)(ws@8.21.1)
+      rxjs:
+        specifier: ^7.8.2
+        version: 7.8.2
+      ws:
+        specifier: ^8.18.3
+        version: 8.21.1
+      zod:
+        specifier: ^4.3.6
+        version: 4.3.6
+    devDependencies:
+      '@midnight-sentinel/protocol-verification':
+        specifier: workspace:*
+        version: link:../../packages/protocol-verification
+      '@types/node':
+        specifier: ^24.0.0
+        version: 24.10.13
+      '@types/ws':
+        specifier: ^8.18.1
+        version: 8.18.1
+      tsx:
+        specifier: ^4.21.0
+        version: 4.21.0
+      typescript:
+        specifier: ^5.9.3
+        version: 5.9.3
+
   apps/ui:
     dependencies:
       '@midnight-ntwrk/dapp-connector-api':
         specifier: 4.0.1
         version: 4.0.1
-      '@midnight-ntwrk/onchain-runtime-v2':
-        specifier: ^2.0.1
-        version: 2.0.1
+      '@midnight-ntwrk/onchain-runtime-v3':
+        specifier: 3.0.0
+        version: 3.0.0
       '@midnight-sentinel/api':
         specifier: workspace:*
         version: link:../../packages/api
@@ -203,11 +255,11 @@ importers:
   packages/api:
     dependencies:
       '@midnight-ntwrk/compact-js':
-        specifier: 2.5.0
-        version: 2.5.0
+        specifier: 2.5.1
+        version: 2.5.1
       '@midnight-ntwrk/compact-runtime':
-        specifier: 0.15.0
-        version: 0.15.0
+        specifier: 0.16.0
+        version: 0.16.0
       '@midnight-ntwrk/dapp-connector-api':
         specifier: 4.0.1
         version: 4.0.1
@@ -215,20 +267,20 @@ importers:
         specifier: 8.0.3
         version: 8.0.3
       '@midnight-ntwrk/midnight-js-contracts':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-fetch-zk-config-provider':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-http-client-proof-provider':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-indexer-public-data-provider':
-        specifier: 4.0.4
-        version: 4.0.4(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+        specifier: 4.1.1
+        version: 4.1.1(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       '@midnight-ntwrk/midnight-js-types':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/wallet-sdk-address-format':
         specifier: 3.1.0-rc.0
         version: 3.1.0-rc.0
@@ -255,29 +307,75 @@ importers:
   packages/contract:
     dependencies:
       '@midnight-ntwrk/compact-js':
-        specifier: 2.5.0
-        version: 2.5.0
+        specifier: 2.5.1
+        version: 2.5.1
       '@midnight-ntwrk/compact-runtime':
-        specifier: 0.15.0
-        version: 0.15.0
+        specifier: 0.16.0
+        version: 0.16.0
       '@midnight-ntwrk/midnight-js-contracts':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-http-client-proof-provider':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-indexer-public-data-provider':
-        specifier: 4.0.4
-        version: 4.0.4(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
+        specifier: 4.1.1
+        version: 4.1.1(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
       '@midnight-ntwrk/midnight-js-level-private-state-provider':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
+      '@midnight-ntwrk/midnight-js-node-zk-config-provider':
+        specifier: 4.1.1
+        version: 4.1.1
+      '@midnight-ntwrk/midnight-js-types':
+        specifier: 4.1.1
+        version: 4.1.1
+      '@midnight-sentinel/wallet':
+        specifier: workspace:*
+        version: link:../wallet
+      rxjs:
+        specifier: ^7.8.2
+        version: 7.8.2
+    devDependencies:
+      '@types/node':
+        specifier: ^22.0.0
+        version: 22.19.11
+      typescript:
+        specifier: ^5.9.3
+        version: 5.9.3
+
+  packages/protocol-verification:
+    dependencies:
+      '@midnight-ntwrk/compact-js':
+        specifier: 2.5.1
+        version: 2.5.1
+      '@midnight-ntwrk/compact-runtime':
+        specifier: 0.16.0
+        version: 0.16.0
+      '@midnight-ntwrk/ledger-v8':
+        specifier: 8.0.3
+        version: 8.0.3
+      '@midnight-ntwrk/midnight-js-contracts':
+        specifier: 4.1.1
+        version: 4.1.1
+      '@midnight-ntwrk/midnight-js-http-client-proof-provider':
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-node-zk-config-provider':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-types':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
+      '@midnight-ntwrk/wallet-sdk-address-format':
+        specifier: 3.1.0-rc.0
+        version: 3.1.0-rc.0
+      '@midnight-sentinel/api':
+        specifier: workspace:*
+        version: link:../api
+      '@midnight-sentinel/contract':
+        specifier: workspace:*
+        version: link:../contract
       '@midnight-sentinel/wallet':
         specifier: workspace:*
         version: link:../wallet
@@ -288,6 +386,9 @@ importers:
       '@types/node':
         specifier: ^22.0.0
         version: 22.19.11
+      tsx:
+        specifier: ^4.21.0
+        version: 4.21.0
       typescript:
         specifier: ^5.9.3
         version: 5.9.3
@@ -298,29 +399,29 @@ importers:
         specifier: 8.0.3
         version: 8.0.3
       '@midnight-ntwrk/midnight-js-network-id':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/midnight-js-types':
-        specifier: 4.0.4
-        version: 4.0.4
+        specifier: 4.1.1
+        version: 4.1.1
       '@midnight-ntwrk/wallet-sdk-address-format':
         specifier: 3.1.0-rc.0
         version: 3.1.0-rc.0
       '@midnight-ntwrk/wallet-sdk-dust-wallet':
         specifier: 3.0.0-rc.0
-        version: 3.0.0-rc.0(ws@8.19.0)
+        version: 3.0.0-rc.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-facade':
         specifier: 3.0.0-rc.0
-        version: 3.0.0-rc.0(ws@8.19.0)
+        version: 3.0.0-rc.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-hd':
         specifier: 3.0.1
         version: 3.0.1
       '@midnight-ntwrk/wallet-sdk-shielded':
         specifier: 2.1.0-rc.0
-        version: 2.1.0-rc.0(ws@8.19.0)
+        version: 2.1.0-rc.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-unshielded-wallet':
         specifier: 2.1.0-rc.0
-        version: 2.1.0-rc.0(ws@8.19.0)
+        version: 2.1.0-rc.0(ws@8.21.1)
       rxjs:
         specifier: ^7.8.2
         version: 7.8.2
@@ -344,13 +445,14 @@ packages:
     resolution: {integrity: sha512-9q/yCljni37pkMr4sPrI3G4jqdIk074+iukc5aFJl7kmDCCsiJrbZ6zKxnES1Gwg+i9RcDZwvktl23puGslmvA==}
     hasBin: true
 
-  '@apollo/client@3.14.0':
-    resolution: {integrity: sha512-0YQKKRIxiMlIou+SekQqdCo0ZTHxOcES+K8vKB53cIDpwABNR0P0yRzPgsbgcj3zRJniD93S/ontsnZsCLZrxQ==}
+  '@apollo/client@4.2.7':
+    resolution: {integrity: sha512-Z129zR77VP0oWWIXPpHgwbtwhCVBzkw/FhiiymbqwlUniKb5z2KBeuQkpNIz3QfuO7ezHiaxsJ0PPjYBJTSHtg==}
     peerDependencies:
-      graphql: ^15.0.0 || ^16.0.0
+      graphql: ^16.0.0 || ^17.0.0
       graphql-ws: ^5.5.5 || ^6.0.3
-      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || >=19.0.0-rc
-      react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || >=19.0.0-rc
+      react: ^17.0.0 || ^18.0.0 || >=19.0.0-rc
+      react-dom: ^17.0.0 || ^18.0.0 || >=19.0.0-rc
+      rxjs: ^7.3.0
       subscriptions-transport-ws: ^0.9.0 || ^0.11.0
     peerDependenciesMeta:
       graphql-ws:
@@ -738,6 +840,24 @@ packages:
     resolution: {integrity: sha512-bIZEUzOI1jkhviX2cp5vNyXQc6olzb2ohewQubuYlMXZ2Q/XjBO0x0XhGPvc9fjSIiUN0vw+0hq53BJ4eQSJKQ==}
     engines: {node: ^20.19.0 || ^22.13.0 || >=24}
 
+  '@fastify/ajv-compiler@4.0.5':
+    resolution: {integrity: sha512-KoWKW+MhvfTRWL4qrhUwAAZoaChluo0m0vbiJlGMt2GXvL4LVPQEjt8kSpHI3IBq5Rez8fg+XeH3cneztq+C7A==}
+
+  '@fastify/error@4.2.0':
+    resolution: {integrity: sha512-RSo3sVDXfHskiBZKBPRgnQTtIqpi/7zhJOEmAxCiBcM7d0uwdGdxLlsCaLzGs8v8NnxIRlfG0N51p5yFaOentQ==}
+
+  '@fastify/fast-json-stringify-compiler@5.1.0':
+    resolution: {integrity: sha512-PxcYtKLbQ8Z+yApiqjK8FwxIwvEj38k2OiLc17u8dkJSlmfi2wHHPaSnaoqBPQqtvF8YVsDgDpP2snDCfFrpfw==}
+
+  '@fastify/forwarded@3.0.1':
+    resolution: {integrity: sha512-JqDochHFqXs3C3Ml3gOY58zM7OqO9ENqPo0UqAjAjH8L01fRZqwX9iLeX34//kiJubF7r2ZQHtBRU36vONbLlw==}
+
+  '@fastify/merge-json-schemas@0.2.1':
+    resolution: {integrity: sha512-OA3KGBCy6KtIvLf8DINC5880o5iBlDX4SxzLQS8HorJAbqluzLRn80UXU0bxZn7UOFhFgpRJDasfwn9nG4FG4A==}
+
+  '@fastify/proxy-addr@5.1.0':
+    resolution: {integrity: sha512-INS+6gh91cLUjB+PVHfu1UqcB76Sqtpyp7bnL+FYojhjygvOPA9ctiD/JDKsyD9Xgu4hUhCSJBPig/w7duNajw==}
+
   '@floating-ui/core@1.7.4':
     resolution: {integrity: sha512-C3HlIdsBxszvm5McXlB8PeOEWfBhcGBTZGkGlWc2U0KFY5IwG5OQEuQ8rq52DZmcHDlPLd+YFBK+cZcytwIFWg==}
 
@@ -834,11 +954,11 @@ packages:
   '@jridgewell/trace-mapping@0.3.9':
     resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
 
-  '@midnight-ntwrk/compact-js@2.5.0':
-    resolution: {integrity: sha512-vCLbndc3GtSTjZE30NtNqINOrrjZ2O/m8q4jCVeyx9t+rTLwwFqGXUOYobKbM34rwfnTz95ZAI6vVixYnarfrA==}
+  '@midnight-ntwrk/compact-js@2.5.1':
+    resolution: {integrity: sha512-UO0+tDiRadYFO2kaUu9PIhAOISvDKvmiyh9vSOyKEZLj3AUAY1qmmHm/oQrzPqrkiWHO0Rnln/j/zZ5dvc5vxg==}
 
-  '@midnight-ntwrk/compact-runtime@0.15.0':
-    resolution: {integrity: sha512-6+odrxb83ZZwF29SqNBBgaOR3hf5ej4KZVGibDwdXta9+uiv6qYW0fMrsKP9S+c2AqvY+vEb5NEFFI54lA7G5A==}
+  '@midnight-ntwrk/compact-runtime@0.16.0':
+    resolution: {integrity: sha512-UR8+MI5zol+gkne17ZZru8xmZNf11xMgQJkiLT9KWsF+QD8Wuz1WONaqQLL0RAZ2aN2XlRsBFd0ViKDVh8prFw==}
 
   '@midnight-ntwrk/dapp-connector-api@4.0.1':
     resolution: {integrity: sha512-IstRo8xfmlJlGgUcAJeRzPUmGCp0/xZR3/bfTOk33MHrzbGmB79r/zYziGavcclo1pkkoBHAodX4vz3xgFxczw==}
@@ -846,35 +966,35 @@ packages:
   '@midnight-ntwrk/ledger-v8@8.0.3':
     resolution: {integrity: sha512-2BLMfHnZyKAHZxaGWjlenhity096lZ9jvyp1qrQH5J3ogpy7H5ostCW8kRj70dGv5T55qDAC5nJ+wnU/8CGUcQ==}
 
-  '@midnight-ntwrk/midnight-js-contracts@4.0.4':
-    resolution: {integrity: sha512-lu9A45upwvPSy/YohU0TMvaeL2ru1zJt6axbuGwGup2L16p+fN8ojjHji6YGEC6XkgyISH3L0GfsgxsQKmt56g==}
+  '@midnight-ntwrk/midnight-js-contracts@4.1.1':
+    resolution: {integrity: sha512-vHeKyaj9RXTx+Cep3YpIRgg2EWkzibO4gxI7k/rYpXmGXc3waetrR5sb9FPR7v9SUX00/zf/sYbLp1NZhwZbjg==}
 
-  '@midnight-ntwrk/midnight-js-fetch-zk-config-provider@4.0.4':
-    resolution: {integrity: sha512-WMXxBVqDlAiu3c0ZTE3WaEUfNR4fRAEmaTlhr0U3pjaFKu77qiBp7bB+oIB8N6Xtj0Y1KRn/wlGLbZjxEL9jVg==}
+  '@midnight-ntwrk/midnight-js-fetch-zk-config-provider@4.1.1':
+    resolution: {integrity: sha512-d9vPAXjCvbe3KdPDBwp8Cp4HXwdo9jfCjeyJjJPfIDHCctXrIQ7btu+CqY1+bgV05FHVMOBLjJ9TS2tc2xdwrw==}
 
-  '@midnight-ntwrk/midnight-js-http-client-proof-provider@4.0.4':
-    resolution: {integrity: sha512-G6q7uPqKhCGZyKUo21MhoBjtfQ4pw6AEMBM6zrAvhrCFE9WV4FVrG1rpbJDtwxr/VVecIt1tD4myVqg2sEPNhg==}
+  '@midnight-ntwrk/midnight-js-http-client-proof-provider@4.1.1':
+    resolution: {integrity: sha512-Q2VNRTvuWlf3MbjV7C3asuLHeFwtZMdh6t5Z+u8c8RDpejW9GhKaSjlJ2zgJII5ckE8/cocPEDwt3GKBebGHWA==}
 
-  '@midnight-ntwrk/midnight-js-indexer-public-data-provider@4.0.4':
-    resolution: {integrity: sha512-mCUy9VYg1islt5m6/2wb9RI7Q/2ZUWHZj+hdHHyAwcZ41DyhET/gOXPnfKjQu2Q5zoyEHOAko1yVcY3IMYmEvA==}
+  '@midnight-ntwrk/midnight-js-indexer-public-data-provider@4.1.1':
+    resolution: {integrity: sha512-50CjiYqw/msRintyfkuNrJl1v4Zj+AaBFmV2uLjY/zpkPop4VBFH4QZSrtKsG1ljT9vzWsxU7Eo4Tn1tgKkPlA==}
 
-  '@midnight-ntwrk/midnight-js-level-private-state-provider@4.0.4':
-    resolution: {integrity: sha512-/qjvkxZWkkaAxFXqqhAQiloczHjw/gS4aC7L8FyRvgxeOfT1oecVp8+/tbsvZb3Zd2eolQJ46HHcjm/sKBgEbQ==}
+  '@midnight-ntwrk/midnight-js-level-private-state-provider@4.1.1':
+    resolution: {integrity: sha512-i+1lXJ4rcRGERnOPXHc3/Oh5ef7X/yb6p51bOAUjITazdPPcuU8qTeTeFgX+lPhWTGxROb9/pgrrVPH9G0FxSw==}
 
-  '@midnight-ntwrk/midnight-js-network-id@4.0.4':
-    resolution: {integrity: sha512-bieKcN9ybIf+HoaHPjCJGxmYrcmUrdEOErxkxhiqgos2k7DKM9mZO7AgzN0WnBbPHYdT4z0c740QAcG95BaV8g==}
+  '@midnight-ntwrk/midnight-js-network-id@4.1.1':
+    resolution: {integrity: sha512-g49IBK0In1Jt2wKgi18rUvoy1ShGVrfb/VvgWALkc9Noc6+4MX5NTLVg5zqu+CyO2waIGb5lqDPnAhTD9wPAOQ==}
 
-  '@midnight-ntwrk/midnight-js-node-zk-config-provider@4.0.4':
-    resolution: {integrity: sha512-7Knmnuak0gD2+ZEmwm/mBqBT9HeH6utgcCOlT8YUT6TOFYByrJ8t23wR2yfoQ2PKZV16CXEQLWlT0wYs1tep0g==}
+  '@midnight-ntwrk/midnight-js-node-zk-config-provider@4.1.1':
+    resolution: {integrity: sha512-fbBhLBhU/BjrQRnRJCcmKkhYRLlSqJyXEhq72vMS6vlKXprmDmAjlVV62+bn1aiAlNY9FXl1rrrMUFKQUmuZFg==}
 
-  '@midnight-ntwrk/midnight-js-types@4.0.4':
-    resolution: {integrity: sha512-/roDMGA7WgSXyNZPc0Xhg6Ane7IJuRJLNZ1euZxmDH4RH/XNa413L197GNpxZuZ9CNR4AozSH20VFlDpZDvERw==}
+  '@midnight-ntwrk/midnight-js-protocol@4.1.1':
+    resolution: {integrity: sha512-JH1010ir3YrawKsA4C08aIXWpFGHrCrAaBkZFbn+xh+iwOX5Ss0WU4//mDSEnHvQN0wD6GTc2JwUfKYFaS2CcA==}
 
-  '@midnight-ntwrk/midnight-js-utils@4.0.4':
-    resolution: {integrity: sha512-x0G2hqpFEyXv/v0Yx/L/veU9UygaJxJxZzf3LtCLMlMf1uoACqo10PiCrssynsn5Xg6Obju9I1cv1IPp5uliRg==}
+  '@midnight-ntwrk/midnight-js-types@4.1.1':
+    resolution: {integrity: sha512-MPT7YToXN2EsDtOOVSJonYZSZ4eqmdVgftBfH56w+tmZM0sZt9u+Mq18uuBQl9ebpTXnp8o7WqeISbgPMxTBcQ==}
 
-  '@midnight-ntwrk/onchain-runtime-v2@2.0.1':
-    resolution: {integrity: sha512-nVtDyPaWD14thZuSz/MVUNNkv4HO2nYf3E3QbaRCE4UR+jKnUrd0s/BN0fLpnrYFlcMNHS7/sZqAeosV80tsOQ==}
+  '@midnight-ntwrk/midnight-js-utils@4.1.1':
+    resolution: {integrity: sha512-b65QADd2FaZbWXe9D3fe9mSGmPlP1DTRMGSruJqhl9fOTNxBhQIzIKs0j/eL9Kv77dVeGDYgQdbV+JkDj3j5Qg==}
 
   '@midnight-ntwrk/onchain-runtime-v3@3.0.0':
     resolution: {integrity: sha512-HbFbUOsvgpEFy1OT0Ni2LMFk4jnMQS1em+H+Mof/B3DpnNKl0Lkx5QiulKOc6pyU4KPEagOqx4fYNyVXFwgZ7g==}
@@ -888,6 +1008,9 @@ packages:
   '@midnight-ntwrk/wallet-sdk-address-format@3.1.0-rc.0':
     resolution: {integrity: sha512-6UFm+Z+zHqV+dnkg/PZjsfY+ADr1AJxAXhcWAoLHOnHAvzrmehu/lAEwF/EYlfI1514xK1N5lGZGon2NQS0W2g==}
 
+  '@midnight-ntwrk/wallet-sdk-address-format@3.1.2':
+    resolution: {integrity: sha512-SRkgwmKFOZSUR25iurAB8U7kTKF7AljSl+tMkuuj8Pthc/l0yIg+/q1rFSozJ0Nz9FJRhshazDyrL0l84fOabg==}
+
   '@midnight-ntwrk/wallet-sdk-capabilities@3.2.0':
     resolution: {integrity: sha512-3S06DbFJ/I+2Zn30jG98a9T3xPxtBwRjm4fCiYnsn8CEcNgH8XINhVimpItWLakeCAviGRA2x7M93phk9u7hbw==}
 
@@ -987,6 +1110,10 @@ packages:
     resolution: {integrity: sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw==}
     engines: {node: ^14.21.3 || >=16}
 
+  '@noble/ciphers@2.2.0':
+    resolution: {integrity: sha512-Z6pjIZ/8IJcCGzb2S/0Px5J81yij85xASuk1teLNeg75bfT07MV3a/O2Mtn1I2se43k3lkVEcFaR10N4cgQcZA==}
+    engines: {node: '>= 20.19.0'}
+
   '@noble/curves@1.9.7':
     resolution: {integrity: sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw==}
     engines: {node: ^14.21.3 || >=16}
@@ -2469,8 +2596,8 @@ packages:
   '@types/validate-npm-package-name@4.0.2':
     resolution: {integrity: sha512-lrpDziQipxCEeK5kWxvljWYhUvOiB2A9izZd9B2AFarYAkqZshb4lPbRs7zKEic6eGtH8V/2qJW+dPp9OtF6bw==}
 
-  '@types/zen-observable@0.8.3':
-    resolution: {integrity: sha512-fbF6oTd4sGGy0xjHPKAt+eS2CrxJ3+6gQ3FGcBoIJR2TLAyCkCyI8JqZNy+FeON0AhVgNJoUumVoZQjBFUqHkw==}
+  '@types/ws@8.18.1':
+    resolution: {integrity: sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==}
 
   '@typescript-eslint/eslint-plugin@8.56.1':
     resolution: {integrity: sha512-Jz9ZztpB37dNC+HU2HI28Bs9QXpzCz+y/twHOwhyrIRdbuVDxSytJNDl6z/aAKlaRIwC7y8wJdkBv7FxYGgi0A==}
@@ -2557,6 +2684,9 @@ packages:
     resolution: {integrity: sha512-CW2gKbJFTuX1feMvOrvsVMmijAOgI9kg2Ie9Dq3gOcMt/dVVoVmqNlLcEUCT13NxHFMEajcUcVBIplbyDroDiw==}
     engines: {node: '>=18'}
 
+  abstract-logging@2.0.1:
+    resolution: {integrity: sha512-2BjRTZxTPvheOvGbBslFSYOUkr+SjPtOnrLP33f+VIWLzezQpZcqVg7ja3L4dBXmzzgwT+a029jRx5PCi3JuiA==}
+
   accepts@2.0.0:
     resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==}
     engines: {node: '>= 0.6'}
@@ -2648,6 +2778,9 @@ packages:
     resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
     engines: {node: '>= 0.4'}
 
+  avvio@9.3.0:
+    resolution: {integrity: sha512-g2tQ7LE7oOSqDfwEm3M+ZCMTJc7KiZCdJ4UwyZJb5ckTKyYu50OYmvv0mCFXPuYXoM4zkSt8zM9XQ9KCvxA74A==}
+
   axios@1.13.5:
     resolution: {integrity: sha512-cz4ur7Vb0xS4/KUN0tPWe44eqxrIu31me+fbang3ijiNscE129POzipJJA6zniq2C/Z6sJCjMimjS8Lc/GAs8Q==}
 
@@ -2963,6 +3096,10 @@ packages:
     resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
     engines: {node: '>= 0.8'}
 
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
   des.js@1.1.0:
     resolution: {integrity: sha512-r17GxjhUCjSRy8aiJpr8/UadFIzMzJGexI3Nmz4ADi9LYSFx4gTBp80+NaX/YsXWWLhpZ7v/v/ubEc/bCNfKwg==}
 
@@ -3198,6 +3335,9 @@ packages:
     resolution: {integrity: sha512-h5+1OzzfCC3Ef7VbtKdcv7zsstUQwUDlYpUTvjeUsJAssPgLn7QzbboPtL5ro04Mq0rPOsMzl7q5hIbRs2wD1A==}
     engines: {node: '>=8.0.0'}
 
+  fast-decode-uri-component@1.0.1:
+    resolution: {integrity: sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg==}
+
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
@@ -3208,12 +3348,24 @@ packages:
   fast-json-stable-stringify@2.1.0:
     resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
 
+  fast-json-stringify@7.0.1:
+    resolution: {integrity: sha512-eRSayARSbbwlBjpP4vnTTIRD5QPcIrmihPxDeN1DtKnHPg66UuJLx+8hlK1kaFdjvzyQ/dzALoi4vwAQ+T+iZA==}
+
   fast-levenshtein@2.0.6:
     resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
 
+  fast-querystring@1.1.2:
+    resolution: {integrity: sha512-g6KuKWmFXc0fID8WWH0jit4g0AGBoJhCkJMb1RmbsSEUNvQ+ZC8D6CUZ+GtF8nMzSPXnhiePyyqqipzNNEnHjg==}
+
   fast-uri@3.1.0:
     resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==}
 
+  fast-uri@4.1.1:
+    resolution: {integrity: sha512-YPOs1zD5TG2+EZt+r88LwF6mclA7TPkpwMP7ZN3TO2HiHS8TXvq7QA/17iJsV9dubcLo/f8eEYqMBruyQV21hQ==}
+
+  fastify@5.10.0:
+    resolution: {integrity: sha512-A9L0ziuWGQHgEEVgF3davQ9vbD93IuX+lo2IsxapQmu5b/Y/ynn9m9K5JHt9dvyJXOFc5iN0Zk5GHEOqnzhWjg==}
+
   fastq@1.20.1:
     resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
 
@@ -3252,6 +3404,10 @@ packages:
   find-my-way-ts@0.1.6:
     resolution: {integrity: sha512-a85L9ZoXtNAey3Y6Z+eBWW658kO/MwR7zIafkIUPUMf3isZG0NCs2pjW2wtjxAKuJPxMAsHUIP4ZPGv0o5gyTA==}
 
+  find-my-way@9.7.0:
+    resolution: {integrity: sha512-f2JHn75x2JlwUwLenZypgczR7YWMb/uO9BvUXtus+JMgkbIkLADd38cI4EiV+OQqrGo1Zlq6V8wnqMJ8e62wUQ==}
+    engines: {node: '>=20'}
+
   find-up@5.0.0:
     resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
     engines: {node: '>=10'}
@@ -3288,9 +3444,6 @@ packages:
     resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
     engines: {node: '>= 0.6'}
 
-  fp-ts@2.16.11:
-    resolution: {integrity: sha512-LaI+KaX2NFkfn1ZGHoKCmcfv7yrZsC3b8NtWsTVQeHkq4F27vI5igUuO53sxqDEa2gNQMHFPmpojDw/1zmUK7w==}
-
   fresh@2.0.0:
     resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
     engines: {node: '>= 0.8'}
@@ -3395,13 +3548,13 @@ packages:
     peerDependencies:
       graphql: ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0
 
-  graphql-ws@6.0.7:
-    resolution: {integrity: sha512-yoLRW+KRlDmnnROdAu7sX77VNLC0bsFoZyGQJLy1cF+X/SkLg/fWkRGrEEYQK8o2cafJ2wmEaMqMEZB3U3DYDg==}
+  graphql-ws@6.1.1:
+    resolution: {integrity: sha512-e5O9S3zTDqIZ15k5Wii3ImmI5zwmRAH5OMaE90H6+jhaVBNDmjSjzumq8VyUSvKnsfByXi9pJ/3Vv1eNzwcPIw==}
     engines: {node: '>=20'}
     peerDependencies:
       '@fastify/websocket': ^10 || ^11
       crossws: ~0.3
-      graphql: ^15.10.1 || ^16
+      graphql: ^15.10.1 || ^16 || ^17
       ws: ^8
     peerDependenciesMeta:
       '@fastify/websocket':
@@ -3419,6 +3572,10 @@ packages:
     resolution: {integrity: sha512-5bJ+nf/UCpAjHM8i06fl7eLyVC9iuNAjm9qzkiu2ZGhM0VscSvS6WDPfAwkdkBuoXGM9FJSbKl6wylMwP9Ktig==}
     engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0}
 
+  graphql@16.14.2:
+    resolution: {integrity: sha512-Chq1s4CY7jmh8gO2qvLIJyfCDIN+EHLFW/9iShnp1z8FjBQMoodWP1kDC36VAMXXIvAjj4ARa7ntfAV2BrjsbA==}
+    engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0}
+
   has-flag@4.0.0:
     resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
     engines: {node: '>=8'}
@@ -3461,9 +3618,6 @@ packages:
   hmac-drbg@1.0.1:
     resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==}
 
-  hoist-non-react-statics@3.3.2:
-    resolution: {integrity: sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==}
-
   hono@4.12.2:
     resolution: {integrity: sha512-gJnaDHXKDayjt8ue0n8Gs0A007yKXj4Xzb8+cNjZeYsSzzwKc0Lr+OZgYwVfB0pHfUs17EPoLvrOsEaJ9mj+Tg==}
     engines: {node: '>=16.9.0'}
@@ -3513,11 +3667,6 @@ packages:
   inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
-  io-ts@2.2.22:
-    resolution: {integrity: sha512-FHCCztTkHoV9mdBsHpocLpdTAfh956ZQcIkWQxxS0U5HT53vtrcuYdQneEJKH6xILaLNzXVl2Cvwtoy8XNN0AA==}
-    peerDependencies:
-      fp-ts: ^2.5.0
-
   ip-address@10.0.1:
     resolution: {integrity: sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA==}
     engines: {node: '>= 12'}
@@ -3526,6 +3675,10 @@ packages:
     resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
     engines: {node: '>= 0.10'}
 
+  ipaddr.js@2.4.0:
+    resolution: {integrity: sha512-9VGk3HGanVE6JoZXHiCpnGy5X0jYDnN4EA4lntFPj+1vIWlFhIylq2CrrCOJH9EAhc5CYhq18F2Av2tgoAPsYQ==}
+    engines: {node: '>= 10'}
+
   is-arguments@1.2.0:
     resolution: {integrity: sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==}
     engines: {node: '>= 0.4'}
@@ -3684,6 +3837,9 @@ packages:
   json-parse-even-better-errors@2.3.1:
     resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
 
+  json-schema-ref-resolver@3.0.0:
+    resolution: {integrity: sha512-hOrZIVL5jyYFjzk7+y7n5JDzGlU8rfWDuYyHwGa2WA8/pcmMHezp2xsVwxrebD/Q9t8Nc5DboieySDpCp4WG4A==}
+
   json-schema-traverse@0.4.1:
     resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
 
@@ -3734,6 +3890,9 @@ packages:
     resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
     engines: {node: '>= 0.8.0'}
 
+  light-my-request@6.6.0:
+    resolution: {integrity: sha512-CHYbu8RtboSIoVsHZ6Ye4cj4Aw/yg2oAFimlF7mNvfDV192LR7nDiKtSIfCuLT7KokPSTn/9kfVLm5OGN0A28A==}
+
   lightningcss-android-arm64@1.31.1:
     resolution: {integrity: sha512-HXJF3x8w9nQ4jbXRiNppBCqeZPIAfUo8zE/kOEGbW5NZvGc/K7nMxbhIr+YlFlHW5mpbg/YFPdbnCh1wAXCKFg==}
     engines: {node: '>= 12.0.0'}
@@ -3818,17 +3977,10 @@ packages:
   lodash.merge@4.6.2:
     resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
 
-  lodash@4.17.23:
-    resolution: {integrity: sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==}
-
   log-symbols@6.0.0:
     resolution: {integrity: sha512-i24m8rpwhmPIS4zscNzK6MSEhk0DUWa/8iYQWxhffV8jkI4Phvs3F+quL5xvS0gdQR0FyTCMMH33Y78dDTzzIw==}
     engines: {node: '>=18'}
 
-  loose-envify@1.4.0:
-    resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
-    hasBin: true
-
   lru-cache@5.1.1:
     resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
 
@@ -4205,6 +4357,9 @@ packages:
   process-nextick-args@2.0.1:
     resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
 
+  process-warning@4.0.1:
+    resolution: {integrity: sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q==}
+
   process-warning@5.0.0:
     resolution: {integrity: sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==}
 
@@ -4216,9 +4371,6 @@ packages:
     resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
     engines: {node: '>= 6'}
 
-  prop-types@15.8.1:
-    resolution: {integrity: sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==}
-
   propagate@2.0.1:
     resolution: {integrity: sha512-vGrhOavPSTz4QVNuBNdcNXePNdNMaO1xj9yBeH1ScQPjk/rhg9sSlCXPhMkFuaNNW/syTvYqsnbIJxMBfRbbag==}
     engines: {node: '>= 8'}
@@ -4289,9 +4441,6 @@ packages:
     peerDependencies:
       react: ^19.2.4
 
-  react-is@16.13.1:
-    resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
-
   react-remove-scroll-bar@2.3.8:
     resolution: {integrity: sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==}
     engines: {node: '>=10'}
@@ -4341,17 +4490,6 @@ packages:
     resolution: {integrity: sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==}
     engines: {node: '>= 4'}
 
-  rehackt@0.1.0:
-    resolution: {integrity: sha512-7kRDOuLHB87D/JESKxQoRwv4DzbIdwkAGQ7p6QKGdVlY1IZheUnVhlk/4UZlNUVxdAXpyxikE3URsG067ybVzw==}
-    peerDependencies:
-      '@types/react': '*'
-      react: '*'
-    peerDependenciesMeta:
-      '@types/react':
-        optional: true
-      react:
-        optional: true
-
   require-directory@2.1.1:
     resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
     engines: {node: '>=0.10.0'}
@@ -4376,6 +4514,10 @@ packages:
     resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==}
     engines: {node: '>=18'}
 
+  ret@0.5.0:
+    resolution: {integrity: sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==}
+    engines: {node: '>=10'}
+
   rettime@0.10.1:
     resolution: {integrity: sha512-uyDrIlUEH37cinabq0AX4QbgV4HbFZ/gqoiunWQ1UqBtRvTTytwhNYjE++pO/MjPTZL5KQCf2bEoJ/BJNVQ5Kw==}
 
@@ -4383,6 +4525,9 @@ packages:
     resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
     engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
 
+  rfdc@1.4.1:
+    resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
+
   ripemd160@2.0.3:
     resolution: {integrity: sha512-5Di9UC0+8h1L6ZD2d7awM7E/T4uA1fJRlx6zk/NvdCCVEoAnFqvHmCuNeIKoCeIixBX/q8uM+6ycDvF8woqosA==}
     engines: {node: '>= 0.8'}
@@ -4421,6 +4566,10 @@ packages:
     resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
     engines: {node: '>= 0.4'}
 
+  safe-regex2@5.1.1:
+    resolution: {integrity: sha512-mOSBvHGDZMuIEZMdOz/aCEYDCv0E7nfcNsIhUF+/P+xC7Hyf3FkvymqgPbg9D1EdSGu+uKbJgy09K/RKKc7kJA==}
+    hasBin: true
+
   safe-stable-stringify@2.5.0:
     resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
     engines: {node: '>=10'}
@@ -4434,6 +4583,9 @@ packages:
   scheduler@0.27.0:
     resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
 
+  secure-json-parse@4.1.0:
+    resolution: {integrity: sha512-l4KnYfEyqYJxDwlNVyRfO2E4NTHfMKAWdUuA8J0yve2Dz/E/PdBepY03RvyJpssIpRFwJoCD55wA+mEDs6ByWA==}
+
   semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
@@ -4451,6 +4603,9 @@ packages:
     resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==}
     engines: {node: '>= 18'}
 
+  set-cookie-parser@2.7.2:
+    resolution: {integrity: sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==}
+
   set-function-length@1.2.2:
     resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
     engines: {node: '>= 0.4'}
@@ -4599,10 +4754,6 @@ packages:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
 
-  symbol-observable@4.0.0:
-    resolution: {integrity: sha512-b19dMThMV4HVFynSAM1++gBHAbk2Tc/osgLIBZMKsyqh34jb2e8Os7T6ZW/Bt3pJFdBTd2JwAnAAEQV7rSNvcQ==}
-    engines: {node: '>=0.10'}
-
   tagged-tag@1.0.0:
     resolution: {integrity: sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng==}
     engines: {node: '>=20'}
@@ -4651,6 +4802,10 @@ packages:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
 
+  toad-cache@3.7.4:
+    resolution: {integrity: sha512-m1TdR/rvT7kgGJZhspNtXdsdYk0fddFpJJFlG5s+UkPFo6lkLoZ3YLOaovPYjq1R75NP5JfeTlSHaOsE09peCg==}
+    engines: {node: '>=20'}
+
   toidentifier@1.0.1:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
@@ -4668,10 +4823,6 @@ packages:
     peerDependencies:
       typescript: '>=4.8.4'
 
-  ts-invariant@0.10.3:
-    resolution: {integrity: sha512-uivwYcQaxAucv1CzRp2n/QdYPo4ILf9VXgH19zEIjFx2EJufV16P0JtJVpYHy89DItG6Kwj2oIUjrcK5au+4tQ==}
-    engines: {node: '>=8'}
-
   ts-morph@26.0.0:
     resolution: {integrity: sha512-ztMO++owQnz8c/gIENcM9XfCEzgoGphTv+nKpYNM1bgsdOVC/jRZuEBf6N+mLLDNg68Kl+GgUZfOySaRiG1/Ug==}
 
@@ -4952,8 +5103,8 @@ packages:
   wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
-  ws@8.19.0:
-    resolution: {integrity: sha512-blAT2mjOEIi0ZzruJfIhb3nps74PRWTCz1IjglWEEpQl5XS/UNama6u2/rjFkDDouqr4L67ry+1aGIALViWjDg==}
+  ws@8.21.1:
+    resolution: {integrity: sha512-+0NTnW77fFN/DjQi6k/Sq/Yvk4Sgajw7urW8V+asjXnRgDs9gyGkdb7EzgfhA4goXsRIZKE28fzIXBHEzhuiWw==}
     engines: {node: '>=10.0.0'}
     peerDependencies:
       bufferutil: ^4.0.1
@@ -5008,15 +5159,6 @@ packages:
     resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==}
     engines: {node: '>=18'}
 
-  zen-observable-ts@1.1.0:
-    resolution: {integrity: sha512-1h4zlLSqI2cRLPJUHJFL8bCWHhkpuXkF+dbGkRaWjgDIG26DmzyshUMrdV/rL3UnR+mhaX4fRq8LPouq0MYYIA==}
-
-  zen-observable-ts@1.2.5:
-    resolution: {integrity: sha512-QZWQekv6iB72Naeake9hS1KxHlotfRpe+WGNbNx5/ta+R3DNjVO2bswf63gXlWDcs+EMd7XY8HfVQyP1X6T4Zg==}
-
-  zen-observable@0.8.15:
-    resolution: {integrity: sha512-PQ2PC7R9rslx84ndNBZB/Dkv8V8fZEpk83RLgXtYd0fwUgEjseMn1Dgajh2x6S8QbZAFa9p2qVCEuYZNgve0dQ==}
-
   zod-to-json-schema@3.25.1:
     resolution: {integrity: sha512-pM/SU9d3YAggzi6MtR4h7ruuQlqKtad8e9S0fmxcMi+ueAK5Korys/aWcV9LIIHTVbj01NdzxcnXSN+O74ZIVA==}
     peerDependencies:
@@ -5043,28 +5185,21 @@ snapshots:
       package-manager-detector: 1.6.0
       tinyexec: 1.0.2
 
-  '@apollo/client@3.14.0(@types/react@19.2.14)(graphql-ws@6.0.7(graphql@16.13.2)(ws@8.19.0))(graphql@16.13.2)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+  '@apollo/client@4.2.7(graphql-ws@6.1.1(graphql@16.14.2)(ws@8.21.1))(graphql@16.14.2)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)(rxjs@7.8.2)':
     dependencies:
-      '@graphql-typed-document-node/core': 3.2.0(graphql@16.13.2)
+      '@graphql-typed-document-node/core': 3.2.0(graphql@16.14.2)
       '@wry/caches': 1.0.1
       '@wry/equality': 0.5.7
       '@wry/trie': 0.5.0
-      graphql: 16.13.2
-      graphql-tag: 2.12.6(graphql@16.13.2)
-      hoist-non-react-statics: 3.3.2
+      graphql: 16.14.2
+      graphql-tag: 2.12.6(graphql@16.14.2)
       optimism: 0.18.1
-      prop-types: 15.8.1
-      rehackt: 0.1.0(@types/react@19.2.14)(react@19.2.4)
-      symbol-observable: 4.0.0
-      ts-invariant: 0.10.3
+      rxjs: 7.8.2
       tslib: 2.8.1
-      zen-observable-ts: 1.2.5
     optionalDependencies:
-      graphql-ws: 6.0.7(graphql@16.13.2)(ws@8.19.0)
+      graphql-ws: 6.1.1(graphql@16.14.2)(ws@8.21.1)
       react: 19.2.4
       react-dom: 19.2.4(react@19.2.4)
-    transitivePeerDependencies:
-      - '@types/react'
 
   '@babel/code-frame@7.29.0':
     dependencies:
@@ -5454,6 +5589,29 @@ snapshots:
       '@eslint/core': 1.1.0
       levn: 0.4.1
 
+  '@fastify/ajv-compiler@4.0.5':
+    dependencies:
+      ajv: 8.18.0
+      ajv-formats: 3.0.1(ajv@8.18.0)
+      fast-uri: 3.1.0
+
+  '@fastify/error@4.2.0': {}
+
+  '@fastify/fast-json-stringify-compiler@5.1.0':
+    dependencies:
+      fast-json-stringify: 7.0.1
+
+  '@fastify/forwarded@3.0.1': {}
+
+  '@fastify/merge-json-schemas@0.2.1':
+    dependencies:
+      dequal: 2.0.3
+
+  '@fastify/proxy-addr@5.1.0':
+    dependencies:
+      '@fastify/forwarded': 3.0.1
+      ipaddr.js: 2.4.0
+
   '@floating-ui/core@1.7.4':
     dependencies:
       '@floating-ui/utils': 0.2.10
@@ -5475,6 +5633,10 @@ snapshots:
     dependencies:
       graphql: 16.13.2
 
+  '@graphql-typed-document-node/core@3.2.0(graphql@16.14.2)':
+    dependencies:
+      graphql: 16.14.2
+
   '@hono/node-server@1.19.9(hono@4.12.2)':
     dependencies:
       hono: 4.12.2
@@ -5542,16 +5704,16 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
-  '@midnight-ntwrk/compact-js@2.5.0':
+  '@midnight-ntwrk/compact-js@2.5.1':
     dependencies:
       '@effect/platform': 0.95.0(effect@3.21.0)
-      '@midnight-ntwrk/compact-runtime': 0.15.0
+      '@midnight-ntwrk/compact-runtime': 0.16.0
       '@midnight-ntwrk/ledger-v8': 8.0.3
       '@midnight-ntwrk/platform-js': 2.2.4
       effect: 3.21.0
       tslib: 2.8.1
 
-  '@midnight-ntwrk/compact-runtime@0.15.0':
+  '@midnight-ntwrk/compact-runtime@0.16.0':
     dependencies:
       '@midnight-ntwrk/onchain-runtime-v3': 3.0.0
       '@types/object-inspect': 1.13.0
@@ -5561,49 +5723,50 @@ snapshots:
 
   '@midnight-ntwrk/ledger-v8@8.0.3': {}
 
-  '@midnight-ntwrk/midnight-js-contracts@4.0.4':
+  '@midnight-ntwrk/midnight-js-contracts@4.1.1':
     dependencies:
-      '@midnight-ntwrk/compact-js': 2.5.0
-      '@midnight-ntwrk/midnight-js-network-id': 4.0.4
-      '@midnight-ntwrk/midnight-js-types': 4.0.4
-      '@midnight-ntwrk/midnight-js-utils': 4.0.4
+      '@midnight-ntwrk/midnight-js-network-id': 4.1.1
+      '@midnight-ntwrk/midnight-js-protocol': 4.1.1
+      '@midnight-ntwrk/midnight-js-types': 4.1.1
+      '@midnight-ntwrk/midnight-js-utils': 4.1.1
 
-  '@midnight-ntwrk/midnight-js-fetch-zk-config-provider@4.0.4':
+  '@midnight-ntwrk/midnight-js-fetch-zk-config-provider@4.1.1':
     dependencies:
-      '@midnight-ntwrk/midnight-js-types': 4.0.4
+      '@midnight-ntwrk/midnight-js-types': 4.1.1
+      '@midnight-ntwrk/midnight-js-utils': 4.1.1
       cross-fetch: 4.1.0
     transitivePeerDependencies:
       - encoding
 
-  '@midnight-ntwrk/midnight-js-http-client-proof-provider@4.0.4':
+  '@midnight-ntwrk/midnight-js-http-client-proof-provider@4.1.1':
     dependencies:
-      '@midnight-ntwrk/midnight-js-contracts': 4.0.4
-      '@midnight-ntwrk/midnight-js-network-id': 4.0.4
-      '@midnight-ntwrk/midnight-js-types': 4.0.4
-      '@midnight-ntwrk/midnight-js-utils': 4.0.4
+      '@midnight-ntwrk/midnight-js-contracts': 4.1.1
+      '@midnight-ntwrk/midnight-js-network-id': 4.1.1
+      '@midnight-ntwrk/midnight-js-protocol': 4.1.1
+      '@midnight-ntwrk/midnight-js-types': 4.1.1
+      '@midnight-ntwrk/midnight-js-utils': 4.1.1
       cross-fetch: 4.1.0
       fetch-retry: 6.0.0
-      lodash: 4.17.23
     transitivePeerDependencies:
       - encoding
 
-  '@midnight-ntwrk/midnight-js-indexer-public-data-provider@4.0.4(@types/react@19.2.14)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
+  '@midnight-ntwrk/midnight-js-indexer-public-data-provider@4.1.1(react-dom@19.2.4(react@19.2.4))(react@19.2.4)':
     dependencies:
-      '@apollo/client': 3.14.0(@types/react@19.2.14)(graphql-ws@6.0.7(graphql@16.13.2)(ws@8.19.0))(graphql@16.13.2)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)
-      '@midnight-ntwrk/midnight-js-network-id': 4.0.4
-      '@midnight-ntwrk/midnight-js-types': 4.0.4
-      '@midnight-ntwrk/midnight-js-utils': 4.0.4
+      '@apollo/client': 4.2.7(graphql-ws@6.1.1(graphql@16.14.2)(ws@8.21.1))(graphql@16.14.2)(react-dom@19.2.4(react@19.2.4))(react@19.2.4)(rxjs@7.8.2)
+      '@graphql-typed-document-node/core': 3.2.0(graphql@16.14.2)
+      '@midnight-ntwrk/midnight-js-network-id': 4.1.1
+      '@midnight-ntwrk/midnight-js-protocol': 4.1.1
+      '@midnight-ntwrk/midnight-js-types': 4.1.1
+      '@midnight-ntwrk/midnight-js-utils': 4.1.1
       buffer: 6.0.3
       cross-fetch: 4.1.0
-      graphql: 16.13.2
-      graphql-ws: 6.0.7(graphql@16.13.2)(ws@8.19.0)
-      isomorphic-ws: 5.0.0(ws@8.19.0)
+      graphql: 16.14.2
+      graphql-ws: 6.1.1(graphql@16.14.2)(ws@8.21.1)
+      isomorphic-ws: 5.0.0(ws@8.21.1)
       rxjs: 7.8.2
-      ws: 8.19.0
-      zen-observable-ts: 1.1.0
+      ws: 8.21.1
     transitivePeerDependencies:
       - '@fastify/websocket'
-      - '@types/react'
       - bufferutil
       - crossws
       - encoding
@@ -5612,34 +5775,45 @@ snapshots:
       - subscriptions-transport-ws
       - utf-8-validate
 
-  '@midnight-ntwrk/midnight-js-level-private-state-provider@4.0.4':
+  '@midnight-ntwrk/midnight-js-level-private-state-provider@4.1.1':
     dependencies:
-      '@midnight-ntwrk/midnight-js-types': 4.0.4
+      '@midnight-ntwrk/midnight-js-protocol': 4.1.1
+      '@midnight-ntwrk/midnight-js-types': 4.1.1
+      '@midnight-ntwrk/midnight-js-utils': 4.1.1
+      '@noble/ciphers': 2.2.0
+      '@noble/hashes': 2.2.0
       abstract-level: 3.1.1
       buffer: 6.0.3
-      fp-ts: 2.16.11
-      io-ts: 2.2.22(fp-ts@2.16.11)
       level: 10.0.0
       superjson: 2.2.6
 
-  '@midnight-ntwrk/midnight-js-network-id@4.0.4': {}
+  '@midnight-ntwrk/midnight-js-network-id@4.1.1': {}
 
-  '@midnight-ntwrk/midnight-js-node-zk-config-provider@4.0.4':
+  '@midnight-ntwrk/midnight-js-node-zk-config-provider@4.1.1':
     dependencies:
-      '@midnight-ntwrk/midnight-js-types': 4.0.4
+      '@midnight-ntwrk/midnight-js-types': 4.1.1
+      '@midnight-ntwrk/midnight-js-utils': 4.1.1
 
-  '@midnight-ntwrk/midnight-js-types@4.0.4':
+  '@midnight-ntwrk/midnight-js-protocol@4.1.1':
     dependencies:
-      '@midnight-ntwrk/compact-js': 2.5.0
+      '@midnight-ntwrk/compact-js': 2.5.1
+      '@midnight-ntwrk/compact-runtime': 0.16.0
+      '@midnight-ntwrk/ledger-v8': 8.0.3
+      '@midnight-ntwrk/onchain-runtime-v3': 3.0.0
       '@midnight-ntwrk/platform-js': 2.2.4
-      rxjs: 7.8.2
 
-  '@midnight-ntwrk/midnight-js-utils@4.0.4':
+  '@midnight-ntwrk/midnight-js-types@4.1.1':
     dependencies:
-      '@midnight-ntwrk/midnight-js-network-id': 4.0.4
-      '@scure/base': 2.0.0
+      '@midnight-ntwrk/midnight-js-protocol': 4.1.1
+      effect: 3.21.0
+      pino: 10.3.1
+      rxjs: 7.8.2
 
-  '@midnight-ntwrk/onchain-runtime-v2@2.0.1': {}
+  '@midnight-ntwrk/midnight-js-utils@4.1.1':
+    dependencies:
+      '@midnight-ntwrk/midnight-js-network-id': 4.1.1
+      '@midnight-ntwrk/midnight-js-protocol': 4.1.1
+      '@midnight-ntwrk/wallet-sdk-address-format': 3.1.2
 
   '@midnight-ntwrk/onchain-runtime-v3@3.0.0': {}
 
@@ -5656,14 +5830,20 @@ snapshots:
   '@midnight-ntwrk/wallet-sdk-address-format@3.1.0-rc.0':
     dependencies:
       '@midnight-ntwrk/ledger-v8': 8.0.3
-      '@scure/base': 2.0.0
+      '@scure/base': 2.2.0
       '@subsquid/scale-codec': 4.0.1
 
-  '@midnight-ntwrk/wallet-sdk-capabilities@3.2.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-address-format@3.1.2':
+    dependencies:
+      '@midnight-ntwrk/ledger-v8': 8.0.3
+      '@scure/base': 2.2.0
+      '@subsquid/scale-codec': 4.0.1
+
+  '@midnight-ntwrk/wallet-sdk-capabilities@3.2.0(ws@8.21.1)':
     dependencies:
       '@midnight-ntwrk/ledger-v8': 8.0.3
       '@midnight-ntwrk/wallet-sdk-abstractions': 2.0.0
-      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0(ws@8.19.0)
+      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-node-client': 1.1.0
       '@midnight-ntwrk/wallet-sdk-prover-client': 1.2.0
       '@midnight-ntwrk/wallet-sdk-utilities': 1.1.0
@@ -5678,11 +5858,11 @@ snapshots:
       - utf-8-validate
       - ws
 
-  '@midnight-ntwrk/wallet-sdk-capabilities@3.2.0-rc.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-capabilities@3.2.0-rc.0(ws@8.21.1)':
     dependencies:
       '@midnight-ntwrk/ledger-v8': 8.0.3
       '@midnight-ntwrk/wallet-sdk-abstractions': 2.0.0
-      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.19.0)
+      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-node-client': 1.1.0
       '@midnight-ntwrk/wallet-sdk-prover-client': 1.2.0
       '@midnight-ntwrk/wallet-sdk-utilities': 1.1.0-rc.0
@@ -5697,13 +5877,13 @@ snapshots:
       - utf-8-validate
       - ws
 
-  '@midnight-ntwrk/wallet-sdk-dust-wallet@3.0.0-rc.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-dust-wallet@3.0.0-rc.0(ws@8.21.1)':
     dependencies:
       '@midnight-ntwrk/ledger-v8': 8.0.3
       '@midnight-ntwrk/wallet-sdk-abstractions': 2.0.0
       '@midnight-ntwrk/wallet-sdk-address-format': 3.1.0-rc.0
-      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0-rc.0(ws@8.19.0)
-      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.19.0)
+      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0-rc.0(ws@8.21.1)
+      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-runtime': 1.0.2-rc.0
       '@midnight-ntwrk/wallet-sdk-utilities': 1.1.0-rc.0
       effect: 3.21.0
@@ -5716,15 +5896,15 @@ snapshots:
       - utf-8-validate
       - ws
 
-  '@midnight-ntwrk/wallet-sdk-facade@3.0.0-rc.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-facade@3.0.0-rc.0(ws@8.21.1)':
     dependencies:
       '@midnight-ntwrk/ledger-v8': 8.0.3
       '@midnight-ntwrk/wallet-sdk-address-format': 3.1.0-rc.0
-      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0(ws@8.19.0)
-      '@midnight-ntwrk/wallet-sdk-dust-wallet': 3.0.0-rc.0(ws@8.19.0)
-      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0(ws@8.19.0)
-      '@midnight-ntwrk/wallet-sdk-shielded': 2.1.0-rc.0(ws@8.19.0)
-      '@midnight-ntwrk/wallet-sdk-unshielded-wallet': 2.1.0-rc.0(ws@8.19.0)
+      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0(ws@8.21.1)
+      '@midnight-ntwrk/wallet-sdk-dust-wallet': 3.0.0-rc.0(ws@8.21.1)
+      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0(ws@8.21.1)
+      '@midnight-ntwrk/wallet-sdk-shielded': 2.1.0-rc.0(ws@8.21.1)
+      '@midnight-ntwrk/wallet-sdk-unshielded-wallet': 2.1.0-rc.0(ws@8.21.1)
       rxjs: 7.8.2
     transitivePeerDependencies:
       - '@fastify/websocket'
@@ -5739,27 +5919,27 @@ snapshots:
       '@scure/bip32': 2.0.1
       '@scure/bip39': 2.0.1
 
-  '@midnight-ntwrk/wallet-sdk-indexer-client@1.2.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-indexer-client@1.2.0(ws@8.21.1)':
     dependencies:
       '@graphql-typed-document-node/core': 3.2.0(graphql@16.13.2)
       '@midnight-ntwrk/wallet-sdk-utilities': 1.1.0
       effect: 3.21.0
       graphql: 16.13.2
       graphql-http: 1.22.4(graphql@16.13.2)
-      graphql-ws: 6.0.7(graphql@16.13.2)(ws@8.19.0)
+      graphql-ws: 6.1.1(graphql@16.13.2)(ws@8.21.1)
     transitivePeerDependencies:
       - '@fastify/websocket'
       - crossws
       - ws
 
-  '@midnight-ntwrk/wallet-sdk-indexer-client@1.2.0-rc.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-indexer-client@1.2.0-rc.0(ws@8.21.1)':
     dependencies:
       '@graphql-typed-document-node/core': 3.2.0(graphql@16.13.2)
       '@midnight-ntwrk/wallet-sdk-utilities': 1.1.0-rc.0
       effect: 3.21.0
       graphql: 16.13.2
       graphql-http: 1.22.4(graphql@16.13.2)
-      graphql-ws: 6.0.7(graphql@16.13.2)(ws@8.19.0)
+      graphql-ws: 6.1.1(graphql@16.13.2)(ws@8.21.1)
     transitivePeerDependencies:
       - '@fastify/websocket'
       - crossws
@@ -5796,13 +5976,13 @@ snapshots:
       effect: 3.21.0
       rxjs: 7.8.2
 
-  '@midnight-ntwrk/wallet-sdk-shielded@2.1.0-rc.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-shielded@2.1.0-rc.0(ws@8.21.1)':
     dependencies:
       '@midnight-ntwrk/ledger-v8': 8.0.3
       '@midnight-ntwrk/wallet-sdk-abstractions': 2.0.0
       '@midnight-ntwrk/wallet-sdk-address-format': 3.1.0-rc.0
-      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0-rc.0(ws@8.19.0)
-      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.19.0)
+      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0-rc.0(ws@8.21.1)
+      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-runtime': 1.0.2-rc.0
       '@midnight-ntwrk/wallet-sdk-utilities': 1.1.0-rc.0
       effect: 3.21.0
@@ -5815,13 +5995,13 @@ snapshots:
       - utf-8-validate
       - ws
 
-  '@midnight-ntwrk/wallet-sdk-unshielded-wallet@2.1.0-rc.0(ws@8.19.0)':
+  '@midnight-ntwrk/wallet-sdk-unshielded-wallet@2.1.0-rc.0(ws@8.21.1)':
     dependencies:
       '@midnight-ntwrk/ledger-v8': 8.0.3
       '@midnight-ntwrk/wallet-sdk-abstractions': 2.0.0
       '@midnight-ntwrk/wallet-sdk-address-format': 3.1.0-rc.0
-      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0-rc.0(ws@8.19.0)
-      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.19.0)
+      '@midnight-ntwrk/wallet-sdk-capabilities': 3.2.0-rc.0(ws@8.21.1)
+      '@midnight-ntwrk/wallet-sdk-indexer-client': 1.2.0-rc.0(ws@8.21.1)
       '@midnight-ntwrk/wallet-sdk-runtime': 1.0.2-rc.0
       '@midnight-ntwrk/wallet-sdk-utilities': 1.1.0-rc.0
       effect: 3.21.0
@@ -5906,6 +6086,8 @@ snapshots:
 
   '@noble/ciphers@1.3.0': {}
 
+  '@noble/ciphers@2.2.0': {}
+
   '@noble/curves@1.9.7':
     dependencies:
       '@noble/hashes': 1.8.0
@@ -6258,7 +6440,7 @@ snapshots:
     dependencies:
       '@polkadot/x-global': 14.0.1
       tslib: 2.8.1
-      ws: 8.19.0
+      ws: 8.21.1
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
@@ -7423,7 +7605,9 @@ snapshots:
 
   '@types/validate-npm-package-name@4.0.2': {}
 
-  '@types/zen-observable@0.8.3': {}
+  '@types/ws@8.18.1':
+    dependencies:
+      '@types/node': 24.10.13
 
   '@typescript-eslint/eslint-plugin@8.56.1(@typescript-eslint/parser@8.56.1(eslint@10.0.1(jiti@2.6.1))(typescript@5.9.3))(eslint@10.0.1(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
@@ -7441,10 +7625,10 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@typescript-eslint/eslint-plugin@8.56.1(@typescript-eslint/parser@8.56.1(eslint@10.0.1(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)':
+  '@typescript-eslint/eslint-plugin@8.56.1(@typescript-eslint/parser@8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)':
     dependencies:
       '@eslint-community/regexpp': 4.12.2
-      '@typescript-eslint/parser': 8.56.1(eslint@10.0.1(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/parser': 8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/scope-manager': 8.56.1
       '@typescript-eslint/type-utils': 8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/utils': 8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)
@@ -7600,6 +7784,8 @@ snapshots:
       maybe-combine-errors: 1.0.0
       module-error: 1.0.2
 
+  abstract-logging@2.0.1: {}
+
   accepts@2.0.0:
     dependencies:
       mime-types: 3.0.2
@@ -7688,6 +7874,11 @@ snapshots:
     dependencies:
       possible-typed-array-names: 1.1.0
 
+  avvio@9.3.0:
+    dependencies:
+      '@fastify/error': 4.2.0
+      fastq: 1.20.1
+
   axios@1.13.5:
     dependencies:
       follow-redirects: 1.15.11
@@ -8026,6 +8217,8 @@ snapshots:
 
   depd@2.0.0: {}
 
+  dequal@2.0.3: {}
+
   des.js@1.1.0:
     dependencies:
       inherits: 2.0.4
@@ -8377,6 +8570,8 @@ snapshots:
     dependencies:
       pure-rand: 6.1.0
 
+  fast-decode-uri-component@1.0.1: {}
+
   fast-deep-equal@3.1.3: {}
 
   fast-glob@3.3.3:
@@ -8389,10 +8584,43 @@ snapshots:
 
   fast-json-stable-stringify@2.1.0: {}
 
+  fast-json-stringify@7.0.1:
+    dependencies:
+      '@fastify/merge-json-schemas': 0.2.1
+      ajv: 8.18.0
+      ajv-formats: 3.0.1(ajv@8.18.0)
+      fast-uri: 4.1.1
+      json-schema-ref-resolver: 3.0.0
+      rfdc: 1.4.1
+
   fast-levenshtein@2.0.6: {}
 
+  fast-querystring@1.1.2:
+    dependencies:
+      fast-decode-uri-component: 1.0.1
+
   fast-uri@3.1.0: {}
 
+  fast-uri@4.1.1: {}
+
+  fastify@5.10.0:
+    dependencies:
+      '@fastify/ajv-compiler': 4.0.5
+      '@fastify/error': 4.2.0
+      '@fastify/fast-json-stringify-compiler': 5.1.0
+      '@fastify/proxy-addr': 5.1.0
+      abstract-logging: 2.0.1
+      avvio: 9.3.0
+      fast-json-stringify: 7.0.1
+      find-my-way: 9.7.0
+      light-my-request: 6.6.0
+      pino: 10.3.1
+      process-warning: 5.0.0
+      rfdc: 1.4.1
+      secure-json-parse: 4.1.0
+      semver: 7.7.4
+      toad-cache: 3.7.4
+
   fastq@1.20.1:
     dependencies:
       reusify: 1.1.0
@@ -8433,6 +8661,12 @@ snapshots:
 
   find-my-way-ts@0.1.6: {}
 
+  find-my-way@9.7.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-querystring: 1.1.2
+      safe-regex2: 5.1.1
+
   find-up@5.0.0:
     dependencies:
       locate-path: 6.0.0
@@ -8465,8 +8699,6 @@ snapshots:
 
   forwarded@0.2.0: {}
 
-  fp-ts@2.16.11: {}
-
   fresh@2.0.0: {}
 
   fs-extra@11.3.3:
@@ -8547,21 +8779,29 @@ snapshots:
     dependencies:
       graphql: 16.13.2
 
-  graphql-tag@2.12.6(graphql@16.13.2):
+  graphql-tag@2.12.6(graphql@16.14.2):
     dependencies:
-      graphql: 16.13.2
+      graphql: 16.14.2
       tslib: 2.8.1
 
-  graphql-ws@6.0.7(graphql@16.13.2)(ws@8.19.0):
+  graphql-ws@6.1.1(graphql@16.13.2)(ws@8.21.1):
     dependencies:
       graphql: 16.13.2
     optionalDependencies:
-      ws: 8.19.0
+      ws: 8.21.1
+
+  graphql-ws@6.1.1(graphql@16.14.2)(ws@8.21.1):
+    dependencies:
+      graphql: 16.14.2
+    optionalDependencies:
+      ws: 8.21.1
 
   graphql@16.12.0: {}
 
   graphql@16.13.2: {}
 
+  graphql@16.14.2: {}
+
   has-flag@4.0.0: {}
 
   has-property-descriptors@1.0.2:
@@ -8609,10 +8849,6 @@ snapshots:
       minimalistic-assert: 1.0.1
       minimalistic-crypto-utils: 1.0.1
 
-  hoist-non-react-statics@3.3.2:
-    dependencies:
-      react-is: 16.13.1
-
   hono@4.12.2: {}
 
   http-errors@2.0.1:
@@ -8655,14 +8891,12 @@ snapshots:
 
   inherits@2.0.4: {}
 
-  io-ts@2.2.22(fp-ts@2.16.11):
-    dependencies:
-      fp-ts: 2.16.11
-
   ip-address@10.0.1: {}
 
   ipaddr.js@1.9.1: {}
 
+  ipaddr.js@2.4.0: {}
+
   is-arguments@1.2.0:
     dependencies:
       call-bound: 1.0.4
@@ -8756,9 +8990,9 @@ snapshots:
 
   isomorphic-timers-promises@1.0.1: {}
 
-  isomorphic-ws@5.0.0(ws@8.19.0):
+  isomorphic-ws@5.0.0(ws@8.21.1):
     dependencies:
-      ws: 8.19.0
+      ws: 8.21.1
 
   jiti@2.6.1: {}
 
@@ -8776,6 +9010,10 @@ snapshots:
 
   json-parse-even-better-errors@2.3.1: {}
 
+  json-schema-ref-resolver@3.0.0:
+    dependencies:
+      dequal: 2.0.3
+
   json-schema-traverse@0.4.1: {}
 
   json-schema-traverse@1.0.0: {}
@@ -8820,6 +9058,12 @@ snapshots:
       prelude-ls: 1.2.1
       type-check: 0.4.0
 
+  light-my-request@6.6.0:
+    dependencies:
+      cookie: 1.1.1
+      process-warning: 4.0.1
+      set-cookie-parser: 2.7.2
+
   lightningcss-android-arm64@1.31.1:
     optional: true
 
@@ -8877,17 +9121,11 @@ snapshots:
 
   lodash.merge@4.6.2: {}
 
-  lodash@4.17.23: {}
-
   log-symbols@6.0.0:
     dependencies:
       chalk: 5.6.2
       is-unicode-supported: 1.3.0
 
-  loose-envify@1.4.0:
-    dependencies:
-      js-tokens: 4.0.0
-
   lru-cache@5.1.1:
     dependencies:
       yallist: 3.1.1
@@ -9288,6 +9526,8 @@ snapshots:
 
   process-nextick-args@2.0.1: {}
 
+  process-warning@4.0.1: {}
+
   process-warning@5.0.0: {}
 
   process@0.11.10: {}
@@ -9297,12 +9537,6 @@ snapshots:
       kleur: 3.0.3
       sisteransi: 1.0.5
 
-  prop-types@15.8.1:
-    dependencies:
-      loose-envify: 1.4.0
-      object-assign: 4.1.1
-      react-is: 16.13.1
-
   propagate@2.0.1: {}
 
   proxy-addr@2.0.7:
@@ -9423,8 +9657,6 @@ snapshots:
       react: 19.2.4
       scheduler: 0.27.0
 
-  react-is@16.13.1: {}
-
   react-remove-scroll-bar@2.3.8(@types/react@19.2.14)(react@19.2.4):
     dependencies:
       react: 19.2.4
@@ -9480,11 +9712,6 @@ snapshots:
       tiny-invariant: 1.3.3
       tslib: 2.8.1
 
-  rehackt@0.1.0(@types/react@19.2.14)(react@19.2.4):
-    optionalDependencies:
-      '@types/react': 19.2.14
-      react: 19.2.4
-
   require-directory@2.1.1: {}
 
   require-from-string@2.0.2: {}
@@ -9504,10 +9731,14 @@ snapshots:
       onetime: 7.0.0
       signal-exit: 4.1.0
 
+  ret@0.5.0: {}
+
   rettime@0.10.1: {}
 
   reusify@1.1.0: {}
 
+  rfdc@1.4.1: {}
+
   ripemd160@2.0.3:
     dependencies:
       hash-base: 3.1.2
@@ -9593,6 +9824,10 @@ snapshots:
       es-errors: 1.3.0
       is-regex: 1.2.1
 
+  safe-regex2@5.1.1:
+    dependencies:
+      ret: 0.5.0
+
   safe-stable-stringify@2.5.0: {}
 
   safer-buffer@2.1.2: {}
@@ -9602,6 +9837,8 @@ snapshots:
 
   scheduler@0.27.0: {}
 
+  secure-json-parse@4.1.0: {}
+
   semver@6.3.1: {}
 
   semver@7.7.4: {}
@@ -9631,6 +9868,8 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  set-cookie-parser@2.7.2: {}
+
   set-function-length@1.2.2:
     dependencies:
       define-data-property: 1.1.4
@@ -9736,7 +9975,7 @@ snapshots:
 
   smoldot@2.0.26:
     dependencies:
-      ws: 8.19.0
+      ws: 8.21.1
     transitivePeerDependencies:
       - bufferutil
       - utf-8-validate
@@ -9827,8 +10066,6 @@ snapshots:
 
   supports-preserve-symlinks-flag@1.0.0: {}
 
-  symbol-observable@4.0.0: {}
-
   tagged-tag@1.0.0: {}
 
   tailwind-merge@3.5.0: {}
@@ -9870,6 +10107,8 @@ snapshots:
     dependencies:
       is-number: 7.0.0
 
+  toad-cache@3.7.4: {}
+
   toidentifier@1.0.1: {}
 
   tough-cookie@6.0.0:
@@ -9882,10 +10121,6 @@ snapshots:
     dependencies:
       typescript: 5.9.3
 
-  ts-invariant@0.10.3:
-    dependencies:
-      tslib: 2.8.1
-
   ts-morph@26.0.0:
     dependencies:
       '@ts-morph/common': 0.27.0
@@ -9991,7 +10226,7 @@ snapshots:
 
   typescript-eslint@8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3):
     dependencies:
-      '@typescript-eslint/eslint-plugin': 8.56.1(@typescript-eslint/parser@8.56.1(eslint@10.0.1(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)
+      '@typescript-eslint/eslint-plugin': 8.56.1(@typescript-eslint/parser@8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3))(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/parser': 8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)
       '@typescript-eslint/typescript-estree': 8.56.1(typescript@5.9.3)
       '@typescript-eslint/utils': 8.56.1(eslint@9.39.3(jiti@2.6.1))(typescript@5.9.3)
@@ -10152,7 +10387,7 @@ snapshots:
 
   wrappy@1.0.2: {}
 
-  ws@8.19.0: {}
+  ws@8.21.1: {}
 
   wsl-utils@0.3.1:
     dependencies:
@@ -10188,17 +10423,6 @@ snapshots:
 
   yoctocolors@2.1.2: {}
 
-  zen-observable-ts@1.1.0:
-    dependencies:
-      '@types/zen-observable': 0.8.3
-      zen-observable: 0.8.15
-
-  zen-observable-ts@1.2.5:
-    dependencies:
-      zen-observable: 0.8.15
-
-  zen-observable@0.8.15: {}
-
   zod-to-json-schema@3.25.1(zod@3.25.76):
     dependencies:
       zod: 3.25.76