@zkproofport-app/sdk 0.3.3 → 0.4.0

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/@zkproofport-app/sdk)](https://www.npmjs.com/package/@zkproofport-app/sdk)
 [![license](https://img.shields.io/npm/l/@zkproofport-app/sdk)](./LICENSE)
 
-TypeScript SDK for requesting zero-knowledge proofs from the [ZKProofport](https://zkproofport.com) mobile app and verifying them on-chain. Three circuits are officially supported today — Coinbase KYC, Coinbase country attestation, and OIDC email-domain attestation (Google, Microsoft 365). Two more prove today against testnet deployments and are marked experimental: Arc eligibility and GIWA attestation. The three Korean mobile ID (mDL) identifiers are reserved and planned. [Circuit Identifiers](#circuit-identifiers) has the full list and what each status means.
+TypeScript SDK for requesting zero-knowledge proofs from the [ZKProofport](https://zkproofport.com) mobile app and verifying them on-chain. Three circuits are officially supported today — Coinbase KYC, Coinbase country attestation, and OIDC email-domain attestation (Google, Microsoft 365). One more proves today against a testnet deployment and is marked experimental: GIWA attestation. The three Korean mobile ID (mDL) identifiers are reserved and planned. [Circuit Identifiers](#circuit-identifiers) has the full list and what each status means.
 
 ## How It Works
 
@@ -124,7 +124,6 @@ import { CIRCUIT_IDS, CIRCUIT_SUPPORT_STATUS } from '@zkproofport-app/sdk/circui
 | `CIRCUIT_IDS.COINBASE_ATTESTATION` | `coinbase_attestation` | **Supported** |
 | `CIRCUIT_IDS.COINBASE_COUNTRY_ATTESTATION` | `coinbase_country_attestation` | **Supported** |
 | `CIRCUIT_IDS.OIDC_DOMAIN_ATTESTATION` | `oidc_domain_attestation` | **Supported** |
-| `CIRCUIT_IDS.ARC_ELIGIBILITY` | `arc_eligibility` | _Experimental_ |
 | `CIRCUIT_IDS.GIWA_ATTESTATION` | `giwa_attestation` | _Experimental_ |
 | `CIRCUIT_IDS.MDL_KR_OWNERSHIP` | `mdl_kr_ownership` | Planned |
 | `CIRCUIT_IDS.MDL_KR_AGE` | `mdl_kr_age` | Planned |
@@ -142,11 +141,11 @@ Every ID appears in `CircuitType` and in `sdk.getSupportedCircuits()`, planned o
 import { CIRCUIT_SUPPORT_STATUS, isSupportedCircuitId } from '@zkproofport-app/sdk';
 
 CIRCUIT_SUPPORT_STATUS.coinbase_attestation; // 'supported'
-CIRCUIT_SUPPORT_STATUS.arc_eligibility;      // 'experimental'
+CIRCUIT_SUPPORT_STATUS.giwa_attestation;     // 'experimental'
 CIRCUIT_SUPPORT_STATUS.mdl_kr_age;           // 'planned'
 
 isSupportedCircuitId('oidc_domain_attestation'); // true
-isSupportedCircuitId('arc_eligibility');         // false — experimental is not supported
+isSupportedCircuitId('giwa_attestation');        // false — experimental is not supported
 isSupportedCircuitId('mdl_kr_age');              // false
 isSupportedCircuitId('coinbase-kyc');            // false — not an ID at all
 ```
@@ -251,75 +250,6 @@ const relay = await sdk.createRelayRequest('oidc_domain_attestation', {
 
 ## Experimental Circuits
 
-### `arc_eligibility`
-
-Proves the same Coinbase attestation as `coinbase_attestation`, with one thing
-changed: the wallet signs a named EIP-712 action instead of an opaque signal
-hash. The proof's public inputs then carry the action's domain separator and
-struct hash, so a verifier checks **which** action was authorised — not merely
-that somebody eligible signed something.
-
-That matters once an agent moves money. `personal_sign` over 32 opaque bytes
-shows a person a hex string, so they approve without seeing what they approve;
-a typed action is rendered field by field in the wallet.
-
-```typescript
-import { CIRCUIT_IDS, validateTypedAction } from '@zkproofport-app/sdk';
-
-const action = {
-  domain: {
-    name: 'MyVault',
-    version: '1',
-    chainId: 5042002,                 // Arc Testnet
-    verifyingContract: '0xYourContract',
-  },
-  types: {
-    Deposit: [
-      { name: 'amount', type: 'uint256' },
-      { name: 'nonce', type: 'uint256' },
-    ],
-  },
-  primaryType: 'Deposit',
-  message: { amount: '1000000', nonce: '1' },
-};
-
-// Optional: catch a malformed action before sending it. The circuit hashes the
-// action without reading it, so a broken one produces a valid proof of the
-// wrong thing rather than failing.
-const problem = validateTypedAction(action);
-if (problem) throw new Error(problem);
-
-const relay = await sdk.createRelayRequest(CIRCUIT_IDS.ARC_ELIGIBILITY, {
-  scope: 'myapp.com',
-  action,
-});
-```
-
-`action` is optional, as of 2026-09-22. Send one and the wallet signs the
-typed data; send none and it personal_signs the request's signal hash, exactly
-as Coinbase KYC does. The circuit branches, and it refuses a request that
-tries to be both: with an action `signal_hash` must be empty, without one the
-EIP-712 pair must be.
-
-It used to be required, and not by choice: the circuit had no second path, so
-a request without an action produced a proof attempt that failed inside the
-prover. `CIRCUIT_ACTION_BINDING` now reports `'optional'` for it.
-
-One more thing worth knowing if you count people: its nullifier is
-`keccak(keccak(wallet ++ keccak("arc_eligibility")) ++ scope)` -- the wallet
-and a constant compiled into the circuit. It used to come from `signal_hash`,
-which nothing constrains and, in action mode, nobody signs.
-
-**Testnet only.** The verifier is deployed on Arc Testnet (chain `5042002`) and
-nowhere else. Circle has not published a mainnet chain id, so there is nothing
-to point a production build at. The mobile app keeps the whole Arc network
-behind Developer Mode for the same reason.
-
-The public inputs are `signal_hash`, `domain_separator`, `action_hash`,
-`signer_list_merkle_root`, `scope`, `nullifier` — a different order from every
-other circuit, which is why `extractScopeFromPublicInputs` and
-`extractNullifierFromPublicInputs` require the circuit id and refuse to guess.
-
 ### `giwa_attestation`
 
 The same attestation shape as Coinbase KYC, against GIWA's attester on GIWA
@@ -333,7 +263,7 @@ const { deepLink } = await sdk.createRelayRequest(
 );
 ```
 
-**An action is optional here, as it is for Arc.** Send one
+**An action is optional here.** Send one
 and the wallet signs EIP-712 typed data, so the person reads named fields and
 the proof carries what they approved. Send none and the wallet signs the
 request's signal hash, exactly as Coinbase KYC does. The circuit itself
@@ -357,8 +287,7 @@ await sdk.createRelayRequest(
 ```
 
 Its public inputs are `signal_hash`, `domain_separator`, `action_hash`,
-`signer_list_merkle_root`, `scope`, `nullifier` — the same order as Arc, and
-64 bytes longer than the Coinbase layout it used to share. Anything holding the
+`signer_list_merkle_root`, `scope`, `nullifier` — 64 bytes longer than the Coinbase layout it used to share. Anything holding the
 old offsets reads the Merkle root where the nullifier is.
 
 One more difference worth knowing if you count people: its nullifier is
@@ -377,13 +306,12 @@ circuit names are special:
 
 | What the circuit does with an action | Circuits |
 |---|---|
-| Signs it when present, signs the signal hash when not | `arc_eligibility`, `giwa_attestation` |
+| Signs it when present, signs the signal hash when not | `giwa_attestation` |
 | Has no action inputs — sending one is refused, not ignored | Coinbase KYC, Coinbase country, OIDC domain, the three mDL circuits |
 
 ```typescript
 import { circuitActionBinding } from '@zkproofport-app/sdk';
 
-circuitActionBinding('arc_eligibility');   // 'optional'
 circuitActionBinding('giwa_attestation');  // 'optional'
 circuitActionBinding('coinbase_attestation'); // 'none'
 ```
@@ -1097,8 +1025,8 @@ import type {
 
 | Type | Description |
 |------|-------------|
-| `CircuitId` | Union of the eight canonical circuit IDs — `'coinbase_attestation' \| 'coinbase_country_attestation' \| 'oidc_domain_attestation' \| 'arc_eligibility' \| 'giwa_attestation' \| 'mdl_kr_ownership' \| 'mdl_kr_age' \| 'mdl_kr_region'`. Also exported from `@zkproofport-app/sdk/circuits` |
-| `TypedAction` | The EIP-712 action an `arc_eligibility` proof binds to: `{ domain, types, primaryType, message }` — the same object `eth_signTypedData_v4` takes |
+| `CircuitId` | Union of the seven canonical circuit IDs — `'coinbase_attestation' \| 'coinbase_country_attestation' \| 'oidc_domain_attestation' \| 'giwa_attestation' \| 'mdl_kr_ownership' \| 'mdl_kr_age' \| 'mdl_kr_region'`. Also exported from `@zkproofport-app/sdk/circuits` |
+| `TypedAction` | The EIP-712 action a `giwa_attestation` proof binds to: `{ domain, types, primaryType, message }` — the same object `eth_signTypedData_v4` takes |
 | `CircuitSupportStatus` | `'supported' \| 'planned'` — see [Circuit Identifiers](#circuit-identifiers) |
 | `CircuitType` | Alias of `CircuitId`. Kept as the name used throughout `ProofRequest`, `ProofResponse` and the SDK methods |
 | `ProofRequestStatus` | `'pending' \| 'completed' \| 'error' \| 'cancelled'` — the status on a `ProofResponse` |
@@ -1106,8 +1034,7 @@ import type {
 | `CoinbaseCountryInputs` | Inputs for `coinbase_country_attestation`: `{ scope, countryList, isIncluded, userAddress?, rawTransaction? }` |
 | `OidcDomainInputs` | Inputs for `oidc_domain_attestation`: `{ domain, scope, provider? }` |
 | `MdlKrOwnershipInputs` | Inputs for `mdl_kr_ownership`: `{ scope, discloseFlags? }` |
-| `ActionBoundInputs` | Inputs for the circuits that can bind an EIP-712 action: `{ scope, action?, userAddress?, rawTransaction? }`. Whether the action is required is the circuit's property, in `CIRCUIT_ACTION_BINDING` — required for `arc_eligibility`, optional for `giwa_attestation` |
-| `ArcEligibilityInputs` | Deprecated alias of `ActionBoundInputs`. It declared `action` as required, which was true of the circuit and not of the shape |
+| `ActionBoundInputs` | Inputs for the circuits that can bind an EIP-712 action: `{ scope, action?, userAddress?, rawTransaction? }`. Whether the action is required is the circuit's property, in `CIRCUIT_ACTION_BINDING` — optional for `giwa_attestation` |
 | `GiwaAttestationInputs` | Alias of `ActionBoundInputs`, for `giwa_attestation` |
 | `MdlKrAgeInputs` | Inputs for `mdl_kr_age`: `{ scope, ageThreshold }` |
 | `MdlKrRegionInputs` | Inputs for `mdl_kr_region`: `{ scope, targetRegion }` |

package/dist/circuits.d.ts

@@ -53,8 +53,6 @@ export declare const CIRCUIT_IDS: Readonly<{
     readonly COINBASE_COUNTRY_ATTESTATION: "coinbase_country_attestation";
     /** OIDC email-domain attestation. Officially supported. */
     readonly OIDC_DOMAIN_ATTESTATION: "oidc_domain_attestation";
-    /** Arc eligibility: exact EIP-712 action authorization. Experimental on Arc Testnet. */
-    readonly ARC_ELIGIBILITY: "arc_eligibility";
     /** GIWA attestation. Planned — not officially supported yet. */
     readonly GIWA_ATTESTATION: "giwa_attestation";
     /** Korea Mobile ID ownership. Planned — not officially supported yet. */
@@ -131,12 +129,11 @@ export declare const SUPPORTED_CIRCUIT_IDS: readonly CircuitId[];
 /**
  * Circuits you can prove today, on a testnet, with everything subject to change.
  *
- * `arc_eligibility` is the reason this status exists. Calling it `planned`
- * would be wrong — the circuit compiles, the verifier is deployed and a proof
- * verifies against it — and calling it `supported` would be worse, because the
- * only deployment is Arc Testnet, Circle has not published a mainnet chain id,
- * and the public-input layout is still open. Neither existing word was true, so
- * the honest move was a third word rather than picking the closer lie.
+ * `giwa_attestation` is in this state. Calling it `planned` would be wrong —
+ * the circuit compiles, the verifier is deployed and a proof verifies against
+ * it — and calling it `supported` would be worse, because the only deployment
+ * is a testnet (GIWA Sepolia). Neither existing word was true, so the honest
+ * move was a third word rather than picking the closer lie.
  */
 export declare const EXPERIMENTAL_CIRCUIT_IDS: readonly CircuitId[];
 export declare const PLANNED_CIRCUIT_IDS: readonly CircuitId[];
@@ -193,7 +190,7 @@ export declare function getCircuitSupportStatus(circuit: CircuitId): CircuitSupp
  *
  * ONE TABLE, because the answer was becoming a chain of `circuit === '...'`
  * tests. It was asked in the deep-link validator and again in
- * `createRelayRequest`, both spelling out `arc_eligibility`, and a second
+ * `createRelayRequest`, both spelling out one circuit id, and a second
  * action-capable circuit would have made each of them a two-branch chain that
  * ends on whatever the last test happens to be.
  *
@@ -212,7 +209,6 @@ export declare const CIRCUIT_ACTION_BINDING: {
     coinbase_attestation: "none";
     coinbase_country_attestation: "none";
     oidc_domain_attestation: "none";
-    arc_eligibility: "optional";
     giwa_attestation: "optional";
     mdl_kr_ownership: "none";
     mdl_kr_age: "none";
@@ -228,7 +224,6 @@ export declare function circuitActionBinding(circuit: string): CircuitActionBind
 export declare const CIRCUIT_NEEDS_WALLET_SIGNATURE: {
     coinbase_attestation: true;
     coinbase_country_attestation: true;
-    arc_eligibility: true;
     oidc_domain_attestation: false;
     mdl_kr_ownership: false;
     mdl_kr_age: false;

package/dist/circuits.esm.js

@@ -44,8 +44,6 @@ const CIRCUIT_IDS = Object.freeze({
     COINBASE_COUNTRY_ATTESTATION: 'coinbase_country_attestation',
     /** OIDC email-domain attestation. Officially supported. */
     OIDC_DOMAIN_ATTESTATION: 'oidc_domain_attestation',
-    /** Arc eligibility: exact EIP-712 action authorization. Experimental on Arc Testnet. */
-    ARC_ELIGIBILITY: 'arc_eligibility',
     /** GIWA attestation. Planned — not officially supported yet. */
     GIWA_ATTESTATION: 'giwa_attestation',
     /** Korea Mobile ID ownership. Planned — not officially supported yet. */
@@ -74,7 +72,6 @@ const CIRCUIT_SUPPORT_STATUS = Object.freeze({
     coinbase_attestation: 'supported',
     coinbase_country_attestation: 'supported',
     oidc_domain_attestation: 'supported',
-    arc_eligibility: 'experimental',
     // Experimental, not planned: the circuit is built, its verifier is
     // deployed on GIWA Sepolia and the demo requests it. What keeps it out of
     // 'supported' is that it is testnet-only, so the app offers it behind
@@ -108,7 +105,6 @@ const CIRCUIT_VK_PATHS = Object.freeze({
     coinbase_attestation: 'coinbase-attestation/target/vk/vk',
     coinbase_country_attestation: 'coinbase-country-attestation/target/vk/vk',
     oidc_domain_attestation: 'oidc-domain-attestation/target/vk/vk',
-    arc_eligibility: 'arc-eligibility/target/vk/vk',
     giwa_attestation: 'giwa-attestation/target/vk/vk',
     mdl_kr_ownership: 'mdl/kr-ownership/target/vk/vk',
     mdl_kr_age: 'mdl/kr-age/target/vk/vk',
@@ -137,12 +133,11 @@ const SUPPORTED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCU
 /**
  * Circuits you can prove today, on a testnet, with everything subject to change.
  *
- * `arc_eligibility` is the reason this status exists. Calling it `planned`
- * would be wrong — the circuit compiles, the verifier is deployed and a proof
- * verifies against it — and calling it `supported` would be worse, because the
- * only deployment is Arc Testnet, Circle has not published a mainnet chain id,
- * and the public-input layout is still open. Neither existing word was true, so
- * the honest move was a third word rather than picking the closer lie.
+ * `giwa_attestation` is in this state. Calling it `planned` would be wrong —
+ * the circuit compiles, the verifier is deployed and a proof verifies against
+ * it — and calling it `supported` would be worse, because the only deployment
+ * is a testnet (GIWA Sepolia). Neither existing word was true, so the honest
+ * move was a third word rather than picking the closer lie.
  */
 const EXPERIMENTAL_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter(id => CIRCUIT_SUPPORT_STATUS[id] === 'experimental'));
 const PLANNED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'planned'));
@@ -196,12 +191,8 @@ const CIRCUIT_ACTION_BINDING = {
     coinbase_country_attestation: 'none',
     // The signature lives inside the identity token; no wallet, no action.
     oidc_domain_attestation: 'none',
-    // Both branch in-circuit: with an action the wallet signs the typed data,
-    // without one it personal_signs the request's signal hash. Arc read
-    // 'required' until 2026-09-22 because its circuit had no second path -- a
-    // request without an action built a vector 64 bytes short and died inside
-    // the prover. The circuit gained the branch; the table follows it.
-    arc_eligibility: 'optional',
+    // Branches in-circuit: with an action the wallet signs the typed data,
+    // without one it personal_signs the request's signal hash.
     giwa_attestation: 'optional',
     mdl_kr_ownership: 'none',
     mdl_kr_age: 'none',
@@ -232,16 +223,13 @@ function circuitActionBinding(circuit) {
 const CIRCUIT_NEEDS_WALLET_SIGNATURE = {
     coinbase_attestation: true,
     coinbase_country_attestation: true,
-    // Same Coinbase-attested wallet as above; what changes is that it signs an
-    // EIP-712 action rather than signal_hash.
-    arc_eligibility: true,
     // The signature is inside the OIDC identity token, checked by the prover.
     oidc_domain_attestation: false,
     // Web2 (OmniOne CX) flows with no wallet binding at all.
     mdl_kr_ownership: false,
     mdl_kr_age: false,
     mdl_kr_region: false,
-    // A GIWA-attested wallet signing an EIP-712 action, the same shape as Arc.
+    // A GIWA-attested wallet signing an EIP-712 action (or its signal hash).
     // This read `false` while the circuit had always verified a wallet signature
     // -- it sat under the Web2 comment above and was never revisited. A request
     // for it would have reached the relay with no signer.

package/dist/circuits.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"circuits.esm.js","sources":["../src/circuits.ts"],"sourcesContent":["/**\n * Canonical ZKProofport circuit identifiers.\n *\n * This module is the single source of truth for circuit IDs. Every other layer\n * — the mobile app, the demo, the relay, server-side provers — reads its list\n * from here instead of keeping a private copy that silently drifts.\n *\n * It has **no imports and no dependencies**, so it can be pulled in on its own:\n *\n * ```typescript\n * import { CIRCUIT_IDS, isCircuitId } from '@zkproofport-app/sdk/circuits';\n * ```\n *\n * The same names are also re-exported from the package root\n * (`@zkproofport-app/sdk`) for callers that already import the SDK.\n *\n * ## Identifiers are canonical and case-sensitive\n *\n * Each ID is the circuit's `name` in its `Nargo.toml`, verbatim. The format is\n * lowercase with underscores. Hyphenated spellings (`coinbase-kyc`,\n * `mdl-kr-age`) are directory or UI route names in other repositories — they\n * are **not** circuit IDs, and passing one produces a nullifier mismatch or a\n * failed on-chain lookup rather than a clear error.\n */\n\n/**\n * Whether a circuit is officially supported today or still on the roadmap.\n *\n * - `supported` — generally available. Safe to build a product on.\n * - `planned` — the identifier is reserved and the circuit exists, but it is\n *   not officially supported yet. Availability, inputs and public-input layout\n *   may change without a major version bump.\n */\nexport type CircuitSupportStatus = 'supported' | 'experimental' | 'planned';\n\n/**\n * Canonical circuit identifiers, keyed by a stable constant name.\n *\n * Prefer these constants over string literals so a rename is a compile error\n * rather than a runtime surprise.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_IDS } from '@zkproofport-app/sdk/circuits';\n *\n * const relay = await sdk.createRelayRequest(CIRCUIT_IDS.COINBASE_ATTESTATION, {\n *   scope: 'myapp.com',\n * });\n * ```\n */\nexport const CIRCUIT_IDS = Object.freeze({\n  /** Coinbase KYC attestation. Officially supported. */\n  COINBASE_ATTESTATION: 'coinbase_attestation',\n  /** Coinbase country attestation (inclusion / exclusion). Officially supported. */\n  COINBASE_COUNTRY_ATTESTATION: 'coinbase_country_attestation',\n  /** OIDC email-domain attestation. Officially supported. */\n  OIDC_DOMAIN_ATTESTATION: 'oidc_domain_attestation',\n  /** Arc eligibility: exact EIP-712 action authorization. Experimental on Arc Testnet. */\n  ARC_ELIGIBILITY: 'arc_eligibility',\n  /** GIWA attestation. Planned — not officially supported yet. */\n  GIWA_ATTESTATION: 'giwa_attestation',\n  /** Korea Mobile ID ownership. Planned — not officially supported yet. */\n  MDL_KR_OWNERSHIP: 'mdl_kr_ownership',\n  /** Korea Mobile ID age threshold. Planned — not officially supported yet. */\n  MDL_KR_AGE: 'mdl_kr_age',\n  /** Korea Mobile ID si/do region. Planned — not officially supported yet. */\n  MDL_KR_REGION: 'mdl_kr_region',\n} as const);\n\n/**\n * Union of every canonical circuit identifier.\n *\n * `CircuitType` (exported from the package root) is an alias of this type — the\n * two names refer to the same union, and this module is where it is defined.\n */\nexport type CircuitId = (typeof CIRCUIT_IDS)[keyof typeof CIRCUIT_IDS];\n\n/**\n * Support status for every circuit.\n *\n * The record is exhaustive over {@link CircuitId}: adding an identifier without\n * giving it a status is a compile error, so this list cannot drift from\n * {@link CIRCUIT_IDS}.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_SUPPORT_STATUS } from '@zkproofport-app/sdk/circuits';\n *\n * CIRCUIT_SUPPORT_STATUS.coinbase_attestation; // 'supported'\n * CIRCUIT_SUPPORT_STATUS.mdl_kr_age;           // 'planned'\n * ```\n */\nexport const CIRCUIT_SUPPORT_STATUS: Readonly<Record<CircuitId, CircuitSupportStatus>> =\n  Object.freeze({\n    coinbase_attestation: 'supported',\n    coinbase_country_attestation: 'supported',\n    oidc_domain_attestation: 'supported',\n    arc_eligibility: 'experimental',\n    // Experimental, not planned: the circuit is built, its verifier is\n    // deployed on GIWA Sepolia and the demo requests it. What keeps it out of\n    // 'supported' is that it is testnet-only, so the app offers it behind\n    // Developer Mode and reads its files from main rather than a release tag.\n    giwa_attestation: 'experimental',\n    mdl_kr_ownership: 'planned',\n    mdl_kr_age: 'planned',\n    mdl_kr_region: 'planned',\n  } as const);\n\n/**\n * Where each circuit's verification key FILE lives inside the\n * `zkproofport/circuits` repository, relative to its root.\n *\n * Off-chain verification needs the verification key and nothing else — no\n * circuit bytecode, no witness. The key is public by nature: it is what anyone\n * checking a proof must already have, and the Solidity verifiers deployed\n * on-chain embed the same key.\n *\n * NOTE THE TRAILING `/vk` TWICE. In that repository `target/vk` is a DIRECTORY\n * holding `vk`, `vk_hash` and `SHA256SUMS`; the key itself is `target/vk/vk`.\n * These paths were first copied here from the mobile app, which keeps the\n * directory and the filename as two fields and joins them — so taking only the\n * directory produced a URL that answers 404, and the first browser to try\n * off-chain verification said \"Could not fetch the verification key (HTTP 404)\".\n *\n * Exhaustive over {@link CircuitId} on purpose. A new circuit whose key path is\n * not listed here fails to compile rather than failing at verification time,\n * where the only symptom would be a proof that cannot be checked.\n */\nexport const CIRCUIT_VK_PATHS: Readonly<Record<CircuitId, string>> = Object.freeze({\n  coinbase_attestation: 'coinbase-attestation/target/vk/vk',\n  coinbase_country_attestation: 'coinbase-country-attestation/target/vk/vk',\n  oidc_domain_attestation: 'oidc-domain-attestation/target/vk/vk',\n  arc_eligibility: 'arc-eligibility/target/vk/vk',\n  giwa_attestation: 'giwa-attestation/target/vk/vk',\n  mdl_kr_ownership: 'mdl/kr-ownership/target/vk/vk',\n  mdl_kr_age: 'mdl/kr-age/target/vk/vk',\n  mdl_kr_region: 'mdl/kr-region/target/vk/vk',\n} as const);\n\n/**\n * Every canonical circuit identifier, in declaration order.\n *\n * Includes circuits that are still `planned`. Use {@link SUPPORTED_CIRCUIT_IDS}\n * when you only want the ones that are officially supported today.\n */\nexport const ALL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  Object.values(CIRCUIT_IDS) as CircuitId[]\n);\n\n/**\n * Circuits that are officially supported today: the two Coinbase circuits and\n * OIDC domain attestation.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\nexport const SUPPORTED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'supported')\n);\n\n/**\n * Circuits whose identifiers are reserved but which are not officially\n * supported yet: GIWA attestation and the three Korea Mobile ID circuits.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\n/**\n * Circuits you can prove today, on a testnet, with everything subject to change.\n *\n * `arc_eligibility` is the reason this status exists. Calling it `planned`\n * would be wrong — the circuit compiles, the verifier is deployed and a proof\n * verifies against it — and calling it `supported` would be worse, because the\n * only deployment is Arc Testnet, Circle has not published a mainnet chain id,\n * and the public-input layout is still open. Neither existing word was true, so\n * the honest move was a third word rather than picking the closer lie.\n */\nexport const EXPERIMENTAL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter(id => CIRCUIT_SUPPORT_STATUS[id] === 'experimental'),\n);\n\nexport const PLANNED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'planned')\n);\n\n/**\n * Narrows an unknown value to a canonical circuit identifier.\n *\n * Returns `false` for hyphenated route names such as `'coinbase-kyc'`, which\n * are not circuit IDs.\n *\n * @example\n * ```typescript\n * isCircuitId('coinbase_attestation'); // true\n * isCircuitId('coinbase-kyc');         // false\n * ```\n */\nexport function isCircuitId(value: unknown): value is CircuitId {\n  return typeof value === 'string' && (ALL_CIRCUIT_IDS as readonly string[]).includes(value);\n}\n\n/**\n * Narrows an unknown value to a circuit identifier that is officially supported\n * today. Planned circuits return `false`.\n *\n * @example\n * ```typescript\n * isSupportedCircuitId('oidc_domain_attestation'); // true\n * isSupportedCircuitId('mdl_kr_age');              // false — planned\n * ```\n */\nexport function isSupportedCircuitId(value: unknown): value is CircuitId {\n  return isCircuitId(value) && CIRCUIT_SUPPORT_STATUS[value] === 'supported';\n}\n\n/**\n * Returns the support status of a circuit.\n *\n * @param circuit - A canonical circuit identifier.\n * @throws Error when the value is not a canonical circuit identifier.\n *\n * @example\n * ```typescript\n * getCircuitSupportStatus('giwa_attestation'); // 'planned'\n * ```\n */\nexport function getCircuitSupportStatus(circuit: CircuitId): CircuitSupportStatus {\n  if (!isCircuitId(circuit)) {\n    throw new Error(\n      `Unknown circuit '${String(circuit)}'. Expected one of: ${ALL_CIRCUIT_IDS.join(', ')}`\n    );\n  }\n  return CIRCUIT_SUPPORT_STATUS[circuit];\n}\n\n/**\n * Whether a circuit's relay request must carry a wallet signature.\n *\n * The SDK checks this to fail fast — \"Signer not set\" locally beats a 401 from\n * the relay two round trips later, with nothing saying which circuit needed\n * what. The relay declares its OWN copy on purpose and does not import this\n * one: it is a security boundary, and an auth policy that a published package\n * can change is not a policy. A test in the relay asserts the two agree.\n *\n * `satisfies` and not an annotation, so a circuit added above is a compile\n * error here until somebody decides which it is.\n */\n/**\n * Whether a circuit's proof can bind an EIP-712 action, and whether it must.\n *\n * ONE TABLE, because the answer was becoming a chain of `circuit === '...'`\n * tests. It was asked in the deep-link validator and again in\n * `createRelayRequest`, both spelling out `arc_eligibility`, and a second\n * action-capable circuit would have made each of them a two-branch chain that\n * ends on whatever the last test happens to be.\n *\n *   'required'  the circuit proves nothing without an action -- the wallet\n *               signs the typed data and there is no other message.\n *   'optional'  the circuit signs the action when one is supplied and\n *               personal_signs its signal hash when one is not. The circuit\n *               itself branches; see giwa-attestation/src/main.nr.\n *   'none'      the circuit has no action inputs. An action sent anyway is a\n *               caller misunderstanding, and is refused rather than dropped:\n *               silently ignoring it would let a dapp believe a proof\n *               authorized something it never mentioned.\n */\nexport type CircuitActionBinding = 'none' | 'required' | 'optional';\n\nexport const CIRCUIT_ACTION_BINDING = {\n  coinbase_attestation: 'none',\n  coinbase_country_attestation: 'none',\n  // The signature lives inside the identity token; no wallet, no action.\n  oidc_domain_attestation: 'none',\n  // Both branch in-circuit: with an action the wallet signs the typed data,\n  // without one it personal_signs the request's signal hash. Arc read\n  // 'required' until 2026-09-22 because its circuit had no second path -- a\n  // request without an action built a vector 64 bytes short and died inside\n  // the prover. The circuit gained the branch; the table follows it.\n  arc_eligibility: 'optional',\n  giwa_attestation: 'optional',\n  mdl_kr_ownership: 'none',\n  mdl_kr_age: 'none',\n  mdl_kr_region: 'none',\n} satisfies Record<CircuitId, CircuitActionBinding>;\n\n/*\n * The union is declared above rather than derived from the table's values.\n *\n * Deriving it narrowed the type to whatever the table happens to hold today --\n * 'none' | 'optional' -- and TypeScript then called every `=== 'required'`\n * check impossible. The publish typecheck caught it; `rollup` and `vitest` did\n * not. 'required' is a state a circuit can legitimately be in (an EIP-712 path\n * and nothing else), so the union says so and the table is checked against it.\n */\n\n/**\n * How this circuit treats an action, or an error naming the id that is not one.\n *\n * No default: a circuit nobody has classified must not inherit 'none', which\n * would silently drop an action a dapp meant to bind.\n */\nexport function circuitActionBinding(circuit: string): CircuitActionBinding {\n  const binding = (CIRCUIT_ACTION_BINDING as Record<string, CircuitActionBinding | undefined>)[circuit];\n  if (!binding) {\n    throw new Error(\n      `Unknown circuit '${circuit}'. Expected: ${ALL_CIRCUIT_IDS.join(', ')}`,\n    );\n  }\n  return binding;\n}\n\nexport const CIRCUIT_NEEDS_WALLET_SIGNATURE = {\n  coinbase_attestation: true,\n  coinbase_country_attestation: true,\n  // Same Coinbase-attested wallet as above; what changes is that it signs an\n  // EIP-712 action rather than signal_hash.\n  arc_eligibility: true,\n  // The signature is inside the OIDC identity token, checked by the prover.\n  oidc_domain_attestation: false,\n  // Web2 (OmniOne CX) flows with no wallet binding at all.\n  mdl_kr_ownership: false,\n  mdl_kr_age: false,\n  mdl_kr_region: false,\n  // A GIWA-attested wallet signing an EIP-712 action, the same shape as Arc.\n  // This read `false` while the circuit had always verified a wallet signature\n  // -- it sat under the Web2 comment above and was never revisited. A request\n  // for it would have reached the relay with no signer.\n  giwa_attestation: true,\n} satisfies Record<CircuitId, boolean>;\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"circuits.esm.js","sources":["../src/circuits.ts"],"sourcesContent":["/**\n * Canonical ZKProofport circuit identifiers.\n *\n * This module is the single source of truth for circuit IDs. Every other layer\n * — the mobile app, the demo, the relay, server-side provers — reads its list\n * from here instead of keeping a private copy that silently drifts.\n *\n * It has **no imports and no dependencies**, so it can be pulled in on its own:\n *\n * ```typescript\n * import { CIRCUIT_IDS, isCircuitId } from '@zkproofport-app/sdk/circuits';\n * ```\n *\n * The same names are also re-exported from the package root\n * (`@zkproofport-app/sdk`) for callers that already import the SDK.\n *\n * ## Identifiers are canonical and case-sensitive\n *\n * Each ID is the circuit's `name` in its `Nargo.toml`, verbatim. The format is\n * lowercase with underscores. Hyphenated spellings (`coinbase-kyc`,\n * `mdl-kr-age`) are directory or UI route names in other repositories — they\n * are **not** circuit IDs, and passing one produces a nullifier mismatch or a\n * failed on-chain lookup rather than a clear error.\n */\n\n/**\n * Whether a circuit is officially supported today or still on the roadmap.\n *\n * - `supported` — generally available. Safe to build a product on.\n * - `planned` — the identifier is reserved and the circuit exists, but it is\n *   not officially supported yet. Availability, inputs and public-input layout\n *   may change without a major version bump.\n */\nexport type CircuitSupportStatus = 'supported' | 'experimental' | 'planned';\n\n/**\n * Canonical circuit identifiers, keyed by a stable constant name.\n *\n * Prefer these constants over string literals so a rename is a compile error\n * rather than a runtime surprise.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_IDS } from '@zkproofport-app/sdk/circuits';\n *\n * const relay = await sdk.createRelayRequest(CIRCUIT_IDS.COINBASE_ATTESTATION, {\n *   scope: 'myapp.com',\n * });\n * ```\n */\nexport const CIRCUIT_IDS = Object.freeze({\n  /** Coinbase KYC attestation. Officially supported. */\n  COINBASE_ATTESTATION: 'coinbase_attestation',\n  /** Coinbase country attestation (inclusion / exclusion). Officially supported. */\n  COINBASE_COUNTRY_ATTESTATION: 'coinbase_country_attestation',\n  /** OIDC email-domain attestation. Officially supported. */\n  OIDC_DOMAIN_ATTESTATION: 'oidc_domain_attestation',\n  /** GIWA attestation. Planned — not officially supported yet. */\n  GIWA_ATTESTATION: 'giwa_attestation',\n  /** Korea Mobile ID ownership. Planned — not officially supported yet. */\n  MDL_KR_OWNERSHIP: 'mdl_kr_ownership',\n  /** Korea Mobile ID age threshold. Planned — not officially supported yet. */\n  MDL_KR_AGE: 'mdl_kr_age',\n  /** Korea Mobile ID si/do region. Planned — not officially supported yet. */\n  MDL_KR_REGION: 'mdl_kr_region',\n} as const);\n\n/**\n * Union of every canonical circuit identifier.\n *\n * `CircuitType` (exported from the package root) is an alias of this type — the\n * two names refer to the same union, and this module is where it is defined.\n */\nexport type CircuitId = (typeof CIRCUIT_IDS)[keyof typeof CIRCUIT_IDS];\n\n/**\n * Support status for every circuit.\n *\n * The record is exhaustive over {@link CircuitId}: adding an identifier without\n * giving it a status is a compile error, so this list cannot drift from\n * {@link CIRCUIT_IDS}.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_SUPPORT_STATUS } from '@zkproofport-app/sdk/circuits';\n *\n * CIRCUIT_SUPPORT_STATUS.coinbase_attestation; // 'supported'\n * CIRCUIT_SUPPORT_STATUS.mdl_kr_age;           // 'planned'\n * ```\n */\nexport const CIRCUIT_SUPPORT_STATUS: Readonly<Record<CircuitId, CircuitSupportStatus>> =\n  Object.freeze({\n    coinbase_attestation: 'supported',\n    coinbase_country_attestation: 'supported',\n    oidc_domain_attestation: 'supported',\n    // Experimental, not planned: the circuit is built, its verifier is\n    // deployed on GIWA Sepolia and the demo requests it. What keeps it out of\n    // 'supported' is that it is testnet-only, so the app offers it behind\n    // Developer Mode and reads its files from main rather than a release tag.\n    giwa_attestation: 'experimental',\n    mdl_kr_ownership: 'planned',\n    mdl_kr_age: 'planned',\n    mdl_kr_region: 'planned',\n  } as const);\n\n/**\n * Where each circuit's verification key FILE lives inside the\n * `zkproofport/circuits` repository, relative to its root.\n *\n * Off-chain verification needs the verification key and nothing else — no\n * circuit bytecode, no witness. The key is public by nature: it is what anyone\n * checking a proof must already have, and the Solidity verifiers deployed\n * on-chain embed the same key.\n *\n * NOTE THE TRAILING `/vk` TWICE. In that repository `target/vk` is a DIRECTORY\n * holding `vk`, `vk_hash` and `SHA256SUMS`; the key itself is `target/vk/vk`.\n * These paths were first copied here from the mobile app, which keeps the\n * directory and the filename as two fields and joins them — so taking only the\n * directory produced a URL that answers 404, and the first browser to try\n * off-chain verification said \"Could not fetch the verification key (HTTP 404)\".\n *\n * Exhaustive over {@link CircuitId} on purpose. A new circuit whose key path is\n * not listed here fails to compile rather than failing at verification time,\n * where the only symptom would be a proof that cannot be checked.\n */\nexport const CIRCUIT_VK_PATHS: Readonly<Record<CircuitId, string>> = Object.freeze({\n  coinbase_attestation: 'coinbase-attestation/target/vk/vk',\n  coinbase_country_attestation: 'coinbase-country-attestation/target/vk/vk',\n  oidc_domain_attestation: 'oidc-domain-attestation/target/vk/vk',\n  giwa_attestation: 'giwa-attestation/target/vk/vk',\n  mdl_kr_ownership: 'mdl/kr-ownership/target/vk/vk',\n  mdl_kr_age: 'mdl/kr-age/target/vk/vk',\n  mdl_kr_region: 'mdl/kr-region/target/vk/vk',\n} as const);\n\n/**\n * Every canonical circuit identifier, in declaration order.\n *\n * Includes circuits that are still `planned`. Use {@link SUPPORTED_CIRCUIT_IDS}\n * when you only want the ones that are officially supported today.\n */\nexport const ALL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  Object.values(CIRCUIT_IDS) as CircuitId[]\n);\n\n/**\n * Circuits that are officially supported today: the two Coinbase circuits and\n * OIDC domain attestation.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\nexport const SUPPORTED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'supported')\n);\n\n/**\n * Circuits whose identifiers are reserved but which are not officially\n * supported yet: GIWA attestation and the three Korea Mobile ID circuits.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\n/**\n * Circuits you can prove today, on a testnet, with everything subject to change.\n *\n * `giwa_attestation` is in this state. Calling it `planned` would be wrong —\n * the circuit compiles, the verifier is deployed and a proof verifies against\n * it — and calling it `supported` would be worse, because the only deployment\n * is a testnet (GIWA Sepolia). Neither existing word was true, so the honest\n * move was a third word rather than picking the closer lie.\n */\nexport const EXPERIMENTAL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter(id => CIRCUIT_SUPPORT_STATUS[id] === 'experimental'),\n);\n\nexport const PLANNED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'planned')\n);\n\n/**\n * Narrows an unknown value to a canonical circuit identifier.\n *\n * Returns `false` for hyphenated route names such as `'coinbase-kyc'`, which\n * are not circuit IDs.\n *\n * @example\n * ```typescript\n * isCircuitId('coinbase_attestation'); // true\n * isCircuitId('coinbase-kyc');         // false\n * ```\n */\nexport function isCircuitId(value: unknown): value is CircuitId {\n  return typeof value === 'string' && (ALL_CIRCUIT_IDS as readonly string[]).includes(value);\n}\n\n/**\n * Narrows an unknown value to a circuit identifier that is officially supported\n * today. Planned circuits return `false`.\n *\n * @example\n * ```typescript\n * isSupportedCircuitId('oidc_domain_attestation'); // true\n * isSupportedCircuitId('mdl_kr_age');              // false — planned\n * ```\n */\nexport function isSupportedCircuitId(value: unknown): value is CircuitId {\n  return isCircuitId(value) && CIRCUIT_SUPPORT_STATUS[value] === 'supported';\n}\n\n/**\n * Returns the support status of a circuit.\n *\n * @param circuit - A canonical circuit identifier.\n * @throws Error when the value is not a canonical circuit identifier.\n *\n * @example\n * ```typescript\n * getCircuitSupportStatus('giwa_attestation'); // 'planned'\n * ```\n */\nexport function getCircuitSupportStatus(circuit: CircuitId): CircuitSupportStatus {\n  if (!isCircuitId(circuit)) {\n    throw new Error(\n      `Unknown circuit '${String(circuit)}'. Expected one of: ${ALL_CIRCUIT_IDS.join(', ')}`\n    );\n  }\n  return CIRCUIT_SUPPORT_STATUS[circuit];\n}\n\n/**\n * Whether a circuit's relay request must carry a wallet signature.\n *\n * The SDK checks this to fail fast — \"Signer not set\" locally beats a 401 from\n * the relay two round trips later, with nothing saying which circuit needed\n * what. The relay declares its OWN copy on purpose and does not import this\n * one: it is a security boundary, and an auth policy that a published package\n * can change is not a policy. A test in the relay asserts the two agree.\n *\n * `satisfies` and not an annotation, so a circuit added above is a compile\n * error here until somebody decides which it is.\n */\n/**\n * Whether a circuit's proof can bind an EIP-712 action, and whether it must.\n *\n * ONE TABLE, because the answer was becoming a chain of `circuit === '...'`\n * tests. It was asked in the deep-link validator and again in\n * `createRelayRequest`, both spelling out one circuit id, and a second\n * action-capable circuit would have made each of them a two-branch chain that\n * ends on whatever the last test happens to be.\n *\n *   'required'  the circuit proves nothing without an action -- the wallet\n *               signs the typed data and there is no other message.\n *   'optional'  the circuit signs the action when one is supplied and\n *               personal_signs its signal hash when one is not. The circuit\n *               itself branches; see giwa-attestation/src/main.nr.\n *   'none'      the circuit has no action inputs. An action sent anyway is a\n *               caller misunderstanding, and is refused rather than dropped:\n *               silently ignoring it would let a dapp believe a proof\n *               authorized something it never mentioned.\n */\nexport type CircuitActionBinding = 'none' | 'required' | 'optional';\n\nexport const CIRCUIT_ACTION_BINDING = {\n  coinbase_attestation: 'none',\n  coinbase_country_attestation: 'none',\n  // The signature lives inside the identity token; no wallet, no action.\n  oidc_domain_attestation: 'none',\n  // Branches in-circuit: with an action the wallet signs the typed data,\n  // without one it personal_signs the request's signal hash.\n  giwa_attestation: 'optional',\n  mdl_kr_ownership: 'none',\n  mdl_kr_age: 'none',\n  mdl_kr_region: 'none',\n} satisfies Record<CircuitId, CircuitActionBinding>;\n\n/*\n * The union is declared above rather than derived from the table's values.\n *\n * Deriving it narrowed the type to whatever the table happens to hold today --\n * 'none' | 'optional' -- and TypeScript then called every `=== 'required'`\n * check impossible. The publish typecheck caught it; `rollup` and `vitest` did\n * not. 'required' is a state a circuit can legitimately be in (an EIP-712 path\n * and nothing else), so the union says so and the table is checked against it.\n */\n\n/**\n * How this circuit treats an action, or an error naming the id that is not one.\n *\n * No default: a circuit nobody has classified must not inherit 'none', which\n * would silently drop an action a dapp meant to bind.\n */\nexport function circuitActionBinding(circuit: string): CircuitActionBinding {\n  const binding = (CIRCUIT_ACTION_BINDING as Record<string, CircuitActionBinding | undefined>)[circuit];\n  if (!binding) {\n    throw new Error(\n      `Unknown circuit '${circuit}'. Expected: ${ALL_CIRCUIT_IDS.join(', ')}`,\n    );\n  }\n  return binding;\n}\n\nexport const CIRCUIT_NEEDS_WALLET_SIGNATURE = {\n  coinbase_attestation: true,\n  coinbase_country_attestation: true,\n  // The signature is inside the OIDC identity token, checked by the prover.\n  oidc_domain_attestation: false,\n  // Web2 (OmniOne CX) flows with no wallet binding at all.\n  mdl_kr_ownership: false,\n  mdl_kr_age: false,\n  mdl_kr_region: false,\n  // A GIWA-attested wallet signing an EIP-712 action (or its signal hash).\n  // This read `false` while the circuit had always verified a wallet signature\n  // -- it sat under the Web2 comment above and was never revisited. A request\n  // for it would have reached the relay with no signer.\n  giwa_attestation: true,\n} satisfies Record<CircuitId, boolean>;\n"],"names":[],"mappings":"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"}

package/dist/circuits.js

@@ -46,8 +46,6 @@ const CIRCUIT_IDS = Object.freeze({
     COINBASE_COUNTRY_ATTESTATION: 'coinbase_country_attestation',
     /** OIDC email-domain attestation. Officially supported. */
     OIDC_DOMAIN_ATTESTATION: 'oidc_domain_attestation',
-    /** Arc eligibility: exact EIP-712 action authorization. Experimental on Arc Testnet. */
-    ARC_ELIGIBILITY: 'arc_eligibility',
     /** GIWA attestation. Planned — not officially supported yet. */
     GIWA_ATTESTATION: 'giwa_attestation',
     /** Korea Mobile ID ownership. Planned — not officially supported yet. */
@@ -76,7 +74,6 @@ const CIRCUIT_SUPPORT_STATUS = Object.freeze({
     coinbase_attestation: 'supported',
     coinbase_country_attestation: 'supported',
     oidc_domain_attestation: 'supported',
-    arc_eligibility: 'experimental',
     // Experimental, not planned: the circuit is built, its verifier is
     // deployed on GIWA Sepolia and the demo requests it. What keeps it out of
     // 'supported' is that it is testnet-only, so the app offers it behind
@@ -110,7 +107,6 @@ const CIRCUIT_VK_PATHS = Object.freeze({
     coinbase_attestation: 'coinbase-attestation/target/vk/vk',
     coinbase_country_attestation: 'coinbase-country-attestation/target/vk/vk',
     oidc_domain_attestation: 'oidc-domain-attestation/target/vk/vk',
-    arc_eligibility: 'arc-eligibility/target/vk/vk',
     giwa_attestation: 'giwa-attestation/target/vk/vk',
     mdl_kr_ownership: 'mdl/kr-ownership/target/vk/vk',
     mdl_kr_age: 'mdl/kr-age/target/vk/vk',
@@ -139,12 +135,11 @@ const SUPPORTED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCU
 /**
  * Circuits you can prove today, on a testnet, with everything subject to change.
  *
- * `arc_eligibility` is the reason this status exists. Calling it `planned`
- * would be wrong — the circuit compiles, the verifier is deployed and a proof
- * verifies against it — and calling it `supported` would be worse, because the
- * only deployment is Arc Testnet, Circle has not published a mainnet chain id,
- * and the public-input layout is still open. Neither existing word was true, so
- * the honest move was a third word rather than picking the closer lie.
+ * `giwa_attestation` is in this state. Calling it `planned` would be wrong —
+ * the circuit compiles, the verifier is deployed and a proof verifies against
+ * it — and calling it `supported` would be worse, because the only deployment
+ * is a testnet (GIWA Sepolia). Neither existing word was true, so the honest
+ * move was a third word rather than picking the closer lie.
  */
 const EXPERIMENTAL_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter(id => CIRCUIT_SUPPORT_STATUS[id] === 'experimental'));
 const PLANNED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'planned'));
@@ -198,12 +193,8 @@ const CIRCUIT_ACTION_BINDING = {
     coinbase_country_attestation: 'none',
     // The signature lives inside the identity token; no wallet, no action.
     oidc_domain_attestation: 'none',
-    // Both branch in-circuit: with an action the wallet signs the typed data,
-    // without one it personal_signs the request's signal hash. Arc read
-    // 'required' until 2026-09-22 because its circuit had no second path -- a
-    // request without an action built a vector 64 bytes short and died inside
-    // the prover. The circuit gained the branch; the table follows it.
-    arc_eligibility: 'optional',
+    // Branches in-circuit: with an action the wallet signs the typed data,
+    // without one it personal_signs the request's signal hash.
     giwa_attestation: 'optional',
     mdl_kr_ownership: 'none',
     mdl_kr_age: 'none',
@@ -234,16 +225,13 @@ function circuitActionBinding(circuit) {
 const CIRCUIT_NEEDS_WALLET_SIGNATURE = {
     coinbase_attestation: true,
     coinbase_country_attestation: true,
-    // Same Coinbase-attested wallet as above; what changes is that it signs an
-    // EIP-712 action rather than signal_hash.
-    arc_eligibility: true,
     // The signature is inside the OIDC identity token, checked by the prover.
     oidc_domain_attestation: false,
     // Web2 (OmniOne CX) flows with no wallet binding at all.
     mdl_kr_ownership: false,
     mdl_kr_age: false,
     mdl_kr_region: false,
-    // A GIWA-attested wallet signing an EIP-712 action, the same shape as Arc.
+    // A GIWA-attested wallet signing an EIP-712 action (or its signal hash).
     // This read `false` while the circuit had always verified a wallet signature
     // -- it sat under the Web2 comment above and was never revisited. A request
     // for it would have reached the relay with no signer.

package/dist/circuits.js.map

@@ -1 +1 @@
-{"version":3,"file":"circuits.js","sources":["../src/circuits.ts"],"sourcesContent":["/**\n * Canonical ZKProofport circuit identifiers.\n *\n * This module is the single source of truth for circuit IDs. Every other layer\n * — the mobile app, the demo, the relay, server-side provers — reads its list\n * from here instead of keeping a private copy that silently drifts.\n *\n * It has **no imports and no dependencies**, so it can be pulled in on its own:\n *\n * ```typescript\n * import { CIRCUIT_IDS, isCircuitId } from '@zkproofport-app/sdk/circuits';\n * ```\n *\n * The same names are also re-exported from the package root\n * (`@zkproofport-app/sdk`) for callers that already import the SDK.\n *\n * ## Identifiers are canonical and case-sensitive\n *\n * Each ID is the circuit's `name` in its `Nargo.toml`, verbatim. The format is\n * lowercase with underscores. Hyphenated spellings (`coinbase-kyc`,\n * `mdl-kr-age`) are directory or UI route names in other repositories — they\n * are **not** circuit IDs, and passing one produces a nullifier mismatch or a\n * failed on-chain lookup rather than a clear error.\n */\n\n/**\n * Whether a circuit is officially supported today or still on the roadmap.\n *\n * - `supported` — generally available. Safe to build a product on.\n * - `planned` — the identifier is reserved and the circuit exists, but it is\n *   not officially supported yet. Availability, inputs and public-input layout\n *   may change without a major version bump.\n */\nexport type CircuitSupportStatus = 'supported' | 'experimental' | 'planned';\n\n/**\n * Canonical circuit identifiers, keyed by a stable constant name.\n *\n * Prefer these constants over string literals so a rename is a compile error\n * rather than a runtime surprise.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_IDS } from '@zkproofport-app/sdk/circuits';\n *\n * const relay = await sdk.createRelayRequest(CIRCUIT_IDS.COINBASE_ATTESTATION, {\n *   scope: 'myapp.com',\n * });\n * ```\n */\nexport const CIRCUIT_IDS = Object.freeze({\n  /** Coinbase KYC attestation. Officially supported. */\n  COINBASE_ATTESTATION: 'coinbase_attestation',\n  /** Coinbase country attestation (inclusion / exclusion). Officially supported. */\n  COINBASE_COUNTRY_ATTESTATION: 'coinbase_country_attestation',\n  /** OIDC email-domain attestation. Officially supported. */\n  OIDC_DOMAIN_ATTESTATION: 'oidc_domain_attestation',\n  /** Arc eligibility: exact EIP-712 action authorization. Experimental on Arc Testnet. */\n  ARC_ELIGIBILITY: 'arc_eligibility',\n  /** GIWA attestation. Planned — not officially supported yet. */\n  GIWA_ATTESTATION: 'giwa_attestation',\n  /** Korea Mobile ID ownership. Planned — not officially supported yet. */\n  MDL_KR_OWNERSHIP: 'mdl_kr_ownership',\n  /** Korea Mobile ID age threshold. Planned — not officially supported yet. */\n  MDL_KR_AGE: 'mdl_kr_age',\n  /** Korea Mobile ID si/do region. Planned — not officially supported yet. */\n  MDL_KR_REGION: 'mdl_kr_region',\n} as const);\n\n/**\n * Union of every canonical circuit identifier.\n *\n * `CircuitType` (exported from the package root) is an alias of this type — the\n * two names refer to the same union, and this module is where it is defined.\n */\nexport type CircuitId = (typeof CIRCUIT_IDS)[keyof typeof CIRCUIT_IDS];\n\n/**\n * Support status for every circuit.\n *\n * The record is exhaustive over {@link CircuitId}: adding an identifier without\n * giving it a status is a compile error, so this list cannot drift from\n * {@link CIRCUIT_IDS}.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_SUPPORT_STATUS } from '@zkproofport-app/sdk/circuits';\n *\n * CIRCUIT_SUPPORT_STATUS.coinbase_attestation; // 'supported'\n * CIRCUIT_SUPPORT_STATUS.mdl_kr_age;           // 'planned'\n * ```\n */\nexport const CIRCUIT_SUPPORT_STATUS: Readonly<Record<CircuitId, CircuitSupportStatus>> =\n  Object.freeze({\n    coinbase_attestation: 'supported',\n    coinbase_country_attestation: 'supported',\n    oidc_domain_attestation: 'supported',\n    arc_eligibility: 'experimental',\n    // Experimental, not planned: the circuit is built, its verifier is\n    // deployed on GIWA Sepolia and the demo requests it. What keeps it out of\n    // 'supported' is that it is testnet-only, so the app offers it behind\n    // Developer Mode and reads its files from main rather than a release tag.\n    giwa_attestation: 'experimental',\n    mdl_kr_ownership: 'planned',\n    mdl_kr_age: 'planned',\n    mdl_kr_region: 'planned',\n  } as const);\n\n/**\n * Where each circuit's verification key FILE lives inside the\n * `zkproofport/circuits` repository, relative to its root.\n *\n * Off-chain verification needs the verification key and nothing else — no\n * circuit bytecode, no witness. The key is public by nature: it is what anyone\n * checking a proof must already have, and the Solidity verifiers deployed\n * on-chain embed the same key.\n *\n * NOTE THE TRAILING `/vk` TWICE. In that repository `target/vk` is a DIRECTORY\n * holding `vk`, `vk_hash` and `SHA256SUMS`; the key itself is `target/vk/vk`.\n * These paths were first copied here from the mobile app, which keeps the\n * directory and the filename as two fields and joins them — so taking only the\n * directory produced a URL that answers 404, and the first browser to try\n * off-chain verification said \"Could not fetch the verification key (HTTP 404)\".\n *\n * Exhaustive over {@link CircuitId} on purpose. A new circuit whose key path is\n * not listed here fails to compile rather than failing at verification time,\n * where the only symptom would be a proof that cannot be checked.\n */\nexport const CIRCUIT_VK_PATHS: Readonly<Record<CircuitId, string>> = Object.freeze({\n  coinbase_attestation: 'coinbase-attestation/target/vk/vk',\n  coinbase_country_attestation: 'coinbase-country-attestation/target/vk/vk',\n  oidc_domain_attestation: 'oidc-domain-attestation/target/vk/vk',\n  arc_eligibility: 'arc-eligibility/target/vk/vk',\n  giwa_attestation: 'giwa-attestation/target/vk/vk',\n  mdl_kr_ownership: 'mdl/kr-ownership/target/vk/vk',\n  mdl_kr_age: 'mdl/kr-age/target/vk/vk',\n  mdl_kr_region: 'mdl/kr-region/target/vk/vk',\n} as const);\n\n/**\n * Every canonical circuit identifier, in declaration order.\n *\n * Includes circuits that are still `planned`. Use {@link SUPPORTED_CIRCUIT_IDS}\n * when you only want the ones that are officially supported today.\n */\nexport const ALL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  Object.values(CIRCUIT_IDS) as CircuitId[]\n);\n\n/**\n * Circuits that are officially supported today: the two Coinbase circuits and\n * OIDC domain attestation.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\nexport const SUPPORTED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'supported')\n);\n\n/**\n * Circuits whose identifiers are reserved but which are not officially\n * supported yet: GIWA attestation and the three Korea Mobile ID circuits.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\n/**\n * Circuits you can prove today, on a testnet, with everything subject to change.\n *\n * `arc_eligibility` is the reason this status exists. Calling it `planned`\n * would be wrong — the circuit compiles, the verifier is deployed and a proof\n * verifies against it — and calling it `supported` would be worse, because the\n * only deployment is Arc Testnet, Circle has not published a mainnet chain id,\n * and the public-input layout is still open. Neither existing word was true, so\n * the honest move was a third word rather than picking the closer lie.\n */\nexport const EXPERIMENTAL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter(id => CIRCUIT_SUPPORT_STATUS[id] === 'experimental'),\n);\n\nexport const PLANNED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'planned')\n);\n\n/**\n * Narrows an unknown value to a canonical circuit identifier.\n *\n * Returns `false` for hyphenated route names such as `'coinbase-kyc'`, which\n * are not circuit IDs.\n *\n * @example\n * ```typescript\n * isCircuitId('coinbase_attestation'); // true\n * isCircuitId('coinbase-kyc');         // false\n * ```\n */\nexport function isCircuitId(value: unknown): value is CircuitId {\n  return typeof value === 'string' && (ALL_CIRCUIT_IDS as readonly string[]).includes(value);\n}\n\n/**\n * Narrows an unknown value to a circuit identifier that is officially supported\n * today. Planned circuits return `false`.\n *\n * @example\n * ```typescript\n * isSupportedCircuitId('oidc_domain_attestation'); // true\n * isSupportedCircuitId('mdl_kr_age');              // false — planned\n * ```\n */\nexport function isSupportedCircuitId(value: unknown): value is CircuitId {\n  return isCircuitId(value) && CIRCUIT_SUPPORT_STATUS[value] === 'supported';\n}\n\n/**\n * Returns the support status of a circuit.\n *\n * @param circuit - A canonical circuit identifier.\n * @throws Error when the value is not a canonical circuit identifier.\n *\n * @example\n * ```typescript\n * getCircuitSupportStatus('giwa_attestation'); // 'planned'\n * ```\n */\nexport function getCircuitSupportStatus(circuit: CircuitId): CircuitSupportStatus {\n  if (!isCircuitId(circuit)) {\n    throw new Error(\n      `Unknown circuit '${String(circuit)}'. Expected one of: ${ALL_CIRCUIT_IDS.join(', ')}`\n    );\n  }\n  return CIRCUIT_SUPPORT_STATUS[circuit];\n}\n\n/**\n * Whether a circuit's relay request must carry a wallet signature.\n *\n * The SDK checks this to fail fast — \"Signer not set\" locally beats a 401 from\n * the relay two round trips later, with nothing saying which circuit needed\n * what. The relay declares its OWN copy on purpose and does not import this\n * one: it is a security boundary, and an auth policy that a published package\n * can change is not a policy. A test in the relay asserts the two agree.\n *\n * `satisfies` and not an annotation, so a circuit added above is a compile\n * error here until somebody decides which it is.\n */\n/**\n * Whether a circuit's proof can bind an EIP-712 action, and whether it must.\n *\n * ONE TABLE, because the answer was becoming a chain of `circuit === '...'`\n * tests. It was asked in the deep-link validator and again in\n * `createRelayRequest`, both spelling out `arc_eligibility`, and a second\n * action-capable circuit would have made each of them a two-branch chain that\n * ends on whatever the last test happens to be.\n *\n *   'required'  the circuit proves nothing without an action -- the wallet\n *               signs the typed data and there is no other message.\n *   'optional'  the circuit signs the action when one is supplied and\n *               personal_signs its signal hash when one is not. The circuit\n *               itself branches; see giwa-attestation/src/main.nr.\n *   'none'      the circuit has no action inputs. An action sent anyway is a\n *               caller misunderstanding, and is refused rather than dropped:\n *               silently ignoring it would let a dapp believe a proof\n *               authorized something it never mentioned.\n */\nexport type CircuitActionBinding = 'none' | 'required' | 'optional';\n\nexport const CIRCUIT_ACTION_BINDING = {\n  coinbase_attestation: 'none',\n  coinbase_country_attestation: 'none',\n  // The signature lives inside the identity token; no wallet, no action.\n  oidc_domain_attestation: 'none',\n  // Both branch in-circuit: with an action the wallet signs the typed data,\n  // without one it personal_signs the request's signal hash. Arc read\n  // 'required' until 2026-09-22 because its circuit had no second path -- a\n  // request without an action built a vector 64 bytes short and died inside\n  // the prover. The circuit gained the branch; the table follows it.\n  arc_eligibility: 'optional',\n  giwa_attestation: 'optional',\n  mdl_kr_ownership: 'none',\n  mdl_kr_age: 'none',\n  mdl_kr_region: 'none',\n} satisfies Record<CircuitId, CircuitActionBinding>;\n\n/*\n * The union is declared above rather than derived from the table's values.\n *\n * Deriving it narrowed the type to whatever the table happens to hold today --\n * 'none' | 'optional' -- and TypeScript then called every `=== 'required'`\n * check impossible. The publish typecheck caught it; `rollup` and `vitest` did\n * not. 'required' is a state a circuit can legitimately be in (an EIP-712 path\n * and nothing else), so the union says so and the table is checked against it.\n */\n\n/**\n * How this circuit treats an action, or an error naming the id that is not one.\n *\n * No default: a circuit nobody has classified must not inherit 'none', which\n * would silently drop an action a dapp meant to bind.\n */\nexport function circuitActionBinding(circuit: string): CircuitActionBinding {\n  const binding = (CIRCUIT_ACTION_BINDING as Record<string, CircuitActionBinding | undefined>)[circuit];\n  if (!binding) {\n    throw new Error(\n      `Unknown circuit '${circuit}'. Expected: ${ALL_CIRCUIT_IDS.join(', ')}`,\n    );\n  }\n  return binding;\n}\n\nexport const CIRCUIT_NEEDS_WALLET_SIGNATURE = {\n  coinbase_attestation: true,\n  coinbase_country_attestation: true,\n  // Same Coinbase-attested wallet as above; what changes is that it signs an\n  // EIP-712 action rather than signal_hash.\n  arc_eligibility: true,\n  // The signature is inside the OIDC identity token, checked by the prover.\n  oidc_domain_attestation: false,\n  // Web2 (OmniOne CX) flows with no wallet binding at all.\n  mdl_kr_ownership: false,\n  mdl_kr_age: false,\n  mdl_kr_region: false,\n  // A GIWA-attested wallet signing an EIP-712 action, the same shape as Arc.\n  // This read `false` while the circuit had always verified a wallet signature\n  // -- it sat under the Web2 comment above and was never revisited. A request\n  // for it would have reached the relay with no signer.\n  giwa_attestation: true,\n} satisfies Record<CircuitId, boolean>;\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"circuits.js","sources":["../src/circuits.ts"],"sourcesContent":["/**\n * Canonical ZKProofport circuit identifiers.\n *\n * This module is the single source of truth for circuit IDs. Every other layer\n * — the mobile app, the demo, the relay, server-side provers — reads its list\n * from here instead of keeping a private copy that silently drifts.\n *\n * It has **no imports and no dependencies**, so it can be pulled in on its own:\n *\n * ```typescript\n * import { CIRCUIT_IDS, isCircuitId } from '@zkproofport-app/sdk/circuits';\n * ```\n *\n * The same names are also re-exported from the package root\n * (`@zkproofport-app/sdk`) for callers that already import the SDK.\n *\n * ## Identifiers are canonical and case-sensitive\n *\n * Each ID is the circuit's `name` in its `Nargo.toml`, verbatim. The format is\n * lowercase with underscores. Hyphenated spellings (`coinbase-kyc`,\n * `mdl-kr-age`) are directory or UI route names in other repositories — they\n * are **not** circuit IDs, and passing one produces a nullifier mismatch or a\n * failed on-chain lookup rather than a clear error.\n */\n\n/**\n * Whether a circuit is officially supported today or still on the roadmap.\n *\n * - `supported` — generally available. Safe to build a product on.\n * - `planned` — the identifier is reserved and the circuit exists, but it is\n *   not officially supported yet. Availability, inputs and public-input layout\n *   may change without a major version bump.\n */\nexport type CircuitSupportStatus = 'supported' | 'experimental' | 'planned';\n\n/**\n * Canonical circuit identifiers, keyed by a stable constant name.\n *\n * Prefer these constants over string literals so a rename is a compile error\n * rather than a runtime surprise.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_IDS } from '@zkproofport-app/sdk/circuits';\n *\n * const relay = await sdk.createRelayRequest(CIRCUIT_IDS.COINBASE_ATTESTATION, {\n *   scope: 'myapp.com',\n * });\n * ```\n */\nexport const CIRCUIT_IDS = Object.freeze({\n  /** Coinbase KYC attestation. Officially supported. */\n  COINBASE_ATTESTATION: 'coinbase_attestation',\n  /** Coinbase country attestation (inclusion / exclusion). Officially supported. */\n  COINBASE_COUNTRY_ATTESTATION: 'coinbase_country_attestation',\n  /** OIDC email-domain attestation. Officially supported. */\n  OIDC_DOMAIN_ATTESTATION: 'oidc_domain_attestation',\n  /** GIWA attestation. Planned — not officially supported yet. */\n  GIWA_ATTESTATION: 'giwa_attestation',\n  /** Korea Mobile ID ownership. Planned — not officially supported yet. */\n  MDL_KR_OWNERSHIP: 'mdl_kr_ownership',\n  /** Korea Mobile ID age threshold. Planned — not officially supported yet. */\n  MDL_KR_AGE: 'mdl_kr_age',\n  /** Korea Mobile ID si/do region. Planned — not officially supported yet. */\n  MDL_KR_REGION: 'mdl_kr_region',\n} as const);\n\n/**\n * Union of every canonical circuit identifier.\n *\n * `CircuitType` (exported from the package root) is an alias of this type — the\n * two names refer to the same union, and this module is where it is defined.\n */\nexport type CircuitId = (typeof CIRCUIT_IDS)[keyof typeof CIRCUIT_IDS];\n\n/**\n * Support status for every circuit.\n *\n * The record is exhaustive over {@link CircuitId}: adding an identifier without\n * giving it a status is a compile error, so this list cannot drift from\n * {@link CIRCUIT_IDS}.\n *\n * @example\n * ```typescript\n * import { CIRCUIT_SUPPORT_STATUS } from '@zkproofport-app/sdk/circuits';\n *\n * CIRCUIT_SUPPORT_STATUS.coinbase_attestation; // 'supported'\n * CIRCUIT_SUPPORT_STATUS.mdl_kr_age;           // 'planned'\n * ```\n */\nexport const CIRCUIT_SUPPORT_STATUS: Readonly<Record<CircuitId, CircuitSupportStatus>> =\n  Object.freeze({\n    coinbase_attestation: 'supported',\n    coinbase_country_attestation: 'supported',\n    oidc_domain_attestation: 'supported',\n    // Experimental, not planned: the circuit is built, its verifier is\n    // deployed on GIWA Sepolia and the demo requests it. What keeps it out of\n    // 'supported' is that it is testnet-only, so the app offers it behind\n    // Developer Mode and reads its files from main rather than a release tag.\n    giwa_attestation: 'experimental',\n    mdl_kr_ownership: 'planned',\n    mdl_kr_age: 'planned',\n    mdl_kr_region: 'planned',\n  } as const);\n\n/**\n * Where each circuit's verification key FILE lives inside the\n * `zkproofport/circuits` repository, relative to its root.\n *\n * Off-chain verification needs the verification key and nothing else — no\n * circuit bytecode, no witness. The key is public by nature: it is what anyone\n * checking a proof must already have, and the Solidity verifiers deployed\n * on-chain embed the same key.\n *\n * NOTE THE TRAILING `/vk` TWICE. In that repository `target/vk` is a DIRECTORY\n * holding `vk`, `vk_hash` and `SHA256SUMS`; the key itself is `target/vk/vk`.\n * These paths were first copied here from the mobile app, which keeps the\n * directory and the filename as two fields and joins them — so taking only the\n * directory produced a URL that answers 404, and the first browser to try\n * off-chain verification said \"Could not fetch the verification key (HTTP 404)\".\n *\n * Exhaustive over {@link CircuitId} on purpose. A new circuit whose key path is\n * not listed here fails to compile rather than failing at verification time,\n * where the only symptom would be a proof that cannot be checked.\n */\nexport const CIRCUIT_VK_PATHS: Readonly<Record<CircuitId, string>> = Object.freeze({\n  coinbase_attestation: 'coinbase-attestation/target/vk/vk',\n  coinbase_country_attestation: 'coinbase-country-attestation/target/vk/vk',\n  oidc_domain_attestation: 'oidc-domain-attestation/target/vk/vk',\n  giwa_attestation: 'giwa-attestation/target/vk/vk',\n  mdl_kr_ownership: 'mdl/kr-ownership/target/vk/vk',\n  mdl_kr_age: 'mdl/kr-age/target/vk/vk',\n  mdl_kr_region: 'mdl/kr-region/target/vk/vk',\n} as const);\n\n/**\n * Every canonical circuit identifier, in declaration order.\n *\n * Includes circuits that are still `planned`. Use {@link SUPPORTED_CIRCUIT_IDS}\n * when you only want the ones that are officially supported today.\n */\nexport const ALL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  Object.values(CIRCUIT_IDS) as CircuitId[]\n);\n\n/**\n * Circuits that are officially supported today: the two Coinbase circuits and\n * OIDC domain attestation.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\nexport const SUPPORTED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'supported')\n);\n\n/**\n * Circuits whose identifiers are reserved but which are not officially\n * supported yet: GIWA attestation and the three Korea Mobile ID circuits.\n *\n * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.\n */\n/**\n * Circuits you can prove today, on a testnet, with everything subject to change.\n *\n * `giwa_attestation` is in this state. Calling it `planned` would be wrong —\n * the circuit compiles, the verifier is deployed and a proof verifies against\n * it — and calling it `supported` would be worse, because the only deployment\n * is a testnet (GIWA Sepolia). Neither existing word was true, so the honest\n * move was a third word rather than picking the closer lie.\n */\nexport const EXPERIMENTAL_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter(id => CIRCUIT_SUPPORT_STATUS[id] === 'experimental'),\n);\n\nexport const PLANNED_CIRCUIT_IDS: readonly CircuitId[] = Object.freeze(\n  ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'planned')\n);\n\n/**\n * Narrows an unknown value to a canonical circuit identifier.\n *\n * Returns `false` for hyphenated route names such as `'coinbase-kyc'`, which\n * are not circuit IDs.\n *\n * @example\n * ```typescript\n * isCircuitId('coinbase_attestation'); // true\n * isCircuitId('coinbase-kyc');         // false\n * ```\n */\nexport function isCircuitId(value: unknown): value is CircuitId {\n  return typeof value === 'string' && (ALL_CIRCUIT_IDS as readonly string[]).includes(value);\n}\n\n/**\n * Narrows an unknown value to a circuit identifier that is officially supported\n * today. Planned circuits return `false`.\n *\n * @example\n * ```typescript\n * isSupportedCircuitId('oidc_domain_attestation'); // true\n * isSupportedCircuitId('mdl_kr_age');              // false — planned\n * ```\n */\nexport function isSupportedCircuitId(value: unknown): value is CircuitId {\n  return isCircuitId(value) && CIRCUIT_SUPPORT_STATUS[value] === 'supported';\n}\n\n/**\n * Returns the support status of a circuit.\n *\n * @param circuit - A canonical circuit identifier.\n * @throws Error when the value is not a canonical circuit identifier.\n *\n * @example\n * ```typescript\n * getCircuitSupportStatus('giwa_attestation'); // 'planned'\n * ```\n */\nexport function getCircuitSupportStatus(circuit: CircuitId): CircuitSupportStatus {\n  if (!isCircuitId(circuit)) {\n    throw new Error(\n      `Unknown circuit '${String(circuit)}'. Expected one of: ${ALL_CIRCUIT_IDS.join(', ')}`\n    );\n  }\n  return CIRCUIT_SUPPORT_STATUS[circuit];\n}\n\n/**\n * Whether a circuit's relay request must carry a wallet signature.\n *\n * The SDK checks this to fail fast — \"Signer not set\" locally beats a 401 from\n * the relay two round trips later, with nothing saying which circuit needed\n * what. The relay declares its OWN copy on purpose and does not import this\n * one: it is a security boundary, and an auth policy that a published package\n * can change is not a policy. A test in the relay asserts the two agree.\n *\n * `satisfies` and not an annotation, so a circuit added above is a compile\n * error here until somebody decides which it is.\n */\n/**\n * Whether a circuit's proof can bind an EIP-712 action, and whether it must.\n *\n * ONE TABLE, because the answer was becoming a chain of `circuit === '...'`\n * tests. It was asked in the deep-link validator and again in\n * `createRelayRequest`, both spelling out one circuit id, and a second\n * action-capable circuit would have made each of them a two-branch chain that\n * ends on whatever the last test happens to be.\n *\n *   'required'  the circuit proves nothing without an action -- the wallet\n *               signs the typed data and there is no other message.\n *   'optional'  the circuit signs the action when one is supplied and\n *               personal_signs its signal hash when one is not. The circuit\n *               itself branches; see giwa-attestation/src/main.nr.\n *   'none'      the circuit has no action inputs. An action sent anyway is a\n *               caller misunderstanding, and is refused rather than dropped:\n *               silently ignoring it would let a dapp believe a proof\n *               authorized something it never mentioned.\n */\nexport type CircuitActionBinding = 'none' | 'required' | 'optional';\n\nexport const CIRCUIT_ACTION_BINDING = {\n  coinbase_attestation: 'none',\n  coinbase_country_attestation: 'none',\n  // The signature lives inside the identity token; no wallet, no action.\n  oidc_domain_attestation: 'none',\n  // Branches in-circuit: with an action the wallet signs the typed data,\n  // without one it personal_signs the request's signal hash.\n  giwa_attestation: 'optional',\n  mdl_kr_ownership: 'none',\n  mdl_kr_age: 'none',\n  mdl_kr_region: 'none',\n} satisfies Record<CircuitId, CircuitActionBinding>;\n\n/*\n * The union is declared above rather than derived from the table's values.\n *\n * Deriving it narrowed the type to whatever the table happens to hold today --\n * 'none' | 'optional' -- and TypeScript then called every `=== 'required'`\n * check impossible. The publish typecheck caught it; `rollup` and `vitest` did\n * not. 'required' is a state a circuit can legitimately be in (an EIP-712 path\n * and nothing else), so the union says so and the table is checked against it.\n */\n\n/**\n * How this circuit treats an action, or an error naming the id that is not one.\n *\n * No default: a circuit nobody has classified must not inherit 'none', which\n * would silently drop an action a dapp meant to bind.\n */\nexport function circuitActionBinding(circuit: string): CircuitActionBinding {\n  const binding = (CIRCUIT_ACTION_BINDING as Record<string, CircuitActionBinding | undefined>)[circuit];\n  if (!binding) {\n    throw new Error(\n      `Unknown circuit '${circuit}'. Expected: ${ALL_CIRCUIT_IDS.join(', ')}`,\n    );\n  }\n  return binding;\n}\n\nexport const CIRCUIT_NEEDS_WALLET_SIGNATURE = {\n  coinbase_attestation: true,\n  coinbase_country_attestation: true,\n  // The signature is inside the OIDC identity token, checked by the prover.\n  oidc_domain_attestation: false,\n  // Web2 (OmniOne CX) flows with no wallet binding at all.\n  mdl_kr_ownership: false,\n  mdl_kr_age: false,\n  mdl_kr_region: false,\n  // A GIWA-attested wallet signing an EIP-712 action (or its signal hash).\n  // This read `false` while the circuit had always verified a wallet signature\n  // -- it sat under the Web2 comment above and was never revisited. A request\n  // for it would have reached the relay with no signer.\n  giwa_attestation: true,\n} satisfies Record<CircuitId, boolean>;\n"],"names":[],"mappings":"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"}

package/dist/circuits.mjs

@@ -44,8 +44,6 @@ const CIRCUIT_IDS = Object.freeze({
     COINBASE_COUNTRY_ATTESTATION: 'coinbase_country_attestation',
     /** OIDC email-domain attestation. Officially supported. */
     OIDC_DOMAIN_ATTESTATION: 'oidc_domain_attestation',
-    /** Arc eligibility: exact EIP-712 action authorization. Experimental on Arc Testnet. */
-    ARC_ELIGIBILITY: 'arc_eligibility',
     /** GIWA attestation. Planned — not officially supported yet. */
     GIWA_ATTESTATION: 'giwa_attestation',
     /** Korea Mobile ID ownership. Planned — not officially supported yet. */
@@ -74,7 +72,6 @@ const CIRCUIT_SUPPORT_STATUS = Object.freeze({
     coinbase_attestation: 'supported',
     coinbase_country_attestation: 'supported',
     oidc_domain_attestation: 'supported',
-    arc_eligibility: 'experimental',
     // Experimental, not planned: the circuit is built, its verifier is
     // deployed on GIWA Sepolia and the demo requests it. What keeps it out of
     // 'supported' is that it is testnet-only, so the app offers it behind
@@ -108,7 +105,6 @@ const CIRCUIT_VK_PATHS = Object.freeze({
     coinbase_attestation: 'coinbase-attestation/target/vk/vk',
     coinbase_country_attestation: 'coinbase-country-attestation/target/vk/vk',
     oidc_domain_attestation: 'oidc-domain-attestation/target/vk/vk',
-    arc_eligibility: 'arc-eligibility/target/vk/vk',
     giwa_attestation: 'giwa-attestation/target/vk/vk',
     mdl_kr_ownership: 'mdl/kr-ownership/target/vk/vk',
     mdl_kr_age: 'mdl/kr-age/target/vk/vk',
@@ -137,12 +133,11 @@ const SUPPORTED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCU
 /**
  * Circuits you can prove today, on a testnet, with everything subject to change.
  *
- * `arc_eligibility` is the reason this status exists. Calling it `planned`
- * would be wrong — the circuit compiles, the verifier is deployed and a proof
- * verifies against it — and calling it `supported` would be worse, because the
- * only deployment is Arc Testnet, Circle has not published a mainnet chain id,
- * and the public-input layout is still open. Neither existing word was true, so
- * the honest move was a third word rather than picking the closer lie.
+ * `giwa_attestation` is in this state. Calling it `planned` would be wrong —
+ * the circuit compiles, the verifier is deployed and a proof verifies against
+ * it — and calling it `supported` would be worse, because the only deployment
+ * is a testnet (GIWA Sepolia). Neither existing word was true, so the honest
+ * move was a third word rather than picking the closer lie.
  */
 const EXPERIMENTAL_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter(id => CIRCUIT_SUPPORT_STATUS[id] === 'experimental'));
 const PLANNED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCUIT_SUPPORT_STATUS[id] === 'planned'));
@@ -196,12 +191,8 @@ const CIRCUIT_ACTION_BINDING = {
     coinbase_country_attestation: 'none',
     // The signature lives inside the identity token; no wallet, no action.
     oidc_domain_attestation: 'none',
-    // Both branch in-circuit: with an action the wallet signs the typed data,
-    // without one it personal_signs the request's signal hash. Arc read
-    // 'required' until 2026-09-22 because its circuit had no second path -- a
-    // request without an action built a vector 64 bytes short and died inside
-    // the prover. The circuit gained the branch; the table follows it.
-    arc_eligibility: 'optional',
+    // Branches in-circuit: with an action the wallet signs the typed data,
+    // without one it personal_signs the request's signal hash.
     giwa_attestation: 'optional',
     mdl_kr_ownership: 'none',
     mdl_kr_age: 'none',
@@ -232,16 +223,13 @@ function circuitActionBinding(circuit) {
 const CIRCUIT_NEEDS_WALLET_SIGNATURE = {
     coinbase_attestation: true,
     coinbase_country_attestation: true,
-    // Same Coinbase-attested wallet as above; what changes is that it signs an
-    // EIP-712 action rather than signal_hash.
-    arc_eligibility: true,
     // The signature is inside the OIDC identity token, checked by the prover.
     oidc_domain_attestation: false,
     // Web2 (OmniOne CX) flows with no wallet binding at all.
     mdl_kr_ownership: false,
     mdl_kr_age: false,
     mdl_kr_region: false,
-    // A GIWA-attested wallet signing an EIP-712 action, the same shape as Arc.
+    // A GIWA-attested wallet signing an EIP-712 action (or its signal hash).
     // This read `false` while the circuit had always verified a wallet signature
     // -- it sat under the Web2 comment above and was never revisited. A request
     // for it would have reached the relay with no signer.