accounts 0.12.2 → 0.14.0

package/src/core/Provider.ts

@@ -1,11 +1,11 @@
 import { announceProvider } from 'mipd'
 import { Mppx, tempo as mppx_tempo } from 'mppx/client'
 import { Address, Hash, Hex, Json, Provider as ox_Provider, RpcResponse } from 'ox'
-import { KeyAuthorization } from 'ox/tempo'
 import { http, parseUnits, type Chain, type Client as ViemClient, type Transport } from 'viem'
-import { tempo, tempoDevnet, tempoModerato } from 'viem/chains'
+import type { JsonRpcAccount } from 'viem/accounts'
 import { parseSiweMessage } from 'viem/siwe'
 import { Actions } from 'viem/tempo'
+import { tempo, tempoDevnet, tempoModerato } from 'viem/tempo/chains'
 import * as z from 'zod/mini'
 
 import * as AccessKey from './AccessKey.js'
@@ -13,6 +13,7 @@ import * as Account from './Account.js'
 import type * as Adapter from './Adapter.js'
 import { dialog } from './adapters/dialog.js'
 import * as Client from './Client.js'
+import * as AccessKeyTransaction from './internal/AccessKeyTransaction.js'
 import { withDedupe } from './internal/withDedupe.js'
 import * as Schema from './Schema.js'
 import * as Storage from './Storage.js'
@@ -25,8 +26,8 @@ export type Provider = ox_Provider.Provider<{ schema: Schema.Ox }> &
   ox_Provider.Emitter & {
     /** Configured chains. */
     chains: readonly [Chain, ...Chain[]]
-    /** Returns a viem Account for the given address (or active account). */
-    getAccount: Account.Find
+    /** Returns the active root account as a viem JSON-RPC account. */
+    getAccount(): JsonRpcAccount
     /** Returns local or on-chain publication status for an access key. */
     getAccessKeyStatus(
       options?: getAccessKeyStatus.Options | undefined,
@@ -271,8 +272,8 @@ export function create(options: create.Options = {}): create.ReturnType {
                     type FillParams = z.output<typeof Rpc.transactionRequest> & {
                       keyAuthorization?: unknown
                     }
+                    const client = getClient({ chainId, feePayer })
                     const fill = (params: FillParams) => {
-                      const client = getClient({ chainId, feePayer })
                       const fillRequest = {
                         ...params,
                         chainId: params.chainId ?? client.chain?.id,
@@ -292,45 +293,38 @@ export function create(options: create.Options = {}): create.ReturnType {
                     // Inject pending keyAuthorization so the node accounts for
                     // key authorization gas during estimation.
                     if (!parameters.keyAuthorization) {
-                      const account = (() => {
-                        try {
-                          const calls =
-                            parameters.calls ??
-                            (parameters.to
-                              ? [
-                                  {
-                                    data: parameters.data,
-                                    to: parameters.to,
-                                  },
-                                ]
-                              : undefined)
-                          return getAccount({
-                            address: parameters.from,
-                            calls,
-                            chainId: parameters.chainId ?? store.getState().chainId,
-                            signable: true,
-                          })
-                        } catch {
-                          return undefined
-                        }
-                      })()
-                      if (account?.source === 'accessKey') {
-                        const keyAuth = AccessKey.getPending(account, { store })
-                        if (keyAuth) {
+                      const state = store.getState()
+                      const address =
+                        parameters.from ?? state.accounts[state.activeAccount]?.address
+                      if (address) {
+                        const calls =
+                          parameters.calls ??
+                          (parameters.to
+                            ? [
+                                {
+                                  data: parameters.data,
+                                  to: parameters.to,
+                                },
+                              ]
+                            : undefined)
+                        const transaction = await AccessKeyTransaction.create({
+                          address,
+                          calls,
+                          chainId: parameters.chainId ?? state.chainId,
+                          client,
+                          store,
+                        })
+                        if (transaction)
                           try {
-                            const result = await fill({
+                            return await transaction.fill({
                               ...parameters,
-                              keyAuthorization: {
-                                address: keyAuth.address,
-                                ...KeyAuthorization.toRpc(keyAuth),
-                              } as never,
+                              chainId: parameters.chainId ?? state.chainId,
+                              from: parameters.from ?? address,
+                              ...(feePayer ? { feePayer: true } : {}),
                             })
-                            return result
-                          } catch (error) {
-                            AccessKey.invalidate(account, error, { store })
+                          } catch {
                             return await fill(parameters)
                           }
-                        }
                       }
                     }
 
@@ -574,6 +568,11 @@ export function create(options: create.Options = {}): create.ReturnType {
                           auth_input as NonNullable<z.output<typeof Rpc.wallet_connect.auth>>,
                         )
                       : undefined
+                    if (auth_request && typeof auth_request === 'object' && !auth_request.challenge)
+                      throw new RpcResponse.InvalidParamsError({
+                        message:
+                          '`auth` capability must include either `url` or an explicit `challenge` endpoint.',
+                      })
                     if (auth_request && capabilities?.personalSign)
                       throw new RpcResponse.InvalidParamsError({
                         message:
@@ -608,56 +607,67 @@ export function create(options: create.Options = {}): create.ReturnType {
                       ? { message: auth.message }
                       : capabilities?.personalSign
 
-                    const { keyAuthorization, accounts, email, personalSign, signature, username } =
-                      await (async () => {
-                        if (capabilities?.method === 'register') {
-                          // If a stored account already has this label, sign in
-                          // with its credential instead of creating a new one.
-                          const existing = capabilities.name
-                            ? store
-                                .getState()
-                                .accounts.find(
-                                  (a) =>
-                                    'credential' in a &&
-                                    a.label?.toLowerCase() === capabilities.name!.toLowerCase(),
-                                )
-                            : undefined
-                          if (existing && 'credential' in existing)
-                            return await actions.loadAccounts(
-                              {
-                                credentialId: existing.credential?.id,
-                                digest: capabilities.digest,
-                                authorizeAccessKey,
-                                ...(personalSign_request
-                                  ? { personalSign: personalSign_request }
-                                  : {}),
-                              },
-                              request,
-                            )
-                          return await actions.createAccount(
+                    const {
+                      accounts,
+                      auth: auth_capability,
+                      email,
+                      keyAuthorization,
+                      personalSign,
+                      signature,
+                      username,
+                    } = await (async () => {
+                      if (capabilities?.method === 'register') {
+                        // If a stored account already has this label, sign in
+                        // with its credential instead of creating a new one.
+                        const existing = capabilities.name
+                          ? store
+                              .getState()
+                              .accounts.find(
+                                (a) =>
+                                  'credential' in a &&
+                                  a.label?.toLowerCase() === capabilities.name!.toLowerCase(),
+                              )
+                          : undefined
+                        if (existing && 'credential' in existing)
+                          return await actions.loadAccounts(
                             {
+                              credentialId: existing.credential?.id,
                               digest: capabilities.digest,
                               authorizeAccessKey,
-                              name: capabilities.name ?? 'default',
-                              userId: capabilities.userId ?? Hex.random(16),
                               ...(personalSign_request
                                 ? { personalSign: personalSign_request }
                                 : {}),
+                              ...(capabilities.showDeposit !== undefined
+                                ? { showDeposit: capabilities.showDeposit }
+                                : {}),
                             },
                             request,
                           )
-                        }
-                        return await actions.loadAccounts(
+                        return await actions.createAccount(
                           {
-                            credentialId: capabilities?.credentialId,
-                            digest: capabilities?.digest,
+                            digest: capabilities.digest,
                             authorizeAccessKey,
-                            selectAccount: capabilities?.selectAccount,
+                            name: capabilities.name ?? 'default',
+                            ...(capabilities.showDeposit !== undefined
+                              ? { showDeposit: capabilities.showDeposit }
+                              : {}),
+                            userId: capabilities.userId ?? Hex.random(16),
                             ...(personalSign_request ? { personalSign: personalSign_request } : {}),
                           },
                           request,
                         )
-                      })()
+                      }
+                      return await actions.loadAccounts(
+                        {
+                          credentialId: capabilities?.credentialId,
+                          digest: capabilities?.digest,
+                          authorizeAccessKey,
+                          selectAccount: capabilities?.selectAccount,
+                          ...(personalSign_request ? { personalSign: personalSign_request } : {}),
+                        },
+                        request,
+                      )
+                    })()
 
                     store.setState({
                       accounts: resolveAccounts(accounts),
@@ -713,12 +723,14 @@ export function create(options: create.Options = {}): create.ReturnType {
                                       },
                                     }
                                   : {}),
-                                ...(signature && (!auth_request || auth_result)
+                                ...(signature && (!auth_request || auth_result || !verifyUrl)
                                   ? { signature }
                                   : {}),
                                 ...(email !== undefined ? { email } : {}),
                                 ...(username !== undefined ? { username } : {}),
-                                ...(auth_result ? { auth: auth_result } : {}),
+                                ...((auth_result ?? auth_capability)
+                                  ? { auth: auth_result ?? auth_capability }
+                                  : {}),
                                 ...(personalSign
                                   ? { personalSign: { message: personalSign.message } }
                                   : {}),
@@ -802,7 +814,7 @@ export function create(options: create.Options = {}): create.ReturnType {
                         message: '`deposit` not supported by adapter.',
                       })
                     return (await actions.deposit(
-                      request._decoded.params[0],
+                      request._decoded.params?.[0] ?? {},
                       request,
                     )) satisfies Rpc.wallet_deposit.Encoded['returns']
                   }
@@ -973,15 +985,20 @@ export function create(options: create.Options = {}): create.ReturnType {
     ),
     {
       chains,
-      getAccount,
+      getAccount() {
+        const account = getAccount()
+        return { address: account.address, type: 'json-rpc' as const }
+      },
       async getAccessKeyStatus(options: getAccessKeyStatus.Options = {}) {
         const state = store.getState()
         const address = options.address ?? state.accounts[state.activeAccount]?.address
-        if (!address) return AccessKey.status.missing
+        if (!address) return 'missing'
         const chainId = options.chainId ?? state.chainId
+        const { accessKey, calls } = options
         return await AccessKey.getStatus({
-          ...options,
-          address,
+          account: address,
+          ...(accessKey ? { accessKey } : {}),
+          ...(calls ? { calls } : {}),
           chainId,
           client: provider.getClient({ chainId }),
           store,
@@ -1031,31 +1048,22 @@ export function create(options: create.Options = {}): create.ReturnType {
     const polyfill = polyfill_option ?? isFetchWritable()
     const getClient = ({ chainId }: { chainId?: number | undefined }) => {
       const client = provider.getClient({ chainId })
-      const account = provider.getAccount()
-      return Object.assign(client, { account })
+      const account = store.getState().accounts[store.getState().activeAccount]
+      if (!account) throw new ox_Provider.DisconnectedError({ message: 'No active account.' })
+      return Object.assign(client, {
+        account: {
+          address: account.address,
+          type: 'json-rpc' as const,
+        },
+      })
     }
-    const mppx = Mppx.create({
+    Mppx.create({
       methods: [
         mppx_tempo({ ...methodOptions, getClient, mode }),
         mppx_tempo.subscription({ getClient }),
       ],
       polyfill,
     })
-    mppx.onPaymentResponse(({ challenge, method }) => {
-      if (method.name !== 'tempo' || method.intent !== 'charge') return
-      const amount = challenge.request.amount
-      if (
-        typeof amount !== 'string' &&
-        typeof amount !== 'number' &&
-        typeof amount !== 'bigint' &&
-        typeof amount !== 'boolean'
-      )
-        return
-      if (BigInt(amount) === 0n) return
-      const account = provider.getAccount()
-      if ('source' in account && account.source === 'accessKey')
-        AccessKey.removePending(account, { store })
-    })
   }
 
   providerRef = provider
@@ -1132,7 +1140,7 @@ export declare namespace create {
      * @example
      * ```ts
      * import { http } from 'viem'
-     * import { tempo, tempoModerato } from 'viem/chains'
+     * import { tempo, tempoModerato } from 'viem/tempo/chains'
      *
      * const provider = Provider.create({
      *   transports: {
@@ -1161,7 +1169,7 @@ export declare namespace getAccessKeyStatus {
   }
 
   /** Access-key publication status. */
-  type ReturnType = AccessKey.Status
+  type ReturnType = 'missing' | 'pending' | 'published' | 'expired'
 }
 
 export declare namespace mpp {
@@ -1266,14 +1274,16 @@ function resolveAuthEndpoint(
 }
 
 /**
- * Pre-resolves the `auth` capability into its absolute, fully-explicit
- * object form. Run once at the dapp-side Provider so forwarding adapters
- * (dialog) carry absolute URLs to the wallet host — the wallet's
- * `window.location.origin` belongs to the wallet, not the dapp, and
- * cannot resolve relative paths correctly.
+ * Pre-resolves the `auth` capability into its absolute object form. Run
+ * once at the dapp-side Provider so forwarding adapters (dialog) carry
+ * absolute URLs to the wallet host — the wallet's `window.location.origin`
+ * belongs to the wallet, not the dapp, and cannot resolve relative paths
+ * correctly.
  *
- * `logout` is omitted when the input doesn't supply enough info to derive
- * one (it's optional in the protocol).
+ * Individual endpoints are omitted when the input doesn't supply enough
+ * info to derive them. `logout` is optional in the protocol; `verify` can
+ * also be omitted by wallet-host re-entry so the dapp-origin Provider runs
+ * verification and receives the session cookie.
  */
 function absolutizeAuth(
   auth: NonNullable<z.output<typeof Rpc.wallet_connect.auth>>,
@@ -1297,10 +1307,6 @@ function absolutizeAuth(
 
 function assertSameAuthOrigin(auth: NonNullable<z.output<typeof Rpc.wallet_connect.auth>>): void {
   if (typeof auth !== 'object') return
-  if (!auth.challenge || !auth.verify)
-    throw new RpcResponse.InvalidParamsError({
-      message: '`auth` requires both `challenge` and `verify` endpoints.',
-    })
   const urls = [auth.challenge, auth.verify, auth.logout].filter(
     (u): u is string => typeof u === 'string',
   )

package/src/core/Remote.test.ts

@@ -290,3 +290,31 @@ describe('validateSearch', () => {
     expect(remote.rejectAll).not.toHaveBeenCalled()
   })
 })
+
+describe('respond', () => {
+  test('behavior: defer returns the provider result without sending a response', async () => {
+    const send = vi.fn()
+    const remote = Remote.create({
+      messenger: {
+        on: vi.fn(),
+        ready: vi.fn(),
+        send,
+      } as never,
+      provider: {
+        request: vi.fn(async () => ({ ok: true })),
+      } as never,
+    })
+
+    const result = await remote.respond(
+      { id: 1, jsonrpc: '2.0', method: 'wallet_connect' } as never,
+      { defer: true },
+    )
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "ok": true,
+      }
+    `)
+    expect(send).not.toHaveBeenCalled()
+  })
+})

package/src/core/Remote.ts

@@ -110,6 +110,8 @@ export declare namespace ready {
 
 export declare namespace respond {
   type Options = {
+    /** Return the resolved result without sending the RPC response. */
+    defer?: boolean | undefined
     /** Error to respond with (takes precedence over result). */
     error?: { code: number; message: string } | undefined
     /**
@@ -237,7 +239,7 @@ export function create(options: create.Options): Remote {
     },
 
     async respond(request, options = {}) {
-      const { error, onError, selector } = options
+      const { defer, error, onError, selector } = options
       const shared = { id: request.id, jsonrpc: '2.0' } as const
 
       if (error) {
@@ -254,6 +256,7 @@ export function create(options: create.Options): Remote {
         let result =
           'result' in options ? options.result : await provider?.request(request as never)
         if (selector) result = selector(result)
+        if (defer) return result
         messenger.send(
           'rpc-response',
           Object.assign(RpcResponse.from({ ...shared, result }), { _request: request }),

package/src/core/Schema.test-d.ts

@@ -98,6 +98,29 @@ describe('Encoded', () => {
     >()
   })
 
+  test('wallet_connect: showDeposit', () => {
+    type Capabilities = NonNullable<
+      NonNullable<Rpc.wallet_connect.Encoded['params']>[number]['capabilities']
+    >
+    type Register = Extract<Capabilities, { method: 'register' }>
+    type Login = Extract<Capabilities, { method?: 'login' | undefined }>
+    type ShowDeposit = Register['showDeposit']
+    type ShowDepositObject = Exclude<Exclude<ShowDeposit, boolean | undefined>, undefined>
+
+    expectTypeOf<ShowDeposit>().toMatchTypeOf<
+      | boolean
+      | {
+          amount?: string | undefined
+          displayName?: string | undefined
+          token?: string | undefined
+        }
+      | undefined
+    >()
+    expectTypeOf<Login>().not.toHaveProperty('showDeposit')
+    expectTypeOf<ShowDepositObject>().not.toHaveProperty('address')
+    expectTypeOf<ShowDepositObject>().not.toHaveProperty('chainId')
+  })
+
   test('wallet_connect: returns', () => {
     expectTypeOf<Rpc.wallet_connect.Encoded['returns']>().toHaveProperty('accounts')
     expectTypeOf<
@@ -156,6 +179,24 @@ describe('Encoded', () => {
     }>()
   })
 
+  test('wallet_deposit', () => {
+    expectTypeOf<Rpc.wallet_deposit.Encoded>().toMatchTypeOf<{
+      method: 'wallet_deposit'
+      params:
+        | readonly [
+            {
+              address?: Hex | undefined
+              amount?: string | undefined
+              chainId?: Hex | undefined
+              displayName?: string | undefined
+              token?: Hex | string | undefined
+            },
+          ]
+        | undefined
+      returns: { receipts?: readonly { transactionHash: Hex }[] | undefined } | undefined
+    }>()
+  })
+
   test('wallet_switchEthereumChain', () => {
     expectTypeOf<Rpc.wallet_switchEthereumChain.Encoded>().toEqualTypeOf<{
       method: 'wallet_switchEthereumChain'