accounts 0.12.2 → 0.14.0

package/src/core/adapters/dialog.ts

@@ -1,12 +1,11 @@
-import { Address, Provider as ox_Provider, RpcRequest as ox_RpcRequest } from 'ox'
+import { Address, Provider as ox_Provider, RpcRequest as ox_RpcRequest, RpcResponse } from 'ox'
 import { KeyAuthorization } from 'ox/tempo'
-import { prepareTransactionRequest } from 'viem/actions'
-import { Account as TempoAccount } from 'viem/tempo'
 import { z } from 'zod/mini'
 
 import * as AccessKey from '../AccessKey.js'
 import * as Adapter from '../Adapter.js'
 import * as Dialog from '../Dialog.js'
+import * as AccessKeyTransaction from '../internal/AccessKeyTransaction.js'
 import * as Schema from '../Schema.js'
 import type * as Store from '../Store.js'
 import * as Rpc from '../zod/rpc.js'
@@ -115,11 +114,16 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
     async function generateAccessKey(options: Adapter.authorizeAccessKey.Parameters | undefined) {
       if (!options) return undefined
       if (options.publicKey || options.address) return undefined
+      if (options.keyType && options.keyType !== 'p256')
+        throw new RpcResponse.InvalidParamsError({
+          message: `\`keyType: "${options.keyType}"\` requires externally generated key material; provide \`publicKey\` or \`address\`.`,
+        })
 
-      const { accessKey, keyPair } = await AccessKey.generate()
+      const generated = await AccessKey.generate()
+      const { accessKey } = generated
       return {
         accessKey,
-        keyPair,
+        generated,
         request: {
           ...options,
           publicKey: accessKey.publicKey,
@@ -135,44 +139,15 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
     function saveAccessKey(
       address: Address.Address,
       keyAuth: KeyAuthorization.Rpc,
-      keyPair: AccessKey.generate.ReturnType['keyPair'],
+      generated: Awaited<ReturnType<typeof AccessKey.generate>>,
     ) {
       const keyAuthorization = KeyAuthorization.fromRpc(keyAuth)
-      AccessKey.save({ address, keyAuthorization, keyPair, store })
-    }
-
-    /**
-     * Tries to execute `fn` with the local access key. Returns `undefined`
-     * when no access key exists so the caller can fall through to the dialog.
-     * On stale-key errors, removes the key and also returns `undefined`.
-     * On recoverable transaction errors, keeps the key and falls through to
-     * the dialog so the user can fund, approve, or retry.
-     */
-    async function withAccessKey<result>(
-      options: Pick<Adapter.sendTransaction.Parameters, 'calls' | 'chainId' | 'from'>,
-      fn: (
-        account: TempoAccount.Account,
-        keyAuthorization?: KeyAuthorization.Signed,
-      ) => Promise<result>,
-    ): Promise<{ account: TempoAccount.Account; result: result } | undefined> {
-      if (!options.from || typeof options.chainId === 'undefined') return undefined
-      const account = AccessKey.selectAccount({
-        address: options.from,
-        calls: options.calls,
-        chainId: options.chainId,
+      AccessKey.add({
+        account: address,
+        authorization: keyAuthorization,
+        keyPair: generated.keyPair,
         store,
       })
-      if (!account) return undefined
-      const keyAuthorization = AccessKey.getPending(account, { store })
-      try {
-        const result = await fn(account, keyAuthorization ?? undefined)
-        return { account, result }
-      } catch (err) {
-        if (AccessKey.invalidate(account, err, { store }))
-          console.warn('[accounts] access key invalidated, falling through to dialog:', err)
-        else console.warn('[accounts] access key sign failed, falling through to dialog:', err)
-        return undefined
-      }
     }
 
     const dialogInstance = dialog({ host, store, theme })
@@ -224,20 +199,18 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
           })
 
           const address = accounts[0]?.address
-          const keyAuthorization = accounts[0]?.capabilities.keyAuthorization
+          const capabilities = accounts[0]?.capabilities
+          const keyAuthorization = capabilities?.keyAuthorization
 
           if (accessKey && address && keyAuthorization)
-            saveAccessKey(address, keyAuthorization, accessKey.keyPair)
+            saveAccessKey(address, keyAuthorization, accessKey.generated)
 
           return {
             accounts: accounts.map((a) => ({ address: a.address })),
+            ...(capabilities?.auth ? { auth: capabilities.auth } : {}),
             ...(keyAuthorization ? { keyAuthorization } : {}),
-            ...(accounts[0]?.capabilities.signature
-              ? { signature: accounts[0].capabilities.signature }
-              : {}),
-            ...(accounts[0]?.capabilities.personalSign
-              ? { personalSign: accounts[0].capabilities.personalSign }
-              : {}),
+            ...(capabilities?.signature ? { signature: capabilities.signature } : {}),
+            ...(capabilities?.personalSign ? { personalSign: capabilities.personalSign } : {}),
           }
         },
 
@@ -265,20 +238,18 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
           })
 
           const address = accounts[0]?.address
-          const keyAuthorization = accounts[0]?.capabilities.keyAuthorization
+          const capabilities = accounts[0]?.capabilities
+          const keyAuthorization = capabilities?.keyAuthorization
 
           if (accessKey && address && keyAuthorization)
-            saveAccessKey(address, keyAuthorization, accessKey.keyPair)
+            saveAccessKey(address, keyAuthorization, accessKey.generated)
 
           return {
             accounts: accounts.map((a) => ({ address: a.address })),
+            ...(capabilities?.auth ? { auth: capabilities.auth } : {}),
             ...(keyAuthorization ? { keyAuthorization } : {}),
-            ...(accounts[0]?.capabilities.signature
-              ? { signature: accounts[0].capabilities.signature }
-              : {}),
-            ...(accounts[0]?.capabilities.personalSign
-              ? { personalSign: accounts[0].capabilities.personalSign }
-              : {}),
+            ...(capabilities?.signature ? { signature: capabilities.signature } : {}),
+            ...(capabilities?.personalSign ? { personalSign: capabilities.personalSign } : {}),
           }
         },
 
@@ -287,26 +258,36 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
         },
 
         async signTransaction(parameters, request) {
-          const result = await withAccessKey(parameters, async (account, keyAuthorization) => {
-            const { feePayer, ...rest } = parameters
-            const client = getClient({
-              chainId: parameters.chainId,
-              feePayer: (() => {
-                if (feePayer === false) return false
-                if (typeof feePayer === 'string') return feePayer
-                return undefined
-              })(),
-            })
-            const prepared = await prepareTransactionRequest(client, {
-              account,
-              ...rest,
-              ...(typeof feePayer !== 'undefined' ? { feePayer: !!feePayer as never } : {}),
-              keyAuthorization,
-              type: 'tempo',
-            })
-            return await account.signTransaction(prepared as never)
+          const { feePayer, ...rest } = parameters
+          const client = getClient({
+            chainId: parameters.chainId,
+            feePayer: (() => {
+              if (feePayer === false) return false
+              if (typeof feePayer === 'string') return feePayer
+              return undefined
+            })(),
           })
-          if (result !== undefined) return result.result
+          const transaction =
+            parameters.from && typeof parameters.chainId !== 'undefined'
+              ? await AccessKeyTransaction.create({
+                  address: parameters.from,
+                  calls: parameters.calls,
+                  chainId: parameters.chainId,
+                  client,
+                  store,
+                })
+              : undefined
+          if (transaction) {
+            try {
+              const prepared = await transaction.prepare({
+                ...rest,
+                ...(typeof feePayer !== 'undefined' ? { feePayer: !!feePayer as never } : {}),
+              })
+              return await prepared.sign()
+            } catch (error) {
+              console.warn('[accounts] access key sign failed, falling through to dialog:', error)
+            }
+          }
           return await provider.request({
             ...request,
             params: [z.encode(Rpc.transactionRequest, parameters)] as const,
@@ -318,32 +299,35 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
         },
 
         async sendTransaction(parameters, request) {
-          const result = await withAccessKey(parameters, async (account, keyAuthorization) => {
-            const { feePayer, ...rest } = parameters
-            const client = getClient({
-              chainId: parameters.chainId,
-              feePayer: (() => {
-                if (feePayer === false) return false
-                if (typeof feePayer === 'string') return feePayer
-                return undefined
-              })(),
-            })
-            const prepared = await prepareTransactionRequest(client, {
-              account,
-              ...rest,
-              ...(typeof feePayer !== 'undefined' ? { feePayer: !!feePayer as never } : {}),
-              keyAuthorization,
-              type: 'tempo',
-            })
-            const signed = await account.signTransaction(prepared as never)
-            return await client.request({
-              method: 'eth_sendRawTransaction' as never,
-              params: [signed],
-            })
+          const { feePayer, ...rest } = parameters
+          const client = getClient({
+            chainId: parameters.chainId,
+            feePayer: (() => {
+              if (feePayer === false) return false
+              if (typeof feePayer === 'string') return feePayer
+              return undefined
+            })(),
           })
-          if (result !== undefined) {
-            AccessKey.removePending(result.account, { store })
-            return result.result
+          const transaction =
+            parameters.from && typeof parameters.chainId !== 'undefined'
+              ? await AccessKeyTransaction.create({
+                  address: parameters.from,
+                  calls: parameters.calls,
+                  chainId: parameters.chainId,
+                  client,
+                  store,
+                })
+              : undefined
+          if (transaction) {
+            try {
+              const prepared = await transaction.prepare({
+                ...rest,
+                ...(typeof feePayer !== 'undefined' ? { feePayer: !!feePayer as never } : {}),
+              })
+              return await prepared.send()
+            } catch (error) {
+              console.warn('[accounts] access key sign failed, falling through to dialog:', error)
+            }
           }
           return await provider.request({
             ...request,
@@ -352,32 +336,35 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
         },
 
         async sendTransactionSync(parameters, request) {
-          const result = await withAccessKey(parameters, async (account, keyAuthorization) => {
-            const { feePayer, ...rest } = parameters
-            const client = getClient({
-              chainId: parameters.chainId,
-              feePayer: (() => {
-                if (feePayer === false) return false
-                if (typeof feePayer === 'string') return feePayer
-                return undefined
-              })(),
-            })
-            const prepared = await prepareTransactionRequest(client, {
-              account,
-              ...rest,
-              ...(typeof feePayer !== 'undefined' ? { feePayer: !!feePayer as never } : {}),
-              keyAuthorization,
-              type: 'tempo',
-            })
-            const signed = await account.signTransaction(prepared as never)
-            return await client.request({
-              method: 'eth_sendRawTransactionSync' as never,
-              params: [signed],
-            })
+          const { feePayer, ...rest } = parameters
+          const client = getClient({
+            chainId: parameters.chainId,
+            feePayer: (() => {
+              if (feePayer === false) return false
+              if (typeof feePayer === 'string') return feePayer
+              return undefined
+            })(),
           })
-          if (result !== undefined) {
-            AccessKey.removePending(result.account, { store })
-            return result.result
+          const transaction =
+            parameters.from && typeof parameters.chainId !== 'undefined'
+              ? await AccessKeyTransaction.create({
+                  address: parameters.from,
+                  calls: parameters.calls,
+                  chainId: parameters.chainId,
+                  client,
+                  store,
+                })
+              : undefined
+          if (transaction) {
+            try {
+              const prepared = await transaction.prepare({
+                ...rest,
+                ...(typeof feePayer !== 'undefined' ? { feePayer: !!feePayer as never } : {}),
+              })
+              return await prepared.sendSync()
+            } catch (error) {
+              console.warn('[accounts] access key sign failed, falling through to dialog:', error)
+            }
           }
           return await provider.request({
             ...request,
@@ -399,15 +386,21 @@ export function dialog(options: dialog.Options = {}): Adapter.Adapter {
           })
 
           if (accessKey) {
-            const account = getAccount({ accessKey: false, signable: false })
-            saveAccessKey(account.address, result.keyAuthorization, accessKey.keyPair)
+            const account = getAccount({ signable: false })
+            saveAccessKey(account.address, result.keyAuthorization, accessKey.generated)
           }
 
           return result
         },
 
-        async revokeAccessKey(_params, request) {
+        async revokeAccessKey(params, request) {
           await provider.request(request)
+          AccessKey.remove({
+            accessKey: params.accessKeyAddress,
+            account: params.address,
+            chainId: store.getState().chainId,
+            store,
+          })
         },
 
         async deposit(_params, request) {

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

@@ -1,6 +1,6 @@
 import type { Hex } from 'viem'
 import { hashMessage, verifyMessage } from 'viem'
-import { tempoLocalnet } from 'viem/chains'
+import { tempoLocalnet } from 'viem/tempo/chains'
 import { describe, expect, test } from 'vp/test'
 
 import {

package/src/core/adapters/local.ts

@@ -1,12 +1,13 @@
 import { Provider as ox_Provider } from 'ox'
-import { KeyAuthorization } from 'ox/tempo'
-import { BaseError, hashMessage } from 'viem'
+import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
+import { hashMessage } from 'viem'
 import { prepareTransactionRequest } from 'viem/actions'
-import { Account as TempoAccount, Actions } from 'viem/tempo'
+import { Actions } from 'viem/tempo'
 
 import * as AccessKey from '../AccessKey.js'
 import * as Account from '../Account.js'
 import * as Adapter from '../Adapter.js'
+import * as AccessKeyTransaction from '../internal/AccessKeyTransaction.js'
 
 /**
  * Creates a local adapter where the app manages keys and signing in-process.
@@ -28,22 +29,67 @@ export function local(options: local.Options): Adapter.Adapter {
   const { createAccount, icon, loadAccounts, name, rdns } = options
 
   return Adapter.define({ icon, name, rdns }, ({ getAccount, getClient, store }) => {
-    async function withAccessKey<result>(
-      options: Pick<Account.find.Options, 'address' | 'calls' | 'chainId'>,
-      fn: (
-        account: TempoAccount.Account,
-        keyAuthorization?: KeyAuthorization.Signed,
-      ) => Promise<result>,
-    ): Promise<result> {
-      const account = getAccount({ ...options, signable: true })
-      const keyAuthorization = AccessKey.getPending(account, { store })
-      try {
-        return await fn(account, keyAuthorization ?? undefined)
-      } catch (error) {
-        if (account.source !== 'accessKey') throw error
-        AccessKey.invalidate(account, error, { store })
-        const root = getAccount({ accessKey: false, address: options.address, signable: true })
-        return await fn(root, undefined)
+    async function prepareTransaction(parameters: Adapter.signTransaction.Parameters) {
+      const { feePayer, ...rest } = parameters
+      const client = getClient({
+        chainId: parameters.chainId,
+        feePayer: (() => {
+          if (feePayer === false) return false
+          if (typeof feePayer === 'string') return feePayer
+          return undefined
+        })(),
+      })
+      const request = {
+        ...rest,
+        ...(feePayer ? { feePayer: true as const } : {}),
+      }
+      const state = store.getState()
+      const address = parameters.from ?? state.accounts[state.activeAccount]?.address
+      const transaction = address
+        ? await AccessKeyTransaction.create({
+            address,
+            calls: parameters.calls,
+            chainId: parameters.chainId ?? state.chainId,
+            client,
+            store,
+          })
+        : undefined
+      if (transaction) {
+        try {
+          return await transaction.prepare(request)
+        } catch {}
+      }
+
+      const account = getAccount({
+        address: parameters.from,
+        signable: true,
+      })
+      const prepared = await prepareTransactionRequest(client, {
+        account,
+        ...request,
+        keyAuthorization: undefined,
+        type: 'tempo',
+      })
+      async function sign() {
+        return await account.signTransaction(prepared as never)
+      }
+      return {
+        request: prepared,
+        sign,
+        async send() {
+          const signed = await sign()
+          return (await client.request({
+            method: 'eth_sendRawTransaction' as never,
+            params: [signed],
+          })) as Adapter.sendTransaction.ReturnType
+        },
+        async sendSync() {
+          const signed = await sign()
+          return (await client.request({
+            method: 'eth_sendRawTransactionSync' as never,
+            params: [signed],
+          })) as Adapter.sendTransactionSync.ReturnType
+        },
       }
     }
 
@@ -102,7 +148,7 @@ export function local(options: local.Options): Adapter.Adapter {
           }
         },
         async authorizeAccessKey(parameters) {
-          const account = getAccount({ accessKey: false, signable: true })
+          const account = getAccount({ signable: true })
           const keyAuthorization = await AccessKey.authorize({
             account,
             chainId: getClient().chain.id,
@@ -139,7 +185,7 @@ export function local(options: local.Options): Adapter.Adapter {
 
           // Slot allocation:
           //   1. `personalSign` digest, if present.
-          //   2. Else key-auth digest (existing 1-prompt fold for `authorizeAccessKey`).
+          //   2. Else unsigned key-auth digest (existing 1-prompt fold for `authorizeAccessKey`).
           //   3. Else caller's `rest.digest`.
           // When BOTH `personalSign` and `authorizeAccessKey` are present,
           // `personalSign` wins the load-accounts ceremony and the key
@@ -169,12 +215,21 @@ export function local(options: local.Options): Adapter.Adapter {
               peronsalSign_digest || !signature_
                 ? await account.sign({ hash: keyAuthorization_digest! })
                 : signature_
-            return AccessKey.saveAuthorization({
-              address: account.address,
-              prepared: keyAuthorization_unsigned,
-              signature: signature_keyAuthorization,
+            const keyAuthorization = KeyAuthorization.from(
+              keyAuthorization_unsigned.keyAuthorization,
+              {
+                signature: SignatureEnvelope.from(signature_keyAuthorization),
+              },
+            )
+            AccessKey.add({
+              account: account.address,
+              authorization: keyAuthorization,
+              ...(keyAuthorization_unsigned.keyPair
+                ? { keyPair: keyAuthorization_unsigned.keyPair }
+                : {}),
               store,
             })
+            return KeyAuthorization.toRpc(keyAuthorization)
           })()
 
           return {
@@ -187,55 +242,30 @@ export function local(options: local.Options): Adapter.Adapter {
           }
         },
         async revokeAccessKey(parameters) {
-          const account = getAccount({ accessKey: false, signable: true })
+          const account = getAccount({ signable: true })
           const client = getClient()
           try {
             await Actions.accessKey.revoke(client, {
               account,
               accessKey: parameters.accessKeyAddress,
-            } as never)
+            })
           } catch (error) {
-            const isKeyNotFound =
-              error instanceof BaseError &&
-              !!error.walk(
-                (e) => (e as { data?: { errorName?: string } }).data?.errorName === 'KeyNotFound',
-              )
-            if (!isKeyNotFound) throw error
+            if (!AccessKey.isUnavailableError(error)) throw error
           }
-          store.setState((state) => ({
-            accessKeys: state.accessKeys.filter(
-              (a) => a.address?.toLowerCase() !== parameters.accessKeyAddress.toLowerCase(),
-            ),
-          }))
+          AccessKey.remove({
+            accessKey: parameters.accessKeyAddress,
+            account: account.address,
+            chainId: client.chain.id,
+            store,
+          })
         },
         async signPersonalMessage({ data, address }) {
           const account = getAccount({ address, signable: true })
           return await account.signMessage({ message: { raw: data } })
         },
         async signTransaction(parameters) {
-          const { feePayer, ...rest } = parameters
-          const client = getClient({
-            chainId: parameters.chainId,
-            feePayer: (() => {
-              if (feePayer === false) return false
-              if (typeof feePayer === 'string') return feePayer
-              return undefined
-            })(),
-          })
-          const { account, prepared } = await withAccessKey(
-            { address: parameters.from, calls: parameters.calls, chainId: parameters.chainId },
-            async (account, keyAuthorization) => ({
-              account,
-              prepared: await prepareTransactionRequest(client, {
-                account,
-                ...rest,
-                ...(feePayer ? { feePayer: true } : {}),
-                keyAuthorization,
-                type: 'tempo',
-              }),
-            }),
-          )
-          return await account.signTransaction(prepared as never)
+          const prepared = await prepareTransaction(parameters)
+          return await prepared.sign()
         },
         async signTypedData({ data, address }) {
           const account = getAccount({ address, signable: true })
@@ -248,66 +278,12 @@ export function local(options: local.Options): Adapter.Adapter {
           return await account.signTypedData(parsed)
         },
         async sendTransaction(parameters) {
-          const { feePayer, ...rest } = parameters
-          const client = getClient({
-            chainId: parameters.chainId,
-            feePayer: (() => {
-              if (feePayer === false) return false
-              if (typeof feePayer === 'string') return feePayer
-              return undefined
-            })(),
-          })
-          const { account, prepared } = await withAccessKey(
-            { address: parameters.from, calls: parameters.calls, chainId: parameters.chainId },
-            async (account, keyAuthorization) => ({
-              account,
-              prepared: await prepareTransactionRequest(client, {
-                account,
-                ...rest,
-                ...(feePayer ? { feePayer: true } : {}),
-                keyAuthorization,
-                type: 'tempo',
-              }),
-            }),
-          )
-          const signed = await account.signTransaction(prepared as never)
-          const result = await client.request({
-            method: 'eth_sendRawTransaction' as never,
-            params: [signed],
-          })
-          AccessKey.removePending(account, { store })
-          return result
+          const prepared = await prepareTransaction(parameters)
+          return await prepared.send()
         },
         async sendTransactionSync(parameters) {
-          const { feePayer, ...rest } = parameters
-          const client = getClient({
-            chainId: parameters.chainId,
-            feePayer: (() => {
-              if (feePayer === false) return false
-              if (typeof feePayer === 'string') return feePayer
-              return undefined
-            })(),
-          })
-          const { account, prepared } = await withAccessKey(
-            { address: parameters.from, calls: parameters.calls, chainId: parameters.chainId },
-            async (account, keyAuthorization) => ({
-              account,
-              prepared: await prepareTransactionRequest(client, {
-                account,
-                ...rest,
-                ...(feePayer ? { feePayer: true } : {}),
-                keyAuthorization,
-                type: 'tempo',
-              }),
-            }),
-          )
-          const signed = await account.signTransaction(prepared as never)
-          const result = await client.request({
-            method: 'eth_sendRawTransactionSync' as never,
-            params: [signed],
-          })
-          AccessKey.removePending(account, { store })
-          return result
+          const prepared = await prepareTransaction(parameters)
+          return await prepared.sendSync()
         },
       },
     }