@zkproofport-app/sdk 0.2.15 → 0.3.0

package/README.md

@@ -124,12 +124,17 @@ 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` | Planned |
 | `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 |
 
-**Supported** means generally available — build a product on it. **Planned** means the identifier is reserved and the circuit exists, but it is not officially supported yet: availability, inputs and public-input layout can change without a major version bump.
+**Supported** means generally available — build a product on it.
+
+**Experimental** means you can prove it today and it verifies, but only against a testnet deployment. Inputs, public-input layout and the verifier address can change without a major version bump, and there is no mainnet to point at. Try it; do not ship on it.
+
+**Planned** means the identifier is reserved and the circuit exists, but it is not officially supported yet: availability, inputs and public-input layout can change without a major version bump.
 
 Every ID appears in `CircuitType` and in `sdk.getSupportedCircuits()`, planned ones included, so being assignable is not a support guarantee. Gate on the status, not on the type:
 
@@ -137,9 +142,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.mdl_kr_age;           // 'planned'
 
 isSupportedCircuitId('oidc_domain_attestation'); // true
+isSupportedCircuitId('arc_eligibility');         // false — experimental is not supported
 isSupportedCircuitId('mdl_kr_age');              // false
 isSupportedCircuitId('coinbase-kyc');            // false — not an ID at all
 ```
@@ -242,6 +249,65 @@ const relay = await sdk.createRelayRequest('oidc_domain_attestation', {
 
 > When `provider` is set, the mobile app verifies the user's account is managed by the specified workspace provider (e.g., Google Workspace `hd` claim, Microsoft 365 `tid` claim). Without `provider`, only the email domain is verified.
 
+## 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 required. A request without one is refused rather than proved
+against some default, because the signature is the whole point.
+
+**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.
+
 ## 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`.
@@ -949,7 +1015,8 @@ import type {
 
 | Type | Description |
 |------|-------------|
-| `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` |
+| `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 |
 | `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` |
@@ -957,6 +1024,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? }` |
+| `ArcEligibilityInputs` | Inputs for `arc_eligibility`: `{ scope, action, userAddress?, rawTransaction? }` — `action` is required |
 | `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/ProofportSDK.d.ts

@@ -842,7 +842,7 @@ export declare class ProofportSDK {
      * const result = await sdk.waitForProof(relay.requestId);
      * ```
      */
-    private static readonly WALLET_SIGNATURE_CIRCUITS;
+    private static needsWalletSignature;
     createRelayRequest(circuit: CircuitType, inputs: CircuitInputs, options?: {
         message?: string;
         dappName?: string;

package/dist/circuits.d.ts

@@ -30,7 +30,7 @@
  *   not officially supported yet. Availability, inputs and public-input layout
  *   may change without a major version bump.
  */
-export type CircuitSupportStatus = 'supported' | 'planned';
+export type CircuitSupportStatus = 'supported' | 'experimental' | 'planned';
 /**
  * Canonical circuit identifiers, keyed by a stable constant name.
  *
@@ -53,6 +53,8 @@ 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. */
+    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. */
@@ -86,14 +88,21 @@ export type CircuitId = (typeof CIRCUIT_IDS)[keyof typeof CIRCUIT_IDS];
  */
 export declare const CIRCUIT_SUPPORT_STATUS: Readonly<Record<CircuitId, CircuitSupportStatus>>;
 /**
- * Where each circuit's verification key lives inside the `zkproofport/circuits`
- * repository, relative to its root.
+ * Where each circuit's verification key FILE lives inside the
+ * `zkproofport/circuits` repository, relative to its root.
  *
  * Off-chain verification needs the verification key and nothing else — no
  * circuit bytecode, no witness. The key is public by nature: it is what anyone
  * checking a proof must already have, and the Solidity verifiers deployed
  * on-chain embed the same key.
  *
+ * NOTE THE TRAILING `/vk` TWICE. In that repository `target/vk` is a DIRECTORY
+ * holding `vk`, `vk_hash` and `SHA256SUMS`; the key itself is `target/vk/vk`.
+ * These paths were first copied here from the mobile app, which keeps the
+ * directory and the filename as two fields and joins them — so taking only the
+ * directory produced a URL that answers 404, and the first browser to try
+ * off-chain verification said "Could not fetch the verification key (HTTP 404)".
+ *
  * Exhaustive over {@link CircuitId} on purpose. A new circuit whose key path is
  * not listed here fails to compile rather than failing at verification time,
  * where the only symptom would be a proof that cannot be checked.
@@ -119,6 +128,17 @@ export declare const SUPPORTED_CIRCUIT_IDS: readonly CircuitId[];
  *
  * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.
  */
+/**
+ * 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.
+ */
+export declare const EXPERIMENTAL_CIRCUIT_IDS: readonly CircuitId[];
 export declare const PLANNED_CIRCUIT_IDS: readonly CircuitId[];
 /**
  * Narrows an unknown value to a canonical circuit identifier.
@@ -156,3 +176,25 @@ export declare function isSupportedCircuitId(value: unknown): value is CircuitId
  * ```
  */
 export declare function getCircuitSupportStatus(circuit: CircuitId): CircuitSupportStatus;
+/**
+ * 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.
+ *
+ * `satisfies` and not an annotation, so a circuit added above is a compile
+ * error here until somebody decides which it is.
+ */
+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;
+    mdl_kr_region: false;
+    giwa_attestation: false;
+};

package/dist/circuits.esm.js

@@ -44,6 +44,8 @@ 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: 'arc_eligibility',
     /** GIWA attestation. Planned — not officially supported yet. */
     GIWA_ATTESTATION: 'giwa_attestation',
     /** Korea Mobile ID ownership. Planned — not officially supported yet. */
@@ -72,32 +74,41 @@ const CIRCUIT_SUPPORT_STATUS = Object.freeze({
     coinbase_attestation: 'supported',
     coinbase_country_attestation: 'supported',
     oidc_domain_attestation: 'supported',
+    arc_eligibility: 'experimental',
     giwa_attestation: 'planned',
     mdl_kr_ownership: 'planned',
     mdl_kr_age: 'planned',
     mdl_kr_region: 'planned',
 });
 /**
- * Where each circuit's verification key lives inside the `zkproofport/circuits`
- * repository, relative to its root.
+ * Where each circuit's verification key FILE lives inside the
+ * `zkproofport/circuits` repository, relative to its root.
  *
  * Off-chain verification needs the verification key and nothing else — no
  * circuit bytecode, no witness. The key is public by nature: it is what anyone
  * checking a proof must already have, and the Solidity verifiers deployed
  * on-chain embed the same key.
  *
+ * NOTE THE TRAILING `/vk` TWICE. In that repository `target/vk` is a DIRECTORY
+ * holding `vk`, `vk_hash` and `SHA256SUMS`; the key itself is `target/vk/vk`.
+ * These paths were first copied here from the mobile app, which keeps the
+ * directory and the filename as two fields and joins them — so taking only the
+ * directory produced a URL that answers 404, and the first browser to try
+ * off-chain verification said "Could not fetch the verification key (HTTP 404)".
+ *
  * Exhaustive over {@link CircuitId} on purpose. A new circuit whose key path is
  * not listed here fails to compile rather than failing at verification time,
  * where the only symptom would be a proof that cannot be checked.
  */
 const CIRCUIT_VK_PATHS = Object.freeze({
-    coinbase_attestation: 'coinbase-attestation/target/vk',
-    coinbase_country_attestation: 'coinbase-country-attestation/target/vk',
-    oidc_domain_attestation: 'oidc-domain-attestation/target/vk',
-    giwa_attestation: 'giwa-attestation/target/vk',
-    mdl_kr_ownership: 'mdl/kr-ownership/target/vk',
-    mdl_kr_age: 'mdl/kr-age/target/vk',
-    mdl_kr_region: 'mdl/kr-region/target/vk',
+    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',
+    mdl_kr_region: 'mdl/kr-region/target/vk/vk',
 });
 /**
  * Every canonical circuit identifier, in declaration order.
@@ -119,6 +130,17 @@ const SUPPORTED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCU
  *
  * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.
  */
+/**
+ * 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.
+ */
+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'));
 /**
  * Narrows an unknown value to a canonical circuit identifier.
@@ -165,6 +187,32 @@ function getCircuitSupportStatus(circuit) {
     }
     return CIRCUIT_SUPPORT_STATUS[circuit];
 }
+/**
+ * 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.
+ *
+ * `satisfies` and not an annotation, so a circuit added above is a compile
+ * error here until somebody decides which it is.
+ */
+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,
+    giwa_attestation: false,
+};
 
-export { ALL_CIRCUIT_IDS, CIRCUIT_IDS, CIRCUIT_SUPPORT_STATUS, CIRCUIT_VK_PATHS, PLANNED_CIRCUIT_IDS, SUPPORTED_CIRCUIT_IDS, getCircuitSupportStatus, isCircuitId, isSupportedCircuitId };
+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 };
 //# 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' | '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    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 lives inside the `zkproofport/circuits`\n * 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 * 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',\n  coinbase_country_attestation: 'coinbase-country-attestation/target/vk',\n  oidc_domain_attestation: 'oidc-domain-attestation/target/vk',\n  giwa_attestation: 'giwa-attestation/target/vk',\n  mdl_kr_ownership: 'mdl/kr-ownership/target/vk',\n  mdl_kr_age: 'mdl/kr-age/target/vk',\n  mdl_kr_region: 'mdl/kr-region/target/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 */\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"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AAYH;;;;;;;;;;;;;;AAcG;AACI,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;;AAEvC,IAAA,oBAAoB,EAAE,sBAAsB;;AAE5C,IAAA,4BAA4B,EAAE,8BAA8B;;AAE5D,IAAA,uBAAuB,EAAE,yBAAyB;;AAElD,IAAA,gBAAgB,EAAE,kBAAkB;;AAEpC,IAAA,gBAAgB,EAAE,kBAAkB;;AAEpC,IAAA,UAAU,EAAE,YAAY;;AAExB,IAAA,aAAa,EAAE,eAAe;AACtB,CAAA;AAUV;;;;;;;;;;;;;;AAcG;AACI,MAAM,sBAAsB,GACjC,MAAM,CAAC,MAAM,CAAC;AACZ,IAAA,oBAAoB,EAAE,WAAW;AACjC,IAAA,4BAA4B,EAAE,WAAW;AACzC,IAAA,uBAAuB,EAAE,WAAW;AACpC,IAAA,gBAAgB,EAAE,SAAS;AAC3B,IAAA,gBAAgB,EAAE,SAAS;AAC3B,IAAA,UAAU,EAAE,SAAS;AACrB,IAAA,aAAa,EAAE,SAAS;AAChB,CAAA;AAEZ;;;;;;;;;;;;AAYG;AACI,MAAM,gBAAgB,GAAwC,MAAM,CAAC,MAAM,CAAC;AACjF,IAAA,oBAAoB,EAAE,gCAAgC;AACtD,IAAA,4BAA4B,EAAE,wCAAwC;AACtE,IAAA,uBAAuB,EAAE,mCAAmC;AAC5D,IAAA,gBAAgB,EAAE,4BAA4B;AAC9C,IAAA,gBAAgB,EAAE,4BAA4B;AAC9C,IAAA,UAAU,EAAE,sBAAsB;AAClC,IAAA,aAAa,EAAE,yBAAyB;AAChC,CAAA;AAEV;;;;;AAKG;AACI,MAAM,eAAe,GAAyB,MAAM,CAAC,MAAM,CAChE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAgB;AAG3C;;;;;AAKG;AACI,MAAM,qBAAqB,GAAyB,MAAM,CAAC,MAAM,CACtE,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,sBAAsB,CAAC,EAAE,CAAC,KAAK,WAAW,CAAC;AAG5E;;;;;AAKG;AACI,MAAM,mBAAmB,GAAyB,MAAM,CAAC,MAAM,CACpE,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,sBAAsB,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC;AAG1E;;;;;;;;;;;AAWG;AACG,SAAU,WAAW,CAAC,KAAc,EAAA;IACxC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC;AAC5F;AAEA;;;;;;;;;AASG;AACG,SAAU,oBAAoB,CAAC,KAAc,EAAA;IACjD,OAAO,WAAW,CAAC,KAAK,CAAC,IAAI,sBAAsB,CAAC,KAAK,CAAC,KAAK,WAAW;AAC5E;AAEA;;;;;;;;;;AAUG;AACG,SAAU,uBAAuB,CAAC,OAAkB,EAAA;AACxD,IAAA,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE;AACzB,QAAA,MAAM,IAAI,KAAK,CACb,CAAA,iBAAA,EAAoB,MAAM,CAAC,OAAO,CAAC,CAAA,oBAAA,EAAuB,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAE,CACvF;IACH;AACA,IAAA,OAAO,sBAAsB,CAAC,OAAO,CAAC;AACxC;;;;"}
+{"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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"}

package/dist/circuits.js

@@ -46,6 +46,8 @@ 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: 'arc_eligibility',
     /** GIWA attestation. Planned — not officially supported yet. */
     GIWA_ATTESTATION: 'giwa_attestation',
     /** Korea Mobile ID ownership. Planned — not officially supported yet. */
@@ -74,32 +76,41 @@ const CIRCUIT_SUPPORT_STATUS = Object.freeze({
     coinbase_attestation: 'supported',
     coinbase_country_attestation: 'supported',
     oidc_domain_attestation: 'supported',
+    arc_eligibility: 'experimental',
     giwa_attestation: 'planned',
     mdl_kr_ownership: 'planned',
     mdl_kr_age: 'planned',
     mdl_kr_region: 'planned',
 });
 /**
- * Where each circuit's verification key lives inside the `zkproofport/circuits`
- * repository, relative to its root.
+ * Where each circuit's verification key FILE lives inside the
+ * `zkproofport/circuits` repository, relative to its root.
  *
  * Off-chain verification needs the verification key and nothing else — no
  * circuit bytecode, no witness. The key is public by nature: it is what anyone
  * checking a proof must already have, and the Solidity verifiers deployed
  * on-chain embed the same key.
  *
+ * NOTE THE TRAILING `/vk` TWICE. In that repository `target/vk` is a DIRECTORY
+ * holding `vk`, `vk_hash` and `SHA256SUMS`; the key itself is `target/vk/vk`.
+ * These paths were first copied here from the mobile app, which keeps the
+ * directory and the filename as two fields and joins them — so taking only the
+ * directory produced a URL that answers 404, and the first browser to try
+ * off-chain verification said "Could not fetch the verification key (HTTP 404)".
+ *
  * Exhaustive over {@link CircuitId} on purpose. A new circuit whose key path is
  * not listed here fails to compile rather than failing at verification time,
  * where the only symptom would be a proof that cannot be checked.
  */
 const CIRCUIT_VK_PATHS = Object.freeze({
-    coinbase_attestation: 'coinbase-attestation/target/vk',
-    coinbase_country_attestation: 'coinbase-country-attestation/target/vk',
-    oidc_domain_attestation: 'oidc-domain-attestation/target/vk',
-    giwa_attestation: 'giwa-attestation/target/vk',
-    mdl_kr_ownership: 'mdl/kr-ownership/target/vk',
-    mdl_kr_age: 'mdl/kr-age/target/vk',
-    mdl_kr_region: 'mdl/kr-region/target/vk',
+    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',
+    mdl_kr_region: 'mdl/kr-region/target/vk/vk',
 });
 /**
  * Every canonical circuit identifier, in declaration order.
@@ -121,6 +132,17 @@ const SUPPORTED_CIRCUIT_IDS = Object.freeze(ALL_CIRCUIT_IDS.filter((id) => CIRCU
  *
  * Derived from {@link CIRCUIT_SUPPORT_STATUS}, so it cannot fall out of sync.
  */
+/**
+ * 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.
+ */
+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'));
 /**
  * Narrows an unknown value to a canonical circuit identifier.
@@ -167,11 +189,39 @@ function getCircuitSupportStatus(circuit) {
     }
     return CIRCUIT_SUPPORT_STATUS[circuit];
 }
+/**
+ * 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.
+ *
+ * `satisfies` and not an annotation, so a circuit added above is a compile
+ * error here until somebody decides which it is.
+ */
+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,
+    giwa_attestation: false,
+};
 
 exports.ALL_CIRCUIT_IDS = ALL_CIRCUIT_IDS;
 exports.CIRCUIT_IDS = CIRCUIT_IDS;
+exports.CIRCUIT_NEEDS_WALLET_SIGNATURE = CIRCUIT_NEEDS_WALLET_SIGNATURE;
 exports.CIRCUIT_SUPPORT_STATUS = CIRCUIT_SUPPORT_STATUS;
 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.getCircuitSupportStatus = getCircuitSupportStatus;

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' | '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    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 lives inside the `zkproofport/circuits`\n * 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 * 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',\n  coinbase_country_attestation: 'coinbase-country-attestation/target/vk',\n  oidc_domain_attestation: 'oidc-domain-attestation/target/vk',\n  giwa_attestation: 'giwa-attestation/target/vk',\n  mdl_kr_ownership: 'mdl/kr-ownership/target/vk',\n  mdl_kr_age: 'mdl/kr-age/target/vk',\n  mdl_kr_region: 'mdl/kr-region/target/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 */\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"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AAYH;;;;;;;;;;;;;;AAcG;AACI,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;;AAEvC,IAAA,oBAAoB,EAAE,sBAAsB;;AAE5C,IAAA,4BAA4B,EAAE,8BAA8B;;AAE5D,IAAA,uBAAuB,EAAE,yBAAyB;;AAElD,IAAA,gBAAgB,EAAE,kBAAkB;;AAEpC,IAAA,gBAAgB,EAAE,kBAAkB;;AAEpC,IAAA,UAAU,EAAE,YAAY;;AAExB,IAAA,aAAa,EAAE,eAAe;AACtB,CAAA;AAUV;;;;;;;;;;;;;;AAcG;AACI,MAAM,sBAAsB,GACjC,MAAM,CAAC,MAAM,CAAC;AACZ,IAAA,oBAAoB,EAAE,WAAW;AACjC,IAAA,4BAA4B,EAAE,WAAW;AACzC,IAAA,uBAAuB,EAAE,WAAW;AACpC,IAAA,gBAAgB,EAAE,SAAS;AAC3B,IAAA,gBAAgB,EAAE,SAAS;AAC3B,IAAA,UAAU,EAAE,SAAS;AACrB,IAAA,aAAa,EAAE,SAAS;AAChB,CAAA;AAEZ;;;;;;;;;;;;AAYG;AACI,MAAM,gBAAgB,GAAwC,MAAM,CAAC,MAAM,CAAC;AACjF,IAAA,oBAAoB,EAAE,gCAAgC;AACtD,IAAA,4BAA4B,EAAE,wCAAwC;AACtE,IAAA,uBAAuB,EAAE,mCAAmC;AAC5D,IAAA,gBAAgB,EAAE,4BAA4B;AAC9C,IAAA,gBAAgB,EAAE,4BAA4B;AAC9C,IAAA,UAAU,EAAE,sBAAsB;AAClC,IAAA,aAAa,EAAE,yBAAyB;AAChC,CAAA;AAEV;;;;;AAKG;AACI,MAAM,eAAe,GAAyB,MAAM,CAAC,MAAM,CAChE,MAAM,CAAC,MAAM,CAAC,WAAW,CAAgB;AAG3C;;;;;AAKG;AACI,MAAM,qBAAqB,GAAyB,MAAM,CAAC,MAAM,CACtE,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,sBAAsB,CAAC,EAAE,CAAC,KAAK,WAAW,CAAC;AAG5E;;;;;AAKG;AACI,MAAM,mBAAmB,GAAyB,MAAM,CAAC,MAAM,CACpE,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,sBAAsB,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC;AAG1E;;;;;;;;;;;AAWG;AACG,SAAU,WAAW,CAAC,KAAc,EAAA;IACxC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,eAAqC,CAAC,QAAQ,CAAC,KAAK,CAAC;AAC5F;AAEA;;;;;;;;;AASG;AACG,SAAU,oBAAoB,CAAC,KAAc,EAAA;IACjD,OAAO,WAAW,CAAC,KAAK,CAAC,IAAI,sBAAsB,CAAC,KAAK,CAAC,KAAK,WAAW;AAC5E;AAEA;;;;;;;;;;AAUG;AACG,SAAU,uBAAuB,CAAC,OAAkB,EAAA;AACxD,IAAA,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE;AACzB,QAAA,MAAM,IAAI,KAAK,CACb,CAAA,iBAAA,EAAoB,MAAM,CAAC,OAAO,CAAC,CAAA,oBAAA,EAAuB,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAE,CACvF;IACH;AACA,IAAA,OAAO,sBAAsB,CAAC,OAAO,CAAC;AACxC;;;;;;;;;;;;"}
+{"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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"}