@rhinestone/1auth 0.6.8 → 0.6.10

package/README.md

@@ -28,7 +28,7 @@ The SDK provides multiple entry points for different use cases:
 |-------------|--------|----------|
 | Default | `@rhinestone/1auth` | Core client, provider, types |
 | React | `@rhinestone/1auth/react` | PayButton component |
-| Server | `@rhinestone/1auth/server` | Server-side intent signing |
+| Server | `@rhinestone/1auth/server` | JWT signer for app-sponsored intents |
 | Wagmi | `@rhinestone/1auth/wagmi` | Wagmi connector integration |
 
 ## Quick Start
@@ -84,18 +84,22 @@ const config = createConfig({
 });
 ```
 
-### Server-Side Intent Signing
+### Server-Side JWT Sponsorship
 
 ```typescript
-import { signIntent, createSignIntentHandler } from '@rhinestone/1auth/server';
-
-// Sign an intent with Ed25519
-const signedIntent = await signIntent(intent, privateKey);
-
-// Or create a request handler
-const handler = createSignIntentHandler({
-  privateKey: process.env.SIGNING_KEY,
+import { createJwtSigner } from '@rhinestone/1auth/server';
+
+const signer = createJwtSigner({
+  privateKey: JSON.parse(process.env.RHINESTONE_JWT_PRIVATE_KEY),
+  integratorId: process.env.RHINESTONE_INTEGRATOR_ID,
+  projectId: process.env.RHINESTONE_PROJECT_ID,
+  appId: process.env.RHINESTONE_APP_ID,
+  keyId: process.env.RHINESTONE_KEY_ID,
 });
+
+// Use in your API routes
+const accessToken = await signer.accessToken();
+const extensionToken = await signer.getIntentExtensionToken(intentInput);
 ```
 
 ## Core Exports
@@ -118,13 +122,168 @@ const handler = createSignIntentHandler({
 
 ### `@rhinestone/1auth/server`
 
-- `signIntent()` - Server-side intent signing with Ed25519
-- `createSignIntentHandler()` - Express/fetch handler for intent signing
+- `createJwtSigner()` - Create a JWT signer for app-sponsored intents (RS256)
+- `JwtSignerConfig` - Configuration type for the JWT signer
 
 ### `@rhinestone/1auth/wagmi`
 
 - `oneAuth()` - Wagmi connector factory
 
+## App-Sponsored Intents
+
+By default, 1auth sponsors transaction fees for all intents. With sponsorship, your app takes over billing by providing JWT tokens to authorize each intent.
+
+### How It Works
+
+```mermaid
+sequenceDiagram
+    participant App as Your App
+    participant BE as Your Backend
+    participant SDK as @rhinestone/1auth
+    participant PS as 1auth Passkey Service
+
+    Note over App,SDK: 1. Configure the client with sponsorship URLs
+    App->>SDK: new OneAuthClient({<br/>  sponsorship: {<br/>    accessTokenUrl,<br/>    extensionTokenUrl<br/>  }<br/>})
+
+    Note over SDK,BE: 2. Prepare the intent
+    SDK->>PS: POST /api/intent/prepare
+    PS-->>SDK: { intentOp, digestResult, ... }
+
+    Note over SDK,BE: 3. In parallel: fetch tokens (same-origin, with session cookie) + WebAuthn ceremony
+    par
+      SDK->>BE: GET /sponsorship/access-token
+      BE-->>SDK: { token: "eyJhbG..." }
+    and
+      SDK->>BE: POST /sponsorship/extension-token { intentOp }
+      BE-->>SDK: { token: "eyJhbG..." }
+    and
+      SDK->>SDK: WebAuthn signing ceremony
+    end
+
+    Note over SDK,PS: 4. Execute with pre-fetched tokens in request body
+    SDK->>PS: POST /api/intent/execute<br/>{ signature, sponsorship: { accessToken, extensionToken } }
+    PS-->>SDK: { intentId }
+```
+
+### Why this shape
+
+The SDK calls your token endpoints **from the browser, same-origin**. Your app's session cookie naturally authenticates the request — no need to pass bearer tokens through the SDK. The passkey service never fetches from your backend on your behalf, so there's no SSRF surface and no CORS config to worry about.
+
+### Setup
+
+**1. Create two endpoints on your backend, on the same origin as your app**
+
+Gate these with your existing session auth — the user's cookie rides along automatically.
+
+```typescript
+// GET /api/sponsorship/access-token
+import { createJwtSigner } from '@rhinestone/1auth/server';
+
+const signer = createJwtSigner({
+  jwt: {
+    privateKey: JSON.parse(process.env.RHINESTONE_JWT_PRIVATE_KEY),
+    integratorId: process.env.RHINESTONE_INTEGRATOR_ID,
+    projectId: process.env.RHINESTONE_PROJECT_ID,
+    appId: process.env.RHINESTONE_APP_ID,
+    keyId: process.env.RHINESTONE_KEY_ID,
+  },
+});
+
+export async function handleAccessToken(req, res) {
+  const user = await verifySession(req); // your app's auth
+  if (!user) return res.status(401).json({ error: 'Unauthorized' });
+  const token = await signer.accessToken();
+  res.json({ token });
+}
+
+// POST /api/sponsorship/extension-token
+// Body: { intentOp: string }  — JSON-stringified intent operation
+export async function handleExtensionToken(req, res) {
+  const user = await verifySession(req);
+  if (!user) return res.status(401).json({ error: 'Unauthorized' });
+
+  const { intentOp } = req.body;
+  const intentInput = JSON.parse(intentOp);
+
+  // Enforce policies
+  if (await exceedsSpendingLimit(user.id)) {
+    return res.status(403).json({ error: 'Spending limit exceeded' });
+  }
+
+  const token = await signer.getIntentExtensionToken(intentInput);
+  res.json({ token });
+}
+```
+
+**2. Configure `OneAuthClient` with the URL form**
+
+```typescript
+import { OneAuthClient, createOneAuthProvider } from '@rhinestone/1auth';
+
+const client = new OneAuthClient({
+  providerUrl: 'https://passkey.1auth.box',
+  sponsorship: {
+    accessTokenUrl: '/api/sponsorship/access-token',
+    extensionTokenUrl: '/api/sponsorship/extension-token',
+  },
+});
+
+const provider = createOneAuthProvider({ client, chainId: 8453 });
+
+const txHash = await provider.request({
+  method: 'eth_sendTransaction',
+  params: [{ to: '0x...', data: '0x...' }],
+});
+```
+
+**React apps** can use the convenience hook:
+
+```tsx
+import { useSponsorship } from '@rhinestone/1auth/react';
+import { OneAuthClient } from '@rhinestone/1auth';
+
+function MyApp() {
+  const sponsorship = useSponsorship({
+    accessTokenUrl: '/api/sponsorship/access-token',
+    extensionTokenUrl: '/api/sponsorship/extension-token',
+  });
+
+  const client = useMemo(
+    () => new OneAuthClient({ providerUrl, sponsorship }),
+    [sponsorship],
+  );
+  // ...
+}
+```
+
+The hook caches the access token in a ref and refetches on 401 from the extension-token endpoint.
+
+### SponsorshipConfig
+
+`SponsorshipConfig` is a discriminated union — pick whichever form fits:
+
+```typescript
+// Convenience form — SDK does the fetching.
+type SponsorshipUrlConfig = {
+  accessTokenUrl: string;     // GET  → { token }
+  extensionTokenUrl: string;  // POST { intentOp: string } → { token }
+};
+
+// Low-level form — you control token sourcing / refresh / caching.
+type SponsorshipCallbackConfig = {
+  accessToken: () => Promise<string>;
+  getExtensionToken: (intentOp: string) => Promise<string>;
+};
+
+type SponsorshipConfig = SponsorshipUrlConfig | SponsorshipCallbackConfig;
+```
+
+The SDK pre-fetches both tokens in parallel with the WebAuthn signing ceremony and passes them to the passkey service via the execute request body. The passkey service never makes outbound requests to your backend.
+
+### Without Sponsorship
+
+If you don't pass `sponsorship`, 1auth sponsors intents on your behalf using its own API key. No changes needed — this is the default behavior.
+
 ## License
 
 MIT

package/dist/chunk-GUAI55LL.mjs

@@ -0,0 +1,179 @@
+// src/registry.ts
+import { isAddress } from "viem";
+import * as viemChains from "viem/chains";
+import { chainRegistry } from "@rhinestone/shared-configs";
+var env = typeof process !== "undefined" ? process.env : {};
+var VIEM_CHAIN_BY_ID = /* @__PURE__ */ new Map();
+for (const value of Object.values(viemChains)) {
+  if (typeof value !== "object" || value === null || !("id" in value) || !("name" in value)) continue;
+  const chain = value;
+  const existing = VIEM_CHAIN_BY_ID.get(chain.id);
+  if (!existing || existing.testnet && !chain.testnet) {
+    VIEM_CHAIN_BY_ID.set(chain.id, chain);
+  }
+}
+function isEvmRegistryEntry(entry) {
+  return entry?.vmType === "evm";
+}
+function getEvmRegistryEntry(chainId) {
+  const entry = chainRegistry[String(chainId)];
+  return isEvmRegistryEntry(entry) ? entry : void 0;
+}
+var REGISTRY_CHAIN_IDS = Object.entries(chainRegistry).filter(([, entry]) => isEvmRegistryEntry(entry)).map(([id]) => Number(id));
+var SUPPORTED_CHAIN_IDS = new Set(REGISTRY_CHAIN_IDS);
+function tokensForChain(chainId) {
+  const entry = getEvmRegistryEntry(chainId);
+  if (!entry) return [];
+  return entry.tokens.map((token) => ({
+    symbol: token.symbol,
+    address: token.address,
+    decimals: token.decimals
+  }));
+}
+function isAddressInput(value) {
+  return isAddress(value, { strict: false });
+}
+function parseBool(value) {
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  return void 0;
+}
+function resolveIncludeTestnets(explicit) {
+  if (explicit !== void 0) return explicit;
+  const envValue = parseBool(env.NEXT_PUBLIC_ORCHESTRATOR_USE_TESTNETS) ?? parseBool(env.ORCHESTRATOR_USE_TESTNETS);
+  return envValue ?? false;
+}
+function applyChainFilters(chainIds, options) {
+  const includeTestnets = resolveIncludeTestnets(options?.includeTestnets);
+  const allowlist = options?.chainIds;
+  let filtered = chainIds;
+  if (!includeTestnets) {
+    filtered = filtered.filter((chainId) => !isTestnet(chainId));
+  }
+  if (allowlist) {
+    const allowed = new Set(allowlist);
+    filtered = filtered.filter((chainId) => allowed.has(chainId));
+  }
+  return filtered;
+}
+function getSupportedChainIds(options) {
+  return applyChainFilters(REGISTRY_CHAIN_IDS, options);
+}
+function getSupportedChains(options) {
+  return getSupportedChainIds(options).map((chainId) => VIEM_CHAIN_BY_ID.get(chainId)).filter((chain) => Boolean(chain));
+}
+function getAllSupportedChainsAndTokens(options) {
+  return getSupportedChainIds(options).map((chainId) => ({
+    chainId,
+    tokens: tokensForChain(chainId)
+  }));
+}
+function getChainById(chainId) {
+  if (!SUPPORTED_CHAIN_IDS.has(chainId)) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  const chain = VIEM_CHAIN_BY_ID.get(chainId);
+  if (!chain) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return chain;
+}
+function getChainName(chainId) {
+  try {
+    return getChainById(chainId).name;
+  } catch {
+    return `Chain ${chainId}`;
+  }
+}
+function getChainExplorerUrl(chainId) {
+  try {
+    return getChainById(chainId).blockExplorers?.default?.url;
+  } catch {
+    return void 0;
+  }
+}
+function getChainRpcUrl(chainId) {
+  try {
+    const chain = getChainById(chainId);
+    return chain.rpcUrls?.default?.http?.[0] || chain.rpcUrls?.public?.http?.[0];
+  } catch {
+    return void 0;
+  }
+}
+function getSupportedTokens(chainId) {
+  return tokensForChain(chainId);
+}
+function getSupportedTokenSymbols(chainId) {
+  return getSupportedTokens(chainId).map((token) => token.symbol);
+}
+function getTokenAddress(symbolOrAddress, chainId) {
+  if (isAddressInput(symbolOrAddress)) {
+    return symbolOrAddress;
+  }
+  const match = getSupportedTokens(chainId).find(
+    (t) => t.symbol.toUpperCase() === symbolOrAddress.toUpperCase()
+  );
+  if (!match) {
+    throw new Error(`Unsupported token "${symbolOrAddress}" on chain ${chainId}`);
+  }
+  return match.address;
+}
+function getTokenDecimals(symbolOrAddress, chainId) {
+  const match = getSupportedTokens(chainId).find(
+    (t) => isAddressInput(symbolOrAddress) ? t.address.toLowerCase() === symbolOrAddress.toLowerCase() : t.symbol.toUpperCase() === symbolOrAddress.toUpperCase()
+  );
+  if (!match && isAddressInput(symbolOrAddress) && SUPPORTED_CHAIN_IDS.has(chainId)) {
+    return 18;
+  }
+  if (!match) {
+    throw new Error(`Unsupported token "${symbolOrAddress}" on chain ${chainId}`);
+  }
+  return match.decimals;
+}
+function resolveTokenAddress(token, chainId) {
+  if (isAddressInput(token)) {
+    return token;
+  }
+  return getTokenAddress(token, chainId);
+}
+function isTestnet(chainId) {
+  try {
+    return getChainById(chainId).testnet ?? false;
+  } catch {
+    return false;
+  }
+}
+function getTokenSymbol(tokenAddress, chainId) {
+  const token = getSupportedTokens(chainId).find(
+    (entry) => entry.address.toLowerCase() === tokenAddress.toLowerCase()
+  );
+  if (token) {
+    return token.symbol;
+  }
+  if (!SUPPORTED_CHAIN_IDS.has(chainId)) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return "Token";
+}
+function isTokenAddressSupported(tokenAddress, chainId) {
+  return isAddressInput(tokenAddress) && SUPPORTED_CHAIN_IDS.has(chainId);
+}
+
+export {
+  getSupportedChainIds,
+  getSupportedChains,
+  getAllSupportedChainsAndTokens,
+  getChainById,
+  getChainName,
+  getChainExplorerUrl,
+  getChainRpcUrl,
+  getSupportedTokens,
+  getSupportedTokenSymbols,
+  getTokenAddress,
+  getTokenDecimals,
+  resolveTokenAddress,
+  isTestnet,
+  getTokenSymbol,
+  isTokenAddressSupported
+};
+//# sourceMappingURL=chunk-GUAI55LL.mjs.map

package/dist/chunk-GUAI55LL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/registry.ts"],"sourcesContent":["/**\n * @file Chain and token registry for the 1auth SDK.\n *\n * Wraps `@rhinestone/shared-configs` chain/token data and combines it with\n * viem's chain definitions to expose a filtered, testnet-aware registry.\n * Consumers can look up supported chains and tokens, resolve token addresses\n * by symbol, and retrieve chain metadata such as explorer URLs and default RPC\n * endpoints.\n *\n * Testnet inclusion is controlled by the `includeTestnets` option on each\n * function or, as a project-wide default, by the environment variables\n * `NEXT_PUBLIC_ORCHESTRATOR_USE_TESTNETS` or `ORCHESTRATOR_USE_TESTNETS`.\n */\n\nimport type { Address, Chain } from \"viem\";\nimport { isAddress } from \"viem\";\nimport * as viemChains from \"viem/chains\";\nimport { chainRegistry } from \"@rhinestone/shared-configs\";\n\nexport type TokenConfig = {\n  symbol: string;\n  address: Address;\n  decimals: number;\n};\n\nexport type ChainFilterOptions = {\n  includeTestnets?: boolean;\n  chainIds?: number[];\n};\n\ntype ChainRegistryEntry = (typeof chainRegistry)[keyof typeof chainRegistry];\n\nconst env: Record<string, string | undefined> =\n  typeof process !== \"undefined\" ? process.env : {};\n\n// Build a chain-ID-to-Chain map from viem, resolving collisions by preferring\n// mainnet definitions over testnets. viem exports duplicate numeric IDs (e.g.\n// zoraTestnet and hyperEvm both use 999); a naive Map would silently keep\n// whichever entry happens to appear last in iteration order, which may be the\n// testnet. The loop below only overwrites an existing entry when the incoming\n// chain is NOT a testnet and the existing one IS, ensuring the production chain\n// always wins while still falling back to a testnet entry when no mainnet\n// definition exists for a given ID.\nconst VIEM_CHAIN_BY_ID = new Map<number, Chain>();\nfor (const value of Object.values(viemChains)) {\n  if (typeof value !== \"object\" || value === null || !(\"id\" in value) || !(\"name\" in value)) continue;\n  const chain = value as Chain;\n  const existing = VIEM_CHAIN_BY_ID.get(chain.id);\n  if (!existing || (existing.testnet && !chain.testnet)) {\n    VIEM_CHAIN_BY_ID.set(chain.id, chain);\n  }\n}\n\nfunction isEvmRegistryEntry(\n  entry: ChainRegistryEntry | undefined,\n): entry is ChainRegistryEntry & { vmType: \"evm\" } {\n  return entry?.vmType === \"evm\";\n}\n\nfunction getEvmRegistryEntry(\n  chainId: number,\n): (ChainRegistryEntry & { vmType: \"evm\" }) | undefined {\n  const entry = chainRegistry[String(chainId) as keyof typeof chainRegistry];\n  return isEvmRegistryEntry(entry) ? entry : undefined;\n}\n\n// The shared-configs registry includes non-EVM chains (Solana, Tron). Filter\n// to EVM entries before exposing supported chains — downstream consumers\n// (viem clients, wallet_getCapabilities, RPC proxy) only handle eip155 chains.\nconst REGISTRY_CHAIN_IDS = Object.entries(chainRegistry)\n  .filter(([, entry]) => isEvmRegistryEntry(entry))\n  .map(([id]) => Number(id));\nconst SUPPORTED_CHAIN_IDS = new Set(REGISTRY_CHAIN_IDS);\n\nfunction tokensForChain(chainId: number): TokenConfig[] {\n  const entry = getEvmRegistryEntry(chainId);\n  if (!entry) return [];\n  return entry.tokens.map((token) => ({\n    symbol: token.symbol,\n    address: token.address as Address,\n    decimals: token.decimals,\n  }));\n}\n\n/** Treat any 20-byte hex string as an address; checksum casing is optional for user inputs. */\nfunction isAddressInput(value: string): value is Address {\n  return isAddress(value, { strict: false });\n}\n\n/**\n * Parse a string environment variable into a boolean, returning `undefined`\n * when the value is absent or not a recognised truthy/falsy literal.\n *\n * Accepted truthy values: `\"true\"`, `\"1\"`.\n * Accepted falsy values: `\"false\"`, `\"0\"`.\n */\nfunction parseBool(value?: string): boolean | undefined {\n  if (value === \"true\" || value === \"1\") return true;\n  if (value === \"false\" || value === \"0\") return false;\n  return undefined;\n}\n\n/**\n * Determine whether testnet chains should be included in registry results.\n *\n * Precedence (highest to lowest):\n * 1. `explicit` argument — a caller-supplied boolean always wins.\n * 2. `NEXT_PUBLIC_ORCHESTRATOR_USE_TESTNETS` env var — checked first so\n *    Next.js browser bundles (which only expose `NEXT_PUBLIC_*` variables)\n *    can configure testnet mode without a server-side env var.\n * 3. `ORCHESTRATOR_USE_TESTNETS` env var — server-side / Node.js fallback.\n * 4. Defaults to `false` (testnets excluded) when none of the above is set.\n */\nfunction resolveIncludeTestnets(explicit?: boolean): boolean {\n  if (explicit !== undefined) return explicit;\n  const envValue =\n    parseBool(env.NEXT_PUBLIC_ORCHESTRATOR_USE_TESTNETS) ??\n    parseBool(env.ORCHESTRATOR_USE_TESTNETS);\n  return envValue ?? false;\n}\n\nfunction applyChainFilters(chainIds: number[], options?: ChainFilterOptions): number[] {\n  const includeTestnets = resolveIncludeTestnets(options?.includeTestnets);\n  const allowlist = options?.chainIds;\n  let filtered = chainIds;\n\n  if (!includeTestnets) {\n    filtered = filtered.filter((chainId) => !isTestnet(chainId));\n  }\n\n  if (allowlist) {\n    const allowed = new Set(allowlist);\n    filtered = filtered.filter((chainId) => allowed.has(chainId));\n  }\n\n  return filtered;\n}\n\nexport function getSupportedChainIds(options?: ChainFilterOptions): number[] {\n  return applyChainFilters(REGISTRY_CHAIN_IDS, options);\n}\n\nexport function getSupportedChains(options?: ChainFilterOptions): Chain[] {\n  return getSupportedChainIds(options)\n    .map((chainId) => VIEM_CHAIN_BY_ID.get(chainId))\n    .filter((chain): chain is Chain => Boolean(chain));\n}\n\nexport function getAllSupportedChainsAndTokens(options?: ChainFilterOptions): Array<{\n  chainId: number;\n  tokens: TokenConfig[];\n}> {\n  return getSupportedChainIds(options).map((chainId) => ({\n    chainId,\n    tokens: tokensForChain(chainId),\n  }));\n}\n\nexport function getChainById(chainId: number): Chain {\n  if (!SUPPORTED_CHAIN_IDS.has(chainId)) {\n    throw new Error(`Unsupported chain ID: ${chainId}`);\n  }\n  const chain = VIEM_CHAIN_BY_ID.get(chainId);\n  if (!chain) {\n    throw new Error(`Unsupported chain ID: ${chainId}`);\n  }\n  return chain;\n}\n\nexport function getChainName(chainId: number): string {\n  try {\n    return getChainById(chainId).name;\n  } catch {\n    return `Chain ${chainId}`;\n  }\n}\n\nexport function getChainExplorerUrl(chainId: number): string | undefined {\n  try {\n    return getChainById(chainId).blockExplorers?.default?.url;\n  } catch {\n    return undefined;\n  }\n}\n\nexport function getChainRpcUrl(chainId: number): string | undefined {\n  try {\n    const chain = getChainById(chainId);\n    return chain.rpcUrls?.default?.http?.[0] || chain.rpcUrls?.public?.http?.[0];\n  } catch {\n    return undefined;\n  }\n}\n\nexport function getSupportedTokens(chainId: number): TokenConfig[] {\n  return tokensForChain(chainId);\n}\n\nexport function getSupportedTokenSymbols(chainId: number): string[] {\n  return getSupportedTokens(chainId).map((token) => token.symbol);\n}\n\nexport function getTokenAddress(symbolOrAddress: string, chainId: number): Address {\n  if (isAddressInput(symbolOrAddress)) {\n    return symbolOrAddress;\n  }\n  const match = getSupportedTokens(chainId).find(\n    (t) => t.symbol.toUpperCase() === symbolOrAddress.toUpperCase()\n  );\n  if (!match) {\n    throw new Error(`Unsupported token \"${symbolOrAddress}\" on chain ${chainId}`);\n  }\n  return match.address;\n}\n\nexport function getTokenDecimals(symbolOrAddress: string, chainId: number): number {\n  const match = getSupportedTokens(chainId).find(\n    (t) =>\n      isAddressInput(symbolOrAddress)\n        ? t.address.toLowerCase() === symbolOrAddress.toLowerCase()\n        : t.symbol.toUpperCase() === symbolOrAddress.toUpperCase()\n  );\n  if (!match && isAddressInput(symbolOrAddress) && SUPPORTED_CHAIN_IDS.has(chainId)) {\n    return 18;\n  }\n  if (!match) {\n    throw new Error(`Unsupported token \"${symbolOrAddress}\" on chain ${chainId}`);\n  }\n  return match.decimals;\n}\n\nexport function resolveTokenAddress(token: string, chainId: number): Address {\n  if (isAddressInput(token)) {\n    return token;\n  }\n  return getTokenAddress(token, chainId);\n}\n\nexport function isTestnet(chainId: number): boolean {\n  try {\n    return getChainById(chainId).testnet ?? false;\n  } catch {\n    return false;\n  }\n}\n\nexport function getTokenSymbol(tokenAddress: Address, chainId: number): string {\n  const token = getSupportedTokens(chainId).find(\n    (entry) => entry.address.toLowerCase() === tokenAddress.toLowerCase()\n  );\n  if (token) {\n    return token.symbol;\n  }\n  if (!SUPPORTED_CHAIN_IDS.has(chainId)) {\n    throw new Error(`Unsupported chain ID: ${chainId}`);\n  }\n  return \"Token\";\n}\n\nexport function isTokenAddressSupported(tokenAddress: Address, chainId: number): boolean {\n  return isAddressInput(tokenAddress) && SUPPORTED_CHAIN_IDS.has(chainId);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-IHBVEU33.mjs

@@ -0,0 +1,20 @@
+// src/verify.ts
+import { keccak256, toBytes } from "viem";
+var ETHEREUM_MESSAGE_PREFIX = "Ethereum Signed Message:\n";
+function hashMessage(message) {
+  const messageBytes = toBytes(message);
+  const prefixed = ETHEREUM_MESSAGE_PREFIX + messageBytes.length.toString() + message;
+  return keccak256(toBytes(prefixed));
+}
+function verifyMessageHash(message, signedHash) {
+  if (!signedHash) return false;
+  const expectedHash = hashMessage(message);
+  return expectedHash.toLowerCase() === signedHash.toLowerCase();
+}
+
+export {
+  ETHEREUM_MESSAGE_PREFIX,
+  hashMessage,
+  verifyMessageHash
+};
+//# sourceMappingURL=chunk-IHBVEU33.mjs.map

package/dist/chunk-IHBVEU33.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/verify.ts"],"sourcesContent":["import { keccak256, toBytes } from \"viem\";\n\n/**\n * The EIP-191 prefix used for personal message signing.\n * This is the standard Ethereum message prefix for `personal_sign`.\n */\nexport const ETHEREUM_MESSAGE_PREFIX = \"\\x19Ethereum Signed Message:\\n\";\n\n/**\n * Hash a message with the EIP-191 Ethereum prefix.\n *\n * This is the same hashing function used by the passkey sign dialog.\n * Use this to verify that the `signedHash` returned from `signMessage()`\n * matches your original message.\n *\n * Format: keccak256(\"\\x19Ethereum Signed Message:\\n\" + len + message)\n *\n * @example\n * ```typescript\n * const message = \"Sign in to MyApp\\nTimestamp: 1234567890\";\n * const result = await client.signMessage({ username: 'alice', message });\n *\n * // Verify the hash matches\n * const expectedHash = hashMessage(message);\n * if (result.signedHash === expectedHash) {\n *   console.log('Hash matches - signature is for this message');\n * }\n * ```\n */\nexport function hashMessage(message: string): `0x${string}` {\n  const messageBytes = toBytes(message);\n  const prefixed = ETHEREUM_MESSAGE_PREFIX + messageBytes.length.toString() + message;\n  return keccak256(toBytes(prefixed));\n}\n\n/**\n * Verify that a signedHash matches the expected message.\n *\n * This is a convenience wrapper around `hashMessage()` that returns\n * a boolean. For full cryptographic verification of the P256 signature,\n * use on-chain verification via the WebAuthn.sol contract.\n *\n * @example\n * ```typescript\n * const result = await client.signMessage({ username: 'alice', message });\n *\n * if (result.success && verifyMessageHash(message, result.signedHash)) {\n *   // The signature is for this exact message\n *   // For full verification, verify the P256 signature on-chain or server-side\n * }\n * ```\n */\nexport function verifyMessageHash(\n  message: string,\n  signedHash: string | undefined\n): boolean {\n  if (!signedHash) return false;\n  const expectedHash = hashMessage(message);\n  return expectedHash.toLowerCase() === signedHash.toLowerCase();\n}\n"],"mappings":";AAAA,SAAS,WAAW,eAAe;AAM5B,IAAM,0BAA0B;AAuBhC,SAAS,YAAY,SAAgC;AAC1D,QAAM,eAAe,QAAQ,OAAO;AACpC,QAAM,WAAW,0BAA0B,aAAa,OAAO,SAAS,IAAI;AAC5E,SAAO,UAAU,QAAQ,QAAQ,CAAC;AACpC;AAmBO,SAAS,kBACd,SACA,YACS;AACT,MAAI,CAAC,WAAY,QAAO;AACxB,QAAM,eAAe,YAAY,OAAO;AACxC,SAAO,aAAa,YAAY,MAAM,WAAW,YAAY;AAC/D;","names":[]}

package/dist/chunk-IIACVHR3.mjs

@@ -0,0 +1,28 @@
+// src/sponsorship-fetch.ts
+async function extractServerReason(response) {
+  try {
+    const text = await response.clone().text();
+    if (!text) return response.statusText;
+    try {
+      const data = JSON.parse(text);
+      const reason = data.error ?? data.message;
+      if (typeof reason === "string" && reason.trim()) return reason;
+    } catch {
+    }
+    return text.slice(0, 200);
+  } catch {
+    return response.statusText;
+  }
+}
+async function tokenFetchError(label, response) {
+  const reason = await extractServerReason(response);
+  const suffix = reason ? `: ${reason}` : "";
+  return new Error(
+    `Failed to fetch ${label} (${response.status} ${response.statusText})${suffix}`
+  );
+}
+
+export {
+  tokenFetchError
+};
+//# sourceMappingURL=chunk-IIACVHR3.mjs.map

package/dist/chunk-IIACVHR3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sponsorship-fetch.ts"],"sourcesContent":["/**\n * Shared helpers for fetching sponsorship tokens (access + extension) from an\n * integrator's backend endpoints.\n *\n * The integrator's token routes return their failure reason in the JSON body\n * (`{ error: \"createSponsorshipSigner: missing env var(s): ...\" }`). Surfacing\n * only the HTTP status — \"Failed to fetch access token (500 ...)\" — hides that\n * reason and turns every misconfiguration into the same opaque dialog error.\n * These helpers read the body and fold the server's message into the thrown\n * Error so the actual cause (missing env var, bad JWK, expired session) is\n * visible at the call site and in the dialog.\n */\n\n/**\n * Pull a human-readable reason out of a failed token response. Tries the JSON\n * `error`/`message` fields first, then falls back to a short text snippet, then\n * to the HTTP status text. Never throws — diagnostics must not mask the original\n * failure with a parse error.\n */\nasync function extractServerReason(response: Response): Promise<string> {\n  try {\n    // Clone so a JSON parse failure can still fall back to reading text.\n    const text = await response.clone().text();\n    if (!text) return response.statusText;\n    try {\n      const data = JSON.parse(text) as { error?: unknown; message?: unknown };\n      const reason = data.error ?? data.message;\n      if (typeof reason === \"string\" && reason.trim()) return reason;\n    } catch {\n      // Body wasn't JSON — fall through to the raw text snippet.\n    }\n    // Cap the snippet so an HTML error page doesn't flood the message.\n    return text.slice(0, 200);\n  } catch {\n    return response.statusText;\n  }\n}\n\n/**\n * Build an Error for a failed token fetch that includes the server's reason.\n * `label` names the token kind, e.g. \"access token\" or \"extension token\".\n */\nexport async function tokenFetchError(\n  label: string,\n  response: Response,\n): Promise<Error> {\n  const reason = await extractServerReason(response);\n  const suffix = reason ? `: ${reason}` : \"\";\n  return new Error(\n    `Failed to fetch ${label} (${response.status} ${response.statusText})${suffix}`,\n  );\n}\n"],"mappings":";AAmBA,eAAe,oBAAoB,UAAqC;AACtE,MAAI;AAEF,UAAM,OAAO,MAAM,SAAS,MAAM,EAAE,KAAK;AACzC,QAAI,CAAC,KAAM,QAAO,SAAS;AAC3B,QAAI;AACF,YAAM,OAAO,KAAK,MAAM,IAAI;AAC5B,YAAM,SAAS,KAAK,SAAS,KAAK;AAClC,UAAI,OAAO,WAAW,YAAY,OAAO,KAAK,EAAG,QAAO;AAAA,IAC1D,QAAQ;AAAA,IAER;AAEA,WAAO,KAAK,MAAM,GAAG,GAAG;AAAA,EAC1B,QAAQ;AACN,WAAO,SAAS;AAAA,EAClB;AACF;AAMA,eAAsB,gBACpB,OACA,UACgB;AAChB,QAAM,SAAS,MAAM,oBAAoB,QAAQ;AACjD,QAAM,SAAS,SAAS,KAAK,MAAM,KAAK;AACxC,SAAO,IAAI;AAAA,IACT,mBAAmB,KAAK,KAAK,SAAS,MAAM,IAAI,SAAS,UAAU,IAAI,MAAM;AAAA,EAC/E;AACF;","names":[]}

package/dist/chunk-N6KE5CII.mjs

@@ -0,0 +1,72 @@
+// src/walletClient/utils.ts
+import { encodeAbiParameters, keccak256 } from "viem";
+var P256_N = BigInt(
+  "0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551"
+);
+var P256_N_DIV_2 = P256_N / 2n;
+var WEBAUTHN_AUTH_TYPE = {
+  type: "tuple",
+  components: [
+    { type: "bytes", name: "authenticatorData" },
+    { type: "string", name: "clientDataJSON" },
+    { type: "uint256", name: "challengeIndex" },
+    { type: "uint256", name: "typeIndex" },
+    { type: "uint256", name: "r" },
+    { type: "uint256", name: "s" }
+  ]
+};
+function encodeWebAuthnSignature(sig) {
+  let s = BigInt(sig.s);
+  if (s > P256_N_DIV_2) {
+    s = P256_N - s;
+  }
+  return encodeAbiParameters([WEBAUTHN_AUTH_TYPE], [
+    {
+      authenticatorData: sig.authenticatorData,
+      clientDataJSON: sig.clientDataJSON,
+      challengeIndex: BigInt(sig.challengeIndex),
+      typeIndex: BigInt(sig.typeIndex),
+      r: BigInt(sig.r),
+      s
+    }
+  ]);
+}
+function hashCalls(calls) {
+  const encoded = encodeAbiParameters(
+    [
+      {
+        type: "tuple[]",
+        components: [
+          { type: "address", name: "to" },
+          { type: "bytes", name: "data" },
+          { type: "uint256", name: "value" }
+        ]
+      }
+    ],
+    [
+      calls.map((c) => ({
+        to: c.to,
+        data: c.data || "0x",
+        value: c.value || 0n
+      }))
+    ]
+  );
+  return keccak256(encoded);
+}
+function buildTransactionReview(calls) {
+  return {
+    actions: calls.map((call, i) => ({
+      type: "custom",
+      label: call.label || `Contract Call ${i + 1}`,
+      sublabel: call.sublabel || `To: ${call.to.slice(0, 10)}...${call.to.slice(-8)}`,
+      amount: call.value ? `${call.value} wei` : void 0
+    }))
+  };
+}
+
+export {
+  encodeWebAuthnSignature,
+  hashCalls,
+  buildTransactionReview
+};
+//# sourceMappingURL=chunk-N6KE5CII.mjs.map

package/dist/chunk-N6KE5CII.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/walletClient/utils.ts"],"sourcesContent":["import { encodeAbiParameters, keccak256 } from 'viem';\nimport type { Hex } from 'viem';\nimport type { WebAuthnSignature } from '../types';\nimport type { TransactionCall } from './types';\n\n/**\n * P-256 curve order (n)\n * Used for signature malleability normalization\n */\nconst P256_N = BigInt(\n  '0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551'\n);\nconst P256_N_DIV_2 = P256_N / 2n;\n\n/**\n * WebAuthnAuth struct type for ABI encoding\n */\nconst WEBAUTHN_AUTH_TYPE = {\n  type: 'tuple',\n  components: [\n    { type: 'bytes', name: 'authenticatorData' },\n    { type: 'string', name: 'clientDataJSON' },\n    { type: 'uint256', name: 'challengeIndex' },\n    { type: 'uint256', name: 'typeIndex' },\n    { type: 'uint256', name: 'r' },\n    { type: 'uint256', name: 's' },\n  ],\n} as const;\n\n/**\n * Encode a WebAuthn signature for ERC-1271 verification on-chain\n *\n * @param sig - The WebAuthn signature from the passkey\n * @returns ABI-encoded signature bytes\n */\nexport function encodeWebAuthnSignature(sig: WebAuthnSignature): Hex {\n  // Normalize s to prevent signature malleability\n  let s = BigInt(sig.s);\n  if (s > P256_N_DIV_2) {\n    s = P256_N - s;\n  }\n\n  return encodeAbiParameters([WEBAUTHN_AUTH_TYPE], [\n    {\n      authenticatorData: sig.authenticatorData as Hex,\n      clientDataJSON: sig.clientDataJSON,\n      challengeIndex: BigInt(sig.challengeIndex),\n      typeIndex: BigInt(sig.typeIndex),\n      r: BigInt(sig.r),\n      s,\n    },\n  ]);\n}\n\n/**\n * Hash an array of transaction calls for signing\n *\n * @param calls - Array of transaction calls\n * @returns keccak256 hash of the encoded calls\n */\nexport function hashCalls(calls: TransactionCall[]): Hex {\n  const encoded = encodeAbiParameters(\n    [\n      {\n        type: 'tuple[]',\n        components: [\n          { type: 'address', name: 'to' },\n          { type: 'bytes', name: 'data' },\n          { type: 'uint256', name: 'value' },\n        ],\n      },\n    ],\n    [\n      calls.map((c) => ({\n        to: c.to,\n        data: c.data || '0x',\n        value: c.value || 0n,\n      })),\n    ]\n  );\n  return keccak256(encoded);\n}\n\n/**\n * Build transaction review display data from calls\n *\n * @param calls - Array of transaction calls\n * @returns TransactionDetails for the signing modal\n */\nexport function buildTransactionReview(calls: TransactionCall[]) {\n  return {\n    actions: calls.map((call, i) => ({\n      type: 'custom' as const,\n      label: call.label || `Contract Call ${i + 1}`,\n      sublabel: call.sublabel || `To: ${call.to.slice(0, 10)}...${call.to.slice(-8)}`,\n      amount: call.value ? `${call.value} wei` : undefined,\n    })),\n  };\n}\n"],"mappings":";AAAA,SAAS,qBAAqB,iBAAiB;AAS/C,IAAM,SAAS;AAAA,EACb;AACF;AACA,IAAM,eAAe,SAAS;AAK9B,IAAM,qBAAqB;AAAA,EACzB,MAAM;AAAA,EACN,YAAY;AAAA,IACV,EAAE,MAAM,SAAS,MAAM,oBAAoB;AAAA,IAC3C,EAAE,MAAM,UAAU,MAAM,iBAAiB;AAAA,IACzC,EAAE,MAAM,WAAW,MAAM,iBAAiB;AAAA,IAC1C,EAAE,MAAM,WAAW,MAAM,YAAY;AAAA,IACrC,EAAE,MAAM,WAAW,MAAM,IAAI;AAAA,IAC7B,EAAE,MAAM,WAAW,MAAM,IAAI;AAAA,EAC/B;AACF;AAQO,SAAS,wBAAwB,KAA6B;AAEnE,MAAI,IAAI,OAAO,IAAI,CAAC;AACpB,MAAI,IAAI,cAAc;AACpB,QAAI,SAAS;AAAA,EACf;AAEA,SAAO,oBAAoB,CAAC,kBAAkB,GAAG;AAAA,IAC/C;AAAA,MACE,mBAAmB,IAAI;AAAA,MACvB,gBAAgB,IAAI;AAAA,MACpB,gBAAgB,OAAO,IAAI,cAAc;AAAA,MACzC,WAAW,OAAO,IAAI,SAAS;AAAA,MAC/B,GAAG,OAAO,IAAI,CAAC;AAAA,MACf;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAQO,SAAS,UAAU,OAA+B;AACvD,QAAM,UAAU;AAAA,IACd;AAAA,MACE;AAAA,QACE,MAAM;AAAA,QACN,YAAY;AAAA,UACV,EAAE,MAAM,WAAW,MAAM,KAAK;AAAA,UAC9B,EAAE,MAAM,SAAS,MAAM,OAAO;AAAA,UAC9B,EAAE,MAAM,WAAW,MAAM,QAAQ;AAAA,QACnC;AAAA,MACF;AAAA,IACF;AAAA,IACA;AAAA,MACE,MAAM,IAAI,CAAC,OAAO;AAAA,QAChB,IAAI,EAAE;AAAA,QACN,MAAM,EAAE,QAAQ;AAAA,QAChB,OAAO,EAAE,SAAS;AAAA,MACpB,EAAE;AAAA,IACJ;AAAA,EACF;AACA,SAAO,UAAU,OAAO;AAC1B;AAQO,SAAS,uBAAuB,OAA0B;AAC/D,SAAO;AAAA,IACL,SAAS,MAAM,IAAI,CAAC,MAAM,OAAO;AAAA,MAC/B,MAAM;AAAA,MACN,OAAO,KAAK,SAAS,iBAAiB,IAAI,CAAC;AAAA,MAC3C,UAAU,KAAK,YAAY,OAAO,KAAK,GAAG,MAAM,GAAG,EAAE,CAAC,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC;AAAA,MAC7E,QAAQ,KAAK,QAAQ,GAAG,KAAK,KAAK,SAAS;AAAA,IAC7C,EAAE;AAAA,EACJ;AACF;","names":[]}