accounts 0.3.0 → 0.4.1

package/src/core/adapters/dialog.ts

@@ -0,0 +1,379 @@
+import { Address, Provider as ox_Provider, RpcRequest as ox_RpcRequest } 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 Schema from '../Schema.js'
+import type * as Store from '../Store.js'
+import * as Rpc from '../zod/rpc.js'
+
+/**
+ * Creates a dialog adapter that delegates signing to a remote embed app
+ * via an iframe or popup dialog.
+ *
+ * @example
+ * ```ts
+ * import { dialog, Provider } from 'accounts'
+ *
+ * const provider = Provider.create({
+ *   adapter: dialog(),
+ * })
+ * ```
+ */
+export function dialog(options: dialog.Options = {}): Adapter.Adapter {
+  const {
+    dialog = Dialog.isSafari() ? Dialog.popup() : Dialog.iframe(),
+    host = 'https://wallet.tempo.xyz/embed',
+    icon,
+    name = 'Tempo',
+    rdns = 'xyz.tempo',
+  } = options
+
+  return Adapter.define({ icon, name, rdns }, ({ getAccount, getClient, store }) => {
+    const listeners = new Set<(requestQueue: readonly Store.QueuedRequest[]) => void>()
+    const requestStore = ox_RpcRequest.createStore()
+
+    /** Wait for a queued request to be resolved via the store. */
+    function waitForQueuedRequest(requestId: number) {
+      return new Promise((resolve, reject) => {
+        const listener = (requestQueue: readonly Store.QueuedRequest[]) => {
+          const queued = requestQueue.find((x) => x.request.id === requestId)
+
+          // Request removed and queue empty — cancelled or dialog closed.
+          if (!queued && requestQueue.length === 0) {
+            listeners.delete(listener)
+            reject(new ox_Provider.UserRejectedRequestError())
+            return
+          }
+
+          // Request not found but queue has other requests — wait.
+          if (!queued) return
+
+          // Request found but not yet resolved — wait.
+          if (queued.status !== 'success' && queued.status !== 'error') return
+
+          listeners.delete(listener)
+
+          if (queued.status === 'success') resolve(queued.result)
+          else reject(new ox_Provider.UserRejectedRequestError({ message: queued.error.message }))
+
+          // Remove the resolved request from the queue.
+          store.setState((x) => ({
+            ...x,
+            requestQueue: x.requestQueue.filter((x) => x.request.id !== requestId),
+          }))
+        }
+
+        listeners.add(listener)
+
+        // Notify immediately with current state so the store subscription
+        // picks up the request that was just added (setState fires
+        // synchronously before this listener is registered).
+        listener(store.getState().requestQueue)
+      })
+    }
+
+    /**
+     * An ox provider that queues RPC requests in the store. The store
+     * subscription syncs the pending queue to the dialog via `syncRequests`.
+     */
+    const provider = ox_Provider.from(
+      {
+        async request(r) {
+          const request = requestStore.prepare(r as never)
+
+          store.setState((x) => ({
+            ...x,
+            requestQueue: [...x.requestQueue, { request, status: 'pending' as const }],
+          }))
+
+          return waitForQueuedRequest(request.id)
+        },
+      },
+      { schema: Schema.ox },
+    )
+
+    /**
+     * Prepares a local key pair when `authorizeAccessKey` is requested without
+     * an external publicKey/address, and returns the params to inject into the
+     * RPC request so the dialog signs the authorization.
+     */
+    async function generateAccessKey(options: Adapter.authorizeAccessKey.Parameters | undefined) {
+      if (!options) return undefined
+      if (options.publicKey || options.address) return undefined
+
+      const { accessKey, keyPair } = await AccessKey.generate()
+      return {
+        accessKey,
+        keyPair,
+        request: {
+          ...options,
+          publicKey: accessKey.publicKey,
+          keyType: 'p256' as const,
+        },
+      }
+    }
+
+    /**
+     * After the dialog returns a signed key authorization, saves the local
+     * key pair + key authorization into the store.
+     */
+    function saveAccessKey(
+      address: Address.Address,
+      keyAuth: KeyAuthorization.Rpc,
+      keyPair: AccessKey.generate.ReturnType['keyPair'],
+    ) {
+      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 access key errors, removes the stale key and also returns `undefined`.
+     */
+    async function withAccessKey<result>(
+      fn: (
+        account: TempoAccount.Account,
+        keyAuthorization?: KeyAuthorization.Signed,
+      ) => Promise<result>,
+    ): Promise<result | undefined> {
+      const account = (() => {
+        try {
+          return getAccount({ signable: true })
+        } catch {
+          return undefined
+        }
+      })()
+      if (!account) return undefined
+      if (account.source !== 'accessKey') return undefined
+      const keyAuthorization = AccessKey.getPending(account, { store })
+      try {
+        const result = await fn(account, keyAuthorization ?? undefined)
+        AccessKey.removePending(account, { store })
+        return result
+      } catch {
+        AccessKey.remove(account, { store })
+        return undefined
+      }
+    }
+
+    const dialogInstance = dialog({ host, store })
+
+    // Sync store → dialog: whenever the request queue changes, notify
+    // listeners and sync pending requests to the dialog.
+    const unsubscribe = store.subscribe(
+      (x) => x.requestQueue,
+      (requestQueue) => {
+        for (const listener of listeners) listener(requestQueue)
+
+        const pending = requestQueue.filter(
+          (x): x is Store.QueuedRequest & { status: 'pending' } => x.status === 'pending',
+        )
+
+        dialogInstance?.syncRequests(pending)
+        if (pending.length === 0) dialogInstance?.close()
+      },
+    )
+
+    return {
+      cleanup() {
+        unsubscribe()
+        dialogInstance?.destroy()
+      },
+      actions: {
+        async createAccount(parameters, request) {
+          const accessKey = await generateAccessKey(parameters.authorizeAccessKey)
+
+          const { accounts } = await provider.request({
+            ...request,
+            params: [
+              {
+                ...request.params?.[0],
+                capabilities: {
+                  ...request.params?.[0]?.capabilities,
+                  ...(accessKey
+                    ? {
+                        authorizeAccessKey: z.encode(
+                          Rpc.wallet_connect.authorizeAccessKey,
+                          accessKey.request,
+                        ),
+                      }
+                    : {}),
+                },
+              },
+            ] as const,
+          })
+
+          const address = accounts[0]?.address
+          const keyAuthorization = accounts[0]?.capabilities.keyAuthorization
+
+          if (accessKey && address && keyAuthorization)
+            saveAccessKey(address, keyAuthorization, accessKey.keyPair)
+
+          return {
+            accounts: accounts.map((a) => ({ address: a.address })),
+            ...(keyAuthorization ? { keyAuthorization } : {}),
+            ...(accounts[0]?.capabilities.signature
+              ? { signature: accounts[0].capabilities.signature }
+              : {}),
+          }
+        },
+
+        async loadAccounts(parameters, request) {
+          const accessKey = await generateAccessKey(parameters?.authorizeAccessKey)
+
+          const { accounts } = await provider.request({
+            ...request,
+            params: [
+              {
+                ...request.params?.[0],
+                capabilities: {
+                  ...request.params?.[0]?.capabilities,
+                  ...(accessKey
+                    ? {
+                        authorizeAccessKey: z.encode(
+                          Rpc.wallet_connect.authorizeAccessKey,
+                          accessKey.request,
+                        ),
+                      }
+                    : {}),
+                },
+              },
+            ] as const,
+          })
+
+          const address = accounts[0]?.address
+          const keyAuthorization = accounts[0]?.capabilities.keyAuthorization
+
+          if (accessKey && address && keyAuthorization)
+            saveAccessKey(address, keyAuthorization, accessKey.keyPair)
+
+          return {
+            accounts: accounts.map((a) => ({ address: a.address })),
+            ...(keyAuthorization ? { keyAuthorization } : {}),
+            ...(accounts[0]?.capabilities.signature
+              ? { signature: accounts[0].capabilities.signature }
+              : {}),
+          }
+        },
+
+        async signPersonalMessage(_params, request) {
+          return await provider.request(request)
+        },
+
+        async signTransaction(parameters, request) {
+          const result = await withAccessKey(async (account, keyAuthorization) => {
+            const { feePayer, ...rest } = parameters
+            const client = getClient({
+              feePayer: typeof feePayer === 'string' ? feePayer : undefined,
+            })
+            const prepared = await prepareTransactionRequest(client, {
+              account,
+              ...rest,
+              ...(feePayer ? { feePayer: true } : {}),
+              keyAuthorization,
+              type: 'tempo',
+            })
+            return await account.signTransaction(prepared as never)
+          })
+          if (result !== undefined) return result
+          return await provider.request(request)
+        },
+
+        async signTypedData(_params, request) {
+          return await provider.request(request)
+        },
+
+        async sendTransaction(parameters, request) {
+          const result = await withAccessKey(async (account, keyAuthorization) => {
+            const { feePayer, ...rest } = parameters
+            const client = getClient({
+              feePayer: typeof feePayer === 'string' ? feePayer : undefined,
+            })
+            const prepared = await prepareTransactionRequest(client, {
+              account,
+              ...rest,
+              ...(feePayer ? { feePayer: true } : {}),
+              keyAuthorization,
+              type: 'tempo',
+            })
+            const signed = await account.signTransaction(prepared as never)
+            return await client.request({
+              method: 'eth_sendRawTransaction' as never,
+              params: [signed],
+            })
+          })
+          if (result !== undefined) return result
+          return await provider.request(request)
+        },
+
+        async sendTransactionSync(parameters, request) {
+          const result = await withAccessKey(async (account, keyAuthorization) => {
+            const { feePayer, ...rest } = parameters
+            const client = getClient({
+              feePayer: typeof feePayer === 'string' ? feePayer : undefined,
+            })
+            const prepared = await prepareTransactionRequest(client, {
+              account,
+              ...rest,
+              ...(feePayer ? { feePayer: true } : {}),
+              keyAuthorization,
+              type: 'tempo',
+            })
+            const signed = await account.signTransaction(prepared as never)
+            return await client.request({
+              method: 'eth_sendRawTransactionSync' as never,
+              params: [signed],
+            })
+          })
+          if (result !== undefined) return result
+          return await provider.request(request)
+        },
+
+        async authorizeAccessKey(parameters, request) {
+          const accessKey = await generateAccessKey(parameters)
+
+          const result = await provider.request({
+            ...request,
+            params: [z.encode(Rpc.wallet_connect.authorizeAccessKey, accessKey!.request)!],
+          })
+
+          if (accessKey) {
+            const account = getAccount({ accessKey: false, signable: false })
+            saveAccessKey(account.address, result, accessKey.keyPair)
+          }
+
+          return result
+        },
+
+        async revokeAccessKey(_params, request) {
+          await provider.request(request)
+        },
+
+        async disconnect() {
+          store.setState({ accessKeys: [], accounts: [], activeAccount: 0 })
+        },
+      },
+    }
+  })
+}
+
+export declare namespace dialog {
+  type Options = {
+    /** Dialog to use for the embed app. @default `Dialog.iframe()` (or `Dialog.popup()` in Safari) */
+    dialog?: Dialog.Dialog | undefined
+    /** URL of the embed app. @default `'https://wallet.tempo.xyz/embed'` */
+    host?: string | undefined
+    /** Data URI of the provider icon. */
+    icon?: `data:image/${string}` | undefined
+    /** Display name of the provider. @default `'Tempo'` */
+    name?: string | undefined
+    /** Reverse DNS identifier. @default `'xyz.tempo'` */
+    rdns?: string | undefined
+  }
+}

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

@@ -0,0 +1,97 @@
+import { tempoLocalnet } from 'viem/chains'
+import { describe, expect, test } from 'vp/test'
+
+import {
+  accounts as core_accounts,
+  getClient,
+  privateKeys,
+  webAuthnAccounts,
+} from '../../../test/config.js'
+import * as Account from '../Account.js'
+import * as Storage from '../Storage.js'
+import * as Store from '../Store.js'
+import { local } from './local.js'
+
+describe('local', () => {
+  describe('loadAccounts', () => {
+    test('default: loads accounts', async () => {
+      const { adapter } = setup()
+
+      const { accounts } = await adapter.actions.loadAccounts(undefined, {
+        method: 'wallet_connect',
+        params: undefined,
+      })
+
+      expect(accounts.map((a) => a.address)).toMatchInlineSnapshot(`
+        [
+          "0x1ecBa262e4510F333FB5051743e2a53a765deBD0",
+        ]
+      `)
+    })
+  })
+
+  describe('createAccount', () => {
+    test('default: creates account', async () => {
+      const { adapter } = setup({
+        createAccount: async () => ({
+          accounts: [
+            {
+              address: core_accounts[1].address,
+              keyType: 'secp256k1',
+              privateKey: privateKeys[1],
+            },
+          ],
+        }),
+      })
+
+      const { accounts } = await adapter.actions.createAccount(
+        { name: 'test' },
+        { method: 'wallet_connect', params: undefined },
+      )
+
+      expect(accounts.map((a) => a.address)).toMatchInlineSnapshot(`
+        [
+          "0x8C8d35429F74ec245F8Ef2f4Fd1e551cFF97d650",
+        ]
+      `)
+    })
+
+    test('error: throws when createAccount not configured', async () => {
+      const { adapter } = setup()
+
+      await expect(
+        adapter.actions.createAccount(
+          { name: 'test' },
+          { method: 'wallet_connect', params: undefined },
+        ),
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `[Provider.UnsupportedMethodError: \`createAccount\` not configured on adapter.]`,
+      )
+    })
+  })
+})
+
+function setup(overrides: Partial<local.Options> = {}) {
+  const storage = Storage.memory()
+  const store = Store.create({ chainId: tempoLocalnet.id, storage })
+  const adapter = local({
+    loadAccounts: async () => ({
+      accounts: [
+        {
+          address: webAuthnAccounts[0]!.address,
+          keyType: 'webAuthn_headless' as const,
+          privateKey: privateKeys[0]!,
+          rpId: 'example.com',
+          origin: 'https://example.com',
+        },
+      ],
+    }),
+    ...overrides,
+  })({
+    getAccount: (options) => Account.find({ ...options, signable: true, store }),
+    getClient: () => getClient({ chain: tempoLocalnet }) as never,
+    storage,
+    store,
+  })
+  return { adapter, store }
+}