From 79d153871518120e8b6babf65f701e6655329d80 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Wed, 28 Oct 2026 22:41:33 +0500
Subject: [PATCH 01/11] feat(dashboard): verify a bond owner with ZKPassport

The operator guide gains a bond-owner identity panel. It reads the
identity policy from the latest IdentityPolicyUpdated log, the
verifier's fixed settings, and the owner's credential. It creates a
ZKPassport request bound to the owner and the chain, shows the QR code,
and builds the registration evidence from the expiry bound that the
proof committed to. An owner wallet registers directly; a Safe owner
downloads a Safe Transaction Builder batch. Before a deployment, the
panel makes a proof with the planned settings and offers only the
download, which the real-proof fork test replays.

The ZKPassport SDK and the QR code load only when an owner asks for a
proof.
---
 packages/interfold-dashboard/.env.example     |    6 +
 packages/interfold-dashboard/README.md        |   23 +
 packages/interfold-dashboard/package.json     |    5 +-
 .../interfold-dashboard/src/Operator.test.tsx |  170 +-
 packages/interfold-dashboard/src/Operator.tsx |  579 ++++++-
 packages/interfold-dashboard/src/lib/chain.ts |   10 +
 .../src/lib/identity.test.ts                  |  135 ++
 .../interfold-dashboard/src/lib/identity.ts   |  322 ++++
 .../interfold-dashboard/src/lib/networks.ts   |   20 +-
 packages/interfold-dashboard/src/styles.css   |   24 +
 pnpm-lock.yaml                                | 1431 +++++++++++++++--
 11 files changed, 2621 insertions(+), 104 deletions(-)
 create mode 100644 packages/interfold-dashboard/src/lib/identity.test.ts
 create mode 100644 packages/interfold-dashboard/src/lib/identity.ts

diff --git a/packages/interfold-dashboard/.env.example b/packages/interfold-dashboard/.env.example
index 8a39a58eb2..2a137d4a97 100644
--- a/packages/interfold-dashboard/.env.example
+++ b/packages/interfold-dashboard/.env.example
@@ -56,6 +56,12 @@
 # VITE_SEPOLIA_DEPLOY_BLOCK=
 # VITE_MAINNET_DEPLOY_BLOCK=
 
+# First block of the bond-owner identity policy scan (IdentityPolicyUpdated logs of
+# the bonding registry). Set it to a block at or before the registry upgrade that
+# added the policy, so the identity panel scans fewer blocks. Unset = DEPLOY_BLOCK.
+# VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK=
+# VITE_MAINNET_IDENTITY_DEPLOY_BLOCK=
+
 # E3 timeout windows (seconds), from the deployment's getTimeoutConfig(). Used to
 # decide whether an E3 is still active vs. expired (input close + these windows).
 # Sepolia: 604800 / 21600. Mainnet: 604800 / 21600.
diff --git a/packages/interfold-dashboard/README.md b/packages/interfold-dashboard/README.md
index 131fbdbedd..f352bed735 100644
--- a/packages/interfold-dashboard/README.md
+++ b/packages/interfold-dashboard/README.md
@@ -91,6 +91,28 @@ rewards** sends `claimRewards(e3Ids)` for the completed E3s of the connected rec
 `claimHonestNodeReward` for each failed E3. Each transaction waits for the previous one. E3s that an
 earlier refund manager recorded are not listed. The amounts use the `FEE_TOKEN_*` display settings.
 
+**Bond-owner identity** (`src/lib/identity.ts`) shows when the operator has a bond owner. Governance
+can require each bond owner to prove one identity document with ZKPassport (`OwnerIdentityRegistry`
+and `ZKPassportIdentityVerifier`). The page:
+
+1. Reads the policy from the latest `IdentityPolicyUpdated` log of the bonding registry (it has no
+   view). Then it reads the verifier's fixed settings (domain, scope, ZKPassport version, identifier
+   type, FaceMatch, proof validity, maximum validity) and the owner's credential (`identityOf`,
+   `isVerifiedAt`).
+2. Creates a ZKPassport request with `@zkpassport/sdk` in `compressed-evm` mode. The document must
+   be valid until a chosen date, and the proof binds the bond owner and the chain. The SDK and the
+   QR code load only when the owner asks for a proof.
+3. Builds the evidence, `abi.encode(ProofVerificationParams, validUntil)`. `validUntil` is the
+   expiry bound that the proof committed to, not the typed date.
+4. Registers it. An owner wallet sends `register(evidence)`. A Safe downloads a Safe Transaction
+   Builder batch and executes it before the proof's validity ends.
+
+The page warns when the proof's ZKPassport version differs from the verifier's, when the proof is
+too old, when a renewal would shorten the credential, and when the credential ends inside the
+current 30-day capacity window. Before a deployment (no policy log), it makes a proof with the
+planned settings (`PREVIEW_SERVICE`) and offers only the download. The download holds the proofs,
+the verifier parameters, and the evidence, so a fork test can replay it.
+
 Only `VITE_BONDING_REGISTRY_ADDRESS` is configured. The ciphernode bond token, ticket wrapper,
 ticket underlying, bond size, ticket price, minimum tickets, and exit delay are all read back from
 the registry, so the guide follows the deployment instead of a hardcoded token list.
@@ -122,6 +144,7 @@ default:
   the "Get test tokens" action on a testnet too.
 - `FEE_TOKEN_SYMBOL`, `FEE_TOKEN_DECIMALS` — fee token display.
 - `DEPLOY_BLOCK` — first block to scan from (the Interfold deploy block).
+- `IDENTITY_DEPLOY_BLOCK` — first block of the identity policy scan (defaults to `DEPLOY_BLOCK`).
 - `COMPUTE_WINDOW`, `DECRYPTION_WINDOW` — E3 timeout windows in seconds.
 
 `vite.config.ts` stops the build when an override has no network scope (for example `VITE_RPC_URL`),
diff --git a/packages/interfold-dashboard/package.json b/packages/interfold-dashboard/package.json
index d4e0c708d7..693ee61d5b 100644
--- a/packages/interfold-dashboard/package.json
+++ b/packages/interfold-dashboard/package.json
@@ -9,16 +9,19 @@
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
-    "test": "tsx --test src/Inspector.test.tsx src/Operator.test.tsx",
+    "test": "tsx --test src/Inspector.test.tsx src/Operator.test.tsx src/lib/identity.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@interfold/contracts": "workspace:*",
+    "@zkpassport/sdk": "0.19.2",
+    "qrcode": "1.5.4",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "viem": "^2.21.0"
   },
   "devDependencies": {
+    "@types/qrcode": "1.5.5",
     "@types/react": "^18.3.3",
     "@types/react-dom": "^18.3.0",
     "@vitejs/plugin-react": "^4.3.1",
diff --git a/packages/interfold-dashboard/src/Operator.test.tsx b/packages/interfold-dashboard/src/Operator.test.tsx
index f5883d1e75..cd1e248a32 100644
--- a/packages/interfold-dashboard/src/Operator.test.tsx
+++ b/packages/interfold-dashboard/src/Operator.test.tsx
@@ -8,10 +8,12 @@ import assert from 'node:assert/strict'
 import test from 'node:test'
 import { renderToStaticMarkup } from 'react-dom/server'
 import type { Address } from 'viem'
-import { CommitteeRewardsView, ManagePosition, positionActions, ticketBurnAmount } from './Operator'
+import { CommitteeRewardsView, IdentityView, ManagePosition, positionActions, ticketBurnAmount, type IdentityService } from './Operator'
 import { CONTRACTS, E3Stage, FEE_TOKEN } from './lib/chain'
 import type { BondingConfig, OperatorStatus } from './lib/bonding'
 import { claimPlan, summarizeRewards, type CommitteeSeat, type SeatStatus } from './lib/rewards'
+import { buildProofBundle, dateInput, identityStatusText, parseDateInput, type OwnerAccount, type VerifierConfig } from './lib/identity'
+import { pad, toHex, type Hex } from 'viem'
 
 const OPERATOR = '0x1111111111111111111111111111111111111111' as Address
 const OWNER = '0x2222222222222222222222222222222222222222' as Address
@@ -168,3 +170,169 @@ test('the claim covers the claimable seats of the connected recipient, and the s
   assert.match(renderToStaticMarkup(<CommitteeRewardsView {...props} statuses={null} wallet={OWNER} />), /Reading rewards/)
   assert.match(renderToStaticMarkup(<CommitteeRewardsView {...props} seats={[]} wallet={OWNER} />), /No committee has selected/)
 })
+
+// ─── Bond-owner identity ───────────────────────────────────────────────────
+
+const DAY = 86_400n
+const NOW = 1_790_000_000n
+const word = (value: bigint): Hex => pad(toHex(value), { size: 32 })
+const VERSION = word(0x14n << 232n)
+
+const service: IdentityService = {
+  domain: 'dashboard.theinterfold.com',
+  scope: 'interfold-bond-owner',
+  faceMatch: true,
+  nullifierType: 0,
+  proofValidity: 7n * DAY,
+  maxValidity: 365n * DAY,
+}
+
+const verifier: VerifierConfig = {
+  address: OTHER,
+  domain: service.domain,
+  scope: service.scope,
+  version: VERSION,
+  nullifierType: 0,
+  oprfKeyHash: word(0n),
+  faceMatchRequired: true,
+  proofValidity: service.proofValidity,
+  maxValidity: service.maxValidity,
+}
+
+const policy = { registry: PROPOSED, required: true, timepoint: NOW - 10n * DAY }
+
+function account(overrides: Partial<OwnerAccount> = {}): OwnerAccount {
+  return { now: NOW, isContract: false, identity: { identityId: word(0n), expiresAt: 0n, verifiedNow: false }, ...overrides }
+}
+
+function bundle(version: Hex = VERSION) {
+  return buildProofBundle({
+    success: {
+      proofs: [
+        {
+          name: 'compare_expiry_evm',
+          committedInputs: { compare_expiry_evm: { minDateTimestamp: Number(NOW + 400n * DAY), maxDateTimestamp: 0 } },
+        },
+        { name: 'outer_evm_count_5', proof: '0x02' },
+      ],
+      result: {},
+    },
+    params: {
+      version,
+      proofVerificationData: {
+        vkeyHash: word(7n),
+        proof: '0x1234',
+        publicInputs: [word(1n), word(2n), word(NOW), word(0n), word(9n), word(0n)],
+      },
+      committedInputs: '0xbeef',
+      serviceConfig: { validityPeriodInSeconds: 604_800, domain: service.domain, scope: service.scope, devMode: false },
+    },
+    owner: OWNER,
+    chainId: 11_155_111,
+    faceMatch: true,
+  })
+}
+
+const identityProps = {
+  owner: OWNER,
+  policy,
+  verifier,
+  account: account(),
+  loadFailed: false,
+  service,
+  validUntilInput: '2027-12-01',
+  onValidUntil: () => {},
+  previewFaceMatch: true,
+  onPreviewFaceMatch: () => {},
+  request: { phase: 'idle' } as const,
+  canRegister: true,
+  busy: null,
+  errFor: () => null,
+  onReload: () => {},
+  onCreate: () => {},
+  onCancel: () => {},
+  onRegister: () => {},
+  onDownloadProof: () => {},
+  onDownloadSafe: () => {},
+}
+
+test('date fields round-trip in UTC and reject impossible dates', () => {
+  assert.equal(parseDateInput('2027-12-01'), BigInt(Date.UTC(2027, 11, 1) / 1000))
+  assert.equal(dateInput(parseDateInput('2027-12-01')!), '2027-12-01')
+  assert.equal(parseDateInput('2026-02-31'), null)
+  assert.equal(parseDateInput('01/12/2027'), null)
+})
+
+test('the identity panel shows the credential and offers a request', () => {
+  const unverified = renderToStaticMarkup(<IdentityView {...identityProps} />)
+  assert.match(unverified, /Yes, since/)
+  assert.match(unverified, /Not verified/)
+  assert.match(unverified, /Verify the owner/)
+  assert.match(unverified, />Create ZKPassport request</)
+  assert.match(unverified, /face scan/)
+
+  const verified = account({ identity: { identityId: word(1n), expiresAt: NOW + 200n * DAY, verifiedNow: true } })
+  assert.equal(
+    identityStatusText(verified),
+    `Verified until ${new Date(Number(NOW + 200n * DAY) * 1000).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric', timeZone: 'UTC' })}`,
+  )
+  const renew = renderToStaticMarkup(<IdentityView {...identityProps} account={verified} validUntilInput={dateInput(NOW + 100n * DAY)} />)
+  assert.match(renew, /Renew the credential/)
+  assert.match(renew, /A renewal cannot shorten the credential/)
+
+  // A credential that ends inside the current window does not count toward request capacity.
+  const short = account({ identity: { identityId: word(1n), expiresAt: NOW + 1n, verifiedNow: true } })
+  assert.match(renderToStaticMarkup(<IdentityView {...identityProps} account={short} />), /does not count toward request capacity/)
+  assert.match(
+    renderToStaticMarkup(<IdentityView {...identityProps} validUntilInput={dateInput(NOW + 1n)} />),
+    /would not count toward request/,
+  )
+})
+
+test('before a deployment the panel makes a proof to download', () => {
+  const preview = renderToStaticMarkup(
+    <IdentityView {...identityProps} policy={null} verifier={null} account={account({ identity: null })} />,
+  )
+  assert.match(preview, /No identity registry on/)
+  assert.match(preview, /planned settings/)
+  assert.match(preview, /Require FaceMatch/)
+
+  const ready = renderToStaticMarkup(
+    <IdentityView
+      {...identityProps}
+      policy={null}
+      verifier={null}
+      account={account({ identity: null })}
+      request={{ phase: 'ready', bundle: bundle() }}
+    />,
+  )
+  assert.match(ready, /Proof ready/)
+  assert.match(ready, />Download the proof \(JSON\)</)
+  assert.doesNotMatch(ready, /Register the identity/)
+})
+
+test('a proof registers from the owner, or as a Safe transaction', () => {
+  const ready = { phase: 'ready', bundle: bundle() } as const
+  const eoa = renderToStaticMarkup(<IdentityView {...identityProps} request={ready} />)
+  assert.match(eoa, /<button class="btn btn--primary">Register the identity/)
+  assert.match(eoa, /Refresh the status/)
+
+  const otherWallet = renderToStaticMarkup(<IdentityView {...identityProps} request={ready} canRegister={false} />)
+  assert.match(otherWallet, /<button class="btn btn--primary" disabled="">Register the identity/)
+  assert.match(otherWallet, /Connect the bond-owner wallet/)
+
+  const safe = renderToStaticMarkup(<IdentityView {...identityProps} account={account({ isContract: true })} request={ready} />)
+  assert.match(safe, />Download the Safe transaction</)
+  assert.doesNotMatch(safe, /Register the identity/)
+  assert.match(safe, /Safe Transaction Builder/)
+
+  // The verifier accepts one ZKPassport version.
+  const otherVersion = { phase: 'ready', bundle: bundle(word(0x15n << 232n)) } as const
+  const mismatch = renderToStaticMarkup(<IdentityView {...identityProps} request={otherVersion} />)
+  assert.match(mismatch, /another ZKPassport version/)
+  assert.match(mismatch, /<button class="btn btn--primary" disabled="">Register the identity/)
+
+  // A proof older than the verifier's validity window cannot register.
+  const late = renderToStaticMarkup(<IdentityView {...identityProps} account={account({ now: NOW + 8n * DAY })} request={ready} />)
+  assert.match(late, /too old to register/)
+})
diff --git a/packages/interfold-dashboard/src/Operator.tsx b/packages/interfold-dashboard/src/Operator.tsx
index a37ca98a15..c304d5e7f0 100644
--- a/packages/interfold-dashboard/src/Operator.tsx
+++ b/packages/interfold-dashboard/src/Operator.tsx
@@ -13,10 +13,11 @@
 // that funds and controls the collateral. They may be the same wallet, and the
 // guide supports either arrangement.
 
-import { useEffect, useMemo, useState, type ReactNode } from 'react'
+import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react'
 import { erc20Abi, formatUnits, isAddress, parseUnits, type Address, type Hash } from 'viem'
 import Loader from './Loader'
 import {
+  CHAIN,
   CONTRACTS,
   FEE_TOKEN,
   IS_TESTNET,
@@ -25,7 +26,28 @@ import {
   e3RefundManagerAbi,
   faucetAbi,
   interfoldAbi,
+  ownerIdentityRegistryAbi,
 } from './lib/chain'
+import {
+  PREVIEW_SERVICE,
+  boundChainName,
+  buildProofBundle,
+  capacityWindowEnd,
+  credentialEnd,
+  dateInput,
+  fetchIdentityPolicy,
+  fetchOwnerAccount,
+  fetchVerifierConfig,
+  fmtDay,
+  identityStatusText,
+  outerEvmProof,
+  parseDateInput,
+  safeRegistrationBatch,
+  type IdentityPolicy,
+  type OwnerAccount,
+  type ProofBundle,
+  type VerifierConfig,
+} from './lib/identity'
 import { LINKS, explorerAddress, explorerTx } from './lib/links'
 import { compactE3Id } from './lib/pollMeta'
 import {
@@ -680,6 +702,16 @@ export default function Operator() {
             </StepCard>
           </div>
 
+          {status?.bondOwner && (
+            <IdentityPanel
+              owner={status.bondOwner}
+              wallet={connected ? wallet.address : null}
+              busy={busy}
+              send={(key, call) => void run(key, () => write(call))}
+              errFor={errFor}
+            />
+          )}
+
           {operator && status && (
             <ManagePosition
               config={config}
@@ -1318,6 +1350,551 @@ function RewardsSummary({
   )
 }
 
+// ─── Bond-owner identity ──────────────────────────────────────────────────
+
+/** The ZKPassport request of the identity panel. */
+export type IdentityRequest =
+  | { phase: 'idle' }
+  | { phase: 'creating' }
+  | { phase: 'waiting'; url: string; qr: string; received: boolean }
+  | { phase: 'proving' }
+  | { phase: 'ready'; bundle: ProofBundle }
+  | { phase: 'failed'; message: string }
+
+/** The proof settings: the deployed verifier's, or the planned ones before a deployment. */
+export type IdentityService = {
+  domain: string
+  scope: string
+  faceMatch: boolean
+  /** 0 non-salted, 1 salted; null keeps the ZKPassport default. */
+  nullifierType: number | null
+  proofValidity: bigint
+  maxValidity: bigint
+}
+
+const REGISTER_IDENTITY_KEY = 'registerIdentity'
+
+function identityService(verifier: VerifierConfig | null, previewFaceMatch: boolean): IdentityService {
+  return verifier
+    ? {
+        domain: verifier.domain,
+        scope: verifier.scope,
+        faceMatch: verifier.faceMatchRequired,
+        nullifierType: verifier.nullifierType,
+        proofValidity: verifier.proofValidity,
+        maxValidity: verifier.maxValidity,
+      }
+    : {
+        domain: PREVIEW_SERVICE.domain,
+        scope: PREVIEW_SERVICE.scope,
+        faceMatch: previewFaceMatch,
+        nullifierType: null,
+        proofValidity: PREVIEW_SERVICE.proofValidity,
+        maxValidity: PREVIEW_SERVICE.maxValidity,
+      }
+}
+
+function IdentityPanel({
+  owner,
+  wallet,
+  busy,
+  send,
+  errFor,
+}: {
+  owner: Address
+  wallet: Address | null
+  busy: string | null
+  send: (key: string, call: ContractCall) => void
+  errFor: (key: string) => ReactNode
+}) {
+  const [reload, setReload] = useState(0)
+  // undefined while loading; null when the network has no identity policy.
+  const [policy, setPolicy] = useState<IdentityPolicy | null | undefined>(undefined)
+  const [verifier, setVerifier] = useState<VerifierConfig | null>(null)
+  // Kept with the owner that it was read for, so another owner never shows these values.
+  const [account, setAccount] = useState<{ owner: Address; value: OwnerAccount } | null>(null)
+  const [loadFailed, setLoadFailed] = useState(false)
+  const [request, setRequest] = useState<IdentityRequest>({ phase: 'idle' })
+  // null until the owner types a date.
+  const [validUntilInput, setValidUntilInput] = useState<string | null>(null)
+  const [previewFaceMatch, setPreviewFaceMatch] = useState(true)
+  const cancelRequest = useRef<(() => void) | null>(null)
+  // Each request gets a token. A callback of an older request changes nothing.
+  const requestToken = useRef(0)
+
+  useEffect(() => {
+    let cancelled = false
+    const load = async () => {
+      const nextPolicy = await fetchIdentityPolicy()
+      const nextVerifier = nextPolicy ? await fetchVerifierConfig(nextPolicy.registry) : null
+      if (cancelled) return
+      setPolicy(nextPolicy)
+      setVerifier(nextVerifier)
+    }
+    load().catch(() => {
+      if (!cancelled) setLoadFailed(true)
+    })
+    return () => {
+      cancelled = true
+    }
+  }, [reload])
+
+  // `busy` changes when a transaction settles, so a registration shows its new expiry.
+  useEffect(() => {
+    if (policy === undefined) return
+    let cancelled = false
+    fetchOwnerAccount(owner, policy?.registry ?? null).then(
+      (value) => {
+        if (!cancelled) setAccount({ owner, value })
+      },
+      () => {
+        if (!cancelled) setLoadFailed(true)
+      },
+    )
+    return () => {
+      cancelled = true
+    }
+  }, [owner, policy, busy, reload])
+
+  // A request binds one owner, so a new owner starts over. Clearing during render (not in an effect)
+  // drops the old owner's request before the browser paints it.
+  const [requestOwner, setRequestOwner] = useState(owner)
+  if (owner !== requestOwner) {
+    setRequestOwner(owner)
+    setRequest({ phase: 'idle' })
+    setValidUntilInput(null)
+  }
+  useEffect(
+    () => () => {
+      requestToken.current += 1
+      cancelRequest.current?.()
+      cancelRequest.current = null
+    },
+    [owner],
+  )
+
+  const service = identityService(verifier, previewFaceMatch)
+  const current = account?.owner === owner ? account.value : null
+  // Until the owner types a date, the field offers the longest credential that the verifier allows.
+  const validUntilValue = validUntilInput ?? (current ? dateInput(current.now + service.maxValidity) : '')
+
+  const create = async () => {
+    const chain = boundChainName(CHAIN.id)
+    const validUntil = parseDateInput(validUntilValue)
+    if (!chain || validUntil === null) return
+    cancelRequest.current?.()
+    const token = ++requestToken.current
+    const update = (next: IdentityRequest) => {
+      if (requestToken.current === token) setRequest(next)
+    }
+    update({ phase: 'creating' })
+    try {
+      // The SDK is large, so it loads only when an owner asks for a proof.
+      const [sdk, qrcode] = await Promise.all([import('@zkpassport/sdk'), import('qrcode')])
+      const zkPassport = new sdk.ZKPassport(service.domain)
+      const builder = await zkPassport.request({
+        name: 'Interfold',
+        purpose: 'Verify the bond owner of an Interfold ciphernode.',
+        scope: service.scope,
+        mode: 'compressed-evm',
+        devMode: false,
+        ...(service.nullifierType === null
+          ? {}
+          : { uniqueIdentifierType: service.nullifierType === 1 ? sdk.NullifierType.SALTED : sdk.NullifierType.NON_SALTED }),
+      })
+      let query = builder
+        .gte('expiry_date', new Date(Number(validUntil) * 1000))
+        .bind('user_address', owner)
+        .bind('chain', chain)
+      if (service.faceMatch) query = query.facematch('strict')
+      const result = query.done()
+      if (requestToken.current !== token) return zkPassport.cancelRequest(result.requestId)
+      cancelRequest.current = () => zkPassport.cancelRequest(result.requestId)
+      const qr = await qrcode.toDataURL(result.url, { margin: 1, width: 240 })
+      update({ phase: 'waiting', url: result.url, qr, received: false })
+      result.onRequestReceived(() => update({ phase: 'waiting', url: result.url, qr, received: true }))
+      result.onGeneratingProof(() => update({ phase: 'proving' }))
+      result.onSuccess((success) => {
+        try {
+          const outer = outerEvmProof(success.proofs)
+          if (!outer) throw new Error('The app sent no EVM proof.')
+          const params = zkPassport.getSolidityVerifierParameters({ proof: outer, scope: service.scope, devMode: false })
+          update({
+            phase: 'ready',
+            bundle: buildProofBundle({ success, params, owner, chainId: CHAIN.id, faceMatch: service.faceMatch }),
+          })
+        } catch (e) {
+          update({ phase: 'failed', message: walletErrorMessage(e) })
+        }
+      })
+      result.onReject(() => update({ phase: 'failed', message: 'The request was rejected in the ZKPassport app.' }))
+      result.onError((message) => update({ phase: 'failed', message }))
+    } catch (e) {
+      update({ phase: 'failed', message: walletErrorMessage(e) })
+    }
+  }
+
+  return (
+    <IdentityView
+      owner={owner}
+      policy={policy}
+      verifier={verifier}
+      account={current}
+      loadFailed={loadFailed}
+      service={service}
+      validUntilInput={validUntilValue}
+      onValidUntil={setValidUntilInput}
+      previewFaceMatch={previewFaceMatch}
+      onPreviewFaceMatch={setPreviewFaceMatch}
+      request={request}
+      canRegister={sameAddress(wallet, owner)}
+      busy={busy}
+      errFor={errFor}
+      onReload={() => {
+        setLoadFailed(false)
+        setReload((n) => n + 1)
+      }}
+      onCreate={() => void create()}
+      onCancel={() => {
+        requestToken.current += 1
+        cancelRequest.current?.()
+        cancelRequest.current = null
+        setRequest({ phase: 'idle' })
+      }}
+      onRegister={(bundle) =>
+        send(REGISTER_IDENTITY_KEY, {
+          address: policy!.registry,
+          abi: ownerIdentityRegistryAbi,
+          functionName: 'register',
+          args: [bundle.evidence],
+        })
+      }
+      onDownloadProof={(bundle) => downloadJson(`interfold-identity-proof-${owner}.json`, bundle)}
+      onDownloadSafe={(bundle) =>
+        downloadJson(
+          `interfold-identity-safe-${owner}.json`,
+          safeRegistrationBatch(policy!.registry, owner, CHAIN.id, bundle.evidence, Date.now()),
+        )
+      }
+    />
+  )
+}
+
+/**
+ * The bond owner's credential, the ZKPassport request, and the registration. `policy` is undefined
+ * while it loads and null when the network has no identity registry; `account` is null while it loads.
+ */
+export function IdentityView({
+  owner,
+  policy,
+  verifier,
+  account,
+  loadFailed,
+  service,
+  validUntilInput,
+  onValidUntil,
+  previewFaceMatch,
+  onPreviewFaceMatch,
+  request,
+  canRegister,
+  busy,
+  errFor,
+  onReload,
+  onCreate,
+  onCancel,
+  onRegister,
+  onDownloadProof,
+  onDownloadSafe,
+}: {
+  owner: Address
+  policy: IdentityPolicy | null | undefined
+  verifier: VerifierConfig | null
+  account: OwnerAccount | null
+  loadFailed: boolean
+  service: IdentityService
+  validUntilInput: string
+  onValidUntil: (value: string) => void
+  previewFaceMatch: boolean
+  onPreviewFaceMatch: (value: boolean) => void
+  request: IdentityRequest
+  canRegister: boolean
+  busy: string | null
+  errFor: (key: string) => ReactNode
+  onReload: () => void
+  onCreate: () => void
+  onCancel: () => void
+  onRegister: (bundle: ProofBundle) => void
+  onDownloadProof: (bundle: ProofBundle) => void
+  onDownloadSafe: (bundle: ProofBundle) => void
+}) {
+  const preview = policy === null
+  const chain = boundChainName(CHAIN.id)
+  const validUntil = parseDateInput(validUntilInput)
+  const windowEnd = account ? capacityWindowEnd(account.now) : null
+  const currentExpiry = account?.identity?.expiresAt ?? 0n
+  const requesting = request.phase === 'creating' || request.phase === 'waiting' || request.phase === 'proving'
+
+  return (
+    <section className='opposition opidentity'>
+      <div className='section__eyebrow'>Bond owner / Identity</div>
+      <h3 className='oprewards__title'>Bond-owner identity</h3>
+      <p className='opnext__body'>
+        Governance can require each bond owner to prove one identity document with the ZKPassport app. The proof shows that the document is
+        valid. It puts no personal data on chain. One owner may fund many operators.
+      </p>
+
+      {loadFailed ? (
+        <>
+          <Note kind='warn'>Could not read the identity registry.</Note>
+          <button className='btn btn--ghost' onClick={onReload}>
+            Try again
+          </button>
+        </>
+      ) : policy === undefined || !account ? (
+        <p className='opmanage__text'>Loading the identity status…</p>
+      ) : (
+        <>
+          <dl className='dl'>
+            <dt>Bond owner</dt>
+            <dd>
+              <AddrLink address={owner} />
+              {account.isContract && <span className='dl__muted'> · contract wallet (Safe)</span>}
+            </dd>
+            <dt>Identity required</dt>
+            <dd>
+              {preview ? (
+                <span className='dl__muted'>No identity registry on {NETWORK_NAME} yet</span>
+              ) : policy.required ? (
+                `Yes, since ${fmtDay(policy.timepoint)}`
+              ) : (
+                'Not yet'
+              )}
+            </dd>
+            {!preview && (
+              <>
+                <dt>Credential</dt>
+                <dd>{identityStatusText(account)}</dd>
+              </>
+            )}
+          </dl>
+          {!preview && account.identity && account.identity.verifiedNow && windowEnd !== null && currentExpiry < windowEnd && (
+            <Note kind='warn'>
+              The credential ends before this 30-day window ends ({fmtDay(windowEnd)}), so this owner does not count toward request capacity
+              in this window. Renew it.
+            </Note>
+          )}
+          {preview && (
+            <Note>
+              You can still make a proof and download it. It uses the planned settings: domain{' '}
+              <code className='mono'>{service.domain}</code>, scope <code className='mono'>{service.scope}</code>.
+            </Note>
+          )}
+
+          {!chain ? (
+            <Note kind='warn'>ZKPassport does not verify proofs on {NETWORK_NAME}.</Note>
+          ) : request.phase === 'ready' ? (
+            <IdentityProof
+              bundle={request.bundle}
+              owner={owner}
+              preview={preview}
+              verifier={verifier}
+              account={account}
+              service={service}
+              canRegister={canRegister}
+              busy={busy}
+              errFor={errFor}
+              onRegister={onRegister}
+              onDownloadProof={onDownloadProof}
+              onDownloadSafe={onDownloadSafe}
+              onRestart={onCancel}
+            />
+          ) : (
+            <div className='opmanage__group'>
+              <h4 className='opmanage__title'>{account.identity?.expiresAt ? 'Renew the credential' : 'Verify the owner'}</h4>
+              <p className='opmanage__text'>
+                Use a passport, ID card or residence permit with a chip, and a phone with NFC and the ZKPassport app. The proof is bound to
+                this owner and to {NETWORK_NAME}.
+              </p>
+              <Field
+                label='Document valid until (UTC date)'
+                value={validUntilInput}
+                onChange={onValidUntil}
+                placeholder='YYYY-MM-DD'
+                invalid={validUntilInput.trim() !== '' && validUntil === null}
+                hint={`The document must be valid at least until this date. The credential ends on this date, or ${formatDuration(
+                  service.maxValidity,
+                )} after the proof, if that is earlier.`}
+              />
+              {validUntil !== null && windowEnd !== null && validUntil < windowEnd && (
+                <Note kind='warn'>
+                  This date is before the end of the current 30-day window ({fmtDay(windowEnd)}). The owner would not count toward request
+                  capacity in this window.
+                </Note>
+              )}
+              {validUntil !== null && account.identity && validUntil <= currentExpiry && (
+                <Note kind='warn'>
+                  Pick a date after the current expiry ({fmtDay(currentExpiry)}). A renewal cannot shorten the credential.
+                </Note>
+              )}
+              {preview ? (
+                <label className='opcheck'>
+                  <input type='checkbox' checked={previewFaceMatch} onChange={(e) => onPreviewFaceMatch(e.target.checked)} />
+                  <span>Require FaceMatch (a live face scan against the chip photo)</span>
+                </label>
+              ) : (
+                service.faceMatch && <Note>The app also asks for a face scan (FaceMatch).</Note>
+              )}
+
+              {request.phase === 'waiting' ? (
+                <div className='opidentity__request'>
+                  <img className='opidentity__qr' src={request.qr} alt='ZKPassport request QR code' width={240} height={240} />
+                  <div>
+                    <p className='opmanage__text'>
+                      {request.received
+                        ? 'The request is open in the app. Check the site and the bound address, then approve it.'
+                        : 'Scan this code with the ZKPassport app.'}
+                    </p>
+                    <a className='link-inline' href={request.url} target='_blank' rel='noreferrer'>
+                      Open the request on this phone
+                    </a>
+                  </div>
+                </div>
+              ) : request.phase === 'proving' ? (
+                <p className='opmanage__text'>The app is making the proof. This takes up to a minute.</p>
+              ) : request.phase === 'failed' ? (
+                <Note kind='warn'>{request.message}</Note>
+              ) : null}
+
+              <div className='opactions'>
+                {requesting ? (
+                  <button className='btn btn--ghost' onClick={onCancel}>
+                    Cancel
+                  </button>
+                ) : (
+                  <button className='btn btn--primary' disabled={validUntil === null} onClick={onCreate}>
+                    {request.phase === 'failed' ? 'Try again' : 'Create ZKPassport request'}
+                  </button>
+                )}
+              </div>
+            </div>
+          )}
+        </>
+      )}
+    </section>
+  )
+}
+
+/** A proof from the app: what the verifier will read from it, and the ways to register it. */
+function IdentityProof({
+  bundle,
+  owner,
+  preview,
+  verifier,
+  account,
+  service,
+  canRegister,
+  busy,
+  errFor,
+  onRegister,
+  onDownloadProof,
+  onDownloadSafe,
+  onRestart,
+}: {
+  bundle: ProofBundle
+  owner: Address
+  preview: boolean
+  verifier: VerifierConfig | null
+  account: OwnerAccount
+  service: IdentityService
+  canRegister: boolean
+  busy: string | null
+  errFor: (key: string) => ReactNode
+  onRegister: (bundle: ProofBundle) => void
+  onDownloadProof: (bundle: ProofBundle) => void
+  onDownloadSafe: (bundle: ProofBundle) => void
+  onRestart: () => void
+}) {
+  const validUntil = BigInt(bundle.validUntil)
+  const proofDate = BigInt(bundle.proofDate)
+  const ends = credentialEnd(validUntil, proofDate, service.maxValidity)
+  const deadline = proofDate + service.proofValidity
+  const versionMatches = !verifier || bundle.version.toLowerCase() === verifier.version.toLowerCase()
+  const expired = account.now > deadline
+  const shortens = account.identity !== null && ends <= account.identity.expiresAt
+  const blocked = !versionMatches || expired || shortens
+
+  return (
+    <div className='opmanage__group'>
+      <h4 className='opmanage__title'>Proof ready</h4>
+      <dl className='dl'>
+        <dt>Bound to</dt>
+        <dd>
+          <AddrLink address={bundle.owner} /> on {NETWORK_NAME}
+        </dd>
+        <dt>Document valid until</dt>
+        <dd>{fmtDay(validUntil)}</dd>
+        <dt>Credential ends</dt>
+        <dd>{fmtDay(ends)}</dd>
+        <dt>Register before</dt>
+        <dd>{fmtDay(deadline)}</dd>
+        <dt>Identifier type</dt>
+        <dd>{bundle.nullifierType === 1 ? 'Salted' : 'Not salted'}</dd>
+      </dl>
+      {!versionMatches && (
+        <Note kind='warn'>
+          The app made the proof with another ZKPassport version than the verifier accepts. Governance must deploy a verifier for the new
+          version first.
+        </Note>
+      )}
+      {expired && <Note kind='warn'>The proof is too old to register. Create a new request.</Note>}
+      {shortens && <Note kind='warn'>This proof ends before the current credential. A renewal cannot shorten it.</Note>}
+
+      <div className='opactions'>
+        {!preview && !account.isContract && (
+          <button className='btn btn--primary' disabled={busy !== null || !canRegister || blocked} onClick={() => onRegister(bundle)}>
+            {busy === REGISTER_IDENTITY_KEY ? 'Confirming…' : 'Register the identity'}
+          </button>
+        )}
+        {!preview && account.isContract && (
+          <button className='btn btn--primary' disabled={blocked} onClick={() => onDownloadSafe(bundle)}>
+            Download the Safe transaction
+          </button>
+        )}
+        <button className='btn btn--ghost' onClick={() => onDownloadProof(bundle)}>
+          Download the proof (JSON)
+        </button>
+        <button className='btn btn--ghost' onClick={onRestart}>
+          New request
+        </button>
+      </div>
+      {errFor(REGISTER_IDENTITY_KEY)}
+      {!preview && !account.isContract && !canRegister && <Note>Connect the bond-owner wallet {shortAddr(owner)} to register.</Note>}
+      {!preview && account.isContract && (
+        <Note>
+          Load the file in the Safe Transaction Builder and execute it before {fmtDay(deadline)}. The registration costs about 1.3 million
+          gas.
+        </Note>
+      )}
+      {!preview && (
+        <Note>
+          The owner's operators count toward this window's request capacity after their next status refresh. Each node refreshes itself when
+          a window starts; to count now, use <strong>Refresh the status</strong> in Manage the position.
+        </Note>
+      )}
+    </div>
+  )
+}
+
+function downloadJson(name: string, value: unknown) {
+  const text = JSON.stringify(value, (_, v) => (typeof v === 'bigint' ? v.toString() : v), 2)
+  const url = URL.createObjectURL(new Blob([text], { type: 'application/json' }))
+  const link = document.createElement('a')
+  link.href = url
+  link.download = name
+  link.click()
+  URL.revokeObjectURL(url)
+}
+
 const bigMax = (a: bigint, b: bigint): bigint => (a > b ? a : b)
 
 // Parse a user-typed decimal amount. Returns null for anything that isn't a
diff --git a/packages/interfold-dashboard/src/lib/chain.ts b/packages/interfold-dashboard/src/lib/chain.ts
index 5ea364f783..3aaf964031 100644
--- a/packages/interfold-dashboard/src/lib/chain.ts
+++ b/packages/interfold-dashboard/src/lib/chain.ts
@@ -15,9 +15,12 @@ import {
   CiphernodeRegistryOwnable__factory,
   E3RefundManager__factory,
   Faucet__factory,
+  IOwnerIdentityRegistry__factory,
+  IZKPassportVerifier__factory,
   Interfold__factory,
   InterfoldTicketToken__factory,
   InterfoldToken__factory,
+  ZKPassportIdentityVerifier__factory,
 } from '@interfold/contracts/types'
 import { NETWORKS, overrideKey, selectNetwork, type Env, type Setting } from './networks'
 
@@ -123,6 +126,10 @@ export const FEE_TOKEN = {
 // emitted before Interfold was deployed.
 export const DEPLOY_BLOCK = BigInt(envStr('DEPLOY_BLOCK', NET.deployBlock))
 
+// First block of the bond-owner identity policy scan. The policy is the latest
+// IdentityPolicyUpdated log of the bonding registry.
+export const IDENTITY_DEPLOY_BLOCK = BigInt(envStr('IDENTITY_DEPLOY_BLOCK', NET.identityDeployBlock || String(DEPLOY_BLOCK)))
+
 // E3 timeout windows (seconds), matching the deployment's timeoutConfig. Used to
 // decide whether an E3 is still genuinely active vs. expired without completing.
 export const TIMEOUTS = {
@@ -137,3 +144,6 @@ export const bondingRegistryAbi = BondingRegistry__factory.abi
 export const ticketTokenAbi = InterfoldTicketToken__factory.abi
 export const ciphernodeBondTokenAbi = InterfoldToken__factory.abi
 export const faucetAbi = Faucet__factory.abi
+export const ownerIdentityRegistryAbi = IOwnerIdentityRegistry__factory.abi
+export const zkPassportIdentityVerifierAbi = ZKPassportIdentityVerifier__factory.abi
+export const zkPassportRootVerifierAbi = IZKPassportVerifier__factory.abi
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
new file mode 100644
index 0000000000..eefd2dc42f
--- /dev/null
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { decodeAbiParameters, decodeFunctionData, getAbiItem, pad, toHex, type Address, type Hex } from 'viem'
+import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk'
+import { ownerIdentityRegistryAbi, zkPassportRootVerifierAbi } from './chain'
+import {
+  CAPACITY_WINDOW,
+  boundChainName,
+  buildProofBundle,
+  capacityWindowEnd,
+  credentialEnd,
+  encodeEvidence,
+  expiryLowerBound,
+  outerEvmProof,
+  proofFacts,
+  safeRegistrationBatch,
+  type ProofResult,
+} from './identity'
+
+const OWNER = '0x2222222222222222222222222222222222222222' as Address
+const REGISTRY = '0x5555555555555555555555555555555555555555' as Address
+const word = (value: bigint): Hex => pad(toHex(value), { size: 32 })
+const PROOF_DATE = 1_790_000_000n
+const VALID_UNTIL = 1_830_000_000n
+
+function verifierParams(): SolidityVerifierParameters {
+  return {
+    version: word(0x14_00_00n << 224n),
+    proofVerificationData: {
+      vkeyHash: word(7n),
+      proof: '0x1234',
+      // The verifier reads the proof date at index 2 and ends with
+      // [nullifier type, scoped nullifier, OPRF key hash].
+      publicInputs: [word(1n), word(2n), word(PROOF_DATE), word(9n), word(0n), word(0xabcdefn), word(0n)],
+    },
+    committedInputs: '0xbeef',
+    serviceConfig: {
+      validityPeriodInSeconds: 604_800,
+      domain: 'dashboard.theinterfold.com',
+      scope: 'interfold-bond-owner',
+      devMode: false,
+    },
+  }
+}
+
+function proofs(): ProofResult[] {
+  return [
+    { name: 'sig_check_dsc', proof: '0x01' },
+    { name: 'compare_expiry_evm', committedInputs: { compare_expiry_evm: { minDateTimestamp: Number(VALID_UNTIL), maxDateTimestamp: 0 } } },
+    { name: 'outer_evm_count_5', proof: '0x02', version: '0.21.1' },
+  ]
+}
+
+test('capacity windows end at the same second as BondOwnerCapacityLib', () => {
+  const start = CAPACITY_WINDOW * 680n
+  assert.equal(capacityWindowEnd(start), start + CAPACITY_WINDOW - 1n)
+  assert.equal(capacityWindowEnd(start + CAPACITY_WINDOW - 1n), start + CAPACITY_WINDOW - 1n)
+  assert.equal(capacityWindowEnd(start + CAPACITY_WINDOW), start + 2n * CAPACITY_WINDOW - 1n)
+})
+
+test('a proof binds to the ZKPassport name of the dashboard chain', () => {
+  assert.equal(boundChainName(1), 'ethereum')
+  assert.equal(boundChainName(11_155_111), 'ethereum_sepolia')
+  assert.equal(boundChainName(8453), null)
+})
+
+test('the evidence carries the outer proof and the committed expiry bound', () => {
+  assert.equal(outerEvmProof(proofs())?.name, 'outer_evm_count_5')
+  assert.equal(outerEvmProof(proofs().slice(0, 2)), null)
+  assert.equal(expiryLowerBound(proofs()), VALID_UNTIL)
+  assert.equal(expiryLowerBound([{ name: 'outer_evm' }]), null)
+
+  const facts = proofFacts(verifierParams())
+  assert.deepEqual(facts, { proofDate: PROOF_DATE, nullifierType: 0, scopedNullifier: word(0xabcdefn), oprfKeyHash: word(0n) })
+  assert.equal(credentialEnd(VALID_UNTIL, PROOF_DATE, 365n * 86_400n), PROOF_DATE + 365n * 86_400n)
+  assert.equal(credentialEnd(PROOF_DATE + 10n, PROOF_DATE, 365n * 86_400n), PROOF_DATE + 10n)
+})
+
+test('the evidence decodes as the verifier decodes it', () => {
+  const params = verifierParams()
+  const evidence = encodeEvidence(params, VALID_UNTIL)
+  const tuple = getAbiItem({ abi: zkPassportRootVerifierAbi, name: 'verify' }).inputs[0]
+  const [decoded, validUntil] = decodeAbiParameters([tuple, { type: 'uint256' }], evidence) as [any, bigint]
+  assert.equal(validUntil, VALID_UNTIL)
+  assert.equal(decoded.version, params.version)
+  assert.equal(decoded.proofVerificationData.proof, '0x1234')
+  assert.deepEqual(decoded.proofVerificationData.publicInputs, params.proofVerificationData.publicInputs)
+  assert.equal(decoded.committedInputs, '0xbeef')
+  assert.equal(decoded.serviceConfig.domain, 'dashboard.theinterfold.com')
+  assert.equal(decoded.serviceConfig.validityPeriodInSeconds, 604_800n)
+})
+
+test('a Safe batch registers the evidence from the bound Safe', () => {
+  const evidence = encodeEvidence(verifierParams(), VALID_UNTIL)
+  const batch = safeRegistrationBatch(REGISTRY, OWNER, 1, evidence, 1_700_000_000_000)
+  assert.equal(batch.chainId, '1')
+  assert.equal(batch.meta.createdFromSafeAddress, OWNER)
+  assert.equal(batch.transactions.length, 1)
+  assert.equal(batch.transactions[0].to, REGISTRY)
+  assert.equal(batch.transactions[0].value, '0')
+  const call = decodeFunctionData({ abi: ownerIdentityRegistryAbi, data: batch.transactions[0].data })
+  assert.equal(call.functionName, 'register')
+  assert.deepEqual(call.args, [evidence])
+})
+
+test('the downloaded bundle describes the proof that it carries', () => {
+  const success = { proofs: proofs(), result: {} } as RequestSuccess
+  const bundle = buildProofBundle({ success, params: verifierParams(), owner: OWNER, chainId: 1, faceMatch: true })
+  assert.equal(bundle.owner, OWNER)
+  assert.equal(bundle.chainId, 1)
+  assert.equal(bundle.validUntil, VALID_UNTIL.toString())
+  assert.equal(bundle.proofDate, PROOF_DATE.toString())
+  assert.equal(bundle.domain, 'dashboard.theinterfold.com')
+  assert.equal(bundle.scope, 'interfold-bond-owner')
+  assert.equal(bundle.evidence, encodeEvidence(verifierParams(), VALID_UNTIL))
+  assert.doesNotThrow(() => JSON.stringify(bundle))
+
+  assert.throws(
+    () =>
+      buildProofBundle({
+        success: { proofs: [], result: {} } as RequestSuccess,
+        params: verifierParams(),
+        owner: OWNER,
+        chainId: 1,
+        faceMatch: true,
+      }),
+    /no expiry-date check/,
+  )
+})
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
new file mode 100644
index 0000000000..f1a52b5191
--- /dev/null
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -0,0 +1,322 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+// Bond-owner identity behind the operator guide: the governance policy, the owner's credential, and
+// the evidence that OwnerIdentityRegistry.register takes for a ZKPassport proof.
+//
+// The policy has no view. The bonding registry emits IdentityPolicyUpdated(timepoint, registry,
+// required), and the latest log is the current policy. The verifier's fixed settings (domain, scope,
+// ZKPassport version, identifier type) are read from the verifier itself, so the page follows the
+// deployment. Before a deployment, the page can still make a proof with the planned settings
+// (PREVIEW_SERVICE) and offer it as a download.
+
+import { encodeAbiParameters, encodeFunctionData, getAbiItem, type Address, type Hex } from 'viem'
+import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk'
+import {
+  CONTRACTS,
+  IDENTITY_DEPLOY_BLOCK,
+  bondingRegistryAbi,
+  ownerIdentityRegistryAbi,
+  publicClient,
+  zkPassportIdentityVerifierAbi,
+  zkPassportRootVerifierAbi,
+} from './chain'
+import { getLogsChunked } from './e3'
+
+export type ProofResult = RequestSuccess['proofs'][number]
+
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
+
+/** `BondOwnerCapacityLib.IDENTITY_CAPACITY_WINDOW`. Windows start at multiples of it from Unix time zero. */
+export const CAPACITY_WINDOW = 30n * 86_400n
+
+/**
+ * The verifier settings for a proof before governance deploys a verifier. The domain and scope are part
+ * of every identifier, so the deployment must use the same values.
+ */
+export const PREVIEW_SERVICE = {
+  domain: 'dashboard.theinterfold.com',
+  scope: 'interfold-bond-owner',
+  proofValidity: 7n * 86_400n,
+  maxValidity: 365n * 86_400n,
+} as const
+
+const IDENTITY_POLICY_UPDATED = getAbiItem({ abi: bondingRegistryAbi, name: 'IdentityPolicyUpdated' })
+const PROOF_VERIFICATION_PARAMS = getAbiItem({ abi: zkPassportRootVerifierAbi, name: 'verify' }).inputs[0]
+
+export type IdentityPolicy = {
+  registry: Address
+  required: boolean
+  /** Timestamp from which the policy applies. */
+  timepoint: bigint
+}
+
+/** The settings that the deployed ZKPassportIdentityVerifier fixes for every proof. */
+export type VerifierConfig = {
+  address: Address
+  domain: string
+  scope: string
+  /** The one ZKPassport version that the verifier accepts. */
+  version: Hex
+  /** 0 non-salted, 1 salted. */
+  nullifierType: number
+  oprfKeyHash: Hex
+  faceMatchRequired: boolean
+  /** Maximum proof age, in seconds, when the registration is mined. */
+  proofValidity: bigint
+  /** Longest credential, in seconds after the proof date. */
+  maxValidity: bigint
+}
+
+export type OwnerAccount = {
+  /** Latest block timestamp. */
+  now: bigint
+  /** A contract owner (a Safe) registers through its own transaction. */
+  isContract: boolean
+  /** The owner's credential, or null when the network has no identity registry. */
+  identity: { identityId: Hex; expiresAt: bigint; verifiedNow: boolean } | null
+}
+
+/** The current identity policy: the latest IdentityPolicyUpdated log, or null before the first. */
+export async function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
+  const head = await publicClient.getBlockNumber()
+  const logs = await getLogsChunked<any>(
+    { address: CONTRACTS.BondingRegistry, event: IDENTITY_POLICY_UPDATED },
+    IDENTITY_DEPLOY_BLOCK,
+    head,
+  )
+  const latest = logs[logs.length - 1]
+  if (!latest) return null
+  return { registry: latest.args.registry, required: latest.args.required, timepoint: BigInt(latest.args.timepoint) }
+}
+
+export async function fetchVerifierConfig(registry: Address): Promise<VerifierConfig> {
+  const address = (await (publicClient.readContract as any)({
+    address: registry,
+    abi: ownerIdentityRegistryAbi,
+    functionName: 'verifier',
+  })) as Address
+  if (address === ZERO_ADDRESS) throw new Error('The identity registry has no verifier yet.')
+  const read = (functionName: string) => (publicClient.readContract as any)({ address, abi: zkPassportIdentityVerifierAbi, functionName })
+  const [domain, scope, version, nullifierType, oprfKeyHash, faceMatchRequired, proofValidity, maxValidity] = await Promise.all([
+    read('domain'),
+    read('scope'),
+    read('VERSION'),
+    read('NULLIFIER_TYPE'),
+    read('OPRF_KEY_HASH'),
+    read('FACE_MATCH_REQUIRED'),
+    read('PROOF_VALIDITY'),
+    read('MAX_VALIDITY'),
+  ])
+  return {
+    address,
+    domain,
+    scope,
+    version,
+    nullifierType: Number(nullifierType),
+    oprfKeyHash,
+    faceMatchRequired,
+    proofValidity: BigInt(proofValidity),
+    maxValidity: BigInt(maxValidity),
+  }
+}
+
+export async function fetchOwnerAccount(owner: Address, registry: Address | null): Promise<OwnerAccount> {
+  const block = await publicClient.getBlock()
+  const read = (functionName: string, args: readonly unknown[]) =>
+    (publicClient.readContract as any)({ address: registry, abi: ownerIdentityRegistryAbi, functionName, args })
+  const [code, identity] = await Promise.all([
+    publicClient.getCode({ address: owner }),
+    registry
+      ? Promise.all([read('identityOf', [owner]), read('isVerifiedAt', [owner, block.timestamp])]).then(
+          ([[identityId, expiresAt], verifiedNow]: [[Hex, number | bigint], boolean]) => ({
+            identityId,
+            expiresAt: BigInt(expiresAt),
+            verifiedNow,
+          }),
+        )
+      : Promise.resolve(null),
+  ])
+  return { now: block.timestamp, isContract: Boolean(code && code !== '0x'), identity }
+}
+
+/** The last second of the capacity window that contains `timestamp` (`BondOwnerCapacityLib._windowEnd`). */
+export function capacityWindowEnd(timestamp: bigint): bigint {
+  return (timestamp / CAPACITY_WINDOW + 1n) * CAPACITY_WINDOW - 1n
+}
+
+/** The ZKPassport chain name that binds a proof to `chainId`, or null where ZKPassport has no verifier. */
+export function boundChainName(chainId: number): 'ethereum' | 'ethereum_sepolia' | null {
+  if (chainId === 1) return 'ethereum'
+  if (chainId === 11_155_111) return 'ethereum_sepolia'
+  return null
+}
+
+/** The outer EVM proof: the one proof that the verifier checks. */
+export function outerEvmProof(proofs: readonly ProofResult[]): ProofResult | null {
+  return proofs.find((proof) => proof.name?.startsWith('outer_evm')) ?? null
+}
+
+/**
+ * The lower bound of the proof's expiry-date check. The evidence must carry exactly this value as
+ * `validUntil`, because the verifier asks ZKPassport's helper to confirm the committed bound.
+ */
+export function expiryLowerBound(proofs: readonly ProofResult[]): bigint | null {
+  for (const proof of proofs) {
+    const committed = proof.committedInputs?.compare_expiry_evm as { minDateTimestamp?: number } | undefined
+    if (committed?.minDateTimestamp !== undefined) return BigInt(committed.minDateTimestamp)
+  }
+  return null
+}
+
+/** The values that the verifier reads from the proof's public inputs. */
+export function proofFacts(params: SolidityVerifierParameters): {
+  proofDate: bigint
+  nullifierType: number
+  scopedNullifier: Hex
+  oprfKeyHash: Hex
+} {
+  const inputs = params.proofVerificationData.publicInputs
+  return {
+    proofDate: BigInt(inputs[2]),
+    nullifierType: Number(BigInt(inputs[inputs.length - 3])),
+    scopedNullifier: inputs[inputs.length - 2] as Hex,
+    oprfKeyHash: inputs[inputs.length - 1] as Hex,
+  }
+}
+
+/** The credential end that the verifier sets: `validUntil`, or `maxValidity` after the proof date if earlier. */
+export function credentialEnd(validUntil: bigint, proofDate: bigint, maxValidity: bigint): bigint {
+  const capped = proofDate + maxValidity
+  return validUntil < capped ? validUntil : capped
+}
+
+/** `abi.encode(ProofVerificationParams, validUntil)`, the evidence of ZKPassportIdentityVerifier. */
+export function encodeEvidence(params: SolidityVerifierParameters, validUntil: bigint): Hex {
+  return encodeAbiParameters(
+    [PROOF_VERIFICATION_PARAMS, { type: 'uint256' }],
+    [
+      {
+        version: params.version as Hex,
+        proofVerificationData: {
+          vkeyHash: params.proofVerificationData.vkeyHash as Hex,
+          proof: params.proofVerificationData.proof as Hex,
+          publicInputs: params.proofVerificationData.publicInputs as Hex[],
+        },
+        committedInputs: params.committedInputs as Hex,
+        serviceConfig: {
+          validityPeriodInSeconds: BigInt(params.serviceConfig.validityPeriodInSeconds),
+          domain: params.serviceConfig.domain,
+          scope: params.serviceConfig.scope,
+          devMode: params.serviceConfig.devMode,
+        },
+      },
+      validUntil,
+    ],
+  )
+}
+
+/** A Safe Transaction Builder batch that registers the proof from the Safe that it binds. */
+export function safeRegistrationBatch(registry: Address, safe: Address, chainId: number, evidence: Hex, createdAt: number) {
+  return {
+    version: '1.0',
+    chainId: String(chainId),
+    createdAt,
+    meta: {
+      name: 'Interfold bond-owner identity',
+      description: 'OwnerIdentityRegistry.register for this Safe. Execute it before the proof expires.',
+      createdFromSafeAddress: safe,
+    },
+    transactions: [
+      {
+        to: registry,
+        value: '0',
+        data: encodeFunctionData({ abi: ownerIdentityRegistryAbi, functionName: 'register', args: [evidence] }),
+      },
+    ],
+  }
+}
+
+/** The credential line of the identity panel. */
+export function identityStatusText(account: OwnerAccount): string {
+  const identity = account.identity
+  if (!identity || identity.expiresAt === 0n) return 'Not verified'
+  return identity.verifiedNow ? `Verified until ${fmtDay(identity.expiresAt)}` : `Expired on ${fmtDay(identity.expiresAt)}`
+}
+
+export function fmtDay(ts: bigint): string {
+  return new Date(Number(ts) * 1000).toLocaleDateString('en-US', { year: 'numeric', month: 'short', day: 'numeric', timeZone: 'UTC' })
+}
+
+/** A Unix timestamp as the value of a date field: YYYY-MM-DD in UTC. */
+export function dateInput(ts: bigint): string {
+  return new Date(Number(ts) * 1000).toISOString().slice(0, 10)
+}
+
+/** A YYYY-MM-DD date field as the Unix timestamp of its UTC midnight, or null. */
+export function parseDateInput(value: string): bigint | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim())
+  if (!match) return null
+  const ms = Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]))
+  const day = new Date(ms)
+  // Reject dates that roll over, such as 2026-02-31.
+  if (day.getUTCMonth() !== Number(match[2]) - 1 || day.getUTCDate() !== Number(match[3])) return null
+  return BigInt(ms / 1000)
+}
+
+/** Everything that a registration or a test needs to replay one proof, as the page downloads it. */
+export type ProofBundle = {
+  kind: 'interfold.identity.zkpassport-proof'
+  chainId: number
+  owner: Address
+  domain: string
+  scope: string
+  faceMatch: boolean
+  /** Unix seconds. */
+  validUntil: string
+  proofDate: string
+  nullifierType: number
+  oprfKeyHash: Hex
+  version: Hex
+  params: SolidityVerifierParameters
+  evidence: Hex
+  proofs: ProofResult[]
+  result: RequestSuccess['result']
+}
+
+export function buildProofBundle({
+  success,
+  params,
+  owner,
+  chainId,
+  faceMatch,
+}: {
+  success: RequestSuccess
+  params: SolidityVerifierParameters
+  owner: Address
+  chainId: number
+  faceMatch: boolean
+}): ProofBundle {
+  const validUntil = expiryLowerBound(success.proofs)
+  if (validUntil === null) throw new Error('The proof has no expiry-date check.')
+  const facts = proofFacts(params)
+  return {
+    kind: 'interfold.identity.zkpassport-proof',
+    chainId,
+    owner,
+    domain: params.serviceConfig.domain,
+    scope: params.serviceConfig.scope,
+    faceMatch,
+    validUntil: validUntil.toString(),
+    proofDate: facts.proofDate.toString(),
+    nullifierType: facts.nullifierType,
+    oprfKeyHash: facts.oprfKeyHash,
+    version: params.version as Hex,
+    params,
+    evidence: encodeEvidence(params, validUntil),
+    proofs: success.proofs,
+    result: success.result,
+  }
+}
diff --git a/packages/interfold-dashboard/src/lib/networks.ts b/packages/interfold-dashboard/src/lib/networks.ts
index 9a895dc412..723586306a 100644
--- a/packages/interfold-dashboard/src/lib/networks.ts
+++ b/packages/interfold-dashboard/src/lib/networks.ts
@@ -33,6 +33,9 @@ export type NetworkProfile = {
   // Empty string = no faucet on this network (hides the operator-guide card).
   faucet: string
   deployBlock: string
+  // First block of the identity policy scan: a block at or before the BondingRegistry upgrade that
+  // added the policy. Empty = deployBlock.
+  identityDeployBlock: string
   // Fee token metadata for formatting escrowed fees/rewards. Hardcoded per
   // deployment (like the addresses) rather than read on-chain at runtime.
   feeSymbol: string
@@ -50,16 +53,17 @@ export const NETWORKS: Record<NetworkKey, NetworkProfile> = {
     name: 'Sepolia',
     rpc: 'https://ethereum-sepolia.publicnode.com',
     explorer: 'https://sepolia.etherscan.io',
-    interfold: '0xb35EE9ed8BE5967daabBA8c2e817C52D0b57ac26',
-    ciphernodeRegistry: '0x895392D5782E78768A35B1aDfc5b0BD1faB259e4',
-    crispProgram: '0x25Df8D3C04D67efb6198E215963d19a8d119ADFF',
+    interfold: '0xBD5B6D1aDA9e0eB248B678469C9Cd6a63507E42b',
+    ciphernodeRegistry: '0xb1E8640CF8D0A927290E3d9E1b01c4899B5225Ef',
+    crispProgram: '0xA9894A39061EC33f8550a2B63A66Be59fb9fa443',
     previousCrispPrograms: [],
-    bondingRegistry: '0x8f42eD45556bC8fF8949c37c7644Af9Cf321108F',
+    bondingRegistry: '0x8687bC7C8f055b41aD2C2447c04aCBD76C1075b2',
     // Test Faucet. It sends 1000 FOLD and 1000 MockUSDC.
     faucet: '0x1B4340A65BB669267BF5DE37385B139987C3F09c',
-    // Deploy block of the CiphernodeRegistry (12050030), the earlier of it and the Interfold. A later
-    // value silently drops early registry events.
-    deployBlock: '12050030',
+    // Deploy block of the Interfold and the CiphernodeRegistry (11873232), the earliest of those two
+    // and the CRISPProgram (11873424). A later value silently drops early registry events.
+    deployBlock: '11873232',
+    identityDeployBlock: '',
     // MockUSDC (0xE2e534F7…555B), the fee token and ticket collateral. Anyone can mint it.
     feeSymbol: 'USDC',
     feeDecimals: 6,
@@ -81,6 +85,7 @@ export const NETWORKS: Record<NetworkKey, NetworkProfile> = {
     faucet: '',
     // All mainnet contracts were deployed in the same block.
     deployBlock: '25786403',
+    identityDeployBlock: '',
     // USDS (0xdC035D45…384F) on the mainnet deployment.
     feeSymbol: 'USDS',
     feeDecimals: 18,
@@ -100,6 +105,7 @@ const SETTINGS = [
   'FEE_TOKEN_SYMBOL',
   'FEE_TOKEN_DECIMALS',
   'DEPLOY_BLOCK',
+  'IDENTITY_DEPLOY_BLOCK',
   'COMPUTE_WINDOW',
   'DECRYPTION_WINDOW',
 ] as const
diff --git a/packages/interfold-dashboard/src/styles.css b/packages/interfold-dashboard/src/styles.css
index ca7a14ff03..edb8d56f2b 100644
--- a/packages/interfold-dashboard/src/styles.css
+++ b/packages/interfold-dashboard/src/styles.css
@@ -2037,6 +2037,30 @@ button {
   margin: 0;
 }
 
+/* Bond-owner identity: the ZKPassport request and its QR code */
+.opidentity__request {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 18px;
+}
+.opidentity__qr {
+  width: 240px;
+  height: 240px;
+  border: 1px solid var(--rule);
+  border-radius: 8px;
+  background: #fff;
+  image-rendering: pixelated;
+}
+.opcheck {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 13.5px;
+  color: var(--ink-2);
+  cursor: pointer;
+}
+
 /* E3 rewards: the claimable total first, then the committee history */
 .oprewards__title {
   font-family: var(--serif);
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 44f784310a..c96286f6c0 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -309,6 +309,12 @@ importers:
       '@interfold/contracts':
         specifier: workspace:*
         version: link:../interfold-contracts
+      '@zkpassport/sdk':
+        specifier: 0.19.2
+        version: 0.19.2(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      qrcode:
+        specifier: 1.5.4
+        version: 1.5.4
       react:
         specifier: ^18.3.1
         version: 18.3.1
@@ -319,6 +325,9 @@ importers:
         specifier: 2.38.6
         version: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
     devDependencies:
+      '@types/qrcode':
+        specifier: 1.5.5
+        version: 1.5.5
       '@types/react':
         specifier: ^18.3.3
         version: 18.3.31
@@ -410,10 +419,10 @@ importers:
         version: 18.3.1
       viem:
         specifier: 2.38.6
-        version: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+        version: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
       wagmi:
         specifier: ^2.14.16
-        version: 2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(zod@4.4.3)
+        version: 2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(zod@3.25.76)
     devDependencies:
       '@interfold/config':
         specifier: workspace:*
@@ -719,6 +728,14 @@ packages:
     resolution: {integrity: sha512-w+rlVHbSbb1neDeJGMDSbNZCxuD6TeSrN/1lbnVgqhKcVfqdDXdTt2b6RUToCsk7Q2Dmx4oqU5tfBcFY//LQtg==}
     hasBin: true
 
+  '@aztec/bb.js@4.2.0-aztecnr-rc.2':
+    resolution: {integrity: sha512-ksFWHrm8QYAXP059paItEKCM/UhpHg5Dwl/eSp2BI6EAtD9+JlonkOwJ+94TYai2y5Gz0qnrgd65dsvDwJelVQ==}
+    hasBin: true
+
+  '@aztec/bb.js@5.0.0':
+    resolution: {integrity: sha512-O4HDjzrjXMvM44+VbgDG1GaDUztWGEVujbBmwZAEVJh6BHpmJfMxBB2/69h1oi4kX2adgaowlJNFhpzcz1MHSA==}
+    hasBin: true
+
   '@babel/code-frame@7.27.1':
     resolution: {integrity: sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==}
     engines: {node: '>=6.9.0'}
@@ -1701,6 +1718,11 @@ packages:
   '@jridgewell/trace-mapping@0.3.9':
     resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
 
+  '@lapo/asn1js@2.1.3':
+    resolution: {integrity: sha512-eX1xNRPeP5dCtUpQg/lqHZjBd0//wJ05yn/4osewSc4rxC1KCXBfbUeCiQEdNREbGMa3xjZxjkYNY1AHzUkleQ==}
+    engines: {node: '>=14.6.0'}
+    hasBin: true
+
   '@lit-labs/ssr-dom-shim@1.6.0':
     resolution: {integrity: sha512-VHb0ALPMTlgKjM6yIxxoQNnpKyUKLD04VzeQdsiXkMqkvYlAHxq9glGLmgbb889/1GsohSOAjvQYoiBppXFqrQ==}
 
@@ -2059,6 +2081,10 @@ packages:
     resolution: {integrity: sha512-gbKGcRUYIjA3/zCCNaWDciTMFI0dCkvou3TL8Zmy5Nc7sJ47a0jtOeZoTaMxkuqRo9cRhjOdZJXegxYE5FN/xw==}
     engines: {node: ^14.21.3 || >=16}
 
+  '@noble/curves@2.4.0':
+    resolution: {integrity: sha512-P4/62zrgfH33CneE3Dn4WhJVA22YUU0eR51wKIan4NVRvwsA0YnPTwWGpNbpuacSujmSFLvyzpyuR30+fbq2Ew==}
+    engines: {node: '>= 20.19.0'}
+
   '@noble/hashes@1.2.0':
     resolution: {integrity: sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==}
 
@@ -2086,9 +2112,16 @@ packages:
     resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==}
     engines: {node: ^14.21.3 || >=16}
 
+  '@noble/hashes@2.4.0':
+    resolution: {integrity: sha512-X5XaVWZIBCT7HHZGm5I7ZQXDwLG+bGXuSrMQAW+7Zvl87h1kmc1ZB1VSRJcpUfoUrGQp4Fkoxm5kZ+Ms+aW+eA==}
+    engines: {node: '>= 20.19.0'}
+
   '@noble/secp256k1@1.7.1':
     resolution: {integrity: sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==}
 
+  '@noble/secp256k1@2.3.0':
+    resolution: {integrity: sha512-0TQed2gcBbIrh7Ccyw+y/uZQvbJwm7Ao4scBUxqpBCcsOlZG0O4KGfjtNAy/li4W8n1xt3dxrwJ0beZ2h2G6Kw==}
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -2101,15 +2134,27 @@ packages:
     resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
     engines: {node: '>= 8'}
 
+  '@noir-lang/acvm_js@1.0.0-beta.22':
+    resolution: {integrity: sha512-2xXfSKrnskUNmPiG/Kj6yvWi1E6wJBl/1ZsmzVaHEEyJsUBf15xaSRBZR7X1361whUR2vqyG80ck2huLZPb5bA==}
+
   '@noir-lang/acvm_js@1.0.0-rc.3':
     resolution: {integrity: sha512-bTTrcPphNHVrFkbJPVcFrrigwwU/N9+trgEa9PF2X/VWWAX0B1gOGSBwqziOKMwThpU7H2Jb3Z6OFMEhpMKaEQ==}
 
+  '@noir-lang/noir_js@1.0.0-beta.22':
+    resolution: {integrity: sha512-Ts+QI2fN2PsrVjx38CszFSR0TyWpip9TgJ6HM17DIK05Jku4TSKtHMIjrE6lRii4Y+JV0rn70v+TrunJmt/X4w==}
+
   '@noir-lang/noir_js@1.0.0-rc.3':
     resolution: {integrity: sha512-NrJZPd7zpBWXzP240rP78fr6RE8vg3mFIMIsT5Xiqbh6zdBKfLI8Nb7Ea4UFwFWyRFDqZO3qGd3HbGyRWxxZ8Q==}
 
+  '@noir-lang/noirc_abi@1.0.0-beta.22':
+    resolution: {integrity: sha512-vpZtWb946eb4ZxERxY32I4Fv62SAAjhAyJpb2YzWYvnDVTyFVIvr/MSVunrM1osUP35nnRPRGuXVTWy4sBQkIg==}
+
   '@noir-lang/noirc_abi@1.0.0-rc.3':
     resolution: {integrity: sha512-jax7q2CAAG4jxCzr8MllH/LZxnxnS5PF1YyzmFJ7DTf97k3+LaHSnBPXE8TwQYDsWwyNxQTqDWw1QVEoO1ESaQ==}
 
+  '@noir-lang/types@1.0.0-beta.22':
+    resolution: {integrity: sha512-PXD8cmvMT4wybDe1pUPwv2Uz1FYh9B/hdXrY5eOMf1elNVxomj2tHDDYoKI/zNDrJ1JzTL0xhbAX1vBTMMFvBw==}
+
   '@noir-lang/types@1.0.0-rc.3':
     resolution: {integrity: sha512-k1UHd67/OSPJb9E6WNKeMtuoDbflLpu803jtbaVqDlr2P/rH8+joDuIxK+nwBMVlnCO2LlcJaN4wpQ/TRHJ78w==}
 
@@ -2305,6 +2350,11 @@ packages:
     resolution: {integrity: sha512-q4n32/FNKIhQ3zQGGw5CvPF6GTvDCpYwIf7bEY/dZTZbgfDsHyjJwURxUJf3VQuuJj+fDIFl4+KkBVbw4Ef6jA==}
     engines: {node: '>= 12'}
 
+  '@obsidion/bridge@0.12.2':
+    resolution: {integrity: sha512-3swoUCqf+Z06qFYW9fOG5EoETA1lnqbXpmn+LjKT1FqOdgy51Q6gWxyNn99ZMKQcMkk/vbWV11DLpDQAH7YYsg==}
+    peerDependencies:
+      typescript: 5.8.3
+
   '@offchainlabs/upgrade-executor@1.1.0-beta.0':
     resolution: {integrity: sha512-mpn6PHjH/KDDjNX0pXHEKdyv8m6DVGQiI2nGzQn0JbM1nOSHJpWx6fvfjtH7YxHJ6zBZTcsKkqGkFKDtCfoSLw==}
 
@@ -2341,12 +2391,56 @@ packages:
     resolution: {integrity: sha512-IHnV6A+zxU7XwmKFinmYjUcwlyK9+xkG3/s9KcQhI9BjQKycrJ1JRO+FbNYPwZiPKW3je/DR0k7w8/gLa5eaxQ==}
     deprecated: 'Switch to "qr" (new package name) for security updates: npm install qr'
 
+  '@peculiar/asn1-cms@2.11.1':
+    resolution: {integrity: sha512-Bk+oatE62dW0Tzzpfk6vdQxfGGEfvuGdWgmijnKjcv7HqZCJISs85z4zw2uDArrk+R1Oel1wts/BBl7HHrtAcA==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-csr@2.11.1':
+    resolution: {integrity: sha512-KVfbXaKng8886/tOPG55t5K1XkTkGbR4amjIJzytXWobFU5nZgw/sKnSpa1hxP17nUSsrOF/7Mt9WUYeyLsi6Q==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-ecc@2.11.1':
+    resolution: {integrity: sha512-7MSNji77fQa/oN3WAfwagMy8EoJFg50sW4hZ1dtr0zU1BSugit0I2DGpIdPhvkNplopQhz5bogxpn1077eaamA==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-pfx@2.11.1':
+    resolution: {integrity: sha512-2SN2z8qkc2hk/GgTYA8RN54wtsCDZShg9gI2Mq1vLhdj1adcv5fhTbiEmExZUaAMqlizxiEpULQDfHM5iYtn1g==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-pkcs8@2.11.1':
+    resolution: {integrity: sha512-HqsSrnpQghRp9SM9QSmR6fa4z/BNktnKq7928+oq4qF0VAnuHZ4cyePKvcxh9fP4taBCP/WHNItlVNsYaQm2qw==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-pkcs9@2.11.1':
+    resolution: {integrity: sha512-OHFkTg8D2zYafILqFE4KPbqX8srpvd3diGDc2h2cduumawc765mOHGcuFMGvLWlL2bbCMWMmMSCtlXptsOuiPA==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-rsa@2.11.1':
+    resolution: {integrity: sha512-6KwKGjulF489CpidZqkogNgLj6oGzgC4BL2FClM8PuJQ4t5NqT4q4a6A4vrSxBIBhMnL8hGYkLOpbVw0Vq38Tw==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-schema@2.11.1':
+    resolution: {integrity: sha512-jaU9OaCcbZUdyXx9hMETZB9xoNmxTGjOGFqd3cOwKFkpKnyKd9WxF3uqj4PvX4cyOMP9bSdHg5YyML2qtx/d/g==}
+    engines: {node: '>=14'}
+
   '@peculiar/asn1-schema@2.8.0':
     resolution: {integrity: sha512-7YT0U/ze0tF2QOBbE15gKZwy5tvgGyLRiRHLzhlbOpf7BT032oBSd0haZqXn5W6l26WLlu3dyxzjM+2638/z2Q==}
 
+  '@peculiar/asn1-x509-attr@2.11.1':
+    resolution: {integrity: sha512-n7RKFrbTzt8pGBlZ90kmKEn1qsLTTyw7lrvHMK0xsA42kQugPk/GXYpNbEcl7DkkdVsU/one5UX7KQPfxLj8vQ==}
+    engines: {node: '>=14'}
+
+  '@peculiar/asn1-x509@2.11.1':
+    resolution: {integrity: sha512-SXU4/X6B3FquqQAN6ARI0bFDUV7+L1WlvPEPMKzEMkstd2D7UyM0r93fv241+OjdhqAKYGx5MvV3gzZMAp0APA==}
+    engines: {node: '>=14'}
+
   '@peculiar/utils@2.0.3':
     resolution: {integrity: sha512-+oL3HPFRIZ1St2K50lWCXiioIgSoxzz7R1J3uF6neO2yl1sgmpgY6XXJH4BdpoDkMWznQTeYF6oWNDZLCdQ4eQ==}
 
+  '@peculiar/x509@1.14.3':
+    resolution: {integrity: sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==}
+    engines: {node: '>=20.0.0'}
+
   '@phosphor-icons/react@2.1.10':
     resolution: {integrity: sha512-vt8Tvq8GLjheAZZYa+YG/pW7HDbov8El/MANW8pOAz4eGxrwhnbfrQZq0Cp4q8zBEu8NIhHdnr+r8thnfRSNYA==}
     engines: {node: '>=10'}
@@ -3165,6 +3259,18 @@ packages:
     resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==}
     engines: {node: '>=14.16'}
 
+  '@taceo/oprf-client@0.9.0':
+    resolution: {integrity: sha512-kokCCLYjLSH3I7n4D2Yhg1ybNquMRnbHh3r/YTgHIiXxJ+FLsbE9AGT8vhwTmwe2m4X1U3r57yKMsIiaeu/DAg==}
+    engines: {node: '>=22'}
+
+  '@taceo/oprf-core@0.4.0':
+    resolution: {integrity: sha512-Mlo2pjb8O9HDGvjpcun06ZWrW7oBblQESr9EDhW1WvHLDkKDgdlKdx43EVzJMGHcFXaVT4/1MnC1De/5KTQTNg==}
+    engines: {node: '>=22'}
+
+  '@taceo/poseidon2@0.2.0':
+    resolution: {integrity: sha512-+EyFO7zaRrlsdzNEvzTLELDkrgjUgZgSlxGUSQghmmtlZ14nZklYX7D+gecyOkVe/47AGDtA+uZ9sdXiNB8rng==}
+    engines: {node: '>=22'}
+
   '@tailwindcss/typography@0.5.20':
     resolution: {integrity: sha512-hwbzQuNUfcPvbegQFatVPl/MY/tcM9KLl963hQ5laJKPh81TEZ1+dNG9PirGvcaDBkp+BCshExAyKVPW91dozw==}
     peerDependencies:
@@ -3346,12 +3452,18 @@ packages:
   '@types/node@22.7.5':
     resolution: {integrity: sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==}
 
+  '@types/pako@2.0.4':
+    resolution: {integrity: sha512-VWDCbrLeVXJM9fihYodcLiIv0ku+AlOa/TQ1SvYOaBuyrSKgEcro95LJyIsJ4vSo6BXIxOKxiJAat04CmST9Fw==}
+
   '@types/prettier@2.7.3':
     resolution: {integrity: sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==}
 
   '@types/prop-types@15.7.15':
     resolution: {integrity: sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==}
 
+  '@types/qrcode@1.5.5':
+    resolution: {integrity: sha512-CdfBi/e3Qk+3Z/fXYShipBT13OJ2fDO2Q2w5CIP5anLTLIndQG9z6P1cnm+8zCWSpm5dnxMFd/uREtb0EXuQzg==}
+
   '@types/qs@6.15.1':
     resolution: {integrity: sha512-GZHUBZR9hckSUhrxmp1nG6NwdpM9fCunJwyThLW1X3AyHgd9IlHb6VANpQQqDr2o/qQp6McZ3y/IA2rVzKzSbw==}
 
@@ -3687,9 +3799,27 @@ packages:
   '@zk-kit/lean-imt@2.2.5':
     resolution: {integrity: sha512-7pJIWiWp30wKz7OlbzV/+ATvHD+Emwy1aejU+9R4V+a1BkdY/yhGA/hFoVULxYyZ/RohiCfcJC/48cU2xI6Rtw==}
 
+  '@zk-kit/utils@1.3.0':
+    resolution: {integrity: sha512-Gqsq5KLDf2WPuZSsNc2KZy25XeK5d5UV9hwLaPEM5wq+GD2qCi1ZBFzNs0OptiJ9GRGtP2J/xptrszWri+pRqQ==}
+
   '@zk-kit/utils@1.4.1':
     resolution: {integrity: sha512-IoXzy3ElfkvRfC/s6uk3eFQO8uxkCdAOVxKlJlaEjM7pgckX5AK46Q+7n5yMQD/v/o6OL0mMtet065o5EpUocA==}
 
+  '@zkpassport/poseidon2@0.6.2':
+    resolution: {integrity: sha512-6sFHX9kAcrmDmBEEndvjZ8DA9FomunirQ5oCV6oD7bqr/lP0n0OBSRn86SZgQBXwRR+vq7sk16y31OgRBIOJ5Q==}
+
+  '@zkpassport/registry@0.15.3':
+    resolution: {integrity: sha512-Er6bxcB79qtGg9xhAVUkwlbpZYOHsO2hKlbguu+ycnx83NOUsrUyeOYBtajYaDAbHRopFODFYABQFS2zRGKbgg==}
+
+  '@zkpassport/sdk@0.19.2':
+    resolution: {integrity: sha512-OyA9CtXJQTXI2EuDsXegyCQ7lzkuVR4qGaewuIXlgngOsua827X99muh6zSZ7Pv2HzBL0SDAc57D7MONTCbgiQ==}
+
+  '@zkpassport/utils@0.39.0':
+    resolution: {integrity: sha512-oNflZQ9M2bHdQpwYWBN9v6joulMwwy1jdVPVyHFE9FXlRWfJSj7A/tOht/LRzbWq5qTafCuSSyWM1NNbOXOxIg==}
+
+  '@zkpassport/utils@0.40.0-beta.2':
+    resolution: {integrity: sha512-9mAIATw0YsOlw7IWlbaHyP2jxnKXV8u94h+yhhkIYq636xcx3tsf2VetWKVjyPLrCGPM9BE7ifhaz5IOEvSeLQ==}
+
   abbrev@1.0.9:
     resolution: {integrity: sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q==}
 
@@ -4617,6 +4747,9 @@ packages:
     resolution: {integrity: sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==}
     engines: {node: '>=0.11'}
 
+  date-fns@4.4.0:
+    resolution: {integrity: sha512-+1UMbeh68lH1SegH83CGWwpb6OHHbpSgr3+s5Eww5M4CAgswBpoWS0AjTOfEJ33HiYKz1hdj/KTFprzXHmq/6w==}
+
   dayjs@1.11.13:
     resolution: {integrity: sha512-oaMBel6gjolK862uaPQOVTA7q3TZhuSvuMQAAglQDOWYO9A91IrAOUJEyKVlqJlHE0vq5p5UXxzdPfMH/x6xNg==}
 
@@ -4729,6 +4862,9 @@ packages:
   devlop@1.1.0:
     resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
 
+  diacritics@1.3.0:
+    resolution: {integrity: sha512-wlwEkqcsaxvPJML+rDh/2iS824jbREk6DUMUKkEaSlxdYHeS43cClJtsWglvw2RfeXGm6ohKDqsXteJ5sP5enA==}
+
   didyoumean@1.2.2:
     resolution: {integrity: sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==}
 
@@ -5621,6 +5757,10 @@ packages:
     engines: {node: '>=18'}
     hasBin: true
 
+  i18n-iso-countries@7.14.0:
+    resolution: {integrity: sha512-nXHJZYtNrfsi1UQbyRqm3Gou431elgLjKl//CYlnBGt5aTWdRPH1PiS2T/p/n8Q8LnqYqzQJik3Q7mkwvLokeg==}
+    engines: {node: '>= 12'}
+
   iconv-lite@0.4.24:
     resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==}
     engines: {node: '>=0.10.0'}
@@ -7475,6 +7615,9 @@ packages:
     resolution: {integrity: sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==}
     engines: {node: '>=6'}
 
+  reflect-metadata@0.2.2:
+    resolution: {integrity: sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==}
+
   registry-auth-token@5.1.1:
     resolution: {integrity: sha512-P7B4+jq8DeD2nMsAcdfaqHbssgHtZ7Z5+++a5ask90fvmJ8p5je4mOa+wzu+DB4vQ5tdJV/xywY+UnVFeQLV5Q==}
     engines: {node: '>=14'}
@@ -8238,6 +8381,10 @@ packages:
     engines: {node: '>=18.0.0'}
     hasBin: true
 
+  tsyringe@4.10.0:
+    resolution: {integrity: sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==}
+    engines: {node: '>= 6.0.0'}
+
   type-check@0.3.2:
     resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==}
     engines: {node: '>= 0.8.0'}
@@ -9066,6 +9213,24 @@ snapshots:
       proper-lockfile: 4.1.2
       tslib: 2.8.1
 
+  '@aztec/bb.js@4.2.0-aztecnr-rc.2':
+    dependencies:
+      comlink: 4.4.2
+      commander: 12.1.0
+      idb-keyval: 6.3.0
+      msgpackr: 1.12.1
+      pako: 2.2.0
+      tslib: 2.8.1
+
+  '@aztec/bb.js@5.0.0':
+    dependencies:
+      comlink: 4.4.2
+      commander: 12.1.0
+      idb-keyval: 6.3.0
+      msgpackr: 1.12.1
+      pako: 2.2.0
+      tslib: 2.8.1
+
   '@babel/code-frame@7.27.1':
     dependencies:
       '@babel/helper-validator-identifier': 7.28.5
@@ -9265,6 +9430,33 @@ snapshots:
       '@babel/helper-string-parser': 7.29.7
       '@babel/helper-validator-identifier': 7.29.7
 
+  '@base-org/account@2.4.0(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@coinbase/cdp-sdk': 1.54.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@noble/hashes': 1.4.0
+      clsx: 1.2.1
+      eventemitter3: 5.0.1
+      idb-keyval: 6.2.1
+      ox: 0.6.9(typescript@5.8.3)(zod@3.25.76)
+      preact: 10.24.2
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      zustand: 5.0.3(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(use-sync-external-store@1.4.0(react@18.3.1))
+    transitivePeerDependencies:
+      - '@types/react'
+      - '@x402/core'
+      - '@x402/evm'
+      - '@x402/extensions'
+      - '@x402/svm'
+      - bufferutil
+      - debug
+      - fastestsmallesttextencoderdecoder
+      - immer
+      - react
+      - typescript
+      - use-sync-external-store
+      - utf-8-validate
+      - zod
+
   '@base-org/account@2.4.0(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@coinbase/cdp-sdk': 1.54.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
@@ -9504,6 +9696,26 @@ snapshots:
       - preact-render-to-string
       - supports-color
 
+  '@coinbase/wallet-sdk@4.3.6(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@noble/hashes': 1.4.0
+      clsx: 1.2.1
+      eventemitter3: 5.0.1
+      idb-keyval: 6.2.1
+      ox: 0.6.9(typescript@5.8.3)(zod@3.25.76)
+      preact: 10.24.2
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      zustand: 5.0.3(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(use-sync-external-store@1.4.0(react@18.3.1))
+    transitivePeerDependencies:
+      - '@types/react'
+      - bufferutil
+      - immer
+      - react
+      - typescript
+      - use-sync-external-store
+      - utf-8-validate
+      - zod
+
   '@coinbase/wallet-sdk@4.3.6(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@noble/hashes': 1.4.0
@@ -10004,6 +10216,14 @@ snapshots:
 
   '@fastify/busboy@2.1.1': {}
 
+  '@gemini-wallet/core@0.3.2(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))':
+    dependencies:
+      '@metamask/rpc-errors': 7.0.2
+      eventemitter3: 5.0.1
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+    transitivePeerDependencies:
+      - supports-color
+
   '@gemini-wallet/core@0.3.2(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))':
     dependencies:
       '@metamask/rpc-errors': 7.0.2
@@ -10228,6 +10448,8 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  '@lapo/asn1js@2.1.3': {}
+
   '@lit-labs/ssr-dom-shim@1.6.0': {}
 
   '@lit/reactive-element@2.1.2':
@@ -10696,6 +10918,10 @@ snapshots:
     dependencies:
       '@noble/hashes': 1.8.0
 
+  '@noble/curves@2.4.0':
+    dependencies:
+      '@noble/hashes': 2.4.0
+
   '@noble/hashes@1.2.0': {}
 
   '@noble/hashes@1.3.2': {}
@@ -10710,8 +10936,12 @@ snapshots:
 
   '@noble/hashes@1.8.0': {}
 
+  '@noble/hashes@2.4.0': {}
+
   '@noble/secp256k1@1.7.1': {}
 
+  '@noble/secp256k1@2.3.0': {}
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -10724,8 +10954,17 @@ snapshots:
       '@nodelib/fs.scandir': 2.1.5
       fastq: 1.20.1
 
+  '@noir-lang/acvm_js@1.0.0-beta.22': {}
+
   '@noir-lang/acvm_js@1.0.0-rc.3': {}
 
+  '@noir-lang/noir_js@1.0.0-beta.22':
+    dependencies:
+      '@noir-lang/acvm_js': 1.0.0-beta.22
+      '@noir-lang/noirc_abi': 1.0.0-beta.22
+      '@noir-lang/types': 1.0.0-beta.22
+      pako: 2.2.0
+
   '@noir-lang/noir_js@1.0.0-rc.3':
     dependencies:
       '@noir-lang/acvm_js': 1.0.0-rc.3
@@ -10733,10 +10972,16 @@ snapshots:
       '@noir-lang/types': 1.0.0-rc.3
       pako: 3.0.1
 
+  '@noir-lang/noirc_abi@1.0.0-beta.22':
+    dependencies:
+      '@noir-lang/types': 1.0.0-beta.22
+
   '@noir-lang/noirc_abi@1.0.0-rc.3':
     dependencies:
       '@noir-lang/types': 1.0.0-rc.3
 
+  '@noir-lang/types@1.0.0-beta.22': {}
+
   '@noir-lang/types@1.0.0-rc.3': {}
 
   '@nomicfoundation/edr-darwin-arm64@0.12.0-next.10': {}
@@ -11064,6 +11309,21 @@ snapshots:
       '@nomicfoundation/solidity-analyzer-linux-x64-musl': 0.1.2
       '@nomicfoundation/solidity-analyzer-win32-x64-msvc': 0.1.2
 
+  '@obsidion/bridge@0.12.2(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)':
+    dependencies:
+      '@noble/ciphers': 1.3.0
+      '@noble/hashes': 1.8.0
+      '@noble/secp256k1': 2.3.0
+      '@types/pako': 2.0.4
+      debug: 4.4.3(supports-color@5.5.0)
+      pako: 2.2.0
+      typescript: 5.8.3
+      ws: 8.21.1(bufferutil@4.1.0)(utf-8-validate@5.0.10)
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
   '@offchainlabs/upgrade-executor@1.1.0-beta.0':
     dependencies:
       '@openzeppelin/contracts': 4.7.3
@@ -11091,17 +11351,105 @@ snapshots:
 
   '@paulmillr/qr@0.2.1': {}
 
+  '@peculiar/asn1-cms@2.11.1':
+    dependencies:
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/asn1-x509': 2.11.1
+      '@peculiar/asn1-x509-attr': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-csr@2.11.1':
+    dependencies:
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/asn1-x509': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-ecc@2.11.1':
+    dependencies:
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/asn1-x509': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-pfx@2.11.1':
+    dependencies:
+      '@peculiar/asn1-cms': 2.11.1
+      '@peculiar/asn1-pkcs8': 2.11.1
+      '@peculiar/asn1-rsa': 2.11.1
+      '@peculiar/asn1-schema': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-pkcs8@2.11.1':
+    dependencies:
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/asn1-x509': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-pkcs9@2.11.1':
+    dependencies:
+      '@peculiar/asn1-cms': 2.11.1
+      '@peculiar/asn1-pfx': 2.11.1
+      '@peculiar/asn1-pkcs8': 2.11.1
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/asn1-x509': 2.11.1
+      '@peculiar/asn1-x509-attr': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-rsa@2.11.1':
+    dependencies:
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/asn1-x509': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-schema@2.11.1':
+    dependencies:
+      '@peculiar/utils': 2.0.3
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
   '@peculiar/asn1-schema@2.8.0':
     dependencies:
       '@peculiar/utils': 2.0.3
       asn1js: 3.0.10
       tslib: 2.8.1
-    optional: true
+
+  '@peculiar/asn1-x509-attr@2.11.1':
+    dependencies:
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/asn1-x509': 2.11.1
+      asn1js: 3.0.10
+      tslib: 2.8.1
+
+  '@peculiar/asn1-x509@2.11.1':
+    dependencies:
+      '@peculiar/asn1-schema': 2.11.1
+      '@peculiar/utils': 2.0.3
+      asn1js: 3.0.10
+      tslib: 2.8.1
 
   '@peculiar/utils@2.0.3':
     dependencies:
       tslib: 2.8.1
-    optional: true
+
+  '@peculiar/x509@1.14.3':
+    dependencies:
+      '@peculiar/asn1-cms': 2.11.1
+      '@peculiar/asn1-csr': 2.11.1
+      '@peculiar/asn1-ecc': 2.11.1
+      '@peculiar/asn1-pkcs9': 2.11.1
+      '@peculiar/asn1-rsa': 2.11.1
+      '@peculiar/asn1-schema': 2.8.0
+      '@peculiar/asn1-x509': 2.11.1
+      pvtsutils: 1.3.6
+      reflect-metadata: 0.2.2
+      tslib: 2.8.1
+      tsyringe: 4.10.0
 
   '@phosphor-icons/react@2.1.10(react-dom@18.3.1(react@18.3.1))(react@18.3.1)':
     dependencies:
@@ -11162,6 +11510,17 @@ snapshots:
       - utf-8-validate
       - zod
 
+  '@reown/appkit-common@1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      big.js: 6.2.2
+      dayjs: 1.11.13
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+    transitivePeerDependencies:
+      - bufferutil
+      - typescript
+      - utf-8-validate
+      - zod
+
   '@reown/appkit-common@1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       big.js: 6.2.2
@@ -11173,13 +11532,13 @@ snapshots:
       - utf-8-validate
       - zod
 
-  '@reown/appkit-controllers@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+  '@reown/appkit-controllers@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
     dependencies:
-      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
       '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
-      '@walletconnect/universal-provider': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/universal-provider': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
       valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
-      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
     transitivePeerDependencies:
       - '@azure/app-configuration'
       - '@azure/cosmos'
@@ -11208,14 +11567,13 @@ snapshots:
       - utf-8-validate
       - zod
 
-  '@reown/appkit-pay@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+  '@reown/appkit-controllers@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-utils': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)
-      lit: 3.3.0
+      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@walletconnect/universal-provider': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
       valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
     transitivePeerDependencies:
       - '@azure/app-configuration'
       - '@azure/cosmos'
@@ -11244,18 +11602,14 @@ snapshots:
       - utf-8-validate
       - zod
 
-  '@reown/appkit-polyfills@1.7.8':
-    dependencies:
-      buffer: 6.0.3
-
-  '@reown/appkit-scaffold-ui@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)':
+  '@reown/appkit-pay@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
     dependencies:
-      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-utils': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)
-      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-utils': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@3.25.76)
       lit: 3.3.0
+      valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
     transitivePeerDependencies:
       - '@azure/app-configuration'
       - '@azure/cosmos'
@@ -11282,16 +11636,16 @@ snapshots:
       - typescript
       - uploadthing
       - utf-8-validate
-      - valtio
       - zod
 
-  '@reown/appkit-ui@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+  '@reown/appkit-pay@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
       '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@reown/appkit-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-utils': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)
       lit: 3.3.0
-      qrcode: 1.5.3
+      valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
     transitivePeerDependencies:
       - '@azure/app-configuration'
       - '@azure/cosmos'
@@ -11320,16 +11674,202 @@ snapshots:
       - utf-8-validate
       - zod
 
-  '@reown/appkit-utils@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)':
+  '@reown/appkit-polyfills@1.7.8':
     dependencies:
-      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@reown/appkit-polyfills': 1.7.8
+      buffer: 6.0.3
+
+  '@reown/appkit-scaffold-ui@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@3.25.76)':
+    dependencies:
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-utils': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@3.25.76)
       '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
-      '@walletconnect/logger': 2.1.2
-      '@walletconnect/universal-provider': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
-      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      lit: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - encoding
+      - ioredis
+      - react
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - valtio
+      - zod
+
+  '@reown/appkit-scaffold-ui@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)':
+    dependencies:
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-utils': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)
+      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      lit: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - encoding
+      - ioredis
+      - react
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - valtio
+      - zod
+
+  '@reown/appkit-ui@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      lit: 3.3.0
+      qrcode: 1.5.3
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - encoding
+      - ioredis
+      - react
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
+  '@reown/appkit-ui@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+    dependencies:
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      lit: 3.3.0
+      qrcode: 1.5.3
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - encoding
+      - ioredis
+      - react
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
+  '@reown/appkit-utils@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@3.25.76)':
+    dependencies:
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-polyfills': 1.7.8
+      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/universal-provider': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - encoding
+      - ioredis
+      - react
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
+  '@reown/appkit-utils@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@4.4.3)':
+    dependencies:
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@reown/appkit-polyfills': 1.7.8
+      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/universal-provider': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
     transitivePeerDependencies:
       - '@azure/app-configuration'
       - '@azure/cosmos'
@@ -11369,6 +11909,49 @@ snapshots:
       - typescript
       - utf-8-validate
 
+  '@reown/appkit@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-controllers': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-pay': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-polyfills': 1.7.8
+      '@reown/appkit-scaffold-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@3.25.76)
+      '@reown/appkit-ui': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@reown/appkit-utils': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(valtio@1.13.2(@types/react@18.3.31)(react@18.3.1))(zod@3.25.76)
+      '@reown/appkit-wallet': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@walletconnect/types': 2.21.0
+      '@walletconnect/universal-provider': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      bs58: 6.0.0
+      valtio: 1.13.2(@types/react@18.3.31)(react@18.3.1)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - encoding
+      - ioredis
+      - react
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
   '@reown/appkit@1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@reown/appkit-common': 1.7.8(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
@@ -11570,6 +12153,16 @@ snapshots:
       - utf-8-validate
       - zod
 
+  '@safe-global/safe-apps-provider@0.18.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@safe-global/safe-apps-sdk': 9.1.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      events: 3.3.0
+    transitivePeerDependencies:
+      - bufferutil
+      - typescript
+      - utf-8-validate
+      - zod
+
   '@safe-global/safe-apps-provider@0.18.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@safe-global/safe-apps-sdk': 9.1.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
@@ -11580,6 +12173,16 @@ snapshots:
       - utf-8-validate
       - zod
 
+  '@safe-global/safe-apps-sdk@9.1.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@safe-global/safe-gateway-typescript-sdk': 3.23.1
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+    transitivePeerDependencies:
+      - bufferutil
+      - typescript
+      - utf-8-validate
+      - zod
+
   '@safe-global/safe-apps-sdk@9.1.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@safe-global/safe-gateway-typescript-sdk': 3.23.1
@@ -12213,6 +12816,22 @@ snapshots:
     dependencies:
       defer-to-connect: 2.0.1
 
+  '@taceo/oprf-client@0.9.0':
+    dependencies:
+      '@noble/curves': 2.4.0
+      '@noble/hashes': 2.4.0
+      '@taceo/oprf-core': 0.4.0
+
+  '@taceo/oprf-core@0.4.0':
+    dependencies:
+      '@noble/curves': 2.4.0
+      '@noble/hashes': 2.4.0
+      '@taceo/poseidon2': 0.2.0
+
+  '@taceo/poseidon2@0.2.0':
+    dependencies:
+      '@noble/curves': 2.4.0
+
   '@tailwindcss/typography@0.5.20(tailwindcss@3.4.19(tsx@4.20.6)(yaml@2.8.2))':
     dependencies:
       postcss-selector-parser: 6.0.10
@@ -12417,10 +13036,16 @@ snapshots:
     dependencies:
       undici-types: 6.19.8
 
+  '@types/pako@2.0.4': {}
+
   '@types/prettier@2.7.3': {}
 
   '@types/prop-types@15.7.15': {}
 
+  '@types/qrcode@1.5.5':
+    dependencies:
+      '@types/node': 22.7.5
+
   '@types/qs@6.15.1': {}
 
   '@types/range-parser@1.2.7': {}
@@ -12719,19 +13344,19 @@ snapshots:
 
   '@vue/shared@3.5.40': {}
 
-  '@wagmi/connectors@6.2.0(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)))(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(zod@4.4.3))(zod@4.4.3)':
+  '@wagmi/connectors@6.2.0(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)))(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(zod@3.25.76))(zod@3.25.76)':
     dependencies:
-      '@base-org/account': 2.4.0(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@coinbase/wallet-sdk': 4.3.6(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@gemini-wallet/core': 0.3.2(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))
+      '@base-org/account': 2.4.0(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@coinbase/wallet-sdk': 4.3.6(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@gemini-wallet/core': 0.3.2(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))
       '@metamask/sdk': 0.33.1(bufferutil@4.1.0)(utf-8-validate@5.0.10)
-      '@safe-global/safe-apps-provider': 0.18.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@safe-global/safe-apps-sdk': 9.1.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@wagmi/core': 2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))
-      '@walletconnect/ethereum-provider': 2.21.1(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@safe-global/safe-apps-provider': 0.18.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@safe-global/safe-apps-sdk': 9.1.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@wagmi/core': 2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))
+      '@walletconnect/ethereum-provider': 2.21.1(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
       cbw-sdk: '@coinbase/wallet-sdk@3.9.3'
-      porto: 0.2.35(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)))(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(zod@4.4.3))
-      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      porto: 0.2.35(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)))(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(zod@3.25.76))
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
     optionalDependencies:
       typescript: 5.8.3
     transitivePeerDependencies:
@@ -12777,13 +13402,86 @@ snapshots:
       - wagmi
       - zod
 
-  '@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))':
+  '@wagmi/connectors@6.2.0(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)))(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(zod@4.4.3))(zod@4.4.3)':
     dependencies:
-      eventemitter3: 5.0.1
-      mipd: 0.0.7(typescript@5.8.3)
-      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      zustand: 5.0.0(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(use-sync-external-store@1.4.0(react@18.3.1))
-    optionalDependencies:
+      '@base-org/account': 2.4.0(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@coinbase/wallet-sdk': 4.3.6(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@gemini-wallet/core': 0.3.2(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))
+      '@metamask/sdk': 0.33.1(bufferutil@4.1.0)(utf-8-validate@5.0.10)
+      '@safe-global/safe-apps-provider': 0.18.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@safe-global/safe-apps-sdk': 9.1.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@wagmi/core': 2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))
+      '@walletconnect/ethereum-provider': 2.21.1(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      cbw-sdk: '@coinbase/wallet-sdk@3.9.3'
+      porto: 0.2.35(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)))(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(zod@4.4.3))
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+    optionalDependencies:
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@tanstack/react-query'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - '@x402/core'
+      - '@x402/evm'
+      - '@x402/extensions'
+      - '@x402/svm'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - debug
+      - encoding
+      - expo-auth-session
+      - expo-crypto
+      - expo-web-browser
+      - fastestsmallesttextencoderdecoder
+      - immer
+      - ioredis
+      - preact-render-to-string
+      - react
+      - react-native
+      - supports-color
+      - uploadthing
+      - use-sync-external-store
+      - utf-8-validate
+      - wagmi
+      - zod
+
+  '@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))':
+    dependencies:
+      eventemitter3: 5.0.1
+      mipd: 0.0.7(typescript@5.8.3)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      zustand: 5.0.0(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(use-sync-external-store@1.4.0(react@18.3.1))
+    optionalDependencies:
+      '@tanstack/query-core': 5.101.4
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - '@types/react'
+      - immer
+      - react
+      - use-sync-external-store
+
+  '@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))':
+    dependencies:
+      eventemitter3: 5.0.1
+      mipd: 0.0.7(typescript@5.8.3)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      zustand: 5.0.0(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(use-sync-external-store@1.4.0(react@18.3.1))
+    optionalDependencies:
       '@tanstack/query-core': 5.101.4
       typescript: 5.8.3
     transitivePeerDependencies:
@@ -12792,6 +13490,50 @@ snapshots:
       - react
       - use-sync-external-store
 
+  '@walletconnect/core@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-provider': 1.0.14
+      '@walletconnect/jsonrpc-types': 1.0.4
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/jsonrpc-ws-connection': 1.0.16(bufferutil@4.1.0)(utf-8-validate@5.0.10)
+      '@walletconnect/keyvaluestorage': 1.1.1
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/relay-api': 1.0.11
+      '@walletconnect/relay-auth': 1.1.0
+      '@walletconnect/safe-json': 1.0.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.0
+      '@walletconnect/utils': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/window-getters': 1.0.1
+      es-toolkit: 1.33.0
+      events: 3.3.0
+      uint8arrays: 3.1.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - ioredis
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
   '@walletconnect/core@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@walletconnect/heartbeat': 1.2.2
@@ -12836,6 +13578,50 @@ snapshots:
       - utf-8-validate
       - zod
 
+  '@walletconnect/core@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-provider': 1.0.14
+      '@walletconnect/jsonrpc-types': 1.0.4
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/jsonrpc-ws-connection': 1.0.16(bufferutil@4.1.0)(utf-8-validate@5.0.10)
+      '@walletconnect/keyvaluestorage': 1.1.1
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/relay-api': 1.0.11
+      '@walletconnect/relay-auth': 1.1.0
+      '@walletconnect/safe-json': 1.0.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.1
+      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/window-getters': 1.0.1
+      es-toolkit: 1.33.0
+      events: 3.3.0
+      uint8arrays: 3.1.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - ioredis
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
   '@walletconnect/core@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@walletconnect/heartbeat': 1.2.2
@@ -12884,6 +13670,47 @@ snapshots:
     dependencies:
       tslib: 1.14.1
 
+  '@walletconnect/ethereum-provider@2.21.1(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@reown/appkit': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/jsonrpc-http-connection': 1.0.8
+      '@walletconnect/jsonrpc-provider': 1.0.14
+      '@walletconnect/jsonrpc-types': 1.0.4
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/keyvaluestorage': 1.1.1
+      '@walletconnect/sign-client': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/types': 2.21.1
+      '@walletconnect/universal-provider': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      events: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - encoding
+      - ioredis
+      - react
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
   '@walletconnect/ethereum-provider@2.21.1(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@reown/appkit': 1.7.8(@types/react@18.3.31)(bufferutil@4.1.0)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
@@ -13018,16 +13845,190 @@ snapshots:
     dependencies:
       tslib: 1.14.1
 
+  '@walletconnect/sign-client@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@walletconnect/core': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/events': 1.0.1
+      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.0
+      '@walletconnect/utils': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      events: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - ioredis
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
   '@walletconnect/sign-client@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
-      '@walletconnect/core': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/core': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/events': 1.0.1
+      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.0
+      '@walletconnect/utils': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      events: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - ioredis
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
+  '@walletconnect/sign-client@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@walletconnect/core': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/events': 1.0.1
+      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.1
+      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      events: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - ioredis
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
+  '@walletconnect/sign-client@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+    dependencies:
+      '@walletconnect/core': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/events': 1.0.1
+      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/logger': 2.1.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.1
+      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      events: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - ioredis
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
+  '@walletconnect/time@1.0.2':
+    dependencies:
+      tslib: 1.14.1
+
+  '@walletconnect/types@2.21.0':
+    dependencies:
+      '@walletconnect/events': 1.0.1
+      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-types': 1.0.4
+      '@walletconnect/keyvaluestorage': 1.1.1
+      '@walletconnect/logger': 2.1.2
+      events: 3.3.0
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - db0
+      - ioredis
+      - uploadthing
+
+  '@walletconnect/types@2.21.1':
+    dependencies:
       '@walletconnect/events': 1.0.1
       '@walletconnect/heartbeat': 1.2.2
-      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/jsonrpc-types': 1.0.4
+      '@walletconnect/keyvaluestorage': 1.1.1
       '@walletconnect/logger': 2.1.2
-      '@walletconnect/time': 1.0.2
-      '@walletconnect/types': 2.21.0
-      '@walletconnect/utils': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
       events: 3.3.0
     transitivePeerDependencies:
       - '@azure/app-configuration'
@@ -13046,24 +14047,23 @@ snapshots:
       - '@vercel/functions'
       - '@vercel/kv'
       - aws4fetch
-      - bufferutil
       - db0
       - ioredis
-      - typescript
       - uploadthing
-      - utf-8-validate
-      - zod
 
-  '@walletconnect/sign-client@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+  '@walletconnect/universal-provider@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
     dependencies:
-      '@walletconnect/core': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
       '@walletconnect/events': 1.0.1
-      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-http-connection': 1.0.8
+      '@walletconnect/jsonrpc-provider': 1.0.14
+      '@walletconnect/jsonrpc-types': 1.0.4
       '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/keyvaluestorage': 1.1.1
       '@walletconnect/logger': 2.1.2
-      '@walletconnect/time': 1.0.2
-      '@walletconnect/types': 2.21.1
-      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/sign-client': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/types': 2.21.0
+      '@walletconnect/utils': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      es-toolkit: 1.33.0
       events: 3.3.0
     transitivePeerDependencies:
       - '@azure/app-configuration'
@@ -13084,23 +14084,26 @@ snapshots:
       - aws4fetch
       - bufferutil
       - db0
+      - encoding
       - ioredis
       - typescript
       - uploadthing
       - utf-8-validate
       - zod
 
-  '@walletconnect/time@1.0.2':
-    dependencies:
-      tslib: 1.14.1
-
-  '@walletconnect/types@2.21.0':
+  '@walletconnect/universal-provider@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@walletconnect/events': 1.0.1
-      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-http-connection': 1.0.8
+      '@walletconnect/jsonrpc-provider': 1.0.14
       '@walletconnect/jsonrpc-types': 1.0.4
+      '@walletconnect/jsonrpc-utils': 1.0.8
       '@walletconnect/keyvaluestorage': 1.1.1
       '@walletconnect/logger': 2.1.2
+      '@walletconnect/sign-client': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/types': 2.21.0
+      '@walletconnect/utils': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      es-toolkit: 1.33.0
       events: 3.3.0
     transitivePeerDependencies:
       - '@azure/app-configuration'
@@ -13119,17 +14122,28 @@ snapshots:
       - '@vercel/functions'
       - '@vercel/kv'
       - aws4fetch
+      - bufferutil
       - db0
+      - encoding
       - ioredis
+      - typescript
       - uploadthing
+      - utf-8-validate
+      - zod
 
-  '@walletconnect/types@2.21.1':
+  '@walletconnect/universal-provider@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
     dependencies:
       '@walletconnect/events': 1.0.1
-      '@walletconnect/heartbeat': 1.2.2
+      '@walletconnect/jsonrpc-http-connection': 1.0.8
+      '@walletconnect/jsonrpc-provider': 1.0.14
       '@walletconnect/jsonrpc-types': 1.0.4
+      '@walletconnect/jsonrpc-utils': 1.0.8
       '@walletconnect/keyvaluestorage': 1.1.1
       '@walletconnect/logger': 2.1.2
+      '@walletconnect/sign-client': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      '@walletconnect/types': 2.21.1
+      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      es-toolkit: 1.33.0
       events: 3.3.0
     transitivePeerDependencies:
       - '@azure/app-configuration'
@@ -13148,11 +14162,16 @@ snapshots:
       - '@vercel/functions'
       - '@vercel/kv'
       - aws4fetch
+      - bufferutil
       - db0
+      - encoding
       - ioredis
+      - typescript
       - uploadthing
+      - utf-8-validate
+      - zod
 
-  '@walletconnect/universal-provider@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+  '@walletconnect/universal-provider@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@walletconnect/events': 1.0.1
       '@walletconnect/jsonrpc-http-connection': 1.0.8
@@ -13161,9 +14180,9 @@ snapshots:
       '@walletconnect/jsonrpc-utils': 1.0.8
       '@walletconnect/keyvaluestorage': 1.1.1
       '@walletconnect/logger': 2.1.2
-      '@walletconnect/sign-client': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@walletconnect/types': 2.21.0
-      '@walletconnect/utils': 2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/sign-client': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      '@walletconnect/types': 2.21.1
+      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
       es-toolkit: 1.33.0
       events: 3.3.0
     transitivePeerDependencies:
@@ -13192,20 +14211,25 @@ snapshots:
       - utf-8-validate
       - zod
 
-  '@walletconnect/universal-provider@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+  '@walletconnect/utils@2.21.0(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
     dependencies:
-      '@walletconnect/events': 1.0.1
-      '@walletconnect/jsonrpc-http-connection': 1.0.8
-      '@walletconnect/jsonrpc-provider': 1.0.14
-      '@walletconnect/jsonrpc-types': 1.0.4
+      '@noble/ciphers': 1.2.1
+      '@noble/curves': 1.8.1
+      '@noble/hashes': 1.7.1
       '@walletconnect/jsonrpc-utils': 1.0.8
       '@walletconnect/keyvaluestorage': 1.1.1
-      '@walletconnect/logger': 2.1.2
-      '@walletconnect/sign-client': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      '@walletconnect/types': 2.21.1
-      '@walletconnect/utils': 2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
-      es-toolkit: 1.33.0
-      events: 3.3.0
+      '@walletconnect/relay-api': 1.0.11
+      '@walletconnect/relay-auth': 1.1.0
+      '@walletconnect/safe-json': 1.0.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.0
+      '@walletconnect/window-getters': 1.0.1
+      '@walletconnect/window-metadata': 1.0.1
+      bs58: 6.0.0
+      detect-browser: 5.3.0
+      query-string: 7.1.3
+      uint8arrays: 3.1.0
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
     transitivePeerDependencies:
       - '@azure/app-configuration'
       - '@azure/cosmos'
@@ -13225,7 +14249,6 @@ snapshots:
       - aws4fetch
       - bufferutil
       - db0
-      - encoding
       - ioredis
       - typescript
       - uploadthing
@@ -13276,6 +14299,50 @@ snapshots:
       - utf-8-validate
       - zod
 
+  '@walletconnect/utils@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)':
+    dependencies:
+      '@noble/ciphers': 1.2.1
+      '@noble/curves': 1.8.1
+      '@noble/hashes': 1.7.1
+      '@walletconnect/jsonrpc-utils': 1.0.8
+      '@walletconnect/keyvaluestorage': 1.1.1
+      '@walletconnect/relay-api': 1.0.11
+      '@walletconnect/relay-auth': 1.1.0
+      '@walletconnect/safe-json': 1.0.2
+      '@walletconnect/time': 1.0.2
+      '@walletconnect/types': 2.21.1
+      '@walletconnect/window-getters': 1.0.1
+      '@walletconnect/window-metadata': 1.0.1
+      bs58: 6.0.0
+      detect-browser: 5.3.0
+      query-string: 7.1.3
+      uint8arrays: 3.1.0
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - ioredis
+      - typescript
+      - uploadthing
+      - utf-8-validate
+      - zod
+
   '@walletconnect/utils@2.21.1(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
     dependencies:
       '@noble/ciphers': 1.2.1
@@ -13346,6 +14413,10 @@ snapshots:
       - bufferutil
       - utf-8-validate
 
+  '@zk-kit/utils@1.3.0':
+    dependencies:
+      buffer: 6.0.3
+
   '@zk-kit/utils@1.4.1(bufferutil@4.1.0)(utf-8-validate@5.0.10)':
     dependencies:
       buffer: 6.0.3
@@ -13354,6 +14425,83 @@ snapshots:
       - bufferutil
       - utf-8-validate
 
+  '@zkpassport/poseidon2@0.6.2': {}
+
+  '@zkpassport/registry@0.15.3':
+    dependencies:
+      '@zkpassport/poseidon2': 0.6.2
+      '@zkpassport/utils': 0.39.0
+      debug: 4.4.3(supports-color@5.5.0)
+      tslib: 2.8.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@zkpassport/sdk@0.19.2(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)':
+    dependencies:
+      '@aztec/bb.js': 5.0.0
+      '@aztec/bb.js-v4': '@aztec/bb.js@4.2.0-aztecnr-rc.2'
+      '@noble/ciphers': 1.3.0
+      '@noble/hashes': 2.4.0
+      '@noble/secp256k1': 2.3.0
+      '@noir-lang/noir_js': 1.0.0-beta.22
+      '@obsidion/bridge': 0.12.2(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)
+      '@zkpassport/registry': 0.15.3
+      '@zkpassport/utils': 0.40.0-beta.2
+      buffer: 6.0.3
+      i18n-iso-countries: 7.14.0
+      pako: 2.2.0
+      tslib: 2.8.1
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)
+      ws: 8.21.1(bufferutil@4.1.0)(utf-8-validate@5.0.10)
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - typescript
+      - utf-8-validate
+      - zod
+
+  '@zkpassport/utils@0.39.0':
+    dependencies:
+      '@lapo/asn1js': 2.1.3
+      '@noble/ciphers': 1.3.0
+      '@noble/curves': 2.4.0
+      '@noble/hashes': 2.4.0
+      '@noble/secp256k1': 2.3.0
+      '@peculiar/asn1-cms': 2.11.1
+      '@peculiar/asn1-ecc': 2.11.1
+      '@peculiar/asn1-rsa': 2.11.1
+      '@peculiar/asn1-schema': 2.8.0
+      '@peculiar/asn1-x509': 2.11.1
+      '@peculiar/x509': 1.14.3
+      '@taceo/oprf-client': 0.9.0
+      '@taceo/oprf-core': 0.4.0
+      '@zk-kit/utils': 1.3.0
+      '@zkpassport/poseidon2': 0.6.2
+      date-fns: 4.4.0
+      i18n-iso-countries: 7.14.0
+      tslib: 2.8.1
+
+  '@zkpassport/utils@0.40.0-beta.2':
+    dependencies:
+      '@lapo/asn1js': 2.1.3
+      '@noble/ciphers': 1.3.0
+      '@noble/curves': 2.4.0
+      '@noble/hashes': 2.4.0
+      '@noble/secp256k1': 2.3.0
+      '@peculiar/asn1-cms': 2.11.1
+      '@peculiar/asn1-ecc': 2.11.1
+      '@peculiar/asn1-rsa': 2.11.1
+      '@peculiar/asn1-schema': 2.8.0
+      '@peculiar/asn1-x509': 2.11.1
+      '@peculiar/x509': 1.14.3
+      '@taceo/oprf-client': 0.9.0
+      '@taceo/oprf-core': 0.4.0
+      '@zk-kit/utils': 1.3.0
+      '@zkpassport/poseidon2': 0.6.2
+      date-fns: 4.4.0
+      i18n-iso-countries: 7.14.0
+      tslib: 2.8.1
+
   abbrev@1.0.9: {}
 
   abitype@1.0.6(typescript@5.8.3)(zod@3.25.76):
@@ -13522,7 +14670,6 @@ snapshots:
       pvtsutils: 1.3.6
       pvutils: 1.1.5
       tslib: 2.8.1
-    optional: true
 
   assertion-error@1.1.0: {}
 
@@ -14295,6 +15442,8 @@ snapshots:
     dependencies:
       '@babel/runtime': 7.29.7
 
+  date-fns@4.4.0: {}
+
   dayjs@1.11.13: {}
 
   dayjs@1.11.21: {}
@@ -14379,6 +15528,8 @@ snapshots:
     dependencies:
       dequal: 2.0.3
 
+  diacritics@1.3.0: {}
+
   didyoumean@1.2.2: {}
 
   diff-sequences@29.6.3: {}
@@ -15593,6 +16744,10 @@ snapshots:
 
   husky@9.1.7: {}
 
+  i18n-iso-countries@7.14.0:
+    dependencies:
+      diacritics: 1.3.0
+
   iconv-lite@0.4.24:
     dependencies:
       safer-buffer: 2.1.2
@@ -17009,6 +18164,20 @@ snapshots:
 
   outdent@0.5.0: {}
 
+  ox@0.6.9(typescript@5.8.3)(zod@3.25.76):
+    dependencies:
+      '@adraffy/ens-normalize': 1.11.1
+      '@noble/curves': 1.9.7
+      '@noble/hashes': 1.8.0
+      '@scure/bip32': 1.7.0
+      '@scure/bip39': 1.6.0
+      abitype: 1.3.0(typescript@5.8.3)(zod@3.25.76)
+      eventemitter3: 5.0.1
+    optionalDependencies:
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - zod
+
   ox@0.6.9(typescript@5.8.3)(zod@4.4.3):
     dependencies:
       '@adraffy/ens-normalize': 1.11.1
@@ -17308,6 +18477,26 @@ snapshots:
       style-value-types: 5.0.0
       tslib: 2.8.1
 
+  porto@0.2.35(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)))(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(zod@3.25.76)):
+    dependencies:
+      '@wagmi/core': 2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))
+      hono: 4.12.32
+      idb-keyval: 6.3.0
+      mipd: 0.0.7(typescript@5.8.3)
+      ox: 0.9.17(typescript@5.8.3)(zod@4.4.3)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+      zod: 4.4.3
+      zustand: 5.0.14(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(use-sync-external-store@1.4.0(react@18.3.1))
+    optionalDependencies:
+      '@tanstack/react-query': 5.101.4(react@18.3.1)
+      react: 18.3.1
+      typescript: 5.8.3
+      wagmi: 2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(zod@3.25.76)
+    transitivePeerDependencies:
+      - '@types/react'
+      - immer
+      - use-sync-external-store
+
   porto@0.2.35(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3)))(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(zod@4.4.3)):
     dependencies:
       '@wagmi/core': 2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))
@@ -17470,10 +18659,8 @@ snapshots:
   pvtsutils@1.3.6:
     dependencies:
       tslib: 2.8.1
-    optional: true
 
-  pvutils@1.1.5:
-    optional: true
+  pvutils@1.1.5: {}
 
   qrcode@1.5.3:
     dependencies:
@@ -17625,6 +18812,8 @@ snapshots:
 
   reduce-flatten@2.0.0: {}
 
+  reflect-metadata@0.2.2: {}
+
   registry-auth-token@5.1.1:
     dependencies:
       '@pnpm/npm-conf': 3.0.3
@@ -18568,6 +19757,10 @@ snapshots:
     optionalDependencies:
       fsevents: 2.3.3
 
+  tsyringe@4.10.0:
+    dependencies:
+      tslib: 1.14.1
+
   type-check@0.3.2:
     dependencies:
       prelude-ls: 1.1.2
@@ -19042,6 +20235,56 @@ snapshots:
 
   vscode-uri@3.1.0: {}
 
+  wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(zod@3.25.76):
+    dependencies:
+      '@tanstack/react-query': 5.101.4(react@18.3.1)
+      '@wagmi/connectors': 6.2.0(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(@wagmi/core@2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)))(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))(zod@3.25.76))(zod@3.25.76)
+      '@wagmi/core': 2.22.1(@tanstack/query-core@5.101.4)(@types/react@18.3.31)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(use-sync-external-store@1.4.0(react@18.3.1))(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76))
+      react: 18.3.1
+      use-sync-external-store: 1.4.0(react@18.3.1)
+      viem: 2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@3.25.76)
+    optionalDependencies:
+      typescript: 5.8.3
+    transitivePeerDependencies:
+      - '@azure/app-configuration'
+      - '@azure/cosmos'
+      - '@azure/data-tables'
+      - '@azure/identity'
+      - '@azure/keyvault-secrets'
+      - '@azure/storage-blob'
+      - '@capacitor/preferences'
+      - '@deno/kv'
+      - '@netlify/blobs'
+      - '@planetscale/database'
+      - '@react-native-async-storage/async-storage'
+      - '@tanstack/query-core'
+      - '@types/react'
+      - '@upstash/redis'
+      - '@vercel/blob'
+      - '@vercel/functions'
+      - '@vercel/kv'
+      - '@x402/core'
+      - '@x402/evm'
+      - '@x402/extensions'
+      - '@x402/svm'
+      - aws4fetch
+      - bufferutil
+      - db0
+      - debug
+      - encoding
+      - expo-auth-session
+      - expo-crypto
+      - expo-web-browser
+      - fastestsmallesttextencoderdecoder
+      - immer
+      - ioredis
+      - preact-render-to-string
+      - react-native
+      - supports-color
+      - uploadthing
+      - utf-8-validate
+      - zod
+
   wagmi@2.19.5(@tanstack/query-core@5.101.4)(@tanstack/react-query@5.101.4(react@18.3.1))(@types/react@18.3.31)(bufferutil@4.1.0)(immer@10.0.2)(react@18.3.1)(typescript@5.8.3)(utf-8-validate@5.0.10)(viem@2.38.6(bufferutil@4.1.0)(typescript@5.8.3)(utf-8-validate@5.0.10)(zod@4.4.3))(zod@4.4.3):
     dependencies:
       '@tanstack/react-query': 5.101.4(react@18.3.1)

From 9fe870fe170bb89a73fa38666515334620dab793 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Wed, 28 Oct 2026 23:23:42 +0500
Subject: [PATCH 02/11] fix(dashboard): keep the proof and check it as the
 contracts do

- The identity panel follows the bond owner, keyed by owner, so a
  wallet change keeps a finished proof and an old request's callbacks
  cannot reach another owner. A proof for another owner or chain is
  refused.
- The registration deadline is the earlier of the proof validity and
  the credential end, shown to the minute and checked against the
  clock, also before a Safe export.
- An EIP-7702 account registers directly; only contract wallets get
  the Safe batch.
- A registry without a verifier shows the credential and takes no
  registration; a cleared registry reads as no policy.
- Salted identifiers request strict FaceMatch, and a proof with
  another identifier type or OPRF key is refused.
- A renewal with an equal expiry is allowed, and capacity warnings
  apply only under a required policy, with the verifier's cap.
---
 .../interfold-dashboard/src/Operator.test.tsx | 45 +++++++++
 packages/interfold-dashboard/src/Operator.tsx | 96 ++++++++++++++-----
 .../src/lib/identity.test.ts                  | 16 ++++
 .../interfold-dashboard/src/lib/identity.ts   | 33 ++++++-
 4 files changed, 161 insertions(+), 29 deletions(-)

diff --git a/packages/interfold-dashboard/src/Operator.test.tsx b/packages/interfold-dashboard/src/Operator.test.tsx
index cd1e248a32..515e834c4a 100644
--- a/packages/interfold-dashboard/src/Operator.test.tsx
+++ b/packages/interfold-dashboard/src/Operator.test.tsx
@@ -336,3 +336,48 @@ test('a proof registers from the owner, or as a Safe transaction', () => {
   const late = renderToStaticMarkup(<IdentityView {...identityProps} account={account({ now: NOW + 8n * DAY })} request={ready} />)
   assert.match(late, /too old to register/)
 })
+
+test('a registry without a verifier shows the credential but takes no registration', () => {
+  const closed = renderToStaticMarkup(<IdentityView {...identityProps} verifier={null} registrationClosed />)
+  assert.match(closed, /takes no registration/)
+  assert.match(closed, /Not verified/)
+  assert.doesNotMatch(closed, /Create ZKPassport request/)
+})
+
+test('capacity warnings apply only while the policy requires identity', () => {
+  const optional = { ...policy, required: false }
+  const short = account({ identity: { identityId: word(1n), expiresAt: NOW + 1n, verifiedNow: true } })
+  assert.doesNotMatch(renderToStaticMarkup(<IdentityView {...identityProps} policy={optional} account={short} />), /does not count/)
+  assert.doesNotMatch(
+    renderToStaticMarkup(<IdentityView {...identityProps} policy={optional} validUntilInput={dateInput(NOW + 1n)} />),
+    /would not count/,
+  )
+  // The verifier's cap counts too: a far date still ends at the maximum validity.
+  const capped = renderToStaticMarkup(
+    <IdentityView {...identityProps} service={{ ...service, maxValidity: 1n }} validUntilInput={dateInput(NOW + 900n * DAY)} />,
+  )
+  assert.match(capped, /would not count toward request/)
+})
+
+test('a proof that the verifier would reject cannot register, and an equal expiry can', () => {
+  const ready = (b: ReturnType<typeof bundle>) => ({ phase: 'ready', bundle: b }) as const
+  const register = /<button class="btn btn--primary">Register the identity/
+  const disabled = /<button class="btn btn--primary" disabled="">Register the identity/
+
+  // A replacement that ends exactly at the current expiry is allowed by the registry.
+  const proof = bundle()
+  const ends = BigInt(proof.proofDate) + service.maxValidity
+  const same = account({ identity: { identityId: word(1n), expiresAt: ends, verifiedNow: true } })
+  assert.match(renderToStaticMarkup(<IdentityView {...identityProps} account={same} request={ready(proof)} />), register)
+
+  const otherOwner = { ...bundle(), owner: PROPOSED }
+  const moved = renderToStaticMarkup(<IdentityView {...identityProps} request={ready(otherOwner)} />)
+  assert.match(moved, /bound to another owner or network/)
+  assert.match(moved, disabled)
+
+  const salted = renderToStaticMarkup(
+    <IdentityView {...identityProps} verifier={{ ...verifier, nullifierType: 1 }} request={ready(bundle())} />,
+  )
+  assert.match(salted, /identifier type or OPRF key differs/)
+  assert.match(salted, disabled)
+})
diff --git a/packages/interfold-dashboard/src/Operator.tsx b/packages/interfold-dashboard/src/Operator.tsx
index c304d5e7f0..79b78abcd1 100644
--- a/packages/interfold-dashboard/src/Operator.tsx
+++ b/packages/interfold-dashboard/src/Operator.tsx
@@ -42,6 +42,7 @@ import {
   identityStatusText,
   outerEvmProof,
   parseDateInput,
+  registrationDeadline,
   safeRegistrationBatch,
   type IdentityPolicy,
   type OwnerAccount,
@@ -228,6 +229,14 @@ export default function Operator() {
   const registered = Boolean(status?.registered)
   const ticketed = Boolean(config && status && status.availableTickets >= config.minTicketBalance)
 
+  // The identity panel follows the bond owner, not the connected wallet: `useBonding` clears the
+  // status while a new wallet's reads load, and the panel must keep a finished proof meanwhile.
+  const [ownerOf, setOwnerOf] = useState<{ operator: Address; owner: Address } | null>(null)
+  if (operator && status?.bondOwner && (ownerOf?.operator !== operator || !sameAddress(ownerOf.owner, status.bondOwner))) {
+    setOwnerOf({ operator, owner: status.bondOwner })
+  }
+  const identityOwner = operator && ownerOf?.operator === operator ? ownerOf.owner : null
+
   const stepDone = [connected, bondOwnerSet, bonded, registered, ticketed]
   const activeStep = stepDone.findIndex((d) => !d)
   const stateOf = (i: number): StepState => (stepDone[i] ? 'done' : i === activeStep ? 'active' : 'todo')
@@ -702,9 +711,10 @@ export default function Operator() {
             </StepCard>
           </div>
 
-          {status?.bondOwner && (
+          {identityOwner && (
             <IdentityPanel
-              owner={status.bondOwner}
+              key={identityOwner}
+              owner={identityOwner}
               wallet={connected ? wallet.address : null}
               busy={busy}
               send={(key, call) => void run(key, () => write(call))}
@@ -1456,25 +1466,28 @@ function IdentityPanel({
     }
   }, [owner, policy, busy, reload])
 
-  // A request binds one owner, so a new owner starts over. Clearing during render (not in an effect)
-  // drops the old owner's request before the browser paints it.
-  const [requestOwner, setRequestOwner] = useState(owner)
-  if (owner !== requestOwner) {
-    setRequestOwner(owner)
-    setRequest({ phase: 'idle' })
-    setValidUntilInput(null)
-  }
+  // A request binds one owner, and each owner has its own panel instance (keyed by owner).
   useEffect(
     () => () => {
       requestToken.current += 1
       cancelRequest.current?.()
       cancelRequest.current = null
     },
-    [owner],
+    [],
   )
+  // A finished proof expires, so its view follows the clock while the page stays open.
+  const [clock, setClock] = useState(() => BigInt(Math.floor(Date.now() / 1000)))
+  useEffect(() => {
+    if (request.phase !== 'ready') return undefined
+    const id = setInterval(() => setClock(BigInt(Math.floor(Date.now() / 1000))), 30_000)
+    return () => clearInterval(id)
+  }, [request.phase])
 
   const service = identityService(verifier, previewFaceMatch)
-  const current = account?.owner === owner ? account.value : null
+  const loaded = account?.owner === owner ? account.value : null
+  const current = loaded && clock > loaded.now ? { ...loaded, now: clock } : loaded
+  // A published registry without a verifier keeps its credentials, but takes no registration.
+  const registrationClosed = Boolean(policy) && verifier === null
   // Until the owner types a date, the field offers the longest credential that the verifier allows.
   const validUntilValue = validUntilInput ?? (current ? dateInput(current.now + service.maxValidity) : '')
 
@@ -1506,7 +1519,8 @@ function IdentityPanel({
         .gte('expiry_date', new Date(Number(validUntil) * 1000))
         .bind('user_address', owner)
         .bind('chain', chain)
-      if (service.faceMatch) query = query.facematch('strict')
+      // The SDK requires strict FaceMatch for a salted identifier.
+      if (service.faceMatch || service.nullifierType === 1) query = query.facematch('strict')
       const result = query.done()
       if (requestToken.current !== token) return zkPassport.cancelRequest(result.requestId)
       cancelRequest.current = () => zkPassport.cancelRequest(result.requestId)
@@ -1547,6 +1561,7 @@ function IdentityPanel({
       previewFaceMatch={previewFaceMatch}
       onPreviewFaceMatch={setPreviewFaceMatch}
       request={request}
+      registrationClosed={registrationClosed}
       canRegister={sameAddress(wallet, owner)}
       busy={busy}
       errFor={errFor}
@@ -1570,12 +1585,16 @@ function IdentityPanel({
         })
       }
       onDownloadProof={(bundle) => downloadJson(`interfold-identity-proof-${owner}.json`, bundle)}
-      onDownloadSafe={(bundle) =>
+      onDownloadSafe={(bundle) => {
+        if (BigInt(Math.floor(Date.now() / 1000)) > proofDeadline(bundle, service)) {
+          setRequest({ phase: 'failed', message: 'The proof is too old to register. Create a new request.' })
+          return
+        }
         downloadJson(
           `interfold-identity-safe-${owner}.json`,
           safeRegistrationBatch(policy!.registry, owner, CHAIN.id, bundle.evidence, Date.now()),
         )
-      }
+      }}
     />
   )
 }
@@ -1596,6 +1615,7 @@ export function IdentityView({
   previewFaceMatch,
   onPreviewFaceMatch,
   request,
+  registrationClosed = false,
   canRegister,
   busy,
   errFor,
@@ -1617,6 +1637,8 @@ export function IdentityView({
   previewFaceMatch: boolean
   onPreviewFaceMatch: (value: boolean) => void
   request: IdentityRequest
+  /** The policy names a registry that has no verifier. */
+  registrationClosed?: boolean
   canRegister: boolean
   busy: string | null
   errFor: (key: string) => ReactNode
@@ -1632,6 +1654,10 @@ export function IdentityView({
   const validUntil = parseDateInput(validUntilInput)
   const windowEnd = account ? capacityWindowEnd(account.now) : null
   const currentExpiry = account?.identity?.expiresAt ?? 0n
+  // Capacity depends on credentials only while the policy requires them.
+  const capacityApplies = Boolean(policy?.required)
+  // The proof date is about now, so the credential would end on this date or at the verifier's cap.
+  const plannedEnd = validUntil !== null && account ? credentialEnd(validUntil, account.now, service.maxValidity) : null
   const requesting = request.phase === 'creating' || request.phase === 'waiting' || request.phase === 'proving'
 
   return (
@@ -1677,7 +1703,7 @@ export function IdentityView({
               </>
             )}
           </dl>
-          {!preview && account.identity && account.identity.verifiedNow && windowEnd !== null && currentExpiry < windowEnd && (
+          {capacityApplies && account.identity && account.identity.verifiedNow && windowEnd !== null && currentExpiry < windowEnd && (
             <Note kind='warn'>
               The credential ends before this 30-day window ends ({fmtDay(windowEnd)}), so this owner does not count toward request capacity
               in this window. Renew it.
@@ -1692,6 +1718,8 @@ export function IdentityView({
 
           {!chain ? (
             <Note kind='warn'>ZKPassport does not verify proofs on {NETWORK_NAME}.</Note>
+          ) : registrationClosed ? (
+            <Note>The identity registry has no verifier at the moment, so it takes no registration. Credentials it issued stay valid.</Note>
           ) : request.phase === 'ready' ? (
             <IdentityProof
               bundle={request.bundle}
@@ -1725,13 +1753,13 @@ export function IdentityView({
                   service.maxValidity,
                 )} after the proof, if that is earlier.`}
               />
-              {validUntil !== null && windowEnd !== null && validUntil < windowEnd && (
+              {capacityApplies && plannedEnd !== null && windowEnd !== null && plannedEnd < windowEnd && (
                 <Note kind='warn'>
                   This date is before the end of the current 30-day window ({fmtDay(windowEnd)}). The owner would not count toward request
                   capacity in this window.
                 </Note>
               )}
-              {validUntil !== null && account.identity && validUntil <= currentExpiry && (
+              {plannedEnd !== null && account.identity && plannedEnd < currentExpiry && (
                 <Note kind='warn'>
                   Pick a date after the current expiry ({fmtDay(currentExpiry)}). A renewal cannot shorten the credential.
                 </Note>
@@ -1817,11 +1845,16 @@ function IdentityProof({
   const validUntil = BigInt(bundle.validUntil)
   const proofDate = BigInt(bundle.proofDate)
   const ends = credentialEnd(validUntil, proofDate, service.maxValidity)
-  const deadline = proofDate + service.proofValidity
+  const deadline = proofDeadline(bundle, service)
+  // The panel requested this binding; a proof for another owner or chain would only revert.
+  const bound = sameAddress(bundle.owner, owner) && bundle.chainId === CHAIN.id
   const versionMatches = !verifier || bundle.version.toLowerCase() === verifier.version.toLowerCase()
+  const keyMatches =
+    !verifier ||
+    (bundle.nullifierType === verifier.nullifierType && bundle.oprfKeyHash.toLowerCase() === verifier.oprfKeyHash.toLowerCase())
   const expired = account.now > deadline
-  const shortens = account.identity !== null && ends <= account.identity.expiresAt
-  const blocked = !versionMatches || expired || shortens
+  const shortens = account.identity !== null && ends < account.identity.expiresAt
+  const blocked = !bound || !versionMatches || !keyMatches || expired || shortens
 
   return (
     <div className='opmanage__group'>
@@ -1836,10 +1869,14 @@ function IdentityProof({
         <dt>Credential ends</dt>
         <dd>{fmtDay(ends)}</dd>
         <dt>Register before</dt>
-        <dd>{fmtDay(deadline)}</dd>
+        <dd>{fmtMoment(deadline)}</dd>
         <dt>Identifier type</dt>
         <dd>{bundle.nullifierType === 1 ? 'Salted' : 'Not salted'}</dd>
       </dl>
+      {!bound && <Note kind='warn'>This proof is bound to another owner or network. Create a new request.</Note>}
+      {!keyMatches && (
+        <Note kind='warn'>The proof's identifier type or OPRF key differs from the verifier's. The verifier would reject it.</Note>
+      )}
       {!versionMatches && (
         <Note kind='warn'>
           The app made the proof with another ZKPassport version than the verifier accepts. Governance must deploy a verifier for the new
@@ -1871,8 +1908,8 @@ function IdentityProof({
       {!preview && !account.isContract && !canRegister && <Note>Connect the bond-owner wallet {shortAddr(owner)} to register.</Note>}
       {!preview && account.isContract && (
         <Note>
-          Load the file in the Safe Transaction Builder and execute it before {fmtDay(deadline)}. The registration costs about 1.3 million
-          gas.
+          Load the file in the Safe Transaction Builder and execute it before {fmtMoment(deadline)}. The registration costs about 1.3
+          million gas.
         </Note>
       )}
       {!preview && (
@@ -1885,6 +1922,17 @@ function IdentityProof({
   )
 }
 
+/** The last moment that this proof can register under `service`. */
+function proofDeadline(bundle: ProofBundle, service: IdentityService): bigint {
+  const proofDate = BigInt(bundle.proofDate)
+  return registrationDeadline(proofDate, service.proofValidity, credentialEnd(BigInt(bundle.validUntil), proofDate, service.maxValidity))
+}
+
+/** A Unix timestamp as a UTC date and time, to the minute. */
+function fmtMoment(ts: bigint): string {
+  return `${new Date(Number(ts) * 1000).toISOString().slice(0, 16).replace('T', ' ')} UTC`
+}
+
 function downloadJson(name: string, value: unknown) {
   const text = JSON.stringify(value, (_, v) => (typeof v === 'bigint' ? v.toString() : v), 2)
   const url = URL.createObjectURL(new Blob([text], { type: 'application/json' }))
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
index eefd2dc42f..978b47efe5 100644
--- a/packages/interfold-dashboard/src/lib/identity.test.ts
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -17,8 +17,10 @@ import {
   credentialEnd,
   encodeEvidence,
   expiryLowerBound,
+  isContractCode,
   outerEvmProof,
   proofFacts,
+  registrationDeadline,
   safeRegistrationBatch,
   type ProofResult,
 } from './identity'
@@ -133,3 +135,17 @@ test('the downloaded bundle describes the proof that it carries', () => {
     /no expiry-date check/,
   )
 })
+
+test('an EIP-7702 account registers itself; a contract wallet goes through its own transaction', () => {
+  assert.equal(isContractCode(undefined), false)
+  assert.equal(isContractCode('0x'), false)
+  assert.equal(isContractCode(`0xef0100${'ab'.repeat(20)}`), false)
+  assert.equal(isContractCode(`0xEF0100${'AB'.repeat(20)}`), false)
+  assert.equal(isContractCode('0x6080604052'), true)
+  assert.equal(isContractCode(`0xef0100${'ab'.repeat(21)}`), true)
+})
+
+test('a proof registers until it is too old or its credential ends', () => {
+  assert.equal(registrationDeadline(1_000n, 600n, 5_000n), 1_600n)
+  assert.equal(registrationDeadline(1_000n, 600n, 1_200n), 1_200n)
+})
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index f1a52b5191..fce17228bb 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -79,7 +79,10 @@ export type OwnerAccount = {
   identity: { identityId: Hex; expiresAt: bigint; verifiedNow: boolean } | null
 }
 
-/** The current identity policy: the latest IdentityPolicyUpdated log, or null before the first. */
+/**
+ * The current identity policy: the latest IdentityPolicyUpdated log. Null before the first log, and
+ * when the latest log clears the registry.
+ */
 export async function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
   const head = await publicClient.getBlockNumber()
   const logs = await getLogsChunked<any>(
@@ -88,17 +91,18 @@ export async function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
     head,
   )
   const latest = logs[logs.length - 1]
-  if (!latest) return null
+  if (!latest || latest.args.registry === ZERO_ADDRESS) return null
   return { registry: latest.args.registry, required: latest.args.required, timepoint: BigInt(latest.args.timepoint) }
 }
 
-export async function fetchVerifierConfig(registry: Address): Promise<VerifierConfig> {
+/** The verifier settings, or null while the registry has no verifier (registration is closed). */
+export async function fetchVerifierConfig(registry: Address): Promise<VerifierConfig | null> {
   const address = (await (publicClient.readContract as any)({
     address: registry,
     abi: ownerIdentityRegistryAbi,
     functionName: 'verifier',
   })) as Address
-  if (address === ZERO_ADDRESS) throw new Error('The identity registry has no verifier yet.')
+  if (address === ZERO_ADDRESS) return null
   const read = (functionName: string) => (publicClient.readContract as any)({ address, abi: zkPassportIdentityVerifierAbi, functionName })
   const [domain, scope, version, nullifierType, oprfKeyHash, faceMatchRequired, proofValidity, maxValidity] = await Promise.all([
     read('domain'),
@@ -139,7 +143,26 @@ export async function fetchOwnerAccount(owner: Address, registry: Address | null
         )
       : Promise.resolve(null),
   ])
-  return { now: block.timestamp, isContract: Boolean(code && code !== '0x'), identity }
+  return { now: block.timestamp, isContract: isContractCode(code), identity }
+}
+
+/**
+ * Whether account code makes the owner a contract wallet, such as a Safe. An EIP-7702 account's
+ * code is a delegation designator (`0xef0100` and an address): it is still an EOA that sends its own
+ * transactions.
+ */
+export function isContractCode(code: Hex | undefined): boolean {
+  if (!code || code === '0x') return false
+  return !(code.toLowerCase().startsWith('0xef0100') && code.length === 2 + 2 * 23)
+}
+
+/**
+ * The last moment that a registration can be mined: ZKPassport rejects a proof older than the proof
+ * validity, and the registry rejects a credential that has already ended.
+ */
+export function registrationDeadline(proofDate: bigint, proofValidity: bigint, credentialEnds: bigint): bigint {
+  const proofExpires = proofDate + proofValidity
+  return proofExpires < credentialEnds ? proofExpires : credentialEnds
 }
 
 /** The last second of the capacity window that contains `timestamp` (`BondOwnerCapacityLib._windowEnd`). */

From 0415246851ffe57e027e350b2648816b18388abe Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Sat, 31 Oct 2026 01:11:49 +0500
Subject: [PATCH 03/11] docs(dashboard): explain the RPC history the identity
 panel needs

---
 packages/interfold-dashboard/.env.example | 2 ++
 packages/interfold-dashboard/README.md    | 5 +++++
 2 files changed, 7 insertions(+)

diff --git a/packages/interfold-dashboard/.env.example b/packages/interfold-dashboard/.env.example
index 2a137d4a97..ca55983aa9 100644
--- a/packages/interfold-dashboard/.env.example
+++ b/packages/interfold-dashboard/.env.example
@@ -59,6 +59,8 @@
 # First block of the bond-owner identity policy scan (IdentityPolicyUpdated logs of
 # the bonding registry). Set it to a block at or before the registry upgrade that
 # added the policy, so the identity panel scans fewer blocks. Unset = DEPLOY_BLOCK.
+# The RPC must serve logs from this block on (publicnode keeps about a day). Before
+# the upgrade, a block from today is enough for a preview.
 # VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK=
 # VITE_MAINNET_IDENTITY_DEPLOY_BLOCK=
 
diff --git a/packages/interfold-dashboard/README.md b/packages/interfold-dashboard/README.md
index f352bed735..b7c33609e8 100644
--- a/packages/interfold-dashboard/README.md
+++ b/packages/interfold-dashboard/README.md
@@ -113,6 +113,11 @@ current 30-day capacity window. Before a deployment (no policy log), it makes a
 planned settings (`PREVIEW_SERVICE`) and offers only the download. The download holds the proofs,
 the verifier parameters, and the evidence, so a fork test can replay it.
 
+The policy scan needs an RPC that serves logs from `IDENTITY_DEPLOY_BLOCK` on. Public RPCs such as
+publicnode keep only about a day of logs. After the upgrade, set `IDENTITY_DEPLOY_BLOCK` to the
+upgrade block and use an RPC with that history. For a preview before the upgrade, a recent block is
+enough, for example `VITE_MAINNET_IDENTITY_DEPLOY_BLOCK=<a block from today>`.
+
 Only `VITE_BONDING_REGISTRY_ADDRESS` is configured. The ciphernode bond token, ticket wrapper,
 ticket underlying, bond size, ticket price, minimum tickets, and exit delay are all read back from
 the registry, so the guide follows the deployment instead of a hardcoded token list.

From a42efabd3d34785fb9f00247d3fcf1d900c14a57 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Sat, 31 Oct 2026 14:14:59 +0500
Subject: [PATCH 04/11] fix(dashboard): read only recent blocks before the
 identity upgrade

---
 packages/interfold-dashboard/.env.example         |  5 ++---
 packages/interfold-dashboard/README.md            | 11 ++++++-----
 packages/interfold-dashboard/src/lib/chain.ts     |  6 ++++--
 .../interfold-dashboard/src/lib/identity.test.ts  |  8 ++++++++
 packages/interfold-dashboard/src/lib/identity.ts  | 15 ++++++++++++++-
 packages/interfold-dashboard/src/lib/networks.ts  |  2 +-
 6 files changed, 35 insertions(+), 12 deletions(-)

diff --git a/packages/interfold-dashboard/.env.example b/packages/interfold-dashboard/.env.example
index ca55983aa9..5f040f63df 100644
--- a/packages/interfold-dashboard/.env.example
+++ b/packages/interfold-dashboard/.env.example
@@ -58,9 +58,8 @@
 
 # First block of the bond-owner identity policy scan (IdentityPolicyUpdated logs of
 # the bonding registry). Set it to a block at or before the registry upgrade that
-# added the policy, so the identity panel scans fewer blocks. Unset = DEPLOY_BLOCK.
-# The RPC must serve logs from this block on (publicnode keeps about a day). Before
-# the upgrade, a block from today is enough for a preview.
+# added the policy. Unset before that upgrade: the panel then reads only recent
+# blocks. The RPC must serve logs from this block on (publicnode keeps about a day).
 # VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK=
 # VITE_MAINNET_IDENTITY_DEPLOY_BLOCK=
 
diff --git a/packages/interfold-dashboard/README.md b/packages/interfold-dashboard/README.md
index b7c33609e8..cfc3a0a652 100644
--- a/packages/interfold-dashboard/README.md
+++ b/packages/interfold-dashboard/README.md
@@ -113,10 +113,10 @@ current 30-day capacity window. Before a deployment (no policy log), it makes a
 planned settings (`PREVIEW_SERVICE`) and offers only the download. The download holds the proofs,
 the verifier parameters, and the evidence, so a fork test can replay it.
 
-The policy scan needs an RPC that serves logs from `IDENTITY_DEPLOY_BLOCK` on. Public RPCs such as
-publicnode keep only about a day of logs. After the upgrade, set `IDENTITY_DEPLOY_BLOCK` to the
-upgrade block and use an RPC with that history. For a preview before the upgrade, a recent block is
-enough, for example `VITE_MAINNET_IDENTITY_DEPLOY_BLOCK=<a block from today>`.
+Until a network has the identity upgrade, leave `IDENTITY_DEPLOY_BLOCK` unset. No policy log exists
+yet, so the panel reads only the latest 2,000 blocks, which public RPCs serve. After the upgrade,
+set `identityDeployBlock` in `src/lib/networks.ts` to the upgrade block, and use an RPC that serves
+logs from there: public RPCs such as publicnode keep only about a day of logs.
 
 Only `VITE_BONDING_REGISTRY_ADDRESS` is configured. The ciphernode bond token, ticket wrapper,
 ticket underlying, bond size, ticket price, minimum tickets, and exit delay are all read back from
@@ -149,7 +149,8 @@ default:
   the "Get test tokens" action on a testnet too.
 - `FEE_TOKEN_SYMBOL`, `FEE_TOKEN_DECIMALS` — fee token display.
 - `DEPLOY_BLOCK` — first block to scan from (the Interfold deploy block).
-- `IDENTITY_DEPLOY_BLOCK` — first block of the identity policy scan (defaults to `DEPLOY_BLOCK`).
+- `IDENTITY_DEPLOY_BLOCK` — first block of the identity policy scan (unset before the identity
+  upgrade: the scan reads only recent blocks).
 - `COMPUTE_WINDOW`, `DECRYPTION_WINDOW` — E3 timeout windows in seconds.
 
 `vite.config.ts` stops the build when an override has no network scope (for example `VITE_RPC_URL`),
diff --git a/packages/interfold-dashboard/src/lib/chain.ts b/packages/interfold-dashboard/src/lib/chain.ts
index 3aaf964031..1a3cd41c02 100644
--- a/packages/interfold-dashboard/src/lib/chain.ts
+++ b/packages/interfold-dashboard/src/lib/chain.ts
@@ -127,8 +127,10 @@ export const FEE_TOKEN = {
 export const DEPLOY_BLOCK = BigInt(envStr('DEPLOY_BLOCK', NET.deployBlock))
 
 // First block of the bond-owner identity policy scan. The policy is the latest
-// IdentityPolicyUpdated log of the bonding registry.
-export const IDENTITY_DEPLOY_BLOCK = BigInt(envStr('IDENTITY_DEPLOY_BLOCK', NET.identityDeployBlock || String(DEPLOY_BLOCK)))
+// IdentityPolicyUpdated log of the bonding registry. Null until the network has the
+// identity upgrade: the scan then reads only recent blocks (see fetchIdentityPolicy).
+const identityDeployBlock = envStr('IDENTITY_DEPLOY_BLOCK', NET.identityDeployBlock)
+export const IDENTITY_DEPLOY_BLOCK: bigint | null = identityDeployBlock ? BigInt(identityDeployBlock) : null
 
 // E3 timeout windows (seconds), matching the deployment's timeoutConfig. Used to
 // decide whether an E3 is still genuinely active vs. expired without completing.
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
index 978b47efe5..363fa6af54 100644
--- a/packages/interfold-dashboard/src/lib/identity.test.ts
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -23,6 +23,8 @@ import {
   registrationDeadline,
   safeRegistrationBatch,
   type ProofResult,
+  policyScanStart,
+  RECENT_POLICY_BLOCKS,
 } from './identity'
 
 const OWNER = '0x2222222222222222222222222222222222222222' as Address
@@ -149,3 +151,9 @@ test('a proof registers until it is too old or its credential ends', () => {
   assert.equal(registrationDeadline(1_000n, 600n, 5_000n), 1_600n)
   assert.equal(registrationDeadline(1_000n, 600n, 1_200n), 1_200n)
 })
+
+test('the policy scan reads recent blocks until the network has the identity upgrade', () => {
+  assert.equal(policyScanStart(null, 26_311_752n), 26_311_752n - RECENT_POLICY_BLOCKS)
+  assert.equal(policyScanStart(null, 100n), 0n)
+  assert.equal(policyScanStart(26_400_000n, 26_500_000n), 26_400_000n)
+})
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index fce17228bb..8d3a75d352 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -79,6 +79,19 @@ export type OwnerAccount = {
   identity: { identityId: Hex; expiresAt: bigint; verifiedNow: boolean } | null
 }
 
+/** Blocks that the policy scan reads before the network has the identity upgrade (about 6.7 hours). */
+export const RECENT_POLICY_BLOCKS = 2_000n
+
+/**
+ * First block of the policy scan. Without a configured block the network has no identity upgrade
+ * yet, so no policy log exists and recent blocks give the same answer. Public RPCs keep only about a
+ * day of logs, so a scan from the protocol deploy block would fail there.
+ */
+export function policyScanStart(configured: bigint | null, head: bigint): bigint {
+  if (configured !== null) return configured
+  return head > RECENT_POLICY_BLOCKS ? head - RECENT_POLICY_BLOCKS : 0n
+}
+
 /**
  * The current identity policy: the latest IdentityPolicyUpdated log. Null before the first log, and
  * when the latest log clears the registry.
@@ -87,7 +100,7 @@ export async function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
   const head = await publicClient.getBlockNumber()
   const logs = await getLogsChunked<any>(
     { address: CONTRACTS.BondingRegistry, event: IDENTITY_POLICY_UPDATED },
-    IDENTITY_DEPLOY_BLOCK,
+    policyScanStart(IDENTITY_DEPLOY_BLOCK, head),
     head,
   )
   const latest = logs[logs.length - 1]
diff --git a/packages/interfold-dashboard/src/lib/networks.ts b/packages/interfold-dashboard/src/lib/networks.ts
index 723586306a..44d11115c1 100644
--- a/packages/interfold-dashboard/src/lib/networks.ts
+++ b/packages/interfold-dashboard/src/lib/networks.ts
@@ -34,7 +34,7 @@ export type NetworkProfile = {
   faucet: string
   deployBlock: string
   // First block of the identity policy scan: a block at or before the BondingRegistry upgrade that
-  // added the policy. Empty = deployBlock.
+  // added the policy. Empty until that upgrade: the panel then reads only recent blocks.
   identityDeployBlock: string
   // Fee token metadata for formatting escrowed fees/rewards. Hardcoded per
   // deployment (like the addresses) rather than read on-chain at runtime.

From 0124bf9aa8d84645fc54c38d3373e3f894e7b09c Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Sat, 31 Oct 2026 20:29:21 +0500
Subject: [PATCH 05/11] fix(dashboard): drop stale identity reads and check
 block overrides

- useBonding returns no status in the render that switches operators, so
  the identity panel never keeps the previous operator's bond owner.
- The identity panel keeps each owner read with its registry, follows the
  clock in every phase, and shows a credential as expired after its end.
- A salted identifier always requests strict FaceMatch, so the panel and
  the downloaded proof say so.
- parseDateInput keeps years below 100.
- The build stops on a DEPLOY_BLOCK or IDENTITY_DEPLOY_BLOCK override that
  is not a whole number.
---
 packages/interfold-dashboard/package.json     |  2 +-
 .../interfold-dashboard/src/Operator.test.tsx |  1 +
 packages/interfold-dashboard/src/Operator.tsx | 37 +++++++++++++------
 .../interfold-dashboard/src/lib/bonding.ts    |  4 ++
 .../interfold-dashboard/src/lib/identity.ts   |  7 ++--
 .../src/lib/networks.test.ts                  | 22 +++++++++++
 .../interfold-dashboard/src/lib/networks.ts   | 10 +++++
 packages/interfold-dashboard/vite.config.ts   |  6 ++-
 8 files changed, 72 insertions(+), 17 deletions(-)
 create mode 100644 packages/interfold-dashboard/src/lib/networks.test.ts

diff --git a/packages/interfold-dashboard/package.json b/packages/interfold-dashboard/package.json
index 693ee61d5b..00a9b0726c 100644
--- a/packages/interfold-dashboard/package.json
+++ b/packages/interfold-dashboard/package.json
@@ -9,7 +9,7 @@
     "dev": "vite",
     "build": "vite build",
     "preview": "vite preview",
-    "test": "tsx --test src/Inspector.test.tsx src/Operator.test.tsx src/lib/identity.test.ts",
+    "test": "tsx --test src/Inspector.test.tsx src/Operator.test.tsx src/lib/identity.test.ts src/lib/networks.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
diff --git a/packages/interfold-dashboard/src/Operator.test.tsx b/packages/interfold-dashboard/src/Operator.test.tsx
index 515e834c4a..bc5ee885fc 100644
--- a/packages/interfold-dashboard/src/Operator.test.tsx
+++ b/packages/interfold-dashboard/src/Operator.test.tsx
@@ -261,6 +261,7 @@ test('date fields round-trip in UTC and reject impossible dates', () => {
   assert.equal(dateInput(parseDateInput('2027-12-01')!), '2027-12-01')
   assert.equal(parseDateInput('2026-02-31'), null)
   assert.equal(parseDateInput('01/12/2027'), null)
+  assert.equal(parseDateInput('0099-01-01'), BigInt(Date.parse('0099-01-01T00:00:00Z') / 1000))
 })
 
 test('the identity panel shows the credential and offers a request', () => {
diff --git a/packages/interfold-dashboard/src/Operator.tsx b/packages/interfold-dashboard/src/Operator.tsx
index 79b78abcd1..a90ddd7952 100644
--- a/packages/interfold-dashboard/src/Operator.tsx
+++ b/packages/interfold-dashboard/src/Operator.tsx
@@ -1389,7 +1389,8 @@ function identityService(verifier: VerifierConfig | null, previewFaceMatch: bool
     ? {
         domain: verifier.domain,
         scope: verifier.scope,
-        faceMatch: verifier.faceMatchRequired,
+        // The SDK requires strict FaceMatch for a salted identifier.
+        faceMatch: verifier.faceMatchRequired || verifier.nullifierType === 1,
         nullifierType: verifier.nullifierType,
         proofValidity: verifier.proofValidity,
         maxValidity: verifier.maxValidity,
@@ -1421,8 +1422,9 @@ function IdentityPanel({
   // undefined while loading; null when the network has no identity policy.
   const [policy, setPolicy] = useState<IdentityPolicy | null | undefined>(undefined)
   const [verifier, setVerifier] = useState<VerifierConfig | null>(null)
-  // Kept with the owner that it was read for, so another owner never shows these values.
-  const [account, setAccount] = useState<{ owner: Address; value: OwnerAccount } | null>(null)
+  // Kept with the owner and registry that it was read for, so another owner or registry never
+  // shows these values.
+  const [account, setAccount] = useState<{ owner: Address; registry: Address | null; value: OwnerAccount } | null>(null)
   const [loadFailed, setLoadFailed] = useState(false)
   const [request, setRequest] = useState<IdentityRequest>({ phase: 'idle' })
   // null until the owner types a date.
@@ -1453,9 +1455,10 @@ function IdentityPanel({
   useEffect(() => {
     if (policy === undefined) return
     let cancelled = false
-    fetchOwnerAccount(owner, policy?.registry ?? null).then(
+    const registry = policy?.registry ?? null
+    fetchOwnerAccount(owner, registry).then(
       (value) => {
-        if (!cancelled) setAccount({ owner, value })
+        if (!cancelled) setAccount({ owner, registry, value })
       },
       () => {
         if (!cancelled) setLoadFailed(true)
@@ -1475,17 +1478,28 @@ function IdentityPanel({
     },
     [],
   )
-  // A finished proof expires, so its view follows the clock while the page stays open.
+  // A finished proof and a credential both expire, so the panel follows the clock while the page
+  // stays open.
   const [clock, setClock] = useState(() => BigInt(Math.floor(Date.now() / 1000)))
   useEffect(() => {
-    if (request.phase !== 'ready') return undefined
     const id = setInterval(() => setClock(BigInt(Math.floor(Date.now() / 1000))), 30_000)
     return () => clearInterval(id)
-  }, [request.phase])
+  }, [])
 
   const service = identityService(verifier, previewFaceMatch)
-  const loaded = account?.owner === owner ? account.value : null
-  const current = loaded && clock > loaded.now ? { ...loaded, now: clock } : loaded
+  const loaded = account?.owner === owner && account.registry === (policy?.registry ?? null) ? account.value : null
+  const current =
+    loaded && clock > loaded.now
+      ? {
+          ...loaded,
+          now: clock,
+          // isVerifiedAt holds through the expiry second.
+          identity: loaded.identity && {
+            ...loaded.identity,
+            verifiedNow: loaded.identity.verifiedNow && clock <= loaded.identity.expiresAt,
+          },
+        }
+      : loaded
   // A published registry without a verifier keeps its credentials, but takes no registration.
   const registrationClosed = Boolean(policy) && verifier === null
   // Until the owner types a date, the field offers the longest credential that the verifier allows.
@@ -1519,8 +1533,7 @@ function IdentityPanel({
         .gte('expiry_date', new Date(Number(validUntil) * 1000))
         .bind('user_address', owner)
         .bind('chain', chain)
-      // The SDK requires strict FaceMatch for a salted identifier.
-      if (service.faceMatch || service.nullifierType === 1) query = query.facematch('strict')
+      if (service.faceMatch) query = query.facematch('strict')
       const result = query.done()
       if (requestToken.current !== token) return zkPassport.cancelRequest(result.requestId)
       cancelRequest.current = () => zkPassport.cancelRequest(result.requestId)
diff --git a/packages/interfold-dashboard/src/lib/bonding.ts b/packages/interfold-dashboard/src/lib/bonding.ts
index ae8f3ad2a6..1a974460c7 100644
--- a/packages/interfold-dashboard/src/lib/bonding.ts
+++ b/packages/interfold-dashboard/src/lib/bonding.ts
@@ -295,6 +295,10 @@ export function useBonding(operator: string | null, account: Address | null): Bo
     }
   }, [validOperator, account, nonce])
 
+  // The render that switches identity still holds the previous identity's state: the
+  // clearing above applies from the next render. Return the cleared values now, so a
+  // caller never stores the previous operator's status for the new one.
+  if (identity !== loadedIdentity) return { config, status: null, funds: null, loading: true, error: null, refresh }
   return { config, status, funds, loading, error, refresh }
 }
 
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index 8d3a75d352..031e190822 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -295,11 +295,12 @@ export function dateInput(ts: bigint): string {
 export function parseDateInput(value: string): bigint | null {
   const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim())
   if (!match) return null
-  const ms = Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]))
-  const day = new Date(ms)
+  // setUTCFullYear keeps a year below 100, which Date.UTC would move to 19xx.
+  const day = new Date(0)
+  day.setUTCFullYear(Number(match[1]), Number(match[2]) - 1, Number(match[3]))
   // Reject dates that roll over, such as 2026-02-31.
   if (day.getUTCMonth() !== Number(match[2]) - 1 || day.getUTCDate() !== Number(match[3])) return null
-  return BigInt(ms / 1000)
+  return BigInt(day.getTime() / 1000)
 }
 
 /** Everything that a registration or a test needs to replay one proof, as the page downloads it. */
diff --git a/packages/interfold-dashboard/src/lib/networks.test.ts b/packages/interfold-dashboard/src/lib/networks.test.ts
new file mode 100644
index 0000000000..e8f3a17ef3
--- /dev/null
+++ b/packages/interfold-dashboard/src/lib/networks.test.ts
@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: LGPL-3.0-only
+//
+// This file is provided WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.
+
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { invalidBlockOverrides } from './networks'
+
+test('block overrides must be whole numbers on every network', () => {
+  assert.deepEqual(
+    invalidBlockOverrides({
+      VITE_MAINNET_DEPLOY_BLOCK: '26300000',
+      VITE_MAINNET_IDENTITY_DEPLOY_BLOCK: '26300000.0',
+      VITE_SEPOLIA_DEPLOY_BLOCK: ' ',
+      VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK: '-1',
+    }),
+    ['VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK', 'VITE_MAINNET_IDENTITY_DEPLOY_BLOCK'],
+  )
+  assert.deepEqual(invalidBlockOverrides({}), [])
+})
diff --git a/packages/interfold-dashboard/src/lib/networks.ts b/packages/interfold-dashboard/src/lib/networks.ts
index 44d11115c1..268523a2ee 100644
--- a/packages/interfold-dashboard/src/lib/networks.ts
+++ b/packages/interfold-dashboard/src/lib/networks.ts
@@ -161,3 +161,13 @@ export function selectNetwork(env: Env, hostname: string | undefined): NetworkKe
 export function unscopedOverrideKeys(env: Env): string[] {
   return SETTINGS.map((setting) => `VITE_${setting}`).filter((key) => key in env)
 }
+
+// Block overrides that are not whole numbers, for example "26300000.0". The page reads
+// them with BigInt when it loads, so one bad value would stop the whole page.
+export function invalidBlockOverrides(env: Env): string[] {
+  const settings: Setting[] = ['DEPLOY_BLOCK', 'IDENTITY_DEPLOY_BLOCK']
+  return NETWORK_KEYS.flatMap((network) => settings.map((setting) => overrideKey(network, setting))).filter((key) => {
+    const value = env[key]?.trim()
+    return value !== undefined && value !== '' && !/^\d+$/.test(value)
+  })
+}
diff --git a/packages/interfold-dashboard/vite.config.ts b/packages/interfold-dashboard/vite.config.ts
index 39a54f6a55..7c4135e927 100644
--- a/packages/interfold-dashboard/vite.config.ts
+++ b/packages/interfold-dashboard/vite.config.ts
@@ -5,7 +5,7 @@
 // or FITNESS FOR A PARTICULAR PURPOSE.
 import { defineConfig, loadEnv } from 'vite'
 import react from '@vitejs/plugin-react'
-import { parseNetworkHosts, selectNetwork, unscopedOverrideKeys } from './src/lib/networks'
+import { invalidBlockOverrides, parseNetworkHosts, selectNetwork, unscopedOverrideKeys } from './src/lib/networks'
 
 export default defineConfig(({ mode }) => {
   // Fail the build, not the page: the bundle reads these values only in the browser.
@@ -17,6 +17,10 @@ export default defineConfig(({ mode }) => {
         'Network overrides use VITE_<NETWORK>_<SETTING>, for example VITE_MAINNET_RPC_URL. See .env.example.',
     )
   }
+  const badBlocks = invalidBlockOverrides(env)
+  if (badBlocks.length > 0) {
+    throw new Error(`${badBlocks.join(', ')} must be a whole block number. See .env.example.`)
+  }
   parseNetworkHosts(env.VITE_NETWORK_HOSTS)
   selectNetwork(env, undefined)
 

From 6334c46c24e6c2033c2069e40342c2fa49167d67 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Tue, 3 Nov 2026 01:51:06 +0500
Subject: [PATCH 06/11] feat(dashboard): register without policy log history

Public RPCs keep about a day of logs, and the identity panel found the
registry only through the latest IdentityPolicyUpdated log. A day after
the upgrade, owners lost the registration path on such an RPC.

- New network setting identityRegistry (VITE_<NETWORK>_IDENTITY_REGISTRY_ADDRESS),
  the OwnerIdentityRegistry proxy, set after the upgrade.
- The policy log still wins when it can be read. Without one in reach,
  the configured registry opens registration and the policy shows as
  unknown.
- README and .env.example: set both identity values and a log-capable
  RPC on the day of the upgrade.
---
 packages/interfold-dashboard/.env.example     |  5 ++
 packages/interfold-dashboard/README.md        | 14 +++--
 packages/interfold-dashboard/src/Operator.tsx |  8 ++-
 packages/interfold-dashboard/src/lib/chain.ts |  5 ++
 .../src/lib/identity.test.ts                  | 12 +++++
 .../interfold-dashboard/src/lib/identity.ts   | 51 ++++++++++++++-----
 .../interfold-dashboard/src/lib/networks.ts   |  6 +++
 7 files changed, 82 insertions(+), 19 deletions(-)

diff --git a/packages/interfold-dashboard/.env.example b/packages/interfold-dashboard/.env.example
index 5f040f63df..92f490c26e 100644
--- a/packages/interfold-dashboard/.env.example
+++ b/packages/interfold-dashboard/.env.example
@@ -63,6 +63,11 @@
 # VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK=
 # VITE_MAINNET_IDENTITY_DEPLOY_BLOCK=
 
+# The OwnerIdentityRegistry proxy. Unset before the identity upgrade. With it,
+# registration works even when the RPC keeps no policy log.
+# VITE_SEPOLIA_IDENTITY_REGISTRY_ADDRESS=
+# VITE_MAINNET_IDENTITY_REGISTRY_ADDRESS=
+
 # E3 timeout windows (seconds), from the deployment's getTimeoutConfig(). Used to
 # decide whether an E3 is still active vs. expired (input close + these windows).
 # Sepolia: 604800 / 21600. Mainnet: 604800 / 21600.
diff --git a/packages/interfold-dashboard/README.md b/packages/interfold-dashboard/README.md
index cfc3a0a652..fdc6bba926 100644
--- a/packages/interfold-dashboard/README.md
+++ b/packages/interfold-dashboard/README.md
@@ -113,10 +113,15 @@ current 30-day capacity window. Before a deployment (no policy log), it makes a
 planned settings (`PREVIEW_SERVICE`) and offers only the download. The download holds the proofs,
 the verifier parameters, and the evidence, so a fork test can replay it.
 
-Until a network has the identity upgrade, leave `IDENTITY_DEPLOY_BLOCK` unset. No policy log exists
-yet, so the panel reads only the latest 2,000 blocks, which public RPCs serve. After the upgrade,
-set `identityDeployBlock` in `src/lib/networks.ts` to the upgrade block, and use an RPC that serves
-logs from there: public RPCs such as publicnode keep only about a day of logs.
+Until a network has the identity upgrade, leave `IDENTITY_DEPLOY_BLOCK` and
+`IDENTITY_REGISTRY_ADDRESS` unset. No policy log exists yet, so the panel reads only the latest
+2,000 blocks, which public RPCs serve. When the upgrade batch has executed, set
+`identityDeployBlock` (the upgrade block) and `identityRegistry` (the OwnerIdentityRegistry proxy)
+in `src/lib/networks.ts`. With the registry set, registration needs no log history. The policy label
+still comes from the latest `IdentityPolicyUpdated` log, so production also needs an RPC that serves
+logs from the upgrade block (public RPCs such as publicnode keep only about a day); without one, the
+panel shows the policy as unknown. Owners register between the upgrade and the enforcement, so set
+both values and the RPC on the day of the upgrade.
 
 Only `VITE_BONDING_REGISTRY_ADDRESS` is configured. The ciphernode bond token, ticket wrapper,
 ticket underlying, bond size, ticket price, minimum tickets, and exit delay are all read back from
@@ -151,6 +156,7 @@ default:
 - `DEPLOY_BLOCK` — first block to scan from (the Interfold deploy block).
 - `IDENTITY_DEPLOY_BLOCK` — first block of the identity policy scan (unset before the identity
   upgrade: the scan reads only recent blocks).
+- `IDENTITY_REGISTRY_ADDRESS` — the OwnerIdentityRegistry proxy (unset before the identity upgrade).
 - `COMPUTE_WINDOW`, `DECRYPTION_WINDOW` — E3 timeout windows in seconds.
 
 `vite.config.ts` stops the build when an override has no network scope (for example `VITE_RPC_URL`),
diff --git a/packages/interfold-dashboard/src/Operator.tsx b/packages/interfold-dashboard/src/Operator.tsx
index a90ddd7952..1a6386d55d 100644
--- a/packages/interfold-dashboard/src/Operator.tsx
+++ b/packages/interfold-dashboard/src/Operator.tsx
@@ -1703,8 +1703,14 @@ export function IdentityView({
             <dd>
               {preview ? (
                 <span className='dl__muted'>No identity registry on {NETWORK_NAME} yet</span>
+              ) : policy.required === null ? (
+                <span className='dl__muted'>Unknown: this RPC keeps no policy history</span>
               ) : policy.required ? (
-                `Yes, since ${fmtDay(policy.timepoint)}`
+                policy.timepoint === null ? (
+                  'Yes'
+                ) : (
+                  `Yes, since ${fmtDay(policy.timepoint)}`
+                )
               ) : (
                 'Not yet'
               )}
diff --git a/packages/interfold-dashboard/src/lib/chain.ts b/packages/interfold-dashboard/src/lib/chain.ts
index 1a3cd41c02..3895b53e24 100644
--- a/packages/interfold-dashboard/src/lib/chain.ts
+++ b/packages/interfold-dashboard/src/lib/chain.ts
@@ -132,6 +132,11 @@ export const DEPLOY_BLOCK = BigInt(envStr('DEPLOY_BLOCK', NET.deployBlock))
 const identityDeployBlock = envStr('IDENTITY_DEPLOY_BLOCK', NET.identityDeployBlock)
 export const IDENTITY_DEPLOY_BLOCK: bigint | null = identityDeployBlock ? BigInt(identityDeployBlock) : null
 
+// The OwnerIdentityRegistry proxy, set after the identity upgrade. When the RPC keeps no policy log
+// (public RPCs keep about a day), registration still uses it (see fetchIdentityPolicy).
+const identityRegistry = envStr('IDENTITY_REGISTRY_ADDRESS', NET.identityRegistry)
+export const IDENTITY_REGISTRY: Address | null = identityRegistry ? (identityRegistry as Address) : null
+
 // E3 timeout windows (seconds), matching the deployment's timeoutConfig. Used to
 // decide whether an E3 is still genuinely active vs. expired without completing.
 export const TIMEOUTS = {
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
index 363fa6af54..0c9684b9a4 100644
--- a/packages/interfold-dashboard/src/lib/identity.test.ts
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -23,6 +23,7 @@ import {
   registrationDeadline,
   safeRegistrationBatch,
   type ProofResult,
+  policyFromLog,
   policyScanStart,
   RECENT_POLICY_BLOCKS,
 } from './identity'
@@ -157,3 +158,14 @@ test('the policy scan reads recent blocks until the network has the identity upg
   assert.equal(policyScanStart(null, 100n), 0n)
   assert.equal(policyScanStart(26_400_000n, 26_500_000n), 26_400_000n)
 })
+
+test('the policy log wins; the configured registry opens registration without one', () => {
+  const registry = '0x4444444444444444444444444444444444444444' as Address
+  const configured = '0x5555555555555555555555555555555555555555' as Address
+  const log = (address: Address, required: boolean) => ({ args: { registry: address, required, timepoint: 1_700n } })
+  assert.deepEqual(policyFromLog(log(registry, true), configured), { registry, required: true, timepoint: 1_700n })
+  // A log that clears the registry turns the gate off, whatever the profile says.
+  assert.equal(policyFromLog(log('0x0000000000000000000000000000000000000000', false), configured), null)
+  assert.deepEqual(policyFromLog(undefined, configured), { registry: configured, required: null, timepoint: null })
+  assert.equal(policyFromLog(undefined, null), null)
+})
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index 031e190822..87a6ba7e40 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -7,7 +7,8 @@
 // the evidence that OwnerIdentityRegistry.register takes for a ZKPassport proof.
 //
 // The policy has no view. The bonding registry emits IdentityPolicyUpdated(timepoint, registry,
-// required), and the latest log is the current policy. The verifier's fixed settings (domain, scope,
+// required), and the latest log is the current policy. When the RPC keeps no such log, the registry
+// from the network profile still opens registration. The verifier's fixed settings (domain, scope,
 // ZKPassport version, identifier type) are read from the verifier itself, so the page follows the
 // deployment. Before a deployment, the page can still make a proof with the planned settings
 // (PREVIEW_SERVICE) and offer it as a download.
@@ -17,6 +18,7 @@ import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk
 import {
   CONTRACTS,
   IDENTITY_DEPLOY_BLOCK,
+  IDENTITY_REGISTRY,
   bondingRegistryAbi,
   ownerIdentityRegistryAbi,
   publicClient,
@@ -48,9 +50,10 @@ const PROOF_VERIFICATION_PARAMS = getAbiItem({ abi: zkPassportRootVerifierAbi, n
 
 export type IdentityPolicy = {
   registry: Address
-  required: boolean
-  /** Timestamp from which the policy applies. */
-  timepoint: bigint
+  /** Null when no policy log was in reach and the registry comes from the network profile. */
+  required: boolean | null
+  /** Timestamp from which the policy applies; null with an unknown policy. */
+  timepoint: bigint | null
 }
 
 /** The settings that the deployed ZKPassportIdentityVerifier fixes for every proof. */
@@ -92,20 +95,40 @@ export function policyScanStart(configured: bigint | null, head: bigint): bigint
   return head > RECENT_POLICY_BLOCKS ? head - RECENT_POLICY_BLOCKS : 0n
 }
 
+/** The latest IdentityPolicyUpdated log, as the viem log decoder returns it. */
+export type PolicyLog = { args: { registry: Address; required: boolean; timepoint: bigint | number } }
+
+/**
+ * The policy from the latest policy log: null when the log clears the registry. Without a log in
+ * reach, the registry from the network profile still opens registration, with the policy unknown.
+ */
+export function policyFromLog(latest: PolicyLog | undefined, configuredRegistry: Address | null): IdentityPolicy | null {
+  if (latest) {
+    if (latest.args.registry === ZERO_ADDRESS) return null
+    return { registry: latest.args.registry, required: latest.args.required, timepoint: BigInt(latest.args.timepoint) }
+  }
+  return configuredRegistry ? { registry: configuredRegistry, required: null, timepoint: null } : null
+}
+
 /**
  * The current identity policy: the latest IdentityPolicyUpdated log. Null before the first log, and
- * when the latest log clears the registry.
+ * when the latest log clears the registry. A failed log read falls back to the configured registry.
  */
 export async function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
-  const head = await publicClient.getBlockNumber()
-  const logs = await getLogsChunked<any>(
-    { address: CONTRACTS.BondingRegistry, event: IDENTITY_POLICY_UPDATED },
-    policyScanStart(IDENTITY_DEPLOY_BLOCK, head),
-    head,
-  )
-  const latest = logs[logs.length - 1]
-  if (!latest || latest.args.registry === ZERO_ADDRESS) return null
-  return { registry: latest.args.registry, required: latest.args.required, timepoint: BigInt(latest.args.timepoint) }
+  let latest: PolicyLog | undefined
+  try {
+    const head = await publicClient.getBlockNumber()
+    const logs = await getLogsChunked<PolicyLog>(
+      { address: CONTRACTS.BondingRegistry, event: IDENTITY_POLICY_UPDATED },
+      policyScanStart(IDENTITY_DEPLOY_BLOCK, head),
+      head,
+    )
+    latest = logs[logs.length - 1]
+  } catch (error) {
+    // Public RPCs keep about a day of logs. The configured registry needs none.
+    if (!IDENTITY_REGISTRY) throw error
+  }
+  return policyFromLog(latest, IDENTITY_REGISTRY)
 }
 
 /** The verifier settings, or null while the registry has no verifier (registration is closed). */
diff --git a/packages/interfold-dashboard/src/lib/networks.ts b/packages/interfold-dashboard/src/lib/networks.ts
index 268523a2ee..a0ea67b530 100644
--- a/packages/interfold-dashboard/src/lib/networks.ts
+++ b/packages/interfold-dashboard/src/lib/networks.ts
@@ -36,6 +36,9 @@ export type NetworkProfile = {
   // First block of the identity policy scan: a block at or before the BondingRegistry upgrade that
   // added the policy. Empty until that upgrade: the panel then reads only recent blocks.
   identityDeployBlock: string
+  // The OwnerIdentityRegistry proxy. Empty until the identity upgrade. With it, registration works
+  // even when the RPC keeps no policy log; the policy then shows as unknown.
+  identityRegistry: string
   // Fee token metadata for formatting escrowed fees/rewards. Hardcoded per
   // deployment (like the addresses) rather than read on-chain at runtime.
   feeSymbol: string
@@ -64,6 +67,7 @@ export const NETWORKS: Record<NetworkKey, NetworkProfile> = {
     // and the CRISPProgram (11873424). A later value silently drops early registry events.
     deployBlock: '11873232',
     identityDeployBlock: '',
+    identityRegistry: '',
     // MockUSDC (0xE2e534F7…555B), the fee token and ticket collateral. Anyone can mint it.
     feeSymbol: 'USDC',
     feeDecimals: 6,
@@ -86,6 +90,7 @@ export const NETWORKS: Record<NetworkKey, NetworkProfile> = {
     // All mainnet contracts were deployed in the same block.
     deployBlock: '25786403',
     identityDeployBlock: '',
+    identityRegistry: '',
     // USDS (0xdC035D45…384F) on the mainnet deployment.
     feeSymbol: 'USDS',
     feeDecimals: 18,
@@ -106,6 +111,7 @@ const SETTINGS = [
   'FEE_TOKEN_DECIMALS',
   'DEPLOY_BLOCK',
   'IDENTITY_DEPLOY_BLOCK',
+  'IDENTITY_REGISTRY_ADDRESS',
   'COMPUTE_WINDOW',
   'DECRYPTION_WINDOW',
 ] as const

From da99b0129148b0449e9fecb11abe77f13992eec5 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Tue, 3 Nov 2026 01:53:02 +0500
Subject: [PATCH 07/11] feat(dashboard): count a newly verified owner in the
 current window

A registration verifies the owner at once, but owner capacity counts it
only after a status refresh of one of its operators. Nodes refresh at
each window start, so a new owner could wait up to 30 days.

- The Safe batch registers and then refreshes the page's operator when
  it is registered (one atomic batch).
- A wallet owner gets "Count the owner now" after registering, when the
  policy is required.
- Tests decode the refresh call and render both paths.
---
 .../interfold-dashboard/src/Operator.test.tsx | 13 ++++
 packages/interfold-dashboard/src/Operator.tsx | 68 +++++++++++++++++--
 .../src/lib/identity.test.ts                  | 13 +++-
 .../interfold-dashboard/src/lib/identity.ts   | 41 ++++++++---
 4 files changed, 117 insertions(+), 18 deletions(-)

diff --git a/packages/interfold-dashboard/src/Operator.test.tsx b/packages/interfold-dashboard/src/Operator.test.tsx
index bc5ee885fc..710d146765 100644
--- a/packages/interfold-dashboard/src/Operator.test.tsx
+++ b/packages/interfold-dashboard/src/Operator.test.tsx
@@ -327,6 +327,19 @@ test('a proof registers from the owner, or as a Safe transaction', () => {
   assert.doesNotMatch(safe, /Register the identity/)
   assert.match(safe, /Safe Transaction Builder/)
 
+  // A registered operator lets the owner count now: a button for a wallet, the batch for a Safe.
+  const verified = account({ identity: { identityId: word(1n), expiresAt: NOW + 200n * DAY, verifiedNow: true } })
+  const countNow = renderToStaticMarkup(<IdentityView {...identityProps} account={verified} request={ready} onRefresh={() => {}} />)
+  assert.match(countNow, />Count the owner now</)
+  assert.doesNotMatch(
+    renderToStaticMarkup(<IdentityView {...identityProps} request={ready} onRefresh={() => {}} />),
+    /Count the owner now<\/button>/,
+  )
+  const safeBatch = renderToStaticMarkup(
+    <IdentityView {...identityProps} account={account({ isContract: true })} request={ready} refreshInBatch />,
+  )
+  assert.match(safeBatch, /The batch also refreshes the operator/)
+
   // The verifier accepts one ZKPassport version.
   const otherVersion = { phase: 'ready', bundle: bundle(word(0x15n << 232n)) } as const
   const mismatch = renderToStaticMarkup(<IdentityView {...identityProps} request={otherVersion} />)
diff --git a/packages/interfold-dashboard/src/Operator.tsx b/packages/interfold-dashboard/src/Operator.tsx
index 1a6386d55d..78c71e8fd2 100644
--- a/packages/interfold-dashboard/src/Operator.tsx
+++ b/packages/interfold-dashboard/src/Operator.tsx
@@ -716,6 +716,7 @@ export default function Operator() {
               key={identityOwner}
               owner={identityOwner}
               wallet={connected ? wallet.address : null}
+              refreshOperator={registered ? operator : null}
               busy={busy}
               send={(key, call) => void run(key, () => write(call))}
               errFor={errFor}
@@ -1383,6 +1384,7 @@ export type IdentityService = {
 }
 
 const REGISTER_IDENTITY_KEY = 'registerIdentity'
+const REFRESH_AFTER_IDENTITY_KEY = 'refreshAfterIdentity'
 
 function identityService(verifier: VerifierConfig | null, previewFaceMatch: boolean): IdentityService {
   return verifier
@@ -1408,12 +1410,15 @@ function identityService(verifier: VerifierConfig | null, previewFaceMatch: bool
 function IdentityPanel({
   owner,
   wallet,
+  refreshOperator,
   busy,
   send,
   errFor,
 }: {
   owner: Address
   wallet: Address | null
+  /** A registered operator of this owner. A refresh of it counts the owner in the current window. */
+  refreshOperator: Address | null
   busy: string | null
   send: (key: string, call: ContractCall) => void
   errFor: (key: string) => ReactNode
@@ -1605,9 +1610,28 @@ function IdentityPanel({
         }
         downloadJson(
           `interfold-identity-safe-${owner}.json`,
-          safeRegistrationBatch(policy!.registry, owner, CHAIN.id, bundle.evidence, Date.now()),
+          safeRegistrationBatch(
+            policy!.registry,
+            owner,
+            CHAIN.id,
+            bundle.evidence,
+            Date.now(),
+            refreshOperator ? { bondingRegistry: CONTRACTS.BondingRegistry, operator: refreshOperator } : undefined,
+          ),
         )
       }}
+      refreshInBatch={refreshOperator !== null}
+      onRefresh={
+        refreshOperator && policy?.required
+          ? () =>
+              send(REFRESH_AFTER_IDENTITY_KEY, {
+                address: CONTRACTS.BondingRegistry,
+                abi: bondingRegistryAbi,
+                functionName: 'refreshOperatorStatus',
+                args: [refreshOperator],
+              })
+          : null
+      }
     />
   )
 }
@@ -1638,6 +1662,8 @@ export function IdentityView({
   onRegister,
   onDownloadProof,
   onDownloadSafe,
+  refreshInBatch = false,
+  onRefresh = null,
 }: {
   owner: Address
   policy: IdentityPolicy | null | undefined
@@ -1661,6 +1687,10 @@ export function IdentityView({
   onRegister: (bundle: ProofBundle) => void
   onDownloadProof: (bundle: ProofBundle) => void
   onDownloadSafe: (bundle: ProofBundle) => void
+  /** The Safe batch also refreshes a registered operator of the owner. */
+  refreshInBatch?: boolean
+  /** Refreshes a registered operator, so a verified owner counts in this window; null hides it. */
+  onRefresh?: (() => void) | null
 }) {
   const preview = policy === null
   const chain = boundChainName(CHAIN.id)
@@ -1753,6 +1783,8 @@ export function IdentityView({
               onRegister={onRegister}
               onDownloadProof={onDownloadProof}
               onDownloadSafe={onDownloadSafe}
+              refreshInBatch={refreshInBatch}
+              onRefresh={onRefresh}
               onRestart={onCancel}
             />
           ) : (
@@ -1845,6 +1877,8 @@ function IdentityProof({
   onRegister,
   onDownloadProof,
   onDownloadSafe,
+  refreshInBatch,
+  onRefresh,
   onRestart,
 }: {
   bundle: ProofBundle
@@ -1859,6 +1893,8 @@ function IdentityProof({
   onRegister: (bundle: ProofBundle) => void
   onDownloadProof: (bundle: ProofBundle) => void
   onDownloadSafe: (bundle: ProofBundle) => void
+  refreshInBatch: boolean
+  onRefresh: (() => void) | null
   onRestart: () => void
 }) {
   const validUntil = BigInt(bundle.validUntil)
@@ -1916,6 +1952,11 @@ function IdentityProof({
             Download the Safe transaction
           </button>
         )}
+        {!preview && !account.isContract && onRefresh && account.identity?.verifiedNow && (
+          <button className='btn btn--ghost' disabled={busy !== null} onClick={onRefresh}>
+            {busy === REFRESH_AFTER_IDENTITY_KEY ? 'Confirming…' : 'Count the owner now'}
+          </button>
+        )}
         <button className='btn btn--ghost' onClick={() => onDownloadProof(bundle)}>
           Download the proof (JSON)
         </button>
@@ -1924,6 +1965,7 @@ function IdentityProof({
         </button>
       </div>
       {errFor(REGISTER_IDENTITY_KEY)}
+      {errFor(REFRESH_AFTER_IDENTITY_KEY)}
       {!preview && !account.isContract && !canRegister && <Note>Connect the bond-owner wallet {shortAddr(owner)} to register.</Note>}
       {!preview && account.isContract && (
         <Note>
@@ -1931,12 +1973,24 @@ function IdentityProof({
           million gas.
         </Note>
       )}
-      {!preview && (
-        <Note>
-          The owner's operators count toward this window's request capacity after their next status refresh. Each node refreshes itself when
-          a window starts; to count now, use <strong>Refresh the status</strong> in Manage the position.
-        </Note>
-      )}
+      {!preview &&
+        (account.isContract && refreshInBatch ? (
+          <Note>The batch also refreshes the operator's status, so the owner counts toward this window's request capacity.</Note>
+        ) : (
+          <Note>
+            The owner's operators count toward this window's request capacity after their next status refresh. Each node refreshes itself
+            when a window starts;{' '}
+            {onRefresh ? (
+              <>
+                to count now, register and then use <strong>Count the owner now</strong>.
+              </>
+            ) : (
+              <>
+                to count now, use <strong>Refresh the status</strong> in Manage the position.
+              </>
+            )}
+          </Note>
+        ))}
     </div>
   )
 }
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
index 0c9684b9a4..1347356235 100644
--- a/packages/interfold-dashboard/src/lib/identity.test.ts
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -8,7 +8,7 @@ import assert from 'node:assert/strict'
 import test from 'node:test'
 import { decodeAbiParameters, decodeFunctionData, getAbiItem, pad, toHex, type Address, type Hex } from 'viem'
 import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk'
-import { ownerIdentityRegistryAbi, zkPassportRootVerifierAbi } from './chain'
+import { bondingRegistryAbi, ownerIdentityRegistryAbi, zkPassportRootVerifierAbi } from './chain'
 import {
   CAPACITY_WINDOW,
   boundChainName,
@@ -112,6 +112,17 @@ test('a Safe batch registers the evidence from the bound Safe', () => {
   const call = decodeFunctionData({ abi: ownerIdentityRegistryAbi, data: batch.transactions[0].data })
   assert.equal(call.functionName, 'register')
   assert.deepEqual(call.args, [evidence])
+
+  // With a registered operator, the same batch counts the owner in this window.
+  const bonding = '0x6666666666666666666666666666666666666666' as Address
+  const operator = '0x7777777777777777777777777777777777777777' as Address
+  const counted = safeRegistrationBatch(REGISTRY, OWNER, 1, evidence, 1_700_000_000_000, { bondingRegistry: bonding, operator })
+  assert.equal(counted.transactions.length, 2)
+  assert.deepEqual(counted.transactions[0], batch.transactions[0])
+  assert.equal(counted.transactions[1].to, bonding)
+  const refresh = decodeFunctionData({ abi: bondingRegistryAbi, data: counted.transactions[1].data })
+  assert.equal(refresh.functionName, 'refreshOperatorStatus')
+  assert.deepEqual(refresh.args, [operator])
 })
 
 test('the downloaded bundle describes the proof that it carries', () => {
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index 87a6ba7e40..17a13a0cf3 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -277,24 +277,45 @@ export function encodeEvidence(params: SolidityVerifierParameters, validUntil: b
   )
 }
 
-/** A Safe Transaction Builder batch that registers the proof from the Safe that it binds. */
-export function safeRegistrationBatch(registry: Address, safe: Address, chainId: number, evidence: Hex, createdAt: number) {
+/**
+ * A Safe Transaction Builder batch that registers the proof from the Safe that it binds. With a
+ * registered operator of the Safe, the batch then refreshes its status, so the owner counts toward
+ * request capacity in the current window. The operator must stay registered: the batch is atomic.
+ */
+export function safeRegistrationBatch(
+  registry: Address,
+  safe: Address,
+  chainId: number,
+  evidence: Hex,
+  createdAt: number,
+  refresh?: { bondingRegistry: Address; operator: Address },
+) {
+  const transactions = [
+    {
+      to: registry,
+      value: '0',
+      data: encodeFunctionData({ abi: ownerIdentityRegistryAbi, functionName: 'register', args: [evidence] }),
+    },
+  ]
+  if (refresh) {
+    transactions.push({
+      to: refresh.bondingRegistry,
+      value: '0',
+      data: encodeFunctionData({ abi: bondingRegistryAbi, functionName: 'refreshOperatorStatus', args: [refresh.operator] }),
+    })
+  }
   return {
     version: '1.0',
     chainId: String(chainId),
     createdAt,
     meta: {
       name: 'Interfold bond-owner identity',
-      description: 'OwnerIdentityRegistry.register for this Safe. Execute it before the proof expires.',
+      description: refresh
+        ? 'OwnerIdentityRegistry.register for this Safe, then a status refresh of its operator. Execute it before the proof expires.'
+        : 'OwnerIdentityRegistry.register for this Safe. Execute it before the proof expires.',
       createdFromSafeAddress: safe,
     },
-    transactions: [
-      {
-        to: registry,
-        value: '0',
-        data: encodeFunctionData({ abi: ownerIdentityRegistryAbi, functionName: 'register', args: [evidence] }),
-      },
-    ],
+    transactions,
   }
 }
 

From 4af4694b4eb67224bf833827b0ff052e97d4f2d7 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Tue, 3 Nov 2026 02:31:37 +0500
Subject: [PATCH 08/11] test(dashboard): cover the registry fallback when the
 policy log read fails

---
 .../interfold-dashboard/src/Operator.test.tsx |  9 +++++
 .../src/lib/identity.test.ts                  | 14 +++++++
 .../interfold-dashboard/src/lib/identity.ts   | 40 +++++++++++++------
 3 files changed, 50 insertions(+), 13 deletions(-)

diff --git a/packages/interfold-dashboard/src/Operator.test.tsx b/packages/interfold-dashboard/src/Operator.test.tsx
index 710d146765..c001c8fca5 100644
--- a/packages/interfold-dashboard/src/Operator.test.tsx
+++ b/packages/interfold-dashboard/src/Operator.test.tsx
@@ -351,6 +351,15 @@ test('a proof registers from the owner, or as a Safe transaction', () => {
   assert.match(late, /too old to register/)
 })
 
+test('an unknown policy still offers registration', () => {
+  const unknown = { registry: PROPOSED, required: null, timepoint: null }
+  const idle = renderToStaticMarkup(<IdentityView {...identityProps} policy={unknown} />)
+  assert.match(idle, /Unknown: this RPC keeps no policy history/)
+  assert.match(idle, />Create ZKPassport request</)
+  const ready = renderToStaticMarkup(<IdentityView {...identityProps} policy={unknown} request={{ phase: 'ready', bundle: bundle() }} />)
+  assert.match(ready, /<button class="btn btn--primary">Register the identity/)
+})
+
 test('a registry without a verifier shows the credential but takes no registration', () => {
   const closed = renderToStaticMarkup(<IdentityView {...identityProps} verifier={null} registrationClosed />)
   assert.match(closed, /takes no registration/)
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
index 1347356235..a06221c8e2 100644
--- a/packages/interfold-dashboard/src/lib/identity.test.ts
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -26,6 +26,7 @@ import {
   policyFromLog,
   policyScanStart,
   RECENT_POLICY_BLOCKS,
+  resolveIdentityPolicy,
 } from './identity'
 
 const OWNER = '0x2222222222222222222222222222222222222222' as Address
@@ -180,3 +181,16 @@ test('the policy log wins; the configured registry opens registration without on
   assert.deepEqual(policyFromLog(undefined, configured), { registry: configured, required: null, timepoint: null })
   assert.equal(policyFromLog(undefined, null), null)
 })
+
+test('a failed policy log read falls back to the configured registry', async () => {
+  const registry = '0x4444444444444444444444444444444444444444' as Address
+  const configured = '0x5555555555555555555555555555555555555555' as Address
+  const pruned = async () => {
+    throw new Error('block range is too old')
+  }
+  assert.deepEqual(await resolveIdentityPolicy(pruned, configured), { registry: configured, required: null, timepoint: null })
+  // Without a configured registry the read error stays visible.
+  await assert.rejects(resolveIdentityPolicy(pruned, null), /block range is too old/)
+  const read = async () => ({ args: { registry, required: true, timepoint: 1_700n } })
+  assert.deepEqual(await resolveIdentityPolicy(read, configured), { registry, required: true, timepoint: 1_700n })
+})
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index 17a13a0cf3..3ca109501b 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -111,24 +111,38 @@ export function policyFromLog(latest: PolicyLog | undefined, configuredRegistry:
 }
 
 /**
- * The current identity policy: the latest IdentityPolicyUpdated log. Null before the first log, and
- * when the latest log clears the registry. A failed log read falls back to the configured registry.
+ * The policy from `readLatest`, the latest IdentityPolicyUpdated log. A failed read falls back to
+ * the configured registry: public RPCs keep about a day of logs, and registration needs none.
  */
-export async function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
+export async function resolveIdentityPolicy(
+  readLatest: () => Promise<PolicyLog | undefined>,
+  configuredRegistry: Address | null,
+): Promise<IdentityPolicy | null> {
   let latest: PolicyLog | undefined
   try {
-    const head = await publicClient.getBlockNumber()
-    const logs = await getLogsChunked<PolicyLog>(
-      { address: CONTRACTS.BondingRegistry, event: IDENTITY_POLICY_UPDATED },
-      policyScanStart(IDENTITY_DEPLOY_BLOCK, head),
-      head,
-    )
-    latest = logs[logs.length - 1]
+    latest = await readLatest()
   } catch (error) {
-    // Public RPCs keep about a day of logs. The configured registry needs none.
-    if (!IDENTITY_REGISTRY) throw error
+    if (!configuredRegistry) throw error
   }
-  return policyFromLog(latest, IDENTITY_REGISTRY)
+  return policyFromLog(latest, configuredRegistry)
+}
+
+async function readLatestPolicyLog(): Promise<PolicyLog | undefined> {
+  const head = await publicClient.getBlockNumber()
+  const logs = await getLogsChunked<PolicyLog>(
+    { address: CONTRACTS.BondingRegistry, event: IDENTITY_POLICY_UPDATED },
+    policyScanStart(IDENTITY_DEPLOY_BLOCK, head),
+    head,
+  )
+  return logs[logs.length - 1]
+}
+
+/**
+ * The current identity policy: the latest IdentityPolicyUpdated log. Null before the first log, and
+ * when the latest log clears the registry. A failed log read falls back to the configured registry.
+ */
+export function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
+  return resolveIdentityPolicy(readLatestPolicyLog, IDENTITY_REGISTRY)
 }
 
 /** The verifier settings, or null while the registry has no verifier (registration is closed). */

From bf00b4b1ef3dfacd5021008f24da47ead14304dd Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Tue, 3 Nov 2026 16:54:11 +0500
Subject: [PATCH 09/11] fix(dashboard): read the identity policy from storage

With no identity deploy block set, the panel scanned only the latest 2,000 blocks, so a policy set earlier read as 'no identity registry' while it was live. The policy has no view, so the panel now reads it from the bonding registry's ERC-7201 storage: three storage reads, which any RPC serves. The identityDeployBlock and identityRegistry settings and the unknown-policy state are no longer needed, and a contracts spec pins the slots.
---
 packages/interfold-dashboard/.env.example     | 12 ---
 packages/interfold-dashboard/README.md        | 18 +---
 .../interfold-dashboard/src/Operator.test.tsx |  9 --
 packages/interfold-dashboard/src/Operator.tsx |  8 +-
 packages/interfold-dashboard/src/lib/chain.ts | 11 ---
 .../src/lib/identity.test.ts                  | 64 +++++++------
 .../interfold-dashboard/src/lib/identity.ts   | 94 ++++++-------------
 .../src/lib/networks.test.ts                  |  6 +-
 .../interfold-dashboard/src/lib/networks.ts   | 28 ++----
 9 files changed, 79 insertions(+), 171 deletions(-)

diff --git a/packages/interfold-dashboard/.env.example b/packages/interfold-dashboard/.env.example
index 92f490c26e..8a39a58eb2 100644
--- a/packages/interfold-dashboard/.env.example
+++ b/packages/interfold-dashboard/.env.example
@@ -56,18 +56,6 @@
 # VITE_SEPOLIA_DEPLOY_BLOCK=
 # VITE_MAINNET_DEPLOY_BLOCK=
 
-# First block of the bond-owner identity policy scan (IdentityPolicyUpdated logs of
-# the bonding registry). Set it to a block at or before the registry upgrade that
-# added the policy. Unset before that upgrade: the panel then reads only recent
-# blocks. The RPC must serve logs from this block on (publicnode keeps about a day).
-# VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK=
-# VITE_MAINNET_IDENTITY_DEPLOY_BLOCK=
-
-# The OwnerIdentityRegistry proxy. Unset before the identity upgrade. With it,
-# registration works even when the RPC keeps no policy log.
-# VITE_SEPOLIA_IDENTITY_REGISTRY_ADDRESS=
-# VITE_MAINNET_IDENTITY_REGISTRY_ADDRESS=
-
 # E3 timeout windows (seconds), from the deployment's getTimeoutConfig(). Used to
 # decide whether an E3 is still active vs. expired (input close + these windows).
 # Sepolia: 604800 / 21600. Mainnet: 604800 / 21600.
diff --git a/packages/interfold-dashboard/README.md b/packages/interfold-dashboard/README.md
index fdc6bba926..afb37dc406 100644
--- a/packages/interfold-dashboard/README.md
+++ b/packages/interfold-dashboard/README.md
@@ -109,19 +109,14 @@ and `ZKPassportIdentityVerifier`). The page:
 
 The page warns when the proof's ZKPassport version differs from the verifier's, when the proof is
 too old, when a renewal would shorten the credential, and when the credential ends inside the
-current 30-day capacity window. Before a deployment (no policy log), it makes a proof with the
+current 30-day capacity window. Before a deployment (no policy yet), it makes a proof with the
 planned settings (`PREVIEW_SERVICE`) and offers only the download. The download holds the proofs,
 the verifier parameters, and the evidence, so a fork test can replay it.
 
-Until a network has the identity upgrade, leave `IDENTITY_DEPLOY_BLOCK` and
-`IDENTITY_REGISTRY_ADDRESS` unset. No policy log exists yet, so the panel reads only the latest
-2,000 blocks, which public RPCs serve. When the upgrade batch has executed, set
-`identityDeployBlock` (the upgrade block) and `identityRegistry` (the OwnerIdentityRegistry proxy)
-in `src/lib/networks.ts`. With the registry set, registration needs no log history. The policy label
-still comes from the latest `IdentityPolicyUpdated` log, so production also needs an RPC that serves
-logs from the upgrade block (public RPCs such as publicnode keep only about a day); without one, the
-panel shows the policy as unknown. Owners register between the upgrade and the enforcement, so set
-both values and the RPC on the day of the upgrade.
+The policy has no view, so the panel reads it from the bonding registry's ERC-7201 storage
+(`IDENTITY_STORAGE_SLOT` in `src/lib/identity.ts`). These storage reads need no log history, so any
+RPC serves them, and the page needs no setting for the identity upgrade. A contracts spec pins the
+slots.
 
 Only `VITE_BONDING_REGISTRY_ADDRESS` is configured. The ciphernode bond token, ticket wrapper,
 ticket underlying, bond size, ticket price, minimum tickets, and exit delay are all read back from
@@ -154,9 +149,6 @@ default:
   the "Get test tokens" action on a testnet too.
 - `FEE_TOKEN_SYMBOL`, `FEE_TOKEN_DECIMALS` — fee token display.
 - `DEPLOY_BLOCK` — first block to scan from (the Interfold deploy block).
-- `IDENTITY_DEPLOY_BLOCK` — first block of the identity policy scan (unset before the identity
-  upgrade: the scan reads only recent blocks).
-- `IDENTITY_REGISTRY_ADDRESS` — the OwnerIdentityRegistry proxy (unset before the identity upgrade).
 - `COMPUTE_WINDOW`, `DECRYPTION_WINDOW` — E3 timeout windows in seconds.
 
 `vite.config.ts` stops the build when an override has no network scope (for example `VITE_RPC_URL`),
diff --git a/packages/interfold-dashboard/src/Operator.test.tsx b/packages/interfold-dashboard/src/Operator.test.tsx
index c001c8fca5..710d146765 100644
--- a/packages/interfold-dashboard/src/Operator.test.tsx
+++ b/packages/interfold-dashboard/src/Operator.test.tsx
@@ -351,15 +351,6 @@ test('a proof registers from the owner, or as a Safe transaction', () => {
   assert.match(late, /too old to register/)
 })
 
-test('an unknown policy still offers registration', () => {
-  const unknown = { registry: PROPOSED, required: null, timepoint: null }
-  const idle = renderToStaticMarkup(<IdentityView {...identityProps} policy={unknown} />)
-  assert.match(idle, /Unknown: this RPC keeps no policy history/)
-  assert.match(idle, />Create ZKPassport request</)
-  const ready = renderToStaticMarkup(<IdentityView {...identityProps} policy={unknown} request={{ phase: 'ready', bundle: bundle() }} />)
-  assert.match(ready, /<button class="btn btn--primary">Register the identity/)
-})
-
 test('a registry without a verifier shows the credential but takes no registration', () => {
   const closed = renderToStaticMarkup(<IdentityView {...identityProps} verifier={null} registrationClosed />)
   assert.match(closed, /takes no registration/)
diff --git a/packages/interfold-dashboard/src/Operator.tsx b/packages/interfold-dashboard/src/Operator.tsx
index 78c71e8fd2..3d71cc495d 100644
--- a/packages/interfold-dashboard/src/Operator.tsx
+++ b/packages/interfold-dashboard/src/Operator.tsx
@@ -1733,14 +1733,8 @@ export function IdentityView({
             <dd>
               {preview ? (
                 <span className='dl__muted'>No identity registry on {NETWORK_NAME} yet</span>
-              ) : policy.required === null ? (
-                <span className='dl__muted'>Unknown: this RPC keeps no policy history</span>
               ) : policy.required ? (
-                policy.timepoint === null ? (
-                  'Yes'
-                ) : (
-                  `Yes, since ${fmtDay(policy.timepoint)}`
-                )
+                `Yes, since ${fmtDay(policy.timepoint)}`
               ) : (
                 'Not yet'
               )}
diff --git a/packages/interfold-dashboard/src/lib/chain.ts b/packages/interfold-dashboard/src/lib/chain.ts
index 3895b53e24..04a4af9412 100644
--- a/packages/interfold-dashboard/src/lib/chain.ts
+++ b/packages/interfold-dashboard/src/lib/chain.ts
@@ -126,17 +126,6 @@ export const FEE_TOKEN = {
 // emitted before Interfold was deployed.
 export const DEPLOY_BLOCK = BigInt(envStr('DEPLOY_BLOCK', NET.deployBlock))
 
-// First block of the bond-owner identity policy scan. The policy is the latest
-// IdentityPolicyUpdated log of the bonding registry. Null until the network has the
-// identity upgrade: the scan then reads only recent blocks (see fetchIdentityPolicy).
-const identityDeployBlock = envStr('IDENTITY_DEPLOY_BLOCK', NET.identityDeployBlock)
-export const IDENTITY_DEPLOY_BLOCK: bigint | null = identityDeployBlock ? BigInt(identityDeployBlock) : null
-
-// The OwnerIdentityRegistry proxy, set after the identity upgrade. When the RPC keeps no policy log
-// (public RPCs keep about a day), registration still uses it (see fetchIdentityPolicy).
-const identityRegistry = envStr('IDENTITY_REGISTRY_ADDRESS', NET.identityRegistry)
-export const IDENTITY_REGISTRY: Address | null = identityRegistry ? (identityRegistry as Address) : null
-
 // E3 timeout windows (seconds), matching the deployment's timeoutConfig. Used to
 // decide whether an E3 is still genuinely active vs. expired without completing.
 export const TIMEOUTS = {
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
index a06221c8e2..8bfe4438c9 100644
--- a/packages/interfold-dashboard/src/lib/identity.test.ts
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -6,7 +6,17 @@
 
 import assert from 'node:assert/strict'
 import test from 'node:test'
-import { decodeAbiParameters, decodeFunctionData, getAbiItem, pad, toHex, type Address, type Hex } from 'viem'
+import {
+  decodeAbiParameters,
+  decodeFunctionData,
+  encodeAbiParameters,
+  getAbiItem,
+  keccak256,
+  pad,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
 import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk'
 import { bondingRegistryAbi, ownerIdentityRegistryAbi, zkPassportRootVerifierAbi } from './chain'
 import {
@@ -23,10 +33,8 @@ import {
   registrationDeadline,
   safeRegistrationBatch,
   type ProofResult,
-  policyFromLog,
-  policyScanStart,
-  RECENT_POLICY_BLOCKS,
-  resolveIdentityPolicy,
+  IDENTITY_STORAGE_SLOT,
+  readIdentityPolicy,
 } from './identity'
 
 const OWNER = '0x2222222222222222222222222222222222222222' as Address
@@ -165,32 +173,26 @@ test('a proof registers until it is too old or its credential ends', () => {
   assert.equal(registrationDeadline(1_000n, 600n, 1_200n), 1_200n)
 })
 
-test('the policy scan reads recent blocks until the network has the identity upgrade', () => {
-  assert.equal(policyScanStart(null, 26_311_752n), 26_311_752n - RECENT_POLICY_BLOCKS)
-  assert.equal(policyScanStart(null, 100n), 0n)
-  assert.equal(policyScanStart(26_400_000n, 26_500_000n), 26_400_000n)
-})
-
-test('the policy log wins; the configured registry opens registration without one', () => {
-  const registry = '0x4444444444444444444444444444444444444444' as Address
-  const configured = '0x5555555555555555555555555555555555555555' as Address
-  const log = (address: Address, required: boolean) => ({ args: { registry: address, required, timepoint: 1_700n } })
-  assert.deepEqual(policyFromLog(log(registry, true), configured), { registry, required: true, timepoint: 1_700n })
-  // A log that clears the registry turns the gate off, whatever the profile says.
-  assert.equal(policyFromLog(log('0x0000000000000000000000000000000000000000', false), configured), null)
-  assert.deepEqual(policyFromLog(undefined, configured), { registry: configured, required: null, timepoint: null })
-  assert.equal(policyFromLog(undefined, null), null)
-})
-
-test('a failed policy log read falls back to the configured registry', async () => {
+test('the policy comes from the bonding registry storage', async () => {
   const registry = '0x4444444444444444444444444444444444444444' as Address
-  const configured = '0x5555555555555555555555555555555555555555' as Address
-  const pruned = async () => {
-    throw new Error('block range is too old')
+  const slots = (versions: bigint, version: bigint, policy: bigint) => {
+    const checkpoints = BigInt(keccak256(word(IDENTITY_STORAGE_SLOT)))
+    const policySlot = keccak256(encodeAbiParameters([{ type: 'uint256' }, { type: 'uint256' }], [version, IDENTITY_STORAGE_SLOT + 1n]))
+    const values = new Map<string, bigint>([
+      [word(IDENTITY_STORAGE_SLOT), versions],
+      [word(checkpoints + versions - 1n), (version << 48n) | 1_700n],
+      [policySlot, policy],
+    ])
+    return async (slot: Hex) => values.get(slot) ?? 0n
   }
-  assert.deepEqual(await resolveIdentityPolicy(pruned, configured), { registry: configured, required: null, timepoint: null })
-  // Without a configured registry the read error stays visible.
-  await assert.rejects(resolveIdentityPolicy(pruned, null), /block range is too old/)
-  const read = async () => ({ args: { registry, required: true, timepoint: 1_700n } })
-  assert.deepEqual(await resolveIdentityPolicy(read, configured), { registry, required: true, timepoint: 1_700n })
+  // The second version requires the registry: `required` sits in the byte above the address.
+  assert.deepEqual(await readIdentityPolicy(slots(2n, 2n, (1n << 160n) | BigInt(registry))), {
+    registry,
+    required: true,
+    timepoint: 1_700n,
+  })
+  assert.deepEqual(await readIdentityPolicy(slots(1n, 1n, BigInt(registry))), { registry, required: false, timepoint: 1_700n })
+  // A policy that clears the registry turns the gate off, and before the first policy there is none.
+  assert.equal(await readIdentityPolicy(slots(3n, 3n, 0n)), null)
+  assert.equal(await readIdentityPolicy(async () => 0n), null)
 })
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index 3ca109501b..fc19989240 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -6,26 +6,22 @@
 // Bond-owner identity behind the operator guide: the governance policy, the owner's credential, and
 // the evidence that OwnerIdentityRegistry.register takes for a ZKPassport proof.
 //
-// The policy has no view. The bonding registry emits IdentityPolicyUpdated(timepoint, registry,
-// required), and the latest log is the current policy. When the RPC keeps no such log, the registry
-// from the network profile still opens registration. The verifier's fixed settings (domain, scope,
+// The policy has no view, so the page reads it from the bonding registry's ERC-7201 storage. Three
+// storage reads need no log history, so any RPC serves them. The verifier's fixed settings (domain, scope,
 // ZKPassport version, identifier type) are read from the verifier itself, so the page follows the
 // deployment. Before a deployment, the page can still make a proof with the planned settings
 // (PREVIEW_SERVICE) and offer it as a download.
 
-import { encodeAbiParameters, encodeFunctionData, getAbiItem, type Address, type Hex } from 'viem'
+import { encodeAbiParameters, encodeFunctionData, getAbiItem, getAddress, keccak256, toHex, type Address, type Hex } from 'viem'
 import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk'
 import {
   CONTRACTS,
-  IDENTITY_DEPLOY_BLOCK,
-  IDENTITY_REGISTRY,
   bondingRegistryAbi,
   ownerIdentityRegistryAbi,
   publicClient,
   zkPassportIdentityVerifierAbi,
   zkPassportRootVerifierAbi,
 } from './chain'
-import { getLogsChunked } from './e3'
 
 export type ProofResult = RequestSuccess['proofs'][number]
 
@@ -45,15 +41,13 @@ export const PREVIEW_SERVICE = {
   maxValidity: 365n * 86_400n,
 } as const
 
-const IDENTITY_POLICY_UPDATED = getAbiItem({ abi: bondingRegistryAbi, name: 'IdentityPolicyUpdated' })
 const PROOF_VERIFICATION_PARAMS = getAbiItem({ abi: zkPassportRootVerifierAbi, name: 'verify' }).inputs[0]
 
 export type IdentityPolicy = {
   registry: Address
-  /** Null when no policy log was in reach and the registry comes from the network profile. */
-  required: boolean | null
-  /** Timestamp from which the policy applies; null with an unknown policy. */
-  timepoint: bigint | null
+  required: boolean
+  /** Timestamp from which the policy applies. */
+  timepoint: bigint
 }
 
 /** The settings that the deployed ZKPassportIdentityVerifier fixes for every proof. */
@@ -82,67 +76,39 @@ export type OwnerAccount = {
   identity: { identityId: Hex; expiresAt: bigint; verifiedNow: boolean } | null
 }
 
-/** Blocks that the policy scan reads before the network has the identity upgrade (about 6.7 hours). */
-export const RECENT_POLICY_BLOCKS = 2_000n
-
 /**
- * First block of the policy scan. Without a configured block the network has no identity upgrade
- * yet, so no policy log exists and recent blocks give the same answer. Public RPCs keep only about a
- * day of logs, so a scan from the protocol deploy block would fail there.
+ * ERC-7201 slot of the bonding registry's identity storage (`interfold.storage.BondingIdentity`).
+ * It holds `policyVersions` (a Trace208 of version checkpoints), then `policies` (version to policy).
  */
-export function policyScanStart(configured: bigint | null, head: bigint): bigint {
-  if (configured !== null) return configured
-  return head > RECENT_POLICY_BLOCKS ? head - RECENT_POLICY_BLOCKS : 0n
-}
+export const IDENTITY_STORAGE_SLOT = 0xc8753641d15ccfa7705fd1448b954f166a67eee148357f9bd69a050022902400n
 
-/** The latest IdentityPolicyUpdated log, as the viem log decoder returns it. */
-export type PolicyLog = { args: { registry: Address; required: boolean; timepoint: bigint | number } }
-
-/**
- * The policy from the latest policy log: null when the log clears the registry. Without a log in
- * reach, the registry from the network profile still opens registration, with the policy unknown.
- */
-export function policyFromLog(latest: PolicyLog | undefined, configuredRegistry: Address | null): IdentityPolicy | null {
-  if (latest) {
-    if (latest.args.registry === ZERO_ADDRESS) return null
-    return { registry: latest.args.registry, required: latest.args.required, timepoint: BigInt(latest.args.timepoint) }
-  }
-  return configuredRegistry ? { registry: configuredRegistry, required: null, timepoint: null } : null
-}
+const word = (value: bigint): Hex => toHex(value, { size: 32 })
+const low = (value: bigint, bits: bigint) => value & ((1n << bits) - 1n)
 
 /**
- * The policy from `readLatest`, the latest IdentityPolicyUpdated log. A failed read falls back to
- * the configured registry: public RPCs keep about a day of logs, and registration needs none.
+ * The current policy, from three reads of the bonding registry's storage: the number of policy
+ * versions, the latest checkpoint (key in the low 48 bits, version above it), and that version's
+ * policy (registry in the low 160 bits, `required` in the next byte). Null before the first policy
+ * and when the latest policy clears the registry.
  */
-export async function resolveIdentityPolicy(
-  readLatest: () => Promise<PolicyLog | undefined>,
-  configuredRegistry: Address | null,
-): Promise<IdentityPolicy | null> {
-  let latest: PolicyLog | undefined
-  try {
-    latest = await readLatest()
-  } catch (error) {
-    if (!configuredRegistry) throw error
-  }
-  return policyFromLog(latest, configuredRegistry)
-}
-
-async function readLatestPolicyLog(): Promise<PolicyLog | undefined> {
-  const head = await publicClient.getBlockNumber()
-  const logs = await getLogsChunked<PolicyLog>(
-    { address: CONTRACTS.BondingRegistry, event: IDENTITY_POLICY_UPDATED },
-    policyScanStart(IDENTITY_DEPLOY_BLOCK, head),
-    head,
-  )
-  return logs[logs.length - 1]
+export async function readIdentityPolicy(readSlot: (slot: Hex) => Promise<bigint>): Promise<IdentityPolicy | null> {
+  const versions = await readSlot(word(IDENTITY_STORAGE_SLOT))
+  if (versions === 0n) return null
+  const checkpoints = BigInt(keccak256(word(IDENTITY_STORAGE_SLOT)))
+  const checkpoint = await readSlot(word(checkpoints + versions - 1n))
+  const version = checkpoint >> 48n
+  const policySlot = keccak256(encodeAbiParameters([{ type: 'uint256' }, { type: 'uint256' }], [version, IDENTITY_STORAGE_SLOT + 1n]))
+  const policy = await readSlot(policySlot)
+  const registry = getAddress(toHex(low(policy, 160n), { size: 20 }))
+  if (registry === ZERO_ADDRESS) return null
+  return { registry, required: low(policy >> 160n, 8n) === 1n, timepoint: low(checkpoint, 48n) }
 }
 
-/**
- * The current identity policy: the latest IdentityPolicyUpdated log. Null before the first log, and
- * when the latest log clears the registry. A failed log read falls back to the configured registry.
- */
+/** The current identity policy of the bonding registry. Null before the first policy. */
 export function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
-  return resolveIdentityPolicy(readLatestPolicyLog, IDENTITY_REGISTRY)
+  return readIdentityPolicy(async (slot) =>
+    BigInt((await publicClient.getStorageAt({ address: CONTRACTS.BondingRegistry, slot })) ?? '0x0'),
+  )
 }
 
 /** The verifier settings, or null while the registry has no verifier (registration is closed). */
diff --git a/packages/interfold-dashboard/src/lib/networks.test.ts b/packages/interfold-dashboard/src/lib/networks.test.ts
index e8f3a17ef3..249fd38a51 100644
--- a/packages/interfold-dashboard/src/lib/networks.test.ts
+++ b/packages/interfold-dashboard/src/lib/networks.test.ts
@@ -11,12 +11,10 @@ import { invalidBlockOverrides } from './networks'
 test('block overrides must be whole numbers on every network', () => {
   assert.deepEqual(
     invalidBlockOverrides({
-      VITE_MAINNET_DEPLOY_BLOCK: '26300000',
-      VITE_MAINNET_IDENTITY_DEPLOY_BLOCK: '26300000.0',
+      VITE_MAINNET_DEPLOY_BLOCK: '26300000.0',
       VITE_SEPOLIA_DEPLOY_BLOCK: ' ',
-      VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK: '-1',
     }),
-    ['VITE_SEPOLIA_IDENTITY_DEPLOY_BLOCK', 'VITE_MAINNET_IDENTITY_DEPLOY_BLOCK'],
+    ['VITE_MAINNET_DEPLOY_BLOCK'],
   )
   assert.deepEqual(invalidBlockOverrides({}), [])
 })
diff --git a/packages/interfold-dashboard/src/lib/networks.ts b/packages/interfold-dashboard/src/lib/networks.ts
index a0ea67b530..60fb58f486 100644
--- a/packages/interfold-dashboard/src/lib/networks.ts
+++ b/packages/interfold-dashboard/src/lib/networks.ts
@@ -33,12 +33,6 @@ export type NetworkProfile = {
   // Empty string = no faucet on this network (hides the operator-guide card).
   faucet: string
   deployBlock: string
-  // First block of the identity policy scan: a block at or before the BondingRegistry upgrade that
-  // added the policy. Empty until that upgrade: the panel then reads only recent blocks.
-  identityDeployBlock: string
-  // The OwnerIdentityRegistry proxy. Empty until the identity upgrade. With it, registration works
-  // even when the RPC keeps no policy log; the policy then shows as unknown.
-  identityRegistry: string
   // Fee token metadata for formatting escrowed fees/rewards. Hardcoded per
   // deployment (like the addresses) rather than read on-chain at runtime.
   feeSymbol: string
@@ -56,18 +50,16 @@ export const NETWORKS: Record<NetworkKey, NetworkProfile> = {
     name: 'Sepolia',
     rpc: 'https://ethereum-sepolia.publicnode.com',
     explorer: 'https://sepolia.etherscan.io',
-    interfold: '0xBD5B6D1aDA9e0eB248B678469C9Cd6a63507E42b',
-    ciphernodeRegistry: '0xb1E8640CF8D0A927290E3d9E1b01c4899B5225Ef',
-    crispProgram: '0xA9894A39061EC33f8550a2B63A66Be59fb9fa443',
+    interfold: '0xb35EE9ed8BE5967daabBA8c2e817C52D0b57ac26',
+    ciphernodeRegistry: '0x895392D5782E78768A35B1aDfc5b0BD1faB259e4',
+    crispProgram: '0x25Df8D3C04D67efb6198E215963d19a8d119ADFF',
     previousCrispPrograms: [],
-    bondingRegistry: '0x8687bC7C8f055b41aD2C2447c04aCBD76C1075b2',
+    bondingRegistry: '0x8f42eD45556bC8fF8949c37c7644Af9Cf321108F',
     // Test Faucet. It sends 1000 FOLD and 1000 MockUSDC.
     faucet: '0x1B4340A65BB669267BF5DE37385B139987C3F09c',
-    // Deploy block of the Interfold and the CiphernodeRegistry (11873232), the earliest of those two
-    // and the CRISPProgram (11873424). A later value silently drops early registry events.
-    deployBlock: '11873232',
-    identityDeployBlock: '',
-    identityRegistry: '',
+    // Deploy block of the CiphernodeRegistry (12050030), the earlier of it and the Interfold. A later
+    // value silently drops early registry events.
+    deployBlock: '12050030',
     // MockUSDC (0xE2e534F7…555B), the fee token and ticket collateral. Anyone can mint it.
     feeSymbol: 'USDC',
     feeDecimals: 6,
@@ -89,8 +81,6 @@ export const NETWORKS: Record<NetworkKey, NetworkProfile> = {
     faucet: '',
     // All mainnet contracts were deployed in the same block.
     deployBlock: '25786403',
-    identityDeployBlock: '',
-    identityRegistry: '',
     // USDS (0xdC035D45…384F) on the mainnet deployment.
     feeSymbol: 'USDS',
     feeDecimals: 18,
@@ -110,8 +100,6 @@ const SETTINGS = [
   'FEE_TOKEN_SYMBOL',
   'FEE_TOKEN_DECIMALS',
   'DEPLOY_BLOCK',
-  'IDENTITY_DEPLOY_BLOCK',
-  'IDENTITY_REGISTRY_ADDRESS',
   'COMPUTE_WINDOW',
   'DECRYPTION_WINDOW',
 ] as const
@@ -171,7 +159,7 @@ export function unscopedOverrideKeys(env: Env): string[] {
 // Block overrides that are not whole numbers, for example "26300000.0". The page reads
 // them with BigInt when it loads, so one bad value would stop the whole page.
 export function invalidBlockOverrides(env: Env): string[] {
-  const settings: Setting[] = ['DEPLOY_BLOCK', 'IDENTITY_DEPLOY_BLOCK']
+  const settings: Setting[] = ['DEPLOY_BLOCK']
   return NETWORK_KEYS.flatMap((network) => settings.map((setting) => overrideKey(network, setting))).filter((key) => {
     const value = env[key]?.trim()
     return value !== undefined && value !== '' && !/^\d+$/.test(value)

From bc8255a3db1e6acffcf5892f1ab8b96316392c99 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Tue, 3 Nov 2026 16:57:02 +0500
Subject: [PATCH 10/11] fix(dashboard): check the Safe call, the proof binding,
 and the verifier

- The register call's ABI now lists the verifier's errors, so a rejected proof shows the error name instead of a blank reason.
- A Safe batch is simulated from the Safe before the download, and a failure shows under the register actions.
- The owner and chain check reads the binding from the proof's bind_evm inputs. Before, it compared the panel's own values, so it could not fail.
- A registry whose verifier is not a ZKPassport verifier no longer breaks the panel: it shows the credential and says that this page cannot register. Network errors still show the reload.
---
 .../interfold-dashboard/src/Operator.test.tsx | 25 +++++--
 packages/interfold-dashboard/src/Operator.tsx | 38 +++++++++--
 packages/interfold-dashboard/src/lib/chain.ts |  5 ++
 .../src/lib/identity.test.ts                  | 18 ++++-
 .../interfold-dashboard/src/lib/identity.ts   | 67 +++++++++++++++----
 5 files changed, 127 insertions(+), 26 deletions(-)

diff --git a/packages/interfold-dashboard/src/Operator.test.tsx b/packages/interfold-dashboard/src/Operator.test.tsx
index 710d146765..2a0c524d4f 100644
--- a/packages/interfold-dashboard/src/Operator.test.tsx
+++ b/packages/interfold-dashboard/src/Operator.test.tsx
@@ -9,10 +9,18 @@ import test from 'node:test'
 import { renderToStaticMarkup } from 'react-dom/server'
 import type { Address } from 'viem'
 import { CommitteeRewardsView, IdentityView, ManagePosition, positionActions, ticketBurnAmount, type IdentityService } from './Operator'
-import { CONTRACTS, E3Stage, FEE_TOKEN } from './lib/chain'
+import { CHAIN, CONTRACTS, E3Stage, FEE_TOKEN } from './lib/chain'
 import type { BondingConfig, OperatorStatus } from './lib/bonding'
 import { claimPlan, summarizeRewards, type CommitteeSeat, type SeatStatus } from './lib/rewards'
-import { buildProofBundle, dateInput, identityStatusText, parseDateInput, type OwnerAccount, type VerifierConfig } from './lib/identity'
+import {
+  boundChainName,
+  buildProofBundle,
+  dateInput,
+  identityStatusText,
+  parseDateInput,
+  type OwnerAccount,
+  type VerifierConfig,
+} from './lib/identity'
 import { pad, toHex, type Hex } from 'viem'
 
 const OPERATOR = '0x1111111111111111111111111111111111111111' as Address
@@ -205,7 +213,7 @@ function account(overrides: Partial<OwnerAccount> = {}): OwnerAccount {
   return { now: NOW, isContract: false, identity: { identityId: word(0n), expiresAt: 0n, verifiedNow: false }, ...overrides }
 }
 
-function bundle(version: Hex = VERSION) {
+function bundle(version: Hex = VERSION, boundTo: Address = OWNER) {
   return buildProofBundle({
     success: {
       proofs: [
@@ -213,7 +221,11 @@ function bundle(version: Hex = VERSION) {
           name: 'compare_expiry_evm',
           committedInputs: { compare_expiry_evm: { minDateTimestamp: Number(NOW + 400n * DAY), maxDateTimestamp: 0 } },
         },
-        { name: 'outer_evm_count_5', proof: '0x02' },
+        {
+          name: 'outer_evm_count_5',
+          proof: '0x02',
+          committedInputs: { bind_evm: { data: { user_address: boundTo, chain: boundChainName(CHAIN.id) } } },
+        },
       ],
       result: {},
     },
@@ -353,7 +365,7 @@ test('a proof registers from the owner, or as a Safe transaction', () => {
 
 test('a registry without a verifier shows the credential but takes no registration', () => {
   const closed = renderToStaticMarkup(<IdentityView {...identityProps} verifier={null} registrationClosed />)
-  assert.match(closed, /takes no registration/)
+  assert.match(closed, /cannot register with the identity registry/)
   assert.match(closed, /Not verified/)
   assert.doesNotMatch(closed, /Create ZKPassport request/)
 })
@@ -384,7 +396,8 @@ test('a proof that the verifier would reject cannot register, and an equal expir
   const same = account({ identity: { identityId: word(1n), expiresAt: ends, verifiedNow: true } })
   assert.match(renderToStaticMarkup(<IdentityView {...identityProps} account={same} request={ready(proof)} />), register)
 
-  const otherOwner = { ...bundle(), owner: PROPOSED }
+  // The proof itself binds another owner.
+  const otherOwner = bundle(VERSION, PROPOSED)
   const moved = renderToStaticMarkup(<IdentityView {...identityProps} request={ready(otherOwner)} />)
   assert.match(moved, /bound to another owner or network/)
   assert.match(moved, disabled)
diff --git a/packages/interfold-dashboard/src/Operator.tsx b/packages/interfold-dashboard/src/Operator.tsx
index 3d71cc495d..c9e122187c 100644
--- a/packages/interfold-dashboard/src/Operator.tsx
+++ b/packages/interfold-dashboard/src/Operator.tsx
@@ -25,8 +25,9 @@ import {
   bondingRegistryAbi,
   e3RefundManagerAbi,
   faucetAbi,
+  identityRegisterAbi,
   interfoldAbi,
-  ownerIdentityRegistryAbi,
+  publicClient,
 } from './lib/chain'
 import {
   PREVIEW_SERVICE,
@@ -40,6 +41,7 @@ import {
   fetchVerifierConfig,
   fmtDay,
   identityStatusText,
+  proofBinding,
   outerEvmProof,
   parseDateInput,
   registrationDeadline,
@@ -719,6 +721,7 @@ export default function Operator() {
               refreshOperator={registered ? operator : null}
               busy={busy}
               send={(key, call) => void run(key, () => write(call))}
+              reportError={(key, error) => setTxError({ key, message: walletErrorMessage(error) })}
               errFor={errFor}
             />
           )}
@@ -1413,6 +1416,7 @@ function IdentityPanel({
   refreshOperator,
   busy,
   send,
+  reportError,
   errFor,
 }: {
   owner: Address
@@ -1421,6 +1425,8 @@ function IdentityPanel({
   refreshOperator: Address | null
   busy: string | null
   send: (key: string, call: ContractCall) => void
+  /** Show an error under the action of `key`. */
+  reportError: (key: string, error: unknown) => void
   errFor: (key: string) => ReactNode
 }) {
   const [reload, setReload] = useState(0)
@@ -1505,7 +1511,8 @@ function IdentityPanel({
           },
         }
       : loaded
-  // A published registry without a verifier keeps its credentials, but takes no registration.
+  // A published registry without a verifier, or with a verifier that is not ZKPassport's, keeps its
+  // credentials, but this page cannot register with it.
   const registrationClosed = Boolean(policy) && verifier === null
   // Until the owner types a date, the field offers the longest credential that the verifier allows.
   const validUntilValue = validUntilInput ?? (current ? dateInput(current.now + service.maxValidity) : '')
@@ -1597,17 +1604,30 @@ function IdentityPanel({
       onRegister={(bundle) =>
         send(REGISTER_IDENTITY_KEY, {
           address: policy!.registry,
-          abi: ownerIdentityRegistryAbi,
+          abi: identityRegisterAbi,
           functionName: 'register',
           args: [bundle.evidence],
         })
       }
       onDownloadProof={(bundle) => downloadJson(`interfold-identity-proof-${owner}.json`, bundle)}
-      onDownloadSafe={(bundle) => {
+      onDownloadSafe={async (bundle) => {
         if (BigInt(Math.floor(Date.now() / 1000)) > proofDeadline(bundle, service)) {
           setRequest({ phase: 'failed', message: 'The proof is too old to register. Create a new request.' })
           return
         }
+        try {
+          // The Safe sends `register`, so check the call from the Safe before the batch goes out.
+          await publicClient.simulateContract({
+            account: owner,
+            address: policy!.registry,
+            abi: identityRegisterAbi,
+            functionName: 'register',
+            args: [bundle.evidence],
+          })
+        } catch (error) {
+          reportError(REGISTER_IDENTITY_KEY, error)
+          return
+        }
         downloadJson(
           `interfold-identity-safe-${owner}.json`,
           safeRegistrationBatch(
@@ -1762,7 +1782,10 @@ export function IdentityView({
           {!chain ? (
             <Note kind='warn'>ZKPassport does not verify proofs on {NETWORK_NAME}.</Note>
           ) : registrationClosed ? (
-            <Note>The identity registry has no verifier at the moment, so it takes no registration. Credentials it issued stay valid.</Note>
+            <Note>
+              This page cannot register with the identity registry now: it has no verifier, or its verifier is not a ZKPassport verifier.
+              Credentials it issued stay valid.
+            </Note>
           ) : request.phase === 'ready' ? (
             <IdentityProof
               bundle={request.bundle}
@@ -1895,8 +1918,9 @@ function IdentityProof({
   const proofDate = BigInt(bundle.proofDate)
   const ends = credentialEnd(validUntil, proofDate, service.maxValidity)
   const deadline = proofDeadline(bundle, service)
-  // The panel requested this binding; a proof for another owner or chain would only revert.
-  const bound = sameAddress(bundle.owner, owner) && bundle.chainId === CHAIN.id
+  // A proof bound to another owner or chain would only revert. Read the binding from the proof.
+  const binding = proofBinding(bundle.proofs)
+  const bound = binding !== null && sameAddress(binding.owner, owner) && binding.chain === boundChainName(CHAIN.id)
   const versionMatches = !verifier || bundle.version.toLowerCase() === verifier.version.toLowerCase()
   const keyMatches =
     !verifier ||
diff --git a/packages/interfold-dashboard/src/lib/chain.ts b/packages/interfold-dashboard/src/lib/chain.ts
index 04a4af9412..e440e840d5 100644
--- a/packages/interfold-dashboard/src/lib/chain.ts
+++ b/packages/interfold-dashboard/src/lib/chain.ts
@@ -143,3 +143,8 @@ export const faucetAbi = Faucet__factory.abi
 export const ownerIdentityRegistryAbi = IOwnerIdentityRegistry__factory.abi
 export const zkPassportIdentityVerifierAbi = ZKPassportIdentityVerifier__factory.abi
 export const zkPassportRootVerifierAbi = IZKPassportVerifier__factory.abi
+// `register` also reverts with the verifier's errors, so the call's ABI lists them to decode them.
+export const identityRegisterAbi = [
+  ...ownerIdentityRegistryAbi,
+  ...zkPassportIdentityVerifierAbi.filter((item) => item.type === 'error'),
+] as const
diff --git a/packages/interfold-dashboard/src/lib/identity.test.ts b/packages/interfold-dashboard/src/lib/identity.test.ts
index 8bfe4438c9..b4683a529a 100644
--- a/packages/interfold-dashboard/src/lib/identity.test.ts
+++ b/packages/interfold-dashboard/src/lib/identity.test.ts
@@ -18,7 +18,7 @@ import {
   type Hex,
 } from 'viem'
 import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk'
-import { bondingRegistryAbi, ownerIdentityRegistryAbi, zkPassportRootVerifierAbi } from './chain'
+import { bondingRegistryAbi, identityRegisterAbi, ownerIdentityRegistryAbi, zkPassportRootVerifierAbi } from './chain'
 import {
   CAPACITY_WINDOW,
   boundChainName,
@@ -34,6 +34,7 @@ import {
   safeRegistrationBatch,
   type ProofResult,
   IDENTITY_STORAGE_SLOT,
+  proofBinding,
   readIdentityPolicy,
 } from './identity'
 
@@ -196,3 +197,18 @@ test('the policy comes from the bonding registry storage', async () => {
   assert.equal(await readIdentityPolicy(slots(3n, 3n, 0n)), null)
   assert.equal(await readIdentityPolicy(async () => 0n), null)
 })
+
+test('the binding check reads the owner and chain from the proof', () => {
+  const proofs = [
+    { name: 'compare_expiry_evm', committedInputs: { compare_expiry_evm: { minDateTimestamp: 1, maxDateTimestamp: 0 } } },
+    { name: 'outer_evm_count_6', proof: '0x02', committedInputs: { bind_evm: { data: { user_address: OWNER, chain: 'ethereum' } } } },
+  ] as unknown as ProofResult[]
+  assert.deepEqual(proofBinding(proofs), { owner: OWNER, chain: 'ethereum' })
+  assert.equal(proofBinding(proofs.slice(0, 1)), null)
+})
+
+test('a registration that the verifier rejects shows the error name', () => {
+  const errors = identityRegisterAbi.filter((item) => item.type === 'error').map((item) => item.name)
+  assert.ok(errors.includes('WrongBinding'))
+  assert.ok(errors.includes('IdentityInUse'))
+})
diff --git a/packages/interfold-dashboard/src/lib/identity.ts b/packages/interfold-dashboard/src/lib/identity.ts
index fc19989240..481ac43ff2 100644
--- a/packages/interfold-dashboard/src/lib/identity.ts
+++ b/packages/interfold-dashboard/src/lib/identity.ts
@@ -12,7 +12,19 @@
 // deployment. Before a deployment, the page can still make a proof with the planned settings
 // (PREVIEW_SERVICE) and offer it as a download.
 
-import { encodeAbiParameters, encodeFunctionData, getAbiItem, getAddress, keccak256, toHex, type Address, type Hex } from 'viem'
+import {
+  BaseError,
+  ContractFunctionRevertedError,
+  ContractFunctionZeroDataError,
+  encodeAbiParameters,
+  encodeFunctionData,
+  getAbiItem,
+  getAddress,
+  keccak256,
+  toHex,
+  type Address,
+  type Hex,
+} from 'viem'
 import type { RequestSuccess, SolidityVerifierParameters } from '@zkpassport/sdk'
 import {
   CONTRACTS,
@@ -111,7 +123,18 @@ export function fetchIdentityPolicy(): Promise<IdentityPolicy | null> {
   )
 }
 
-/** The verifier settings, or null while the registry has no verifier (registration is closed). */
+/** Whether `error` is a contract call that reverted or returned no data, not a network failure. */
+export function isContractRevert(error: unknown): boolean {
+  return (
+    error instanceof BaseError &&
+    error.walk((cause) => cause instanceof ContractFunctionRevertedError || cause instanceof ContractFunctionZeroDataError) !== null
+  )
+}
+
+/**
+ * The verifier settings, or null while this page cannot register: the registry has no verifier, or
+ * its verifier is not a ZKPassport verifier.
+ */
 export async function fetchVerifierConfig(registry: Address): Promise<VerifierConfig | null> {
   const address = (await (publicClient.readContract as any)({
     address: registry,
@@ -120,16 +143,24 @@ export async function fetchVerifierConfig(registry: Address): Promise<VerifierCo
   })) as Address
   if (address === ZERO_ADDRESS) return null
   const read = (functionName: string) => (publicClient.readContract as any)({ address, abi: zkPassportIdentityVerifierAbi, functionName })
-  const [domain, scope, version, nullifierType, oprfKeyHash, faceMatchRequired, proofValidity, maxValidity] = await Promise.all([
-    read('domain'),
-    read('scope'),
-    read('VERSION'),
-    read('NULLIFIER_TYPE'),
-    read('OPRF_KEY_HASH'),
-    read('FACE_MATCH_REQUIRED'),
-    read('PROOF_VALIDITY'),
-    read('MAX_VALIDITY'),
-  ])
+  let settings
+  try {
+    settings = await Promise.all([
+      read('domain'),
+      read('scope'),
+      read('VERSION'),
+      read('NULLIFIER_TYPE'),
+      read('OPRF_KEY_HASH'),
+      read('FACE_MATCH_REQUIRED'),
+      read('PROOF_VALIDITY'),
+      read('MAX_VALIDITY'),
+    ])
+  } catch (error) {
+    // Another kind of verifier has none of these reads.
+    if (isContractRevert(error)) return null
+    throw error
+  }
+  const [domain, scope, version, nullifierType, oprfKeyHash, faceMatchRequired, proofValidity, maxValidity] = settings
   return {
     address,
     domain,
@@ -193,6 +224,18 @@ export function boundChainName(chainId: number): 'ethereum' | 'ethereum_sepolia'
   return null
 }
 
+/** The owner and chain that the proof binds, from its `bind_evm` committed inputs. */
+export function proofBinding(proofs: readonly ProofResult[]): { owner: string; chain: string } | null {
+  for (const proof of proofs) {
+    const data = (proof.committedInputs as { bind_evm?: { data?: { user_address?: unknown; chain?: unknown } } } | undefined)?.bind_evm
+      ?.data
+    if (typeof data?.user_address === 'string' && typeof data.chain === 'string') {
+      return { owner: data.user_address, chain: data.chain }
+    }
+  }
+  return null
+}
+
 /** The outer EVM proof: the one proof that the verifier checks. */
 export function outerEvmProof(proofs: readonly ProofResult[]): ProofResult | null {
   return proofs.find((proof) => proof.name?.startsWith('outer_evm')) ?? null

From f4fc3e18b67be3b7b5ba8da7601d5899c8ae1eb2 Mon Sep 17 00:00:00 2001
From: Hamza Khalid <hamzakhalid829@gmail.com>
Date: Tue, 3 Nov 2026 17:31:57 +0500
Subject: [PATCH 11/11] docs(dashboard): say where the panel reads the identity
 policy

The walkthrough still said the panel reads the latest IdentityPolicyUpdated log. It reads the bonding registry's storage.
---
 packages/interfold-dashboard/README.md | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/packages/interfold-dashboard/README.md b/packages/interfold-dashboard/README.md
index afb37dc406..ee6f00e26b 100644
--- a/packages/interfold-dashboard/README.md
+++ b/packages/interfold-dashboard/README.md
@@ -95,10 +95,9 @@ earlier refund manager recorded are not listed. The amounts use the `FEE_TOKEN_*
 can require each bond owner to prove one identity document with ZKPassport (`OwnerIdentityRegistry`
 and `ZKPassportIdentityVerifier`). The page:
 
-1. Reads the policy from the latest `IdentityPolicyUpdated` log of the bonding registry (it has no
-   view). Then it reads the verifier's fixed settings (domain, scope, ZKPassport version, identifier
-   type, FaceMatch, proof validity, maximum validity) and the owner's credential (`identityOf`,
-   `isVerifiedAt`).
+1. Reads the policy from the bonding registry's storage (it has no view). Then it reads the
+   verifier's fixed settings (domain, scope, ZKPassport version, identifier type, FaceMatch, proof
+   validity, maximum validity) and the owner's credential (`identityOf`, `isVerifiedAt`).
 2. Creates a ZKPassport request with `@zkpassport/sdk` in `compressed-evm` mode. The document must
    be valid until a chosen date, and the proof binds the bond owner and the chain. The SDK and the
    QR code load only when the owner asks for a proof.