@zkproofport-app/sdk 0.3.1 → 0.3.3

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). Four more identifiers are reserved and planned: GIWA attestation and the three Korean mobile ID (mDL) circuits. [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). 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.
 
 ## How It Works
 
@@ -125,7 +125,7 @@ import { CIRCUIT_IDS, CIRCUIT_SUPPORT_STATUS } from '@zkproofport-app/sdk/circui
 | `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` | Planned |
+| `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 |
 | `CIRCUIT_IDS.MDL_KR_REGION` | `mdl_kr_region` | Planned |
@@ -295,8 +295,20 @@ const relay = await sdk.createRelayRequest(CIRCUIT_IDS.ARC_ELIGIBILITY, {
 });
 ```
 
-`action` is required. A request without one is refused rather than proved
-against some default, because the signature is the whole point.
+`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
@@ -308,13 +320,81 @@ The public inputs are `signal_hash`, `domain_separator`, `action_hash`,
 other circuit, which is why `extractScopeFromPublicInputs` and
 `extractNullifierFromPublicInputs` require the circuit id and refuse to guess.
 
-## Planned Circuits
+### `giwa_attestation`
 
-The identifiers below are reserved and exported, and the circuits exist — but they are **not officially supported yet**. Availability, input shape and public-input layout can change without a major version bump, so treat anything here as provisional. `CIRCUIT_SUPPORT_STATUS` reports each of them as `planned`.
+The same attestation shape as Coinbase KYC, against GIWA's attester on GIWA
+Sepolia. A request needs a scope and nothing else; the app connects the wallet.
 
-### `giwa_attestation`
+```typescript
+const { deepLink } = await sdk.createRelayRequest(
+  CIRCUIT_IDS.GIWA_ATTESTATION,
+  { scope: 'myapp.com' },
+  { dappName: 'My App' },
+);
+```
+
+**An action is optional here, as it is for Arc.** 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
+branches, and it refuses a request that tries to be both: with an action the
+signal hash must be empty, without one the EIP-712 pair must be.
+
+```typescript
+await sdk.createRelayRequest(
+  CIRCUIT_IDS.GIWA_ATTESTATION,
+  {
+    scope: 'myapp.com',
+    action: {
+      domain: { name: 'My Vault', version: '1', chainId: 91342, verifyingContract: '0x…' },
+      types: { Deposit: [{ name: 'amount', type: 'uint256' }] },
+      primaryType: 'Deposit',
+      message: { amount: '1000000' },
+    },
+  },
+  { dappName: 'My App' },
+);
+```
 
-Reserved identifier for GIWA attestation. It is a fork of `coinbase_attestation` and carries the same four public inputs, but there is no dedicated input type for it and no supported request flow. The ID is exported so that every layer spells it the same way; do not build on it yet.
+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
+old offsets reads the Merkle root where the nullifier is.
+
+One more difference worth knowing if you count people: its nullifier is
+`keccak(keccak(wallet ++ keccak("giwa_attestation")) ++ scope)`. The wallet and
+a constant compiled into the circuit, so one wallet in one scope has exactly
+one nullifier and there is no input a prover can vary.
+
+**Testnet only.** The verifier lives on GIWA Sepolia (chain `91342`) and
+nowhere else, so the mobile app keeps it behind Developer Mode. A mainnet
+deployment is planned; until it exists, do not ship on this.
+
+### Which circuits take an action
+
+`CIRCUIT_ACTION_BINDING` is the one table, so you do not have to learn which
+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` |
+| 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'
+```
+
+Sending an action to a circuit that cannot prove one is an error rather than a
+silent drop: a dropped action would leave you believing a proof authorized
+something the circuit never saw.
+
+## Planned Circuits
+
+The identifiers below are reserved and exported, and the circuits exist — but they are **not officially supported yet**. Availability, input shape and public-input layout can change without a major version bump, so treat anything here as provisional. `CIRCUIT_SUPPORT_STATUS` reports each of them as `planned`.
 
 ### `mdl_kr_ownership`
 
@@ -997,6 +1077,8 @@ import type {
   CoinbaseKycInputs,
   CoinbaseCountryInputs,
   OidcDomainInputs,
+  ActionBoundInputs,
+  TypedAction,
   MdlKrOwnershipInputs,
   MdlKrAgeInputs,
   MdlKrRegionInputs,
@@ -1024,7 +1106,9 @@ 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? }` |
-| `ArcEligibilityInputs` | Inputs for `arc_eligibility`: `{ scope, action, userAddress?, rawTransaction? }` — `action` is required |
+| `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 |
+| `GiwaAttestationInputs` | Alias of `ActionBoundInputs`, for `giwa_attestation` |
 | `MdlKrAgeInputs` | Inputs for `mdl_kr_age`: `{ scope, ageThreshold }` |
 | `MdlKrRegionInputs` | Inputs for `mdl_kr_region`: `{ scope, targetRegion }` |
 | `CircuitInputs` | Union of every input type above (plus an empty-input form for circuits that need nothing from the dApp) |

package/dist/circuits.d.ts

@@ -53,7 +53,7 @@ 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: one EIP-712 action, authorized. Officially supported. */
+    /** 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";
@@ -188,6 +188,43 @@ export declare function getCircuitSupportStatus(circuit: CircuitId): CircuitSupp
  * `satisfies` and not an annotation, so a circuit added above is a compile
  * error here until somebody decides which it is.
  */
+/**
+ * Whether a circuit's proof can bind an EIP-712 action, and whether it must.
+ *
+ * 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
+ * action-capable circuit would have made each of them a two-branch chain that
+ * ends on whatever the last test happens to be.
+ *
+ *   'required'  the circuit proves nothing without an action -- the wallet
+ *               signs the typed data and there is no other message.
+ *   'optional'  the circuit signs the action when one is supplied and
+ *               personal_signs its signal hash when one is not. The circuit
+ *               itself branches; see giwa-attestation/src/main.nr.
+ *   'none'      the circuit has no action inputs. An action sent anyway is a
+ *               caller misunderstanding, and is refused rather than dropped:
+ *               silently ignoring it would let a dapp believe a proof
+ *               authorized something it never mentioned.
+ */
+export type CircuitActionBinding = 'none' | 'required' | 'optional';
+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";
+    mdl_kr_region: "none";
+};
+/**
+ * How this circuit treats an action, or an error naming the id that is not one.
+ *
+ * No default: a circuit nobody has classified must not inherit 'none', which
+ * would silently drop an action a dapp meant to bind.
+ */
+export declare function circuitActionBinding(circuit: string): CircuitActionBinding;
 export declare const CIRCUIT_NEEDS_WALLET_SIGNATURE: {
     coinbase_attestation: true;
     coinbase_country_attestation: true;
@@ -196,5 +233,5 @@ export declare const CIRCUIT_NEEDS_WALLET_SIGNATURE: {
     mdl_kr_ownership: false;
     mdl_kr_age: false;
     mdl_kr_region: false;
-    giwa_attestation: false;
+    giwa_attestation: true;
 };

package/dist/circuits.esm.js

@@ -44,7 +44,7 @@ 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: one EIP-712 action, authorized. Officially supported. */
+    /** 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',
@@ -75,7 +75,11 @@ const CIRCUIT_SUPPORT_STATUS = Object.freeze({
     coinbase_country_attestation: 'supported',
     oidc_domain_attestation: 'supported',
     arc_eligibility: 'experimental',
-    giwa_attestation: 'planned',
+    // 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
+    // Developer Mode and reads its files from main rather than a release tag.
+    giwa_attestation: 'experimental',
     mdl_kr_ownership: 'planned',
     mdl_kr_age: 'planned',
     mdl_kr_region: 'planned',
@@ -187,18 +191,44 @@ function getCircuitSupportStatus(circuit) {
     }
     return CIRCUIT_SUPPORT_STATUS[circuit];
 }
+const CIRCUIT_ACTION_BINDING = {
+    coinbase_attestation: 'none',
+    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',
+    giwa_attestation: 'optional',
+    mdl_kr_ownership: 'none',
+    mdl_kr_age: 'none',
+    mdl_kr_region: 'none',
+};
+/*
+ * The union is declared above rather than derived from the table's values.
+ *
+ * Deriving it narrowed the type to whatever the table happens to hold today --
+ * 'none' | 'optional' -- and TypeScript then called every `=== 'required'`
+ * check impossible. The publish typecheck caught it; `rollup` and `vitest` did
+ * not. 'required' is a state a circuit can legitimately be in (an EIP-712 path
+ * and nothing else), so the union says so and the table is checked against it.
+ */
 /**
- * Whether a circuit's relay request must carry a wallet signature.
- *
- * The SDK checks this to fail fast — "Signer not set" locally beats a 401 from
- * the relay two round trips later, with nothing saying which circuit needed
- * what. The relay declares its OWN copy on purpose and does not import this
- * one: it is a security boundary, and an auth policy that a published package
- * can change is not a policy. A test in the relay asserts the two agree.
+ * How this circuit treats an action, or an error naming the id that is not one.
  *
- * `satisfies` and not an annotation, so a circuit added above is a compile
- * error here until somebody decides which it is.
+ * No default: a circuit nobody has classified must not inherit 'none', which
+ * would silently drop an action a dapp meant to bind.
  */
+function circuitActionBinding(circuit) {
+    const binding = CIRCUIT_ACTION_BINDING[circuit];
+    if (!binding) {
+        throw new Error(`Unknown circuit '${circuit}'. Expected: ${ALL_CIRCUIT_IDS.join(', ')}`);
+    }
+    return binding;
+}
 const CIRCUIT_NEEDS_WALLET_SIGNATURE = {
     coinbase_attestation: true,
     coinbase_country_attestation: true,
@@ -211,8 +241,12 @@ const CIRCUIT_NEEDS_WALLET_SIGNATURE = {
     mdl_kr_ownership: false,
     mdl_kr_age: false,
     mdl_kr_region: false,
-    giwa_attestation: false,
+    // A GIWA-attested wallet signing an EIP-712 action, the same shape as Arc.
+    // 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.
+    giwa_attestation: true,
 };
 
-export { ALL_CIRCUIT_IDS, CIRCUIT_IDS, CIRCUIT_NEEDS_WALLET_SIGNATURE, CIRCUIT_SUPPORT_STATUS, CIRCUIT_VK_PATHS, EXPERIMENTAL_CIRCUIT_IDS, PLANNED_CIRCUIT_IDS, SUPPORTED_CIRCUIT_IDS, getCircuitSupportStatus, isCircuitId, isSupportedCircuitId };
+export { ALL_CIRCUIT_IDS, CIRCUIT_ACTION_BINDING, CIRCUIT_IDS, CIRCUIT_NEEDS_WALLET_SIGNATURE, CIRCUIT_SUPPORT_STATUS, CIRCUIT_VK_PATHS, EXPERIMENTAL_CIRCUIT_IDS, PLANNED_CIRCUIT_IDS, SUPPORTED_CIRCUIT_IDS, circuitActionBinding, getCircuitSupportStatus, isCircuitId, isSupportedCircuitId };
 //# sourceMappingURL=circuits.esm.js.map

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: one EIP-712 action, authorized. Officially supported. */\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    giwa_attestation: 'planned',\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 */\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  giwa_attestation: false,\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  /** 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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"}

package/dist/circuits.js

@@ -46,7 +46,7 @@ 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: one EIP-712 action, authorized. Officially supported. */
+    /** 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',
@@ -77,7 +77,11 @@ const CIRCUIT_SUPPORT_STATUS = Object.freeze({
     coinbase_country_attestation: 'supported',
     oidc_domain_attestation: 'supported',
     arc_eligibility: 'experimental',
-    giwa_attestation: 'planned',
+    // 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
+    // Developer Mode and reads its files from main rather than a release tag.
+    giwa_attestation: 'experimental',
     mdl_kr_ownership: 'planned',
     mdl_kr_age: 'planned',
     mdl_kr_region: 'planned',
@@ -189,18 +193,44 @@ function getCircuitSupportStatus(circuit) {
     }
     return CIRCUIT_SUPPORT_STATUS[circuit];
 }
-/**
- * Whether a circuit's relay request must carry a wallet signature.
+const CIRCUIT_ACTION_BINDING = {
+    coinbase_attestation: 'none',
+    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',
+    giwa_attestation: 'optional',
+    mdl_kr_ownership: 'none',
+    mdl_kr_age: 'none',
+    mdl_kr_region: 'none',
+};
+/*
+ * The union is declared above rather than derived from the table's values.
  *
- * The SDK checks this to fail fast — "Signer not set" locally beats a 401 from
- * the relay two round trips later, with nothing saying which circuit needed
- * what. The relay declares its OWN copy on purpose and does not import this
- * one: it is a security boundary, and an auth policy that a published package
- * can change is not a policy. A test in the relay asserts the two agree.
+ * Deriving it narrowed the type to whatever the table happens to hold today --
+ * 'none' | 'optional' -- and TypeScript then called every `=== 'required'`
+ * check impossible. The publish typecheck caught it; `rollup` and `vitest` did
+ * not. 'required' is a state a circuit can legitimately be in (an EIP-712 path
+ * and nothing else), so the union says so and the table is checked against it.
+ */
+/**
+ * How this circuit treats an action, or an error naming the id that is not one.
  *
- * `satisfies` and not an annotation, so a circuit added above is a compile
- * error here until somebody decides which it is.
+ * No default: a circuit nobody has classified must not inherit 'none', which
+ * would silently drop an action a dapp meant to bind.
  */
+function circuitActionBinding(circuit) {
+    const binding = CIRCUIT_ACTION_BINDING[circuit];
+    if (!binding) {
+        throw new Error(`Unknown circuit '${circuit}'. Expected: ${ALL_CIRCUIT_IDS.join(', ')}`);
+    }
+    return binding;
+}
 const CIRCUIT_NEEDS_WALLET_SIGNATURE = {
     coinbase_attestation: true,
     coinbase_country_attestation: true,
@@ -213,10 +243,15 @@ const CIRCUIT_NEEDS_WALLET_SIGNATURE = {
     mdl_kr_ownership: false,
     mdl_kr_age: false,
     mdl_kr_region: false,
-    giwa_attestation: false,
+    // A GIWA-attested wallet signing an EIP-712 action, the same shape as Arc.
+    // 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.
+    giwa_attestation: true,
 };
 
 exports.ALL_CIRCUIT_IDS = ALL_CIRCUIT_IDS;
+exports.CIRCUIT_ACTION_BINDING = CIRCUIT_ACTION_BINDING;
 exports.CIRCUIT_IDS = CIRCUIT_IDS;
 exports.CIRCUIT_NEEDS_WALLET_SIGNATURE = CIRCUIT_NEEDS_WALLET_SIGNATURE;
 exports.CIRCUIT_SUPPORT_STATUS = CIRCUIT_SUPPORT_STATUS;
@@ -224,6 +259,7 @@ exports.CIRCUIT_VK_PATHS = CIRCUIT_VK_PATHS;
 exports.EXPERIMENTAL_CIRCUIT_IDS = EXPERIMENTAL_CIRCUIT_IDS;
 exports.PLANNED_CIRCUIT_IDS = PLANNED_CIRCUIT_IDS;
 exports.SUPPORTED_CIRCUIT_IDS = SUPPORTED_CIRCUIT_IDS;
+exports.circuitActionBinding = circuitActionBinding;
 exports.getCircuitSupportStatus = getCircuitSupportStatus;
 exports.isCircuitId = isCircuitId;
 exports.isSupportedCircuitId = isSupportedCircuitId;

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: one EIP-712 action, authorized. Officially supported. */\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    giwa_attestation: 'planned',\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 */\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  giwa_attestation: false,\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  /** 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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"}