accounts 0.12.0 → 0.12.2

package/src/core/adapters/dialog.ts

@@ -69,7 +69,7 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
           listeners.delete(listener)
 
           if (queued.status === 'success') resolve(queued.result)
-          else reject(new ox_Provider.UserRejectedRequestError({ message: queued.error.message }))
+          else reject(ox_Provider.parseError(queued.error))
 
           // Remove the resolved request from the queue.
           store.setState((x) => ({
@@ -154,7 +154,7 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
         account: TempoAccount.Account,
         keyAuthorization?: KeyAuthorization.Signed,
       ) => Promise<result>,
-    ): Promise<result | undefined> {
+    ): Promise<{ account: TempoAccount.Account; result: result } | undefined> {
       if (!options.from || typeof options.chainId === 'undefined') return undefined
       const account = AccessKey.selectAccount({
         address: options.from,
@@ -166,8 +166,7 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
       const keyAuthorization = AccessKey.getPending(account, { store })
       try {
         const result = await fn(account, keyAuthorization ?? undefined)
-        AccessKey.removePending(account, { store })
-        return result
+        return { account, result }
       } catch (err) {
         if (AccessKey.invalidate(account, err, { store }))
           console.warn('[accounts] access key invalidated, falling through to dialog:', err)
@@ -307,7 +306,7 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
             })
             return await account.signTransaction(prepared as never)
           })
-          if (result !== undefined) return result
+          if (result !== undefined) return result.result
           return await provider.request({
             ...request,
             params: [z.encode(Rpc.transactionRequest, parameters)] as const,
@@ -342,7 +341,10 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
               params: [signed],
             })
           })
-          if (result !== undefined) return result
+          if (result !== undefined) {
+            AccessKey.removePending(result.account, { store })
+            return result.result
+          }
           return await provider.request({
             ...request,
             params: [z.encode(Rpc.transactionRequest, parameters)] as const,
@@ -373,7 +375,10 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
               params: [signed],
             })
           })
-          if (result !== undefined) return result
+          if (result !== undefined) {
+            AccessKey.removePending(result.account, { store })
+            return result.result
+          }
           return await provider.request({
             ...request,
             params: [z.encode(Rpc.transactionRequest, parameters)] as const,

package/src/core/adapters/local.test.ts

@@ -31,6 +31,41 @@ describe('local', () => {
         ]
       `)
     })
+
+    test('default: authorizeAccessKey folds the key authorization digest into the ceremony', async () => {
+      const captured: { digest: Hex | undefined }[] = []
+      const { adapter } = setup({
+        loadAccounts: makeLoadAccounts(0, captured),
+      })
+
+      const result = await adapter.actions.loadAccounts(
+        {
+          authorizeAccessKey: {
+            address: core_accounts[1]!.address,
+            expiry: 0,
+            keyType: 'secp256k1',
+          },
+        },
+        { method: 'wallet_connect', params: undefined },
+      )
+
+      expect({
+        digest: captured[0]?.digest,
+        hasSignature: typeof result.signature === 'string',
+        keyAuthorizationSignature: result.keyAuthorization?.signature,
+      }).toMatchInlineSnapshot(`
+        {
+          "digest": "0x64d5413088ae92221fde7900d29b540efc040ac134ccf50d3e916a9011f81bd0",
+          "hasSignature": true,
+          "keyAuthorizationSignature": {
+            "r": "0x876bd6f1719bdffc65382322939303ef37a804df5011b73704e7f4d9e4603cc8",
+            "s": "0x6c377e36d7a76b2dd15fdc9599ed663136a8e0faa33c3950e72c3b503bc18bab",
+            "type": "secp256k1",
+            "yParity": "0x1",
+          },
+        }
+      `)
+    })
   })
 
   describe('loadAccounts: personalSign', () => {

package/src/core/adapters/local.ts

@@ -1,5 +1,5 @@
-import { Hex, Provider as ox_Provider } from 'ox'
-import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
+import { Provider as ox_Provider } from 'ox'
+import { KeyAuthorization } from 'ox/tempo'
 import { BaseError, hashMessage } from 'viem'
 import { prepareTransactionRequest } from 'viem/actions'
 import { Account as TempoAccount, Actions } from 'viem/tempo'
@@ -28,48 +28,6 @@ export function local(options: local.Options): Adapter.Adapter {
   const { createAccount, icon, loadAccounts, name, rdns } = options
 
   return Adapter.define({ icon, name, rdns }, ({ getAccount, getClient, store }) => {
-    /**
-     * Resolves access key params into an unsigned key authorization.
-     */
-    async function prepareKeyAuthorization(options: Adapter.authorizeAccessKey.Parameters) {
-      const { address, expiry, keyType, limits, publicKey, scopes } = options
-      return await AccessKey.prepare({
-        address,
-        chainId: options.chainId ?? getClient().chain.id,
-        expiry,
-        keyType,
-        limits,
-        publicKey,
-        scopes,
-      })
-    }
-
-    /**
-     * Signs (or wraps a pre-computed signature into) a key authorization
-     * and saves the result to the store.
-     */
-    async function signKeyAuthorization(
-      account: TempoAccount.Account,
-      prepared: Awaited<ReturnType<typeof prepareKeyAuthorization>>,
-      options: {
-        signature?: Hex.Hex | undefined
-      } = {},
-    ) {
-      const { keyPair } = prepared
-
-      const keyAuthorization = await (async () => {
-        const digest = KeyAuthorization.getSignPayload(prepared.keyAuthorization)
-        const signature = options.signature ?? (await account.sign({ hash: digest }))
-        return KeyAuthorization.from(prepared.keyAuthorization, {
-          signature: SignatureEnvelope.from(signature),
-        })
-      })()
-
-      AccessKey.save({ address: account.address, keyAuthorization, keyPair, store })
-
-      return KeyAuthorization.toRpc(keyAuthorization)
-    }
-
     async function withAccessKey<result>(
       options: Pick<Account.find.Options, 'address' | 'calls' | 'chainId'>,
       fn: (
@@ -80,9 +38,7 @@ export function local(options: local.Options): Adapter.Adapter {
       const account = getAccount({ ...options, signable: true })
       const keyAuthorization = AccessKey.getPending(account, { store })
       try {
-        const result = await fn(account, keyAuthorization ?? undefined)
-        AccessKey.removePending(account, { store })
-        return result
+        return await fn(account, keyAuthorization ?? undefined)
       } catch (error) {
         if (account.source !== 'accessKey') throw error
         AccessKey.invalidate(account, error, { store })
@@ -128,8 +84,12 @@ export function local(options: local.Options): Adapter.Adapter {
 
           const keyAuthorization = await (async () => {
             if (!grantOptions) return undefined
-            const prepared = await prepareKeyAuthorization(grantOptions)
-            return await signKeyAuthorization(account, prepared)
+            return await AccessKey.authorize({
+              account,
+              chainId: getClient().chain.id,
+              parameters: grantOptions,
+              store,
+            })
           })()
 
           return {
@@ -142,10 +102,12 @@ export function local(options: local.Options): Adapter.Adapter {
           }
         },
         async authorizeAccessKey(parameters) {
-          const prepared = await prepareKeyAuthorization(parameters)
           const account = getAccount({ accessKey: false, signable: true })
-          const keyAuthorization = await signKeyAuthorization(account, prepared, {
-            signature: parameters.signature,
+          const keyAuthorization = await AccessKey.authorize({
+            account,
+            chainId: getClient().chain.id,
+            parameters,
+            store,
           })
           return { keyAuthorization, rootAddress: account.address }
         },
@@ -165,7 +127,14 @@ export function local(options: local.Options): Adapter.Adapter {
           const peronsalSign_digest = personalSign ? hashMessage(personalSign.message) : undefined
 
           const keyAuthorization_unsigned = authorizeAccessKey
-            ? await prepareKeyAuthorization(authorizeAccessKey)
+            ? await AccessKey.prepareAuthorization({
+                ...authorizeAccessKey,
+                chainId: authorizeAccessKey.chainId ?? getClient().chain.id,
+              })
+            : undefined
+
+          const keyAuthorization_digest = keyAuthorization_unsigned
+            ? KeyAuthorization.getSignPayload(keyAuthorization_unsigned.keyAuthorization)
             : undefined
 
           // Slot allocation:
@@ -176,11 +145,7 @@ export function local(options: local.Options): Adapter.Adapter {
           // `personalSign` wins the load-accounts ceremony and the key
           // authorization gets its own follow-up `account.sign` ceremony
           // (2 prompts total).
-          const digest =
-            peronsalSign_digest ??
-            (keyAuthorization_unsigned
-              ? KeyAuthorization.getSignPayload(keyAuthorization_unsigned.keyAuthorization)
-              : rest.digest)
+          const digest = peronsalSign_digest ?? keyAuthorization_digest ?? rest.digest
 
           // Pass the prepared digest (or the caller's) into loadAccounts so
           // the ceremony can sign it in a single biometric prompt.
@@ -200,10 +165,15 @@ export function local(options: local.Options): Adapter.Adapter {
           //   - Else (key-auth digest took the slot), reuse `signature_`.
           const keyAuthorization = await (async () => {
             if (!keyAuthorization_unsigned || !account) return undefined
-            if (peronsalSign_digest)
-              return await signKeyAuthorization(account, keyAuthorization_unsigned)
-            return await signKeyAuthorization(account, keyAuthorization_unsigned, {
-              signature: signature_,
+            const signature_keyAuthorization =
+              peronsalSign_digest || !signature_
+                ? await account.sign({ hash: keyAuthorization_digest! })
+                : signature_
+            return AccessKey.saveAuthorization({
+              address: account.address,
+              prepared: keyAuthorization_unsigned,
+              signature: signature_keyAuthorization,
+              store,
             })
           })()
 
@@ -301,10 +271,12 @@ export function local(options: local.Options): Adapter.Adapter {
             }),
           )
           const signed = await account.signTransaction(prepared as never)
-          return await client.request({
+          const result = await client.request({
             method: 'eth_sendRawTransaction' as never,
             params: [signed],
           })
+          AccessKey.removePending(account, { store })
+          return result
         },
         async sendTransactionSync(parameters) {
           const { feePayer, ...rest } = parameters
@@ -330,10 +302,12 @@ export function local(options: local.Options): Adapter.Adapter {
             }),
           )
           const signed = await account.signTransaction(prepared as never)
-          return await client.request({
+          const result = await client.request({
             method: 'eth_sendRawTransactionSync' as never,
             params: [signed],
           })
+          AccessKey.removePending(account, { store })
+          return result
         },
       },
     }

package/src/core/adapters/turnkey.ts

@@ -7,7 +7,7 @@ import {
   RpcResponse,
   Secp256k1,
 } from 'ox'
-import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
+import { KeyAuthorization } from 'ox/tempo'
 import { hashMessage, hashTypedData, isAddressEqual } from 'viem'
 import type { Address } from 'viem/accounts'
 import { prepareTransactionRequest } from 'viem/actions'
@@ -273,48 +273,6 @@ export function turnkey<const client extends turnkey.Client>(
       return signatureToHex(result)
     }
 
-    async function prepareKeyAuthorization(options: Adapter.authorizeAccessKey.Parameters) {
-      const { address, expiry, keyType, limits, publicKey, scopes } = options
-      return await AccessKey.prepare({
-        address,
-        chainId: options.chainId ?? getClient().chain.id,
-        expiry,
-        keyType,
-        limits,
-        publicKey,
-        scopes,
-      })
-    }
-
-    async function signKeyAuthorization(
-      account: turnkey.WalletAccount,
-      prepared: Awaited<ReturnType<typeof prepareKeyAuthorization>>,
-      options: {
-        signature?: Hex.Hex | undefined
-      } = {},
-    ) {
-      const digest = KeyAuthorization.getSignPayload(prepared.keyAuthorization)
-      const signature =
-        options.signature ??
-        (await signPayload({
-          payload: digest,
-          turnkeyClient: await getTurnkeyClient(),
-          walletAccount: account,
-        }))
-      const keyAuthorization = KeyAuthorization.from(prepared.keyAuthorization, {
-        signature: SignatureEnvelope.from(signature),
-      })
-
-      AccessKey.save({
-        address: core_Address.from(account.address),
-        keyAuthorization,
-        ...(prepared.keyPair ? { keyPair: prepared.keyPair } : {}),
-        store,
-      })
-
-      return KeyAuthorization.toRpc(keyAuthorization)
-    }
-
     async function withAccessKey<result>(
       options: {
         address?: Address | undefined
@@ -325,7 +283,7 @@ export function turnkey<const client extends turnkey.Client>(
         account: TempoAccount.Account,
         keyAuthorization?: KeyAuthorization.Signed,
       ) => Promise<result>,
-    ) {
+    ): Promise<{ account: TempoAccount.Account; result: result } | undefined> {
       const account = (() => {
         try {
           return getAccount({ ...options, signable: true })
@@ -338,8 +296,7 @@ export function turnkey<const client extends turnkey.Client>(
       const keyAuthorization = AccessKey.getPending(account, { store })
       try {
         const result = await fn(account, keyAuthorization ?? undefined)
-        AccessKey.removePending(account, { store })
-        return result
+        return { account, result }
       } catch (error) {
         AccessKey.invalidate(account, error, { store })
         return undefined
@@ -420,11 +377,12 @@ export function turnkey<const client extends turnkey.Client>(
           const account = walletAccounts[0]
           const keyAuthorization = authorizeAccessKey
             ? account
-              ? await signKeyAuthorization(
-                  account,
-                  await prepareKeyAuthorization(authorizeAccessKey),
-                  { signature: authorizeAccessKey.signature },
-                )
+              ? await AccessKey.authorize({
+                  account: toTempoAccount(account),
+                  chainId: getClient().chain.id,
+                  parameters: authorizeAccessKey,
+                  store,
+                })
               : undefined
             : undefined
 
@@ -463,11 +421,12 @@ export function turnkey<const client extends turnkey.Client>(
           const account = walletAccounts[0]
           const keyAuthorization =
             authorizeAccessKey && account
-              ? await signKeyAuthorization(
-                  account,
-                  await prepareKeyAuthorization(authorizeAccessKey),
-                  { signature: authorizeAccessKey.signature },
-                )
+              ? await AccessKey.authorize({
+                  account: toTempoAccount(account),
+                  chainId: getClient().chain.id,
+                  parameters: authorizeAccessKey,
+                  store,
+                })
               : undefined
 
           return {
@@ -486,9 +445,11 @@ export function turnkey<const client extends turnkey.Client>(
         },
         async authorizeAccessKey(parameters) {
           const account = await accountForSigning(undefined)
-          const prepared = await prepareKeyAuthorization(parameters)
-          const keyAuthorization = await signKeyAuthorization(account, prepared, {
-            signature: parameters.signature,
+          const keyAuthorization = await AccessKey.authorize({
+            account: toTempoAccount(account),
+            chainId: getClient().chain.id,
+            parameters,
+            store,
           })
           return { keyAuthorization, rootAddress: core_Address.from(account.address) }
         },
@@ -520,7 +481,7 @@ export function turnkey<const client extends turnkey.Client>(
               return await account.signTransaction(prepared as never)
             },
           )
-          if (result !== undefined) return result
+          if (result !== undefined) return result.result
           return await signTransaction(parameters)
         },
         async signTypedData(parameters) {
@@ -561,7 +522,10 @@ export function turnkey<const client extends turnkey.Client>(
               })
             },
           )
-          if (result !== undefined) return result
+          if (result !== undefined) {
+            AccessKey.removePending(result.account, { store })
+            return result.result
+          }
           const signed = await signTransaction(parameters)
           const viemClient = getClient({
             chainId: parameters.chainId,
@@ -595,7 +559,10 @@ export function turnkey<const client extends turnkey.Client>(
               })
             },
           )
-          if (result !== undefined) return result
+          if (result !== undefined) {
+            AccessKey.removePending(result.account, { store })
+            return result.result
+          }
           const signed = await signTransaction(parameters)
           const viemClient = getClient({
             chainId: parameters.chainId,

package/src/core/mppx.test.ts

@@ -1,12 +1,14 @@
+import { Fetch } from 'mppx/client'
 import { Mppx as ServerMppx, tempo } from 'mppx/server'
 import { parseUnits } from 'viem'
 import { Addresses } from 'viem/tempo'
 import { Actions } from 'viem/tempo'
-import { afterAll, beforeAll, describe, expect, test } from 'vp/test'
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vp/test'
 
 import { headlessWebAuthn } from '../../test/adapters.js'
 import { accounts, chain, getClient } from '../../test/config.js'
 import { type Server, createServer } from '../../test/utils.js'
+import * as Expiry from './Expiry.js'
 import * as Provider from './Provider.js'
 
 const client = getClient()
@@ -40,6 +42,8 @@ beforeAll(async () => {
 
 afterAll(() => server?.closeAsync())
 
+afterEach(() => Fetch.restore())
+
 describe('mppx integration', () => {
   test('polyfilled fetch handles 402 charge automatically', async () => {
     const provider = Provider.create({
@@ -49,15 +53,7 @@ describe('mppx integration', () => {
     })
 
     const address = await connect(provider)
-
-    const client = getClient()
-    await Actions.token.transferSync(client, {
-      account: accounts[0]!,
-      feeToken: Addresses.pathUsd,
-      to: address,
-      token: Addresses.pathUsd,
-      amount: parseUnits('10', 6),
-    })
+    await fund(address)
 
     const res = await fetch(`${server.url}/fortune`)
     expect(res.status).toBe(200)
@@ -69,6 +65,71 @@ describe('mppx integration', () => {
       }
     `)
   })
+
+  test('pull mode publishes a pending access key on first charge', async () => {
+    const provider = Provider.create({
+      adapter: headlessWebAuthn(),
+      chains: [chain],
+      mpp: { mode: 'pull' },
+    })
+    const address = await connect(provider)
+    await fund(address)
+
+    await provider.request({
+      method: 'wallet_authorizeAccessKey',
+      params: [{ expiry: Expiry.days(1) }],
+    })
+
+    const key = provider.store.getState().accessKeys[0]!
+    expect(key.keyAuthorization).toBeDefined()
+
+    const res = await fetch(`${server.url}/fortune`)
+    expect(res.status).toBe(200)
+    expect(provider.store.getState().accessKeys[0]!.keyAuthorization).toBeUndefined()
+
+    const metadata = await Actions.accessKey.getMetadata(client, {
+      account: address,
+      accessKey: key.address,
+    })
+    expect(metadata.isRevoked).toMatchInlineSnapshot(`false`)
+  })
+
+  test('pull mode keeps pending access key after failed verification', async () => {
+    const failingServer = await createServer(async (req, res) => {
+      if (req.headers.authorization) {
+        res.writeHead(402, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ title: 'Verification Failed' }))
+        return
+      }
+
+      await ServerMppx.toNodeListener(
+        payment.charge({
+          amount: '1',
+        }),
+      )(req, res)
+    })
+
+    try {
+      const provider = Provider.create({
+        adapter: headlessWebAuthn(),
+        chains: [chain],
+        mpp: { mode: 'pull' },
+      })
+      const address = await connect(provider)
+      await fund(address)
+
+      await provider.request({
+        method: 'wallet_authorizeAccessKey',
+        params: [{ expiry: Expiry.days(1) }],
+      })
+
+      const res = await fetch(`${failingServer.url}/fortune`)
+      expect(res.status).toMatchInlineSnapshot(`402`)
+      expect(provider.store.getState().accessKeys[0]!.keyAuthorization).toBeDefined()
+    } finally {
+      await failingServer.closeAsync()
+    }
+  })
 })
 
 async function connect(provider: ReturnType<typeof Provider.create>) {
@@ -80,3 +141,13 @@ async function connect(provider: ReturnType<typeof Provider.create>) {
   })
   return register.accounts[0]!.address
 }
+
+async function fund(address: `0x${string}`) {
+  await Actions.token.transferSync(client, {
+    account: accounts[0]!,
+    feeToken: Addresses.pathUsd,
+    to: address,
+    token: Addresses.pathUsd,
+    amount: parseUnits('10', 6),
+  })
+}

package/src/core/zod/rpc.ts

@@ -393,19 +393,21 @@ export namespace wallet_authorizeAccessKey_strict {
     expiry: z.number(),
     keyType: z.optional(keyType),
     limits: z.readonly(
-      z.array(z.object({ token: u.address(), limit: u.bigint(), period: z.optional(z.number()) })),
+      z
+        .array(z.object({ token: u.address(), limit: u.bigint(), period: z.optional(z.number()) }))
+        .check(z.minLength(1)),
     ),
     publicKey: z.optional(u.hex()),
-    scopes: z.optional(
-      z.readonly(
-        z.array(
+    scopes: z.readonly(
+      z
+        .array(
           z.object({
             address: u.address(),
             selector: z.optional(z.union([u.hex(), z.string()])),
             recipients: z.optional(z.readonly(z.array(u.address()))),
           }),
-        ),
-      ),
+        )
+        .check(z.minLength(1)),
     ),
   })
 }

package/src/index.ts

@@ -1,3 +1,4 @@
+export * as AccessKey from './core/AccessKey.js'
 export * as Adapter from './core/Adapter.js'
 export * as IntersectionObserver from './core/IntersectionObserver.js'
 export * as Dialog from './core/Dialog.js'

package/src/react-native/adapter.ts

@@ -205,9 +205,7 @@ export function reactNative(options: reactNative.Options): Adapter.Adapter {
           keyAuthorization = await reauthorizeManagedKey(rootAddress, managedKey)
 
       try {
-        const result = await fn(account, keyAuthorization ?? undefined)
-        AccessKey.removePending(account, { store })
-        return result
+        return await fn(account, keyAuthorization ?? undefined)
       } catch (error) {
         AccessKey.remove(account, { store })
         throw error
@@ -348,10 +346,12 @@ export function reactNative(options: reactNative.Options): Adapter.Adapter {
             }),
           )
           const signed = await account.signTransaction(prepared as never)
-          return await client.request({
+          const result = await client.request({
             method: 'eth_sendRawTransaction' as never,
             params: [signed],
           })
+          AccessKey.removePending(account, { store })
+          return result
         },
         async sendTransactionSync(parameters) {
           const { feePayer, ...rest } = parameters
@@ -369,10 +369,12 @@ export function reactNative(options: reactNative.Options): Adapter.Adapter {
             }),
           )
           const signed = await account.signTransaction(prepared as never)
-          return await client.request({
+          const result = await client.request({
             method: 'eth_sendRawTransactionSync' as never,
             params: [signed],
           })
+          AccessKey.removePending(account, { store })
+          return result
         },
         async signPersonalMessage({ address, data }) {
           await loadManagedKey(address)

package/src/server/internal/handlers/relay.test.ts

@@ -1426,6 +1426,30 @@ describe('behavior: path A — guaranteed sponsorship (no validate)', () => {
     expect(result.transaction.feePayerSignature).toBeDefined()
     expect(result.capabilities?.sponsored).toBe(true)
   })
+
+  test('behavior: defaults feeToken to chain default when caller omits it', async () => {
+    // Without the default, the broadcast envelope has no feeToken and
+    // the chain falls back to the sender's account token, which often
+    // lacks FeeAMM liquidity.
+    const result = await fillTransaction(client, {
+      account: userAccount.address,
+      calls: [transferCall()],
+    })
+
+    expect(result.transaction.feeToken?.toLowerCase()).toBe(
+      localnetTokens[0]!.address.toLowerCase(),
+    )
+  })
+
+  test('behavior: preserves caller-supplied feeToken', async () => {
+    const result = await fillTransaction(client, {
+      account: userAccount.address,
+      calls: [transferCall()],
+      feeToken: addresses.alphaUsd as Address,
+    })
+
+    expect(result.transaction.feeToken?.toLowerCase()).toBe(addresses.alphaUsd.toLowerCase())
+  })
 })
 
 describe('behavior: path B — conditional sponsorship (validate)', () => {