@tempoxyz/id 0.0.0-stage → 0.0.0

package/dist/internal/KeyAuthorization.js

@@ -0,0 +1,1030 @@
+/**
+ * Access keys (TIP-1011) on a user's Tempo Account, for keys that apps hold. A request takes the
+ * shape of the Accounts SDK's `wallet_connect` key authorization capability. The user approves it on
+ * a page, or it must fit the headless ceiling, and the account's owner signs it. An app that holds
+ * the `tempo-id:sign` scope may send a challenge. Tempo ID binds the challenge as the key's witness
+ * (TIP-1053), so the owner's one signature covers both.
+ * @module
+ */
+import { AbiFunction, Address, Hex, PublicKey, Value } from 'ox';
+import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo';
+import { Authentication } from 'ox/webauthn';
+import { hashMessage, zeroAddress } from 'viem';
+import { Account } from 'viem/tempo';
+import { tempo, tempoDevnet, tempoLocalnet, tempoTestnet, } from 'viem/tempo/chains';
+import { ousd as openUsd, tokens } from 'viem/tokens';
+import { z } from 'zod';
+import * as Apps from './Apps.js';
+import * as ErrorResponse from './ErrorResponse.js';
+/** The request carries a challenge, which its app may not bind. */
+export class ChallengeNotPermittedError extends ErrorResponse.define('challenge_not_permitted') {
+    name = 'KeyAuthorization.ChallengeNotPermittedError';
+    constructor(options) {
+        const { clientId } = options;
+        super({
+            error_description: `Challenge not permitted: the app lacks the \`${Apps.signScope}\` scope. Remove \`challenge\`, or grant the app the scope.`,
+            field: 'challenge',
+            meta: { client_id: clientId, scope: Apps.signScope },
+        });
+    }
+}
+/** Two limits name the same token. */
+export class DuplicateLimitError extends ErrorResponse.define('duplicate_limit') {
+    name = 'KeyAuthorization.DuplicateLimitError';
+}
+/** Two scopes name the same call on one token. */
+export class DuplicateScopeError extends ErrorResponse.define('duplicate_scope') {
+    name = 'KeyAuthorization.DuplicateScopeError';
+}
+/** `limits` is an empty list. */
+export class EmptyLimitsError extends ErrorResponse.define('empty_limits') {
+    name = 'KeyAuthorization.EmptyLimitsError';
+}
+/** `scopes` is an empty list. */
+export class EmptyScopesError extends ErrorResponse.define('empty_scopes') {
+    name = 'KeyAuthorization.EmptyScopesError';
+}
+/** A headless key lasts longer than a year. */
+export class ExpiryExceedsMaximumError extends ErrorResponse.define('expiry_exceeds_maximum') {
+    name = 'KeyAuthorization.ExpiryExceedsMaximumError';
+}
+/** The key expiry is in the past. */
+export class ExpiryPassedError extends ErrorResponse.define('expiry_passed') {
+    name = 'KeyAuthorization.ExpiryPassedError';
+}
+/** The key chain ID is 0. */
+export class InvalidChainError extends ErrorResponse.define('invalid_chain') {
+    name = 'KeyAuthorization.InvalidChainError';
+}
+/** The key expiry is 0, which never expires. */
+export class InvalidExpiryError extends ErrorResponse.define('invalid_expiry') {
+    name = 'KeyAuthorization.InvalidExpiryError';
+}
+/** A limit's `period` is not a whole number of seconds. */
+export class InvalidPeriodError extends ErrorResponse.define('invalid_period') {
+    name = 'KeyAuthorization.InvalidPeriodError';
+}
+/** The key public key is not a valid point. */
+export class InvalidPublicKeyError extends ErrorResponse.define('invalid_public_key') {
+    name = 'KeyAuthorization.InvalidPublicKeyError';
+}
+/** A scope's `recipients` names the zero address, or one address twice. */
+export class InvalidRecipientsError extends ErrorResponse.define('invalid_recipients') {
+    name = 'KeyAuthorization.InvalidRecipientsError';
+}
+/** A headless key limit exceeds the token’s ceiling. */
+export class LimitExceedsMaximumError extends ErrorResponse.define('limit_exceeds_maximum') {
+    name = 'KeyAuthorization.LimitExceedsMaximumError';
+}
+/** The key authorization names no key. */
+export class MissingKeyError extends ErrorResponse.define('missing_key') {
+    name = 'KeyAuthorization.MissingKeyError';
+}
+/** An `approve` scope names no spenders. */
+export class MissingRecipientsError extends ErrorResponse.define('missing_recipients') {
+    name = 'KeyAuthorization.MissingRecipientsError';
+}
+/** A scope calls a token no limit names. */
+export class ScopeWithoutLimitError extends ErrorResponse.define('scope_without_limit') {
+    name = 'KeyAuthorization.ScopeWithoutLimitError';
+}
+/** A scope calls a function a key may not call. */
+export class UnsupportedCallError extends ErrorResponse.define('unsupported_call') {
+    name = 'KeyAuthorization.UnsupportedCallError';
+}
+/** A limit names a token that is not supported on the chain. */
+export class UnsupportedTokenError extends ErrorResponse.define('unsupported_token') {
+    name = 'KeyAuthorization.UnsupportedTokenError';
+}
+/** The key names a passkey-owned Tempo Account, whose passkey signs only on a Tempo ID page. */
+export class WebAuthnRequiredError extends ErrorResponse.define('webauthn_required') {
+    name = 'KeyAuthorization.WebAuthnRequiredError';
+    constructor(options) {
+        super({
+            error_description: options.description ??
+                `Passkey required: Tempo Account ${options.account} signs key authorizations only with its passkey, on a Tempo ID page. Authorize through a redirect, popup, or device grant, or name another account.`,
+            field: 'key_authorization.account',
+            meta: { account: options.account },
+        });
+    }
+}
+/** A `0x`-prefixed hex string. Its digits are checked, since quantities decode with `Hex.toBigInt`. */
+const hex = z
+    .templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]*$/)])
+    .meta({ pattern: '^0x[0-9a-fA-F]*$' });
+/** A 20-byte address. */
+const address = z
+    .templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]{40}$/)])
+    .meta({ pattern: '^0x[0-9a-fA-F]{40}$' });
+/**
+ * A hex quantity of at most 256 bits, the width of every on-chain quantity a key names. The bound
+ * keeps an oversized value from costing work before the request is authenticated.
+ */
+const quantity = z
+    .templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]{0,64}$/)])
+    .meta({ pattern: '^0x[0-9a-fA-F]{0,64}$' });
+/** A 32-byte value as hex. */
+const bytes32 = z
+    .templateLiteral(['0x', z.string().regex(/^[0-9a-fA-F]{64}$/)])
+    .meta({ pattern: '^0x[0-9a-fA-F]{64}$' });
+/**
+ * A bigint, sent as a hex quantity. Zod drops examples on a codec's input, so the hex form carries
+ * the field's `examples`.
+ */
+function bigint(options) {
+    return z.codec(z.union([quantity.meta({ examples: options.examples }), z.bigint()]), z.bigint(), {
+        decode: (value) => typeof value === 'bigint'
+            ? value
+            : value === '0x'
+                ? 0n
+                : Hex.toBigInt(value),
+        encode: (value) => Hex.fromNumber(value),
+    });
+}
+/**
+ * An app's key authorization request as sent: the shape of the Accounts SDK's `wallet_connect`
+ * `authorizeAccessKey` capability, with the user's Tempo Account it acts for.
+ */
+const sent = z.object({
+    /** The user's Tempo Account the key acts for. Defaults to the one they selected at sign-in, or their oldest. */
+    account: z.optional(address).meta({
+        description: 'The Tempo Account the key acts for. Defaults to the account selected at sign-in, or else the oldest account.',
+        examples: ['0x9a073914db0d149375ac2b7fbb72c68c0780fb5f'],
+    }),
+    /** The access key's address. `publicKey` may stand in for it. */
+    address: z.optional(address).meta({
+        description: "The access key's address. Required unless `publicKey` is present.",
+        examples: ['0x81c0f22bd173c115d18eeea0f6a38e935ecf52fb'],
+    }),
+    /** The chain the key acts on. Defaults to Tempo mainnet. */
+    chainId: z.optional(bigint({ examples: ['0x1079'] })).meta({
+        description: 'The chain ID the key acts on, as a hex quantity. Defaults to Tempo mainnet.',
+    }),
+    /** When the key expires, in Unix seconds. Defaults to a year from now. */
+    expiry: z.optional(z.number()).meta({
+        description: 'When the key expires, in Unix seconds. Defaults to one year after the request. A headless request allows at most one year.',
+        examples: [1893456000],
+    }),
+    /** The key's type. Defaults to `secp256k1`. */
+    keyType: z.optional(z.enum(['p256', 'secp256k1', 'webAuthn'])).meta({
+        description: 'The signature scheme of the access key. Defaults to `secp256k1`.',
+        examples: ['secp256k1'],
+    }),
+    /** How much of each token the key may spend. Defaults to the cap of each token it calls, or of OUSD. */
+    limits: z
+        .optional(z
+        .array(z.object({
+        limit: bigint({ examples: ['0x989680'] }).meta({
+            description: 'The most of the token the key may spend, in base units, as a hex quantity. Applies per period when `period` is set.',
+        }),
+        period: z.optional(z.number()).meta({
+            description: 'Seconds after which the limit resets. Omitted or 0 for a one-time limit.',
+            examples: [86400],
+        }),
+        token: address.meta({
+            description: 'The TIP-20 token the limit applies to.',
+            examples: ['0x20c0000000000000000000006a37DA5C996874BE'],
+        }),
+    }))
+        .readonly())
+        .meta({
+        description: 'The spending limit on each token. Defaults to the cap of each token the scopes call, or else of OUSD.',
+    }),
+    /** The access key's public key. */
+    publicKey: z.optional(hex).meta({
+        description: "The access key's uncompressed public key, as hex. Tempo ID derives `address` from it when `address` is absent.",
+        examples: [
+            '0x0438ef39ed22456a6956f380ebc18c50bd18c0402658bc52903817cc8a1e8b2f7ed1da68afc7f343c1debc44c04ac60e62e96bbb261d2226e7a7b96e64fd0f0765',
+        ],
+    }),
+    /** The calls the key may make. Defaults to transfers of each token it limits. */
+    scopes: z
+        .optional(z
+        .array(z.object({
+        address: address.meta({
+            description: 'The TIP-20 token contract the key may call.',
+            examples: ['0x20c0000000000000000000006a37DA5C996874BE'],
+        }),
+        recipients: z.optional(z.array(address).readonly()).meta({
+            description: 'The only addresses the call may name as recipient or spender. Required for `approve`.',
+            examples: [['0xff5deded16eb46018387144ff8bf41f26afb41af']],
+        }),
+        selector: z.optional(z.union([hex, z.string().max(256)])).meta({
+            description: 'The function the key may call, as a 4-byte selector or a function signature: `transfer`, `transferWithMemo`, or `approve`. A scope without a selector is refused.',
+            examples: ['0xa9059cbb', 'transfer(address,uint256)'],
+        }),
+    }))
+        .readonly())
+        .meta({
+        description: 'The calls the key may make. Defaults to `transfer` and `transferWithMemo` on each token the key limits.',
+    }),
+});
+/** Zod schemas for key authorization requests, and for the API's responses about them. */
+export var schema;
+(function (schema) {
+    /** The Tempo Account a signed key acts for. */
+    schema.account = address.meta({
+        description: 'The Tempo Account the key acts for.',
+        examples: ['0x9a073914db0d149375ac2b7fbb72c68c0780fb5f'],
+    });
+    /** An app's key authorization request, with what it leaves out filled with the headless ceiling. */
+    schema.request = z.optional(sent.transform(defaults)).meta({
+        description: "A key authorization for the app's own key: the shape of the Accounts SDK's `wallet_connect` `authorizeAccessKey` capability. Omitted fields default to the headless ceiling.",
+        id: 'KeyAuthorizationRequest',
+    });
+    /** What a key grants, as `describe` returns it for the approval screens. */
+    schema.description = z
+        .object({
+        account: address.optional().meta({
+            description: 'The Tempo Account the request names. Absent when the request names none.',
+            examples: ['0x9a073914db0d149375ac2b7fbb72c68c0780fb5f'],
+        }),
+        expiry: z.number().meta({
+            description: 'Unix seconds.',
+            examples: [1893456000],
+        }),
+        limits: z
+            .array(z.object({
+            amount: z.string().meta({
+                description: 'In whole units.',
+                examples: ['1000'],
+            }),
+            currency: z.string().meta({
+                description: "The tokens' currency, such as `USD`. A yield-bearing token names its own.",
+                examples: ['USD'],
+            }),
+            period: z
+                .number()
+                .optional()
+                .meta({
+                description: 'Seconds after which the amount resets. Omitted for a one-time limit.',
+                examples: [86400],
+            }),
+            tokens: z
+                .array(z.object({
+                amount: z.string().meta({
+                    description: "The token's own limit, in whole units.",
+                    examples: ['1000'],
+                }),
+                symbol: z.string().meta({
+                    description: "The token's symbol, or its address when the token has no symbol.",
+                    examples: ['OUSD'],
+                }),
+            }))
+                .readonly()
+                .meta({ description: 'The tokens the amount spans.' }),
+        }))
+            .readonly()
+            .meta({
+            description: 'The spending limits, totaled for each currency and period.',
+        }),
+    })
+        .meta({
+        description: 'What a key authorization grants, for approval screens.',
+        id: 'KeyAuthorizationDescription',
+    });
+    /** A primitive signature envelope, in the node's RPC format. */
+    const primitive = z
+        .discriminatedUnion('type', [
+        z
+            .object({
+            r: hex.meta({
+                description: "The signature's 32-byte `r` value.",
+                examples: [
+                    '0x12fe6a88b99377b94d6a628a86b9df544202c7b03827f44b16ee1a266ab98e17',
+                ],
+            }),
+            s: hex.meta({
+                description: "The signature's 32-byte `s` value.",
+                examples: [
+                    '0x4b6aa3723402498e07fb1f071673bd969d9f49a286af15ac60581d07ade24b77',
+                ],
+            }),
+            type: z.literal('secp256k1').meta({
+                description: 'A secp256k1 ECDSA signature.',
+            }),
+            v: hex.optional().meta({
+                description: 'The legacy recovery value, which `yParity` replaces. Absent in most envelopes.',
+                examples: ['0x1c'],
+            }),
+            yParity: hex.meta({
+                description: 'The parity of the y-coordinate of the curve point, `0x0` or `0x1`.',
+                examples: ['0x1'],
+            }),
+        })
+            .meta({ description: 'A secp256k1 signature.' }),
+        z
+            .object({
+            preHash: z.boolean().meta({
+                description: 'Whether the signer hashed the digest with SHA-256 before signing it, as WebCrypto keys do.',
+                examples: [true],
+            }),
+            pubKeyX: hex.meta({
+                description: "The 32-byte x-coordinate of the signer's P256 public key.",
+                examples: [
+                    '0xdae3e3e5faba0a2aca73d4d2a4b84ad46460f3f23af8a60b17b8a13537cfd440',
+                ],
+            }),
+            pubKeyY: hex.meta({
+                description: "The 32-byte y-coordinate of the signer's P256 public key.",
+                examples: [
+                    '0x816438c87ffd782cd0e37355eb83fbe1d4e5e905eaafa22fa27c32cc4abf7802',
+                ],
+            }),
+            r: hex.meta({
+                description: "The signature's 32-byte `r` value.",
+                examples: [
+                    '0x9da52cc71c005844434ce6996f7ea3b3262f84ec3a5d54f1d22d0bba9f2e5ea9',
+                ],
+            }),
+            s: hex.meta({
+                description: "The signature's 32-byte `s` value.",
+                examples: [
+                    '0x4b6aa3723402498e07fb1f071673bd969d9f49a286af15ac60581d07ade24b77',
+                ],
+            }),
+            type: z.literal('p256').meta({
+                description: 'A P256 (secp256r1) signature.',
+            }),
+        })
+            .meta({ description: 'A P256 signature, with its public key.' }),
+        z
+            .object({
+            pubKeyX: hex.meta({
+                description: "The 32-byte x-coordinate of the passkey's P256 public key.",
+                examples: [
+                    '0xdae3e3e5faba0a2aca73d4d2a4b84ad46460f3f23af8a60b17b8a13537cfd440',
+                ],
+            }),
+            pubKeyY: hex.meta({
+                description: "The 32-byte y-coordinate of the passkey's P256 public key.",
+                examples: [
+                    '0x816438c87ffd782cd0e37355eb83fbe1d4e5e905eaafa22fa27c32cc4abf7802',
+                ],
+            }),
+            r: hex.meta({
+                description: "The signature's 32-byte `r` value.",
+                examples: [
+                    '0x9da52cc71c005844434ce6996f7ea3b3262f84ec3a5d54f1d22d0bba9f2e5ea9',
+                ],
+            }),
+            s: hex.meta({
+                description: "The signature's 32-byte `s` value.",
+                examples: [
+                    '0x4b6aa3723402498e07fb1f071673bd969d9f49a286af15ac60581d07ade24b77',
+                ],
+            }),
+            type: z.literal('webAuthn').meta({
+                description: 'A WebAuthn passkey signature.',
+            }),
+            webauthnData: hex.meta({
+                description: "The assertion's authenticator data followed by its `clientDataJSON`, as hex.",
+                examples: [
+                    '0xa7cb28053c8ee4e5394fc67a0018dc1c622dad5ce3591b8ca13094ae86d11ba605000000007b2274797065223a22776562617574686e2e676574222c226368616c6c656e6765223a2271334a306257467a6157356e6247567a6157647559585231636d566b6157646c633352765a6d746c65574631644767222c226f726967696e223a2268747470733a2f2f617574682e74656d706f2e78797a222c2263726f73734f726967696e223a66616c73657d',
+                ],
+            }),
+        })
+            .meta({ description: 'A WebAuthn signature, with its public key.' }),
+    ])
+        .meta({
+        description: 'A signature by one key, as secp256k1, P256, or WebAuthn.',
+    });
+    /** A signed key authorization in the node's RPC format, as `sign` returns it. */
+    schema.rpc = z
+        .object({
+        account: address
+            .nullable()
+            .optional()
+            .meta({
+            description: 'The Tempo Account the key is bound to (TIP-1049). Absent or null when the key has no account binding.',
+            examples: ['0x9a073914db0d149375ac2b7fbb72c68c0780fb5f'],
+        }),
+        allowedCalls: z
+            .array(z.object({
+            selectorRules: z
+                .array(z.object({
+                recipients: z
+                    .array(address)
+                    .readonly()
+                    .optional()
+                    .meta({
+                    description: 'The only addresses the call may name as recipient or spender. Absent when any address may receive.',
+                    examples: [
+                        ['0xff5deded16eb46018387144ff8bf41f26afb41af'],
+                    ],
+                }),
+                selector: hex.meta({
+                    description: 'The 4-byte selector of the function the key may call.',
+                    examples: ['0xa9059cbb'],
+                }),
+            }))
+                .readonly()
+                .optional()
+                .meta({
+                description: 'The functions the key may call on the target. Absent when the key may call any function on it.',
+            }),
+            target: address.meta({
+                description: 'The contract the key may call.',
+                examples: ['0x20c0000000000000000000006a37DA5C996874BE'],
+            }),
+        }))
+            .readonly()
+            .optional()
+            .meta({
+            description: 'The calls the key may make. Absent when the key may make any call.',
+        }),
+        chainId: hex.meta({
+            description: 'The chain ID the key acts on, as a hex quantity.',
+            examples: ['0xa5bf'],
+        }),
+        expiry: hex
+            .nullable()
+            .optional()
+            .meta({
+            description: 'When the key expires, in Unix seconds, as a hex quantity. Absent or null when the key never expires.',
+            examples: ['0x6acdc1b4'],
+        }),
+        keyId: address.meta({
+            description: "The access key's address.",
+            examples: ['0x81c0f22bd173c115d18eeea0f6a38e935ecf52fb'],
+        }),
+        keyType: z.string().meta({
+            description: 'The signature scheme of the access key: `secp256k1`, `p256`, or `webAuthn`. The node names a configurable account key `multisig`.',
+            examples: ['secp256k1'],
+        }),
+        limits: z
+            .array(z.object({
+            limit: hex.meta({
+                description: 'The most of the token the key may spend, in base units, as a hex quantity. Applies per period when `period` is set.',
+                examples: ['0x989680'],
+            }),
+            period: hex.optional().meta({
+                description: 'Seconds after which the limit resets, as a hex quantity. Absent or `0x0` for a one-time limit.',
+                examples: ['0x15180'],
+            }),
+            token: address.meta({
+                description: 'The TIP-20 token the limit applies to.',
+                examples: ['0x20c0000000000000000000006a37DA5C996874BE'],
+            }),
+        }))
+            .readonly()
+            .optional()
+            .meta({
+            description: 'The spending limit on each token. Absent when spending is unlimited. An empty list allows no spending.',
+        }),
+        signature: z
+            .union([
+            hex.meta({
+                description: "A configurable account's RLP-encoded signature, which carries its owner approvals.",
+                examples: [
+                    '0xf8a094ff5deded16eb46018387144ff8bf41f26afb41afc0f87cf87a80a012fe6a88b99377b94d6a628a86b9df544202c7b03827f44b16ee1a266ab98e17a04b6aa3723402498e07fb1f071673bd969d9f49a286af15ac60581d07ade24b77',
+                ],
+            }),
+            primitive,
+            z
+                .object({
+                keyId: address.optional().meta({
+                    description: 'The address of the access key that signed. Recovered from `signature` when absent.',
+                    examples: ['0x624f27c462b885a83c698cac444a106a8c519e25'],
+                }),
+                signature: primitive.meta({
+                    description: "The access key's own signature.",
+                }),
+                type: z.literal('keychain').meta({
+                    description: 'A signature by an access key for an account.',
+                }),
+                userAddress: address.meta({
+                    description: 'The Tempo Account the access key signs for.',
+                    examples: ['0x9a073914db0d149375ac2b7fbb72c68c0780fb5f'],
+                }),
+                version: z
+                    .enum(['v1', 'v2'])
+                    .optional()
+                    .meta({
+                    description: 'The keychain signature version. `v2` binds the signature to `userAddress`. Defaults to `v1`.',
+                    examples: ['v2'],
+                }),
+            })
+                .meta({
+                description: 'An access key signature that wraps a primitive signature.',
+            }),
+        ])
+            .meta({
+            description: "The owner's signature envelope, in the node's format.",
+        }),
+        witness: bytes32.optional().meta({
+            description: 'The witness the signature binds, when the request sent one.',
+            examples: [
+                '0xf1e22f902be2546fe35d49388503ef7ea5c6c0e95a0f4b89d474e58793b64dec',
+            ],
+        }),
+    })
+        .meta({
+        description: "A signed key authorization (TIP-1011), in the node's RPC format.",
+        id: 'KeyAuthorization',
+    });
+})(schema || (schema = {}));
+/** The longest a headless key lasts, in seconds, and how long a key lasts when its request names no expiry. */
+export const lifetime = 365 * 24 * 60 * 60;
+/** OUSD's address, the same on every Tempo chain. A key that names no token defaults to it. */
+const ousd = openUsd(tempo.id).address;
+/** Tempo chains, whose token addresses Viem's token list holds. */
+export const chains = [tempo, tempoTestnet, tempoDevnet, tempoLocalnet];
+/** The ID of the chain that a key acts on when its request names none: Tempo mainnet. */
+export const defaultChainId = tempo.id;
+/** About $1,000 in each currency, in whole units. Unlisted currencies are yield-bearing dollars. */
+// ponytail: the rates are fixed. If caps must track markets closely, price them live.
+const caps = {
+    BRL: '5000',
+    BTC: '0.01',
+    CHF: '800',
+    EUR: '850',
+    GBP: '750',
+    USD: '1000',
+};
+/** Every Tempo token in Viem's token list, by chain ID and lowercase address, with its cap in base units. */
+const listed = new Map(tokens.tempo.flatMap((token) => chains.flatMap((chain) => {
+    const addresses = token.addresses;
+    // A local Tempo node predeploys the testnet's tokens, at the same addresses. OUSD has its
+    // mainnet address on every Tempo chain, which Viem's list names only for mainnet.
+    // ponytail: drop the OUSD fallback once Viem lists OUSD on testnet.
+    const address = addresses[chain.id] ??
+        (chain.id === tempoLocalnet.id
+            ? addresses[tempoTestnet.id]
+            : undefined) ??
+        (token.symbol === 'OUSD' ? addresses[tempo.id] : undefined);
+    if (!address)
+        return [];
+    const cap = caps[token.currency ?? ''] ?? caps.USD;
+    return [
+        [
+            `${chain.id}:${address.toLowerCase()}`,
+            {
+                address: Address.checksum(address),
+                cap: Value.from(cap, token.decimals),
+                currency: token.currency,
+                decimals: token.decimals,
+                symbol: token.symbol ?? address,
+            },
+        ],
+    ];
+})));
+/**
+ * TIP-20 calls whose spending the key's limits bound. `approve` needs a spender allowlist, since an
+ * approved spender moves tokens without the key ([TIP-1011](https://tips.sh/1011)).
+ */
+const calls = {
+    approve: AbiFunction.getSelector('approve(address,uint256)'),
+    transfer: AbiFunction.getSelector('transfer(address,uint256)'),
+    transferWithMemo: AbiFunction.getSelector('transferWithMemo(address,uint256,bytes32)'),
+};
+/**
+ * Returns `key` with the witness of `challenge`: its EIP-191 hash, as `hashMessage` computes it, so
+ * a verifier checks the witness against the message it issued. Returns `key` unchanged without one.
+ */
+export function bind(key, options) {
+    if (options.challenge === undefined)
+        return key;
+    return { ...key, witness: hashMessage(options.challenge) };
+}
+/**
+ * Why `key` breaks the rules every flow applies, with the field at fault and the values compared,
+ * or `undefined` when the owner may sign it. Fields are request paths under `key_authorization`,
+ * where every request carries the key.
+ */
+export function check(key) {
+    const now = Math.floor(Date.now() / 1000);
+    // Nodes reject chain ID zero, so a key names its chain.
+    if (!key.chainId)
+        return new InvalidChainError({
+            error_description: 'Invalid `chainId`: 0. Use a Tempo chain ID, such as 4217.',
+            field: 'key_authorization.chainId',
+            meta: { chain_id: 0 },
+        });
+    const chainId = Number(key.chainId);
+    if (!key.address && !key.publicKey)
+        return new MissingKeyError({
+            error_description: 'Missing `address` or `publicKey`. Provide the access key.',
+            field: 'key_authorization.address',
+        });
+    // The chain rejects the zero address, which no key holds, also beside a public key.
+    if (key.address === zeroAddress)
+        return new MissingKeyError({
+            error_description: 'Invalid `address`: the zero address holds no key. Provide the address of the access key.',
+            field: 'key_authorization.address',
+        });
+    if (key.publicKey && !parse(key.publicKey))
+        return new InvalidPublicKeyError({
+            error_description: 'Invalid `publicKey`. Provide an uncompressed public key, or `address`.',
+            field: 'key_authorization.publicKey',
+        });
+    if (!Number.isSafeInteger(key.expiry))
+        return new InvalidExpiryError({
+            error_description: `Invalid \`expiry\`: ${key.expiry} is not a whole number of seconds. Use a future Unix time in seconds.`,
+            field: 'key_authorization.expiry',
+            meta: { expiry: key.expiry },
+        });
+    // Zero means the key never expires.
+    if (key.expiry === 0)
+        return new InvalidExpiryError({
+            error_description: 'Invalid `expiry`: 0 never expires. Use a future Unix time.',
+            field: 'key_authorization.expiry',
+            meta: { expiry: 0 },
+        });
+    if (key.expiry <= now)
+        return new ExpiryPassedError({
+            error_description: `Invalid \`expiry\`: ${date(key.expiry)} has passed. Use a future Unix time.`,
+            field: 'key_authorization.expiry',
+            meta: { expiry: key.expiry, now },
+        });
+    if (!key.limits.length)
+        return new EmptyLimitsError({
+            error_description: 'Empty `limits`. Name at least one token, or omit `limits`.',
+            field: 'key_authorization.limits',
+        });
+    if (!key.scopes.length)
+        return new EmptyScopesError({
+            error_description: 'Empty `scopes`. Name at least one call, or omit `scopes`.',
+            field: 'key_authorization.scopes',
+        });
+    // A scope's token is checked first, since `defaults` adds a limit for it that the request did not send.
+    for (const [index, scope] of key.scopes.entries())
+        if (!token(key, scope.address))
+            return new UnsupportedTokenError({
+                error_description: `Unsupported token on chain ${chainId}: ${scope.address}. Use a supported token, such as OUSD.`,
+                field: `key_authorization.scopes.${index}.address`,
+                meta: { chain_id: chainId, token: scope.address },
+            });
+    const seen = new Set();
+    for (const [index, limit] of key.limits.entries()) {
+        // TIP-1011 rejects a key that limits one token twice.
+        if (seen.has(limit.token.toLowerCase()))
+            return new DuplicateLimitError({
+                error_description: `Duplicate limit for ${limit.token}. Limit each token once.`,
+                field: `key_authorization.limits.${index}.token`,
+                meta: { token: limit.token },
+            });
+        seen.add(limit.token.toLowerCase());
+        const listing = token(key, limit.token);
+        if (!listing)
+            return new UnsupportedTokenError({
+                error_description: `Unsupported token on chain ${chainId}: ${limit.token}. Use a supported token, such as OUSD.`,
+                field: `key_authorization.limits.${index}.token`,
+                meta: { chain_id: chainId, token: limit.token },
+            });
+        if (limit.period !== undefined &&
+            (!Number.isSafeInteger(limit.period) || limit.period < 0))
+            return new InvalidPeriodError({
+                error_description: `Invalid \`period\` on the ${listing.symbol} limit: ${limit.period}. Use a whole number of seconds, or 0 for a one-time limit.`,
+                field: `key_authorization.limits.${index}.period`,
+                meta: {
+                    period: limit.period,
+                    symbol: listing.symbol,
+                    token: listing.address,
+                },
+            });
+    }
+    const rules = new Set();
+    for (const [index, scope] of key.scopes.entries()) {
+        // Every call targets a token the key limits, so no call moves an unlimited token.
+        const listing = key.limits.some((limit) => Address.isEqual(limit.token, scope.address))
+            ? token(key, scope.address)
+            : undefined;
+        if (!listing)
+            return new ScopeWithoutLimitError({
+                error_description: `Scope on ${scope.address} has no limit. Add a limit for it, or remove the scope.`,
+                field: `key_authorization.scopes.${index}.address`,
+                meta: { token: scope.address },
+            });
+        const selector = scope.selector ? normalize(scope.selector) : undefined;
+        const named = (() => {
+            if (selector)
+                return selector;
+            if (scope.selector)
+                return 'an unknown function';
+            return 'any function';
+        })();
+        if (selector === calls.approve && !scope.recipients?.length)
+            return new MissingRecipientsError({
+                error_description: `Missing \`recipients\` for \`approve\` on ${listing.symbol}. Name the allowed spenders.`,
+                field: `key_authorization.scopes.${index}.recipients`,
+                meta: { symbol: listing.symbol, token: listing.address },
+            });
+        if (selector !== calls.approve &&
+            selector !== calls.transfer &&
+            selector !== calls.transferWithMemo)
+            return new UnsupportedCallError({
+                // Only the normalized selector is echoed, so a request cannot place its own text on a page.
+                error_description: `Unsupported call on ${listing.symbol}: ${named}. Use \`transfer\`, \`transferWithMemo\`, or \`approve\`.`,
+                field: `key_authorization.scopes.${index}.selector`,
+                meta: {
+                    ...(selector ? { selector } : {}),
+                    symbol: listing.symbol,
+                    token: listing.address,
+                },
+            });
+        // TIP-1011 rejects a key that names one call on a token twice.
+        const rule = `${listing.address.toLowerCase()}:${selector}`;
+        if (rules.has(rule))
+            return new DuplicateScopeError({
+                error_description: `Duplicate scope for ${selector} on ${listing.symbol}. Name each call on a token once.`,
+                field: `key_authorization.scopes.${index}.selector`,
+                meta: { selector, symbol: listing.symbol, token: listing.address },
+            });
+        rules.add(rule);
+        // TIP-1011 rejects recipients that hold the zero address or repeat an address.
+        const recipients = (scope.recipients ?? []).map((entry) => entry.toLowerCase());
+        // One pass with a set keeps the check linear in the number of recipients.
+        const unique = new Set();
+        const position = recipients.findIndex((entry) => {
+            if (entry === zeroAddress || unique.has(entry))
+                return true;
+            unique.add(entry);
+            return false;
+        });
+        const recipient = scope.recipients?.[position];
+        if (recipient)
+            return new InvalidRecipientsError({
+                error_description: `Invalid recipient ${recipient} for ${selector} on ${listing.symbol}. Name each recipient once, and never the zero address.`,
+                field: `key_authorization.scopes.${index}.recipients.${position}`,
+                meta: { recipient, symbol: listing.symbol, token: listing.address },
+            });
+    }
+    return undefined;
+}
+(function (check) {
+    /** The refusals `check` returns. Its return type admits no other. */
+    check.errors = [
+        DuplicateLimitError,
+        DuplicateScopeError,
+        EmptyLimitsError,
+        EmptyScopesError,
+        ExpiryPassedError,
+        InvalidChainError,
+        InvalidExpiryError,
+        InvalidPeriodError,
+        InvalidPublicKeyError,
+        InvalidRecipientsError,
+        MissingKeyError,
+        MissingRecipientsError,
+        ScopeWithoutLimitError,
+        UnsupportedCallError,
+        UnsupportedTokenError,
+    ];
+})(check || (check = {}));
+/**
+ * Why the request for `key` is refused for the app `app`. The request carries a challenge, which
+ * became the key's witness, and the app does not hold the `tempo-id:sign` scope. Returns `undefined`
+ * when the key has no witness or the app holds the scope. A browser request names a redirect URI on
+ * its own origin, which the app registers, so the app's scope covers its pages.
+ */
+export function checkChallenge(options) {
+    const { app, clientId, key } = options;
+    if (!key?.witness)
+        return undefined;
+    if (!app?.sign)
+        return new ChallengeNotPermittedError({ clientId });
+    return undefined;
+}
+(function (checkChallenge) {
+    /** The refusals `checkChallenge` returns. */
+    checkChallenge.errors = [ChallengeNotPermittedError];
+})(checkChallenge || (checkChallenge = {}));
+/**
+ * Why `key` is refused in a flow that shows the user nothing: the rules `check` applies, then the
+ * headless ceiling. Returns `undefined` when the owner may sign it.
+ */
+export function checkHeadless(key) {
+    const error = check(key);
+    if (error)
+        return error;
+    const now = Math.floor(Date.now() / 1000);
+    const chainId = Number(key.chainId);
+    if (key.expiry > now + lifetime)
+        return new ExpiryExceedsMaximumError({
+            error_description: `Invalid \`expiry\`: ${date(key.expiry)} exceeds the one-year maximum. Use an earlier expiry, or authorize through a redirect or device grant.`,
+            field: 'key_authorization.expiry',
+            meta: { expiry: key.expiry, maximum: now + lifetime },
+        });
+    for (const [index, limit] of key.limits.entries()) {
+        const listing = token(key, limit.token);
+        // A periodic limit resets each period, so the ceiling bounds what it allows before the key expires.
+        const periods = limit.period
+            ? BigInt(Math.ceil((key.expiry - now) / limit.period))
+            : 1n;
+        const total = limit.limit * periods;
+        if (total > listing.cap)
+            return new LimitExceedsMaximumError({
+                error_description: `Invalid ${listing.symbol} limit: ${Value.format(total, listing.decimals)}${periods > 1n ? ` over ${periods} periods before the key expires` : ''} exceeds the ${Value.format(listing.cap, listing.decimals)} maximum. ${periods > 1n ? 'Lower the limit or shorten the expiry' : 'Lower the limit'}, or authorize through a redirect or device grant.`,
+                field: `key_authorization.limits.${index}.limit`,
+                meta: {
+                    chain_id: chainId,
+                    // The compared total: the limit, times its periods before the key expires.
+                    limit: total.toString(),
+                    maximum: listing.cap.toString(),
+                    periods: Number(periods),
+                    symbol: listing.symbol,
+                    token: listing.address,
+                },
+            });
+    }
+    return undefined;
+}
+(function (checkHeadless) {
+    /** The refusals `checkHeadless` returns: `check`'s, then the headless ceiling's. */
+    checkHeadless.errors = [
+        ...check.errors,
+        ExpiryExceedsMaximumError,
+        LimitExceedsMaximumError,
+    ];
+})(checkHeadless || (checkHeadless = {}));
+/**
+ * What a `key` that passes `check` grants, as the approval screens show it: its limits totaled per
+ * currency and period, and its expiry.
+ */
+export function describe(key) {
+    // The screens state spending per currency, so limits on tokens of one currency and period add up.
+    const totals = new Map();
+    for (const limit of key.limits) {
+        const listing = token(key, limit.token);
+        const period = limit.period ?? 0;
+        const group = `${listing.currency}\0${period}`;
+        const total = totals.get(group);
+        if (!total) {
+            totals.set(group, {
+                amount: limit.limit,
+                currency: listing.currency,
+                decimals: listing.decimals,
+                period,
+                tokens: [
+                    {
+                        amount: Value.format(limit.limit, listing.decimals),
+                        symbol: listing.symbol,
+                    },
+                ],
+            });
+            continue;
+        }
+        total.tokens.push({
+            amount: Value.format(limit.limit, listing.decimals),
+            symbol: listing.symbol,
+        });
+        const decimals = Math.max(total.decimals, listing.decimals);
+        total.amount =
+            total.amount * 10n ** BigInt(decimals - total.decimals) +
+                limit.limit * 10n ** BigInt(decimals - listing.decimals);
+        total.decimals = decimals;
+    }
+    return {
+        account: key.account,
+        expiry: key.expiry,
+        limits: [...totals.values()].map((total) => ({
+            amount: Value.format(total.amount, total.decimals),
+            currency: total.currency,
+            ...(total.period ? { period: total.period } : {}),
+            tokens: total.tokens,
+        })),
+    };
+}
+/**
+ * Returns the digest that an account's owner signs for `key`, which a passkey owner signs as its
+ * WebAuthn challenge. An owner's digest binds no account, so it is known before the passkey is.
+ * `witness` replaces the key's own, as a one-tap sign-in binds it.
+ */
+export function digest(options) {
+    const { key: accessKey, ...rest } = parameters(options.key);
+    return KeyAuthorization.getSignPayload({
+        ...rest,
+        address: accessKey.address,
+        type: accessKey.type,
+        ...(options.witness ? { witness: options.witness } : {}),
+    });
+}
+/** Returns the access key's address, which `publicKey` stands in for when the request names none. */
+export function keyId(key) {
+    return parameters(key).key.address;
+}
+/** Returns the tokens of Viem's token list on the chain with `chainId`, as keys limit them. */
+export function listings(options) {
+    const prefix = `${options.chainId}:`;
+    return [...listed].flatMap((entry) => entry[0].startsWith(prefix) ? [entry[1]] : []);
+}
+/**
+ * Signs `key` with `owner`, the account's owner key, and returns the signed authorization in the
+ * node's RPC format. A Privy owner signs through Privy with the user's token.
+ */
+export async function sign(owner, options) {
+    return KeyAuthorization.toRpc(await Account.signKeyAuthorization(owner, parameters(options.key)));
+}
+/**
+ * Signs `key` with `assertion`, a passkey's assertion over the key's {@link digest} that
+ * `Passkey.verify` accepted, and returns the signed authorization in the node's RPC format. The
+ * assertion becomes the authorization's WebAuthn signature envelope.
+ */
+export async function signWithAssertion(assertion, options) {
+    const { metadata, signature } = Authentication.deserializeResponse(assertion);
+    const challenge = digest({ key: options.key });
+    const publicKey = PublicKey.fromHex(options.publicKey);
+    // The passkey already signed the digest, so this owner returns the assertion as its envelope.
+    const owner = Account.from({
+        keyType: 'webAuthn',
+        publicKey,
+        sign(request) {
+            if (request.hash !== challenge)
+                return Promise.reject(new Error('The assertion signs another key authorization.'));
+            return Promise.resolve(SignatureEnvelope.serialize({
+                metadata: {
+                    authenticatorData: metadata.authenticatorData,
+                    clientDataJSON: metadata.clientDataJSON,
+                },
+                publicKey,
+                signature,
+                type: 'webAuthn',
+            }));
+        },
+    });
+    return await sign(owner, { key: options.key });
+}
+/**
+ * Fills what a request leaves out with the headless ceiling:
+ *
+ * - Tempo mainnet.
+ * - A year.
+ * - The cap of each token it calls, or of OUSD.
+ * - Transfers of each token it limits.
+ */
+function defaults(key) {
+    const chainId = key.chainId ?? BigInt(defaultChainId);
+    // Empty scopes keep the default limit, so `check` refuses the scopes that the request sent.
+    const addresses = key.scopes?.length
+        ? [...new Set(key.scopes.map((scope) => scope.address.toLowerCase()))]
+        : [ousd.toLowerCase()];
+    // A scope on an unlisted token keeps a zero limit, which `check` refuses at the scope.
+    const limits = key.limits ??
+        addresses.map((address) => {
+            const listing = listed.get(`${chainId}:${address}`);
+            return listing
+                ? { limit: listing.cap, token: listing.address }
+                : { limit: 0n, token: Address.checksum(address) };
+        });
+    const scopes = key.scopes ??
+        limits.flatMap((limit) => [calls.transfer, calls.transferWithMemo].map((selector) => ({
+            address: limit.token,
+            selector,
+        })));
+    return {
+        ...key,
+        chainId,
+        expiry: key.expiry ?? Math.floor(Date.now() / 1000) + lifetime,
+        limits,
+        scopes,
+    };
+}
+/** The listed token at `address` on the key's chain, if any. */
+function token(key, address) {
+    return listed.get(`${Number(key.chainId)}:${address.toLowerCase()}`);
+}
+/**
+ * A selector as lowercase hex, from hex or a function signature, or `undefined` when the
+ * signature does not parse.
+ */
+function normalize(selector) {
+    if (/^0x[0-9a-fA-F]{8}$/.test(selector))
+        return selector.toLowerCase();
+    // The parser throws on a malformed signature, which the caller refuses as an unsupported call.
+    try {
+        return AbiFunction.getSelector(selector);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The address of a public key, or `undefined` when it is not a valid point. */
+/** The fields of `key` that its owner signs, as Viem's `Account.signKeyAuthorization` takes them. */
+function parameters(key) {
+    return {
+        chainId: key.chainId,
+        expiry: key.expiry,
+        key: {
+            address: key.address ?? parse(key.publicKey),
+            // The Accounts SDK's default for a key the app holds.
+            type: key.keyType ?? 'secp256k1',
+        },
+        limits: key.limits,
+        scopes: key.scopes,
+        ...(key.witness ? { witness: key.witness } : {}),
+    };
+}
+/** A Unix time as a UTC date and time, for messages. */
+function date(seconds) {
+    return new Date(seconds * 1000).toUTCString();
+}
+function parse(publicKey) {
+    try {
+        return Address.fromPublicKey(PublicKey.from(publicKey));
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=KeyAuthorization.js.map