accounts 0.17.0 → 0.17.2

package/src/core/Provider.localnet.test.ts

@@ -23,7 +23,7 @@ import { Account as TempoAccount, Actions, Addresses, Transaction } from 'viem/t
 import { tempo, tempoModerato } from 'viem/tempo/chains'
 import { afterAll, beforeAll, describe, expect, test } from 'vp/test'
 
-import { headlessWebAuthn, secp256k1 } from '../../test/adapters.js'
+import { cli, headlessWebAuthn, secp256k1 } from '../../test/adapters.js'
 import { accounts, chain, getClient, http } from '../../test/config.js'
 import { createJsonStorage, createServer, type Server } from '../../test/utils.js'
 import * as Handler from '../server/Handler.js'
@@ -34,7 +34,11 @@ import * as Keystore from './Keystore.js'
 import * as Provider from './Provider.js'
 import * as Storage from './Storage.js'
 
+beforeAll(cli.setup)
+afterAll(cli.teardown)
+
 const adapters = [
+  { name: 'cli', adapter: cli },
   { name: 'headlessWebAuthn', adapter: headlessWebAuthn },
   { name: 'secp256k1', adapter: secp256k1 },
 ] as const
@@ -856,7 +860,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
       test('behavior: provider mints identity when configured with an issuer', async () => {
         const provider = Provider.create({
-          adapter: adapter(),
+          adapter: adapter({ identity: { audience: 'https://app.example.com', issuer } }),
           identity: { audience: 'https://app.example.com', issuer },
         })
 
@@ -889,7 +893,9 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
       test('behavior: provider identity mint is best-effort (failure omits the claim)', async () => {
         const provider = Provider.create({
-          adapter: adapter(),
+          adapter: adapter({
+            identity: { audience: 'https://app.example.com', issuer: `${server.url}/nowhere` },
+          }),
           identity: { audience: 'https://app.example.com', issuer: `${server.url}/nowhere` },
         })
 
@@ -904,7 +910,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
       test('behavior: provider identity is not minted unless requested', async () => {
         const provider = Provider.create({
-          adapter: adapter(),
+          adapter: adapter({ identity: { audience: 'https://app.example.com', issuer } }),
           identity: { audience: 'https://app.example.com', issuer },
         })
 
@@ -1564,7 +1570,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: includes feePayer when configured', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: 'https://fee-payer.example.com' }),
         feePayer: 'https://fee-payer.example.com',
       })
 
@@ -1783,7 +1789,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
       const storage = Storage.memory({ key: 'persist-invalid' })
       storage.setItem('store', {
         state: {
-          accounts: [{ address: '0x0000000000000000000000000000000000000001' }],
+          accounts: [{ address: 'invalid' }],
           activeAccount: 0,
           chainId: chain.id,
         },
@@ -3228,7 +3234,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: feePayer: true uses default from Provider.create', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3251,7 +3257,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: feePayer: true on eth_sendTransactionSync', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3293,7 +3299,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: precedence fee-payer-first (default) on eth_sendTransaction', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3314,7 +3320,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: precedence fee-payer-first (default) on eth_sendTransactionSync', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3337,7 +3343,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: precedence user-first on eth_sendTransaction', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: { url: server.url, precedence: 'user-first' } }),
         chains: [chain],
         feePayer: { url: server.url, precedence: 'user-first' },
       })
@@ -3358,7 +3364,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: precedence user-first on eth_sendTransactionSync', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: { url: server.url, precedence: 'user-first' } }),
         chains: [chain],
         feePayer: { url: server.url, precedence: 'user-first' },
       })
@@ -3381,7 +3387,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: precedence user-first on eth_signTransaction', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: { url: server.url, precedence: 'user-first' } }),
         chains: [chain],
         feePayer: { url: server.url, precedence: 'user-first' },
       })
@@ -3399,7 +3405,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: feePayer: false opts out on eth_sendTransaction', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3422,7 +3428,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: feePayer: false opts out on eth_sendTransactionSync', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3445,7 +3451,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: feePayer: false opts out on eth_signTransaction', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3488,7 +3494,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: wallet_sendCalls with feePayer: true uses provider default', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })
@@ -3517,7 +3523,7 @@ describe.each(adapters)('$name', ({ adapter, name }: (typeof adapters)[number])
 
     test('behavior: wallet_sendCalls with feePayer: false opts out', async () => {
       const provider = Provider.create({
-        adapter: adapter(),
+        adapter: adapter({ feePayer: server.url }),
         chains: [chain],
         feePayer: server.url,
       })

package/src/core/Provider.test.ts

@@ -11,6 +11,54 @@ import * as Storage from './Storage.js'
 
 const address = '0x0000000000000000000000000000000000000001'
 
+describe('eth_fillTransaction', () => {
+  test('behavior: forwards Tempo-formatted request capabilities', async () => {
+    const capabilities: unknown[] = []
+    const request = tempo.formatters.transactionRequest.format(
+      {
+        capabilities: { balanceDiffs: false, errors: true },
+        from: address,
+        to: address,
+        type: 'tempo',
+      },
+      'fillTransaction',
+    )
+    const provider = Provider.create({
+      chains: [tempo],
+      storage: Storage.memory(),
+      transports: {
+        [tempo.id]: custom(
+          {
+            async request(request) {
+              if (request.method === 'eth_fillTransaction')
+                capabilities.push(
+                  (request.params?.[0] as { capabilities?: unknown } | undefined)?.capabilities,
+                )
+              throw new Error('capture complete')
+            },
+          },
+          { retryCount: 0 },
+        ),
+      },
+    })
+
+    await expect(
+      provider.request({
+        method: 'eth_fillTransaction',
+        params: [request as never],
+      }),
+    ).rejects.toThrow('capture complete')
+    expect(capabilities).toMatchInlineSnapshot(`
+      [
+        {
+          "balanceDiffs": false,
+          "errors": true,
+        },
+      ]
+    `)
+  })
+})
+
 describe('getMppxParameters', () => {
   test('error: rejects unsupported chain IDs', () => {
     const provider = Provider.create({ storage: Storage.memory() })

package/src/core/Provider.ts

@@ -176,6 +176,7 @@ export function create(options: create.Options = {}): create.ReturnType {
   Object.assign(keystores, keystores_configured ?? Keystore.defaults)
 
   const emitter = ox_Provider.createEmitter()
+  const requestCache = new Map<string, Promise<unknown>>()
 
   // Emit EIP-1193 events on state changes.
   store.subscribe(
@@ -573,7 +574,7 @@ export function create(options: create.Options = {}): create.ReturnType {
       })
     } else {
       try {
-        await Actions.accessKey.revoke(getClient(), {
+        await Actions.accessKey.revokeSync(getClient(), {
           account: selected.account as TempoAccount.Account,
           accessKey: parameters.accessKeyAddress,
         })
@@ -1157,7 +1158,7 @@ export function create(options: create.Options = {}): create.ReturnType {
                         calls,
                         chainId,
                         from: from_,
-                        ...(feePayer ? { feePayer } : {}),
+                        ...(feePayer !== undefined ? { feePayer } : {}),
                       }
                       if (!sync) {
                         const hash = await sendTransactionAction(txRequest, {
@@ -1783,6 +1784,7 @@ export function create(options: create.Options = {}): create.ReturnType {
               return result
             },
             {
+              cache: requestCache,
               enabled: shouldDedupe,
               id: Json.stringify({ method, params }),
             },

package/src/core/adapters/internal/fromRequest.ts

@@ -5,6 +5,7 @@ import { z } from 'zod/mini'
 import * as Adapter from '../../Adapter.js'
 import type * as Keystore from '../../Keystore.js'
 import * as Rpc from '../../zod/rpc.js'
+import * as u from '../../zod/utils.js'
 
 /**
  * Builds an adapter that forwards wallet RPC to a remote wallet through a
@@ -29,7 +30,7 @@ export function fromRequest(options: fromRequest.Options): Adapter.Adapter {
   } = options
 
   return Adapter.define(
-    { ...(icon ? { icon } : {}), name, rdns },
+    { ...(icon ? { icon } : {}), name, rdns, schema: z.object({ address: u.address() }) },
     ({ getAccount, getClient, store }) => {
       // Late-bind the store so the request channel can reconcile local
       // connection state (e.g. a wallet `accountsChanged` notification).

package/src/core/internal/withDedupe.test.ts

@@ -41,6 +41,23 @@ describe('withDedupe', () => {
     expect(b).toMatchInlineSnapshot(`2`)
   })
 
+  test('behavior: separate caches execute independently', async () => {
+    let calls = 0
+    const fn = () => Promise.resolve(++calls)
+
+    const [a, b] = await Promise.all([
+      withDedupe(fn, { cache: new Map(), id: 'same' }),
+      withDedupe(fn, { cache: new Map(), id: 'same' }),
+    ])
+
+    expect([a, b]).toMatchInlineSnapshot(`
+      [
+        1,
+        2,
+      ]
+    `)
+  })
+
   test('behavior: cache is cleared after promise resolves', async () => {
     const fn = () => Promise.resolve('ok')
 

package/src/core/internal/withDedupe.ts

@@ -1,20 +1,22 @@
 /** Deduplicates in-flight promises by key. */
 export function withDedupe<data>(
   fn: () => Promise<data>,
-  { enabled = true, id }: withDedupe.Options,
+  { cache = withDedupe.cache, enabled = true, id }: withDedupe.Options,
 ): Promise<data> {
   if (!enabled || !id) return fn()
-  if (withDedupe.cache.get(id)) return withDedupe.cache.get(id)!
-  const promise = fn().finally(() => withDedupe.cache.delete(id))
-  withDedupe.cache.set(id, promise)
+  const cached = cache.get(id)
+  if (cached) return cached as Promise<data>
+  const promise = fn().finally(() => cache.delete(id))
+  cache.set(id, promise)
   return promise
 }
 
 export declare namespace withDedupe {
   type Options = {
+    cache?: Map<string, Promise<unknown>> | undefined
     enabled?: boolean | undefined
     id?: string | undefined
   }
 }
 
-withDedupe.cache = new Map<string, Promise<any>>()
+withDedupe.cache = new Map<string, Promise<unknown>>()

package/src/core/zod/rpc.ts

@@ -171,6 +171,7 @@ export const transactionRequest = z.object({
     z.array(z.object({ address: u.address(), storageKeys: z.array(u.hex()) })),
   ),
   calls: z.optional(z.readonly(z.array(call))),
+  capabilities: z.optional(z.record(z.string(), z.unknown())),
   chainId: z.optional(u.number()),
   data: z.optional(u.hex()),
   feePayer: z.optional(z.union([z.boolean(), z.string()])),