accounts 0.15.3 → 0.16.0

package/src/core/Client.test.ts

@@ -87,12 +87,12 @@ describe('caching', () => {
       chains: [tempoModerato, tempo],
       storage: Storage.memory(),
     })
-    const client_a = Client.fromChainId(tempo.id, {
+    const client_a = Client.fromChainId(undefined, {
       chains: [tempo, tempoModerato],
       provider: provider_a,
       store,
     })
-    const client_b = Client.fromChainId(tempo.id, {
+    const client_b = Client.fromChainId(undefined, {
       chains: [tempo, tempoModerato],
       provider: provider_b,
       store,
@@ -203,35 +203,51 @@ describe('caching', () => {
 })
 
 describe('providerTransport', () => {
-  test('default: routes requests through the provider', async () => {
+  test('behavior: returns empty accounts before connecting', async () => {
     const store = setup()
     const provider = Provider.create({
       adapter: secp256k1(),
-      chains: [tempoModerato, tempo],
+      chains: [tempo],
       storage: Storage.memory(),
     })
-    // Wire the client to chain ID `tempo.id` but route through a provider
-    // whose default chain is `tempoModerato`. The returned chain ID must
-    // come from the provider, not the requested chain.
+    const client = Client.fromChainId(tempo.id, { chains: [tempo], provider, store })
+    const result = await client.request({ method: 'eth_accounts' })
+    expect(result).toMatchInlineSnapshot(`[]`)
+  })
+
+  test('behavior: fills transactions on the requested chain', async () => {
+    const requests: unknown[] = []
+    const store = setup()
+    const provider = {
+      async request(request: unknown) {
+        requests.push(request)
+        return {}
+      },
+    } as never
     const client = Client.fromChainId(tempo.id, {
       chains: [tempo, tempoModerato],
       provider,
       store,
     })
-    const result = await client.request({ method: 'eth_chainId' })
-    expect(result).toMatchInlineSnapshot(`"0xa5bf"`)
-  })
 
-  test('behavior: returns empty accounts before connecting', async () => {
-    const store = setup()
-    const provider = Provider.create({
-      adapter: secp256k1(),
-      chains: [tempo],
-      storage: Storage.memory(),
+    await client.request({
+      method: 'eth_fillTransaction' as never,
+      params: [{ to: '0x0000000000000000000000000000000000000001' }] as never,
     })
-    const client = Client.fromChainId(tempo.id, { chains: [tempo], provider, store })
-    const result = await client.request({ method: 'eth_accounts' })
-    expect(result).toMatchInlineSnapshot(`[]`)
+
+    expect(requests).toMatchInlineSnapshot(`
+      [
+        {
+          "method": "eth_fillTransaction",
+          "params": [
+            {
+              "chainId": 4217,
+              "to": "0x0000000000000000000000000000000000000001",
+            },
+          ],
+        },
+      ]
+    `)
   })
 })
 

package/src/core/Client.ts

@@ -34,11 +34,6 @@ export function fromChainId(
   })()
   const id = chainId ?? store.getState().chainId
   const key = `${id}:${provider ? 'p' : ''}:${feePayerOption === false ? 'no-fp' : (feePayerUrl ?? '')}:${precedence}`
-  // Scope the cache by `provider` (preferred) or `transports`, falling back
-  // to a shared module-level map. The cache key only encodes a boolean for
-  // `provider`, so without scoping, two providers sharing the same chainId
-  // would hit each other's cached clients and route requests to the wrong
-  // adapter via `providerTransport`.
   const scope = provider ?? transports
   const cache = (() => {
     if (!scope) return defaultClients
@@ -53,7 +48,9 @@ export function fromChainId(
   if (!client) {
     const chain = chains.find((c) => c.id === id) ?? chains[0]!
     const base = transports?.[id] ?? http()
-    const transport_base = provider ? providerTransport(provider, base) : base
+    const transport_base = provider
+      ? providerTransport(provider, base, chainId === undefined ? undefined : chain.id)
+      : base
     const transport = feePayerUrl
       ? feePayerTransport(transport_base, feePayerUrl, precedence)
       : transport_base
@@ -78,7 +75,7 @@ export declare namespace fromChainId {
           precedence?: 'fee-payer-first' | 'user-first' | undefined
         }
       | undefined
-    /** Provider instance. When set, the transport routes requests through the provider first, falling back to HTTP for unknown methods. */
+    /** Provider for account operations and active-chain requests. Explicit-chain RPCs use the matching transport. */
     provider?: ox_Provider.Provider | undefined
     /** Reactive state store. */
     store: Store.Store
@@ -88,24 +85,52 @@ export declare namespace fromChainId {
 }
 
 /**
- * Creates a transport that routes requests through the provider, falling
- * back to the given base transport for methods the provider proxies to RPC.
+ * Routes account operations through the provider and explicit-chain RPCs
+ * through the requested chain's transport.
  */
-function providerTransport(provider: ox_Provider.Provider, base: Transport): Transport {
+function providerTransport(
+  provider: ox_Provider.Provider,
+  base: Transport,
+  chainId: number | undefined,
+): Transport {
   return (params) => {
     const baseTransport = base(params)
     return {
       ...baseTransport,
       async request({ method, params: reqParams }) {
+        if (chainId !== undefined && !usesProvider(method))
+          return baseTransport.request({ method, params: reqParams } as never)
+        const params = (() => {
+          if (method !== 'eth_fillTransaction' || chainId === undefined) return reqParams
+          const request = (reqParams as readonly unknown[] | undefined)?.[0]
+          if (!request || typeof request !== 'object') return reqParams
+          return [{ ...request, chainId }]
+        })()
         return (provider as { request: EIP1193RequestFn }).request({
           method,
-          params: reqParams,
+          params,
         } as any)
       },
     } as ReturnType<Transport>
   }
 }
 
+function usesProvider(method: string) {
+  return (
+    method.startsWith('wallet_') ||
+    [
+      'eth_accounts',
+      'eth_fillTransaction',
+      'eth_requestAccounts',
+      'eth_sendTransaction',
+      'eth_sendTransactionSync',
+      'eth_signTransaction',
+      'eth_signTypedData_v4',
+      'personal_sign',
+    ].includes(method)
+  )
+}
+
 /**
  * Resolves a fee payer URL to an absolute URL string. Relative paths (e.g.
  * `/relay`) are resolved against `window.location.origin` when running in a

package/src/core/Provider.test.ts

@@ -1,5 +1,7 @@
 import { Hex } from 'ox'
+import { custom } from 'viem'
 import { createSiweMessage } from 'viem/siwe'
+import { tempo, tempoModerato } from 'viem/tempo/chains'
 import { afterEach, describe, expect, test, vi } from 'vp/test'
 
 import { accounts, privateKeys } from '../../test/config.js'
@@ -36,6 +38,20 @@ describe('getMppxParameters', () => {
     expect((client as { account?: unknown }).account).toBeUndefined()
   })
 
+  test('behavior: routes chain RPCs to the requested chain', async () => {
+    const provider = Provider.create({
+      chains: [tempo, tempoModerato],
+      storage: Storage.memory(),
+      transports: {
+        [tempoModerato.id]: custom({ request: async () => '0xa5bf' }),
+      },
+    })
+    provider.store.setState({ accounts: [{ address }], activeAccount: 0 })
+
+    const client = await provider.getMppxParameters().getClient({ chainId: tempoModerato.id })
+    expect(await client.request({ method: 'eth_chainId' })).toBe('0xa5bf')
+  })
+
   test('behavior: resolves existing access key for connected account', async () => {
     const payer = accounts[0]!
     const provider = Provider.create({ storage: Storage.memory() })

package/src/react/privy.ts

@@ -82,12 +82,12 @@ export function PrivyAccountsBridge() {
     }
 
     login_started.current = false
-    if (!wallets.ready) return
+    const embedded = wallets.wallets.filter(isEmbeddedEthereumWallet)
+    if (!wallets.ready && embedded.length === 0) return
 
     loading.current = true
     void (async () => {
       try {
-        const embedded = wallets.wallets.filter(isEmbeddedEthereumWallet)
         if (embedded.length === 0)
           throw new Error('Privy React returned no embedded Ethereum wallet.')
 
@@ -190,7 +190,7 @@ const client = {
 function setPrivyReactState(next: PrivyReactState) {
   state = next
   if (next.ready) emitReady()
-  if (next.ready && next.walletsReady) emitWalletsReady()
+  if (next.ready && (next.walletsReady || next.wallets.length > 0)) emitWalletsReady()
 }
 
 function usePrivyAccountsRequest() {
@@ -242,7 +242,11 @@ function getSnapshot() {
 }
 
 function isEmbeddedEthereumWallet(wallet: ConnectedWallet) {
-  return wallet.type === 'ethereum' && wallet.walletClientType === 'privy'
+  return (
+    wallet.type === 'ethereum' &&
+    wallet.walletClientType === 'privy' &&
+    wallet.connectorType === 'embedded'
+  )
 }
 
 function sameAddress(a: string, b: string) {
@@ -261,7 +265,7 @@ function waitForReady() {
 
 async function waitForWallets() {
   await waitForReady()
-  if (state.walletsReady) return
+  if (state.walletsReady || state.wallets.length > 0) return
   return new Promise<void>((resolve) => wallets_ready_listeners.add(resolve))
 }
 

package/src/server/CliAuth.test-d.ts

@@ -6,7 +6,8 @@ import * as CliAuth from './CliAuth.js'
 
 describe('createRequest', () => {
   test('includes the v1 device-code request fields', () => {
-    expectTypeOf<z.output<typeof CliAuth.createRequest>>().toMatchTypeOf<{
+    type Request = Exclude<z.output<typeof CliAuth.createRequest>, { action: 'updateAccessKey' }>
+    expectTypeOf<Request>().toMatchTypeOf<{
       account?: Hex | undefined
       codeChallenge: string
       expiry?: number | undefined
@@ -25,13 +26,26 @@ describe('createRequest', () => {
     }>()
   })
 
+  test('includes access-key update requests', () => {
+    type Request = Extract<z.output<typeof CliAuth.createRequest>, { action: 'updateAccessKey' }>
+    expectTypeOf<Request>().toMatchTypeOf<{
+      action: 'updateAccessKey'
+      accessKeyAddress: Hex
+      account: Hex
+      chainId?: bigint | undefined
+      codeChallenge: string
+      keyAuthorization?: z.output<typeof CliAuth.keyAuthorization> | undefined
+      limits: readonly { token: Hex; limit: bigint }[]
+    }>()
+  })
+
   test('does not include scopes in v1', () => {
-    type Request = z.output<typeof CliAuth.createRequest>
+    type Request = Exclude<z.output<typeof CliAuth.createRequest>, { action: 'updateAccessKey' }>
     expectTypeOf<Request>().not.toHaveProperty('scopes')
   })
 
   test('showDeposit does not include address or chainId', () => {
-    type Request = z.output<typeof CliAuth.createRequest>
+    type Request = Exclude<z.output<typeof CliAuth.createRequest>, { action: 'updateAccessKey' }>
     type ShowDeposit = Exclude<Exclude<Request['showDeposit'], boolean | undefined>, undefined>
     expectTypeOf<ShowDeposit>().not.toHaveProperty('address')
     expectTypeOf<ShowDeposit>().not.toHaveProperty('chainId')
@@ -40,18 +54,31 @@ describe('createRequest', () => {
 
 describe('pollResponse', () => {
   test('authorized responses carry the normal keyAuthorization shape', () => {
-    type Response = Extract<z.output<typeof CliAuth.pollResponse>, { status: 'authorized' }>
+    type Response = Exclude<
+      Extract<z.output<typeof CliAuth.pollResponse>, { status: 'authorized' }>,
+      { action: 'updateAccessKey' }
+    >
     expectTypeOf<Response>().toMatchTypeOf<{
       accountAddress: Hex
       keyAuthorization: z.output<typeof CliAuth.keyAuthorization>
       status: 'authorized'
     }>()
   })
+
+  test('access-key updates can return a replacement authorization', () => {
+    type Response = Extract<z.output<typeof CliAuth.pollResponse>, { action: 'updateAccessKey' }>
+    expectTypeOf<Response>().toMatchTypeOf<{
+      action: 'updateAccessKey'
+      keyAuthorization?: z.output<typeof CliAuth.keyAuthorization> | undefined
+      status: 'authorized'
+    }>()
+  })
 })
 
 describe('pendingResponse', () => {
   test('pending responses expose the browser approval payload', () => {
-    expectTypeOf<z.output<typeof CliAuth.pendingResponse>>().toMatchTypeOf<{
+    type Response = Exclude<z.output<typeof CliAuth.pendingResponse>, { action: 'updateAccessKey' }>
+    expectTypeOf<Response>().toMatchTypeOf<{
       accessKeyAddress: Hex
       account?: Hex | undefined
       chainId: bigint
@@ -72,6 +99,14 @@ describe('pendingResponse', () => {
       status: 'pending'
     }>()
   })
+
+  test('pending access-key updates expose an optional current authorization', () => {
+    type Response = Extract<z.output<typeof CliAuth.pendingResponse>, { action: 'updateAccessKey' }>
+    expectTypeOf<Response>().toMatchTypeOf<{
+      action: 'updateAccessKey'
+      keyAuthorization?: z.output<typeof CliAuth.keyAuthorization> | undefined
+    }>()
+  })
 })
 
 describe('Store', () => {