accounts 0.17.1 → 0.17.2

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>>()