tempo.ts 0.11.0 → 0.12.0

package/src/wagmi/Connector.ts

@@ -1,28 +1,27 @@
+import * as idb from 'idb-keyval'
 import * as Address from 'ox/Address'
 import type * as Hex from 'ox/Hex'
 import * as PublicKey from 'ox/PublicKey'
 import { KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
 import {
   createClient,
+  defineChain,
   type EIP1193Provider,
   getAddress,
   type LocalAccount,
   SwitchChainError,
 } from 'viem'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+import {
+  Account,
+  WebAuthnP256,
+  WebCryptoP256,
+  walletNamespaceCompat,
+} from 'viem/tempo'
 import { ChainNotConfiguredError, createConnector } from 'wagmi'
 import type { OneOf } from '../internal/types.js'
-import * as Account from '../viem/Account.js'
-import type * as tempo_Chain from '../viem/Chain.js'
-import { normalizeValue } from '../viem/internal/utils.js'
-import * as Storage from '../viem/Storage.js'
-import { walletNamespaceCompat } from '../viem/Transport.js'
-import * as WebAuthnP256 from '../viem/WebAuthnP256.js'
-import * as WebCryptoP256 from '../viem/WebCryptoP256.js'
 import type * as KeyManager from './KeyManager.js'
 
-type Chain = ReturnType<ReturnType<typeof tempo_Chain.define>>
-
 /**
  * Connector for a Secp256k1 EOA.
  *
@@ -180,10 +179,14 @@ export function dangerous_secp256k1(
       const transport = transports[chain.id]
       if (!transport) throw new ChainNotConfiguredError()
 
+      if (!account) throw new Error('account not found.')
+
       return createClient({
         account,
-        chain: chain as Chain,
-        transport: walletNamespaceCompat(transport),
+        chain,
+        transport: walletNamespaceCompat(transport, {
+          account,
+        }),
       })
     },
     async getProvider({ chainId } = {}) {
@@ -221,12 +224,6 @@ export function webAuthn(options: webAuthn.Parameters) {
     return undefined
   })()
 
-  const idbStorage = Storage.idb<{
-    [key: `accessKey:${string}`]: WebCryptoP256.createKeyPair.ReturnType & {
-      keyAuthorization: KeyAuthorization.KeyAuthorization
-    }
-  }>()
-
   type Properties = {
     connect<withCapabilities extends boolean = false>(parameters: {
       chainId?: number | undefined
@@ -249,6 +246,9 @@ export function webAuthn(options: webAuthn.Parameters) {
   }
   type Provider = Pick<EIP1193Provider, 'request'>
   type StorageItem = {
+    [
+      key: `pendingKeyAuthorization:${string}`
+    ]: KeyAuthorization.KeyAuthorization
     'webAuthn.activeCredential': WebAuthnP256.P256Credential
     'webAuthn.lastActiveCredential': WebAuthnP256.P256Credential
   }
@@ -329,7 +329,7 @@ export function webAuthn(options: webAuthn.Parameters) {
               const address = Address.fromPublicKey(
                 PublicKey.fromHex(credential.publicKey),
               )
-              return await idbStorage.getItem(`accessKey:${address}`)
+              return await idb.get(`accessKey:${address}`)
             })()
 
             // If the access key provisioning is not in strict mode, return the credential and key pair (if exists).
@@ -414,14 +414,11 @@ export function webAuthn(options: webAuthn.Parameters) {
         normalizeValue(credential),
       )
 
-      account = Account.fromWebAuthnP256(credential, {
-        storage: Storage.from(config.storage as never),
-      })
+      account = Account.fromWebAuthnP256(credential)
 
       if (keyPair) {
         accessKey = Account.fromWebCryptoP256(keyPair, {
           access: account,
-          storage: Storage.from(config.storage as never),
         })
 
         // If we are reconnecting, check if the access key is expired.
@@ -432,7 +429,9 @@ export function webAuthn(options: webAuthn.Parameters) {
             keyPair.keyAuthorization.expiry < Date.now() / 1000
           ) {
             // remove any pending key authorizations from storage.
-            await account?.storage.removeItem('pendingKeyAuthorization')
+            await config?.storage?.removeItem(
+              `pendingKeyAuthorization:${account.address.toLowerCase()}`,
+            )
 
             const message = `Access key expired (on ${new Date(keyPair.keyAuthorization.expiry * 1000).toLocaleString()}).`
             accessKey = undefined
@@ -452,11 +451,14 @@ export function webAuthn(options: webAuthn.Parameters) {
             keyAuthorization ??
             (await account.signKeyAuthorization(accessKey, accessKeyOptions))
 
-          await account.storage.setItem('pendingKeyAuthorization', keyAuth)
-          await idbStorage.setItem(
-            `accessKey:${account.address.toLowerCase()}`,
-            { ...keyPair, keyAuthorization: keyAuth },
+          await config?.storage?.setItem(
+            `pendingKeyAuthorization:${account.address.toLowerCase()}`,
+            keyAuth,
           )
+          await idb.set(`accessKey:${account.address.toLowerCase()}`, {
+            ...keyPair,
+            keyAuthorization: keyAuth,
+          })
         }
         // If we are granting an access key and it is in strict mode, throw an error if the access key is not provisioned.
       } else if (accessKeyOptions?.strict) {
@@ -528,7 +530,7 @@ export function webAuthn(options: webAuthn.Parameters) {
       const targetAccount = await (async () => {
         if (!accessKey) return account
 
-        const item = await idbStorage.getItem(
+        const item = await idb.get(
           `accessKey:${accessKey.address.toLowerCase()}`,
         )
         if (
@@ -536,7 +538,9 @@ export function webAuthn(options: webAuthn.Parameters) {
           item.keyAuthorization.expiry < Date.now() / 1000
         ) {
           // remove any pending key authorizations from storage.
-          await account?.storage.removeItem('pendingKeyAuthorization')
+          await config?.storage?.removeItem(
+            `pendingKeyAuthorization:${accessKey.address.toLowerCase()}`,
+          )
 
           const message = `Access key expired (on ${new Date(item.keyAuthorization.expiry * 1000).toLocaleString()}).`
 
@@ -552,11 +556,60 @@ export function webAuthn(options: webAuthn.Parameters) {
         }
         return accessKey
       })()
+      if (!targetAccount) throw new Error('account not found.')
+
+      const targetChain = defineChain({
+        ...chain,
+        async prepareTransactionRequest(args, { phase }) {
+          const keyAuthorization = await (async () => {
+            {
+              const keyAuthorization = (
+                args as {
+                  keyAuthorization?:
+                    | KeyAuthorization.KeyAuthorization
+                    | undefined
+                }
+              ).keyAuthorization
+              if (keyAuthorization) return keyAuthorization
+            }
+
+            const keyAuthorization = await config.storage?.getItem(
+              `pendingKeyAuthorization:${targetAccount?.address.toLowerCase()}`,
+            )
+            await config.storage?.removeItem(
+              `pendingKeyAuthorization:${targetAccount?.address.toLowerCase()}`,
+            )
+            return keyAuthorization
+          })()
+
+          const [prepareTransactionRequestFn, options] = (() => {
+            if (!chain.prepareTransactionRequest) return [undefined, undefined]
+            if (typeof chain.prepareTransactionRequest === 'function')
+              return [chain.prepareTransactionRequest, undefined]
+            return chain.prepareTransactionRequest
+          })()
+
+          const request = await (async () => {
+            if (!prepareTransactionRequestFn) return {}
+            if (!options || options?.runAt?.includes(phase))
+              return await prepareTransactionRequestFn(args, { phase })
+            return {}
+          })()
+
+          return {
+            ...args,
+            ...request,
+            keyAuthorization,
+          }
+        },
+      })
 
       return createClient({
         account: targetAccount,
-        chain: chain as Chain,
-        transport: walletNamespaceCompat(transport),
+        chain: targetChain,
+        transport: walletNamespaceCompat(transport, {
+          account: targetAccount,
+        }),
       })
     },
     async getProvider({ chainId } = {}) {
@@ -594,3 +647,24 @@ export namespace webAuthn {
     rpId?: string | undefined
   }
 }
+
+/**
+ * Normalizes a value into a structured-clone compatible format.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone
+ */
+function normalizeValue<type>(value: type): type {
+  if (Array.isArray(value)) return value.map(normalizeValue) as never
+  if (typeof value === 'function') return undefined as never
+  if (typeof value !== 'object' || value === null) return value
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    try {
+      return structuredClone(value)
+    } catch {
+      return undefined as never
+    }
+
+  const normalized: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(value)) normalized[k] = normalizeValue(v)
+  return normalized as never
+}

package/src/wagmi/Hooks/dex.test.ts

@@ -1,6 +1,6 @@
-import { Tick } from 'tempo.ts/viem'
 import { Actions, Hooks } from 'tempo.ts/wagmi'
 import { type Address, isAddress, parseUnits } from 'viem'
+import { Tick } from 'viem/tempo'
 import { describe, expect, test, vi } from 'vitest'
 import { useConnect } from 'wagmi'
 import { addresses } from '../../../test/config.js'

package/src/wagmi/Hooks/fee.test.ts

@@ -100,7 +100,6 @@ describe('useUserToken', () => {
           {
             "account": {
               "address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
-              "assignKeyAuthorization": [Function],
               "keyType": "secp256k1",
               "publicKey": "0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5",
               "sign": [Function],
@@ -110,11 +109,6 @@ describe('useUserToken', () => {
               "signTransaction": [Function],
               "signTypedData": [Function],
               "source": "root",
-              "storage": {
-                "getItem": [Function],
-                "removeItem": [Function],
-                "setItem": [Function],
-              },
               "type": "local",
             },
             "chainId": 1337,

package/src/wagmi/Hooks/nonce.test.ts

@@ -6,7 +6,7 @@ import { config, renderHook } from '../../../test/wagmi/config.js'
 import * as hooks from './nonce.js'
 import * as tokenHooks from './token.js'
 
-const { useNonceKeyCount, useNonce } = hooks
+const { useNonce } = hooks
 
 const account = accounts[0]
 const account2 = accounts[1]
@@ -90,35 +90,6 @@ describe('useNonce', () => {
   })
 })
 
-describe('useNonceKeyCount', () => {
-  test('default', async () => {
-    let testAccount: Address | undefined
-
-    const { result, rerender } = await renderHook(() =>
-      useNonceKeyCount({ account: testAccount }),
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'fetching')
-
-    // Should be disabled when account is undefined
-    expect(result.current.data).toBeUndefined()
-    expect(result.current.isPending).toBe(true)
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set account
-    testAccount = account.address
-    rerender()
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy(), {
-      timeout: 5_000,
-    })
-
-    // Should now be enabled and have data
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBe(0n)
-  })
-})
-
 describe('useWatchNonceIncremented', () => {
   test('default', async () => {
     const { result: connectResult } = await renderHook(() => ({
@@ -169,39 +140,3 @@ describe('useWatchNonceIncremented', () => {
     expect(events[1]?.newNonce).toBe(2n)
   })
 })
-
-describe('useWatchActiveKeyCountChanged', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      transferSync: tokenHooks.useTransferSync(),
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchActiveKeyCountChanged({
-        onActiveKeyCountChanged(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    await connectResult.current.transferSync.mutateAsync({
-      to: account2.address,
-      amount: 1n,
-      token: 1n,
-      nonceKey: 10n,
-      nonce: 0,
-    })
-
-    await vi.waitUntil(() => events.length >= 1)
-
-    expect(events).toHaveLength(1)
-    expect(events[0]?.account).toBe(account.address)
-    expect(events[0]?.newCount).toBe(2n)
-  })
-})

package/src/wagmi/Hooks/nonce.ts

@@ -6,12 +6,7 @@ import type { ConfigParameter, QueryParameter } from 'wagmi/internal'
 import { type UseQueryReturnType, useQuery } from 'wagmi/query'
 
 import type { ExactPartial, UnionCompute } from '../../internal/types.js'
-import {
-  getNonce,
-  getNonceKeyCount,
-  watchActiveKeyCountChanged,
-  watchNonceIncremented,
-} from '../Actions/nonce.js'
+import { getNonce, watchNonceIncremented } from '../Actions/nonce.js'
 
 /**
  * Hook for getting the nonce for an account and nonce key.
@@ -74,67 +69,6 @@ export declare namespace useNonce {
     UseQueryReturnType<selectData, Error>
 }
 
-/**
- * Hook for getting the number of active nonce keys for an account.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { data, isLoading } = Hooks.nonce.useNonceKeyCount({
- *     account: '0x...',
- *   })
- *
- *   if (isLoading) return <div>Loading...</div>
- *   return <div>Active keys: {data?.toString()}</div>
- * }
- * ```
- *
- * @param parameters - Parameters.
- * @returns Query result with active nonce key count.
- */
-export function useNonceKeyCount<
-  config extends Config = ResolvedRegister['config'],
-  selectData = getNonceKeyCount.ReturnValue,
->(parameters: useNonceKeyCount.Parameters<config, selectData> = {}) {
-  const { account, query = {} } = parameters
-
-  const config = useConfig(parameters)
-  const chainId = useChainId({ config })
-
-  const options = getNonceKeyCount.queryOptions(config, {
-    ...parameters,
-    chainId: parameters.chainId ?? chainId,
-    query: undefined,
-  })
-  const enabled = Boolean(account && (query.enabled ?? true))
-
-  return useQuery({ ...query, ...options, enabled })
-}
-
-export declare namespace useNonceKeyCount {
-  export type Parameters<
-    config extends Config = ResolvedRegister['config'],
-    selectData = getNonceKeyCount.ReturnValue,
-  > = ConfigParameter<config> &
-    QueryParameter<
-      getNonceKeyCount.ReturnValue,
-      DefaultError,
-      selectData,
-      getNonceKeyCount.QueryKey<config>
-    > &
-    ExactPartial<
-      Omit<
-        getNonceKeyCount.queryOptions.Parameters<config, selectData>,
-        'query'
-      >
-    >
-
-  export type ReturnValue<selectData = getNonceKeyCount.ReturnValue> =
-    UseQueryReturnType<selectData, Error>
-}
-
 /**
  * Hook for watching nonce incremented events.
  *
@@ -181,50 +115,3 @@ export declare namespace useWatchNonceIncremented {
       ConfigParameter<config> & { enabled?: boolean | undefined }
   >
 }
-
-/**
- * Hook for watching active key count changed events.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   Hooks.nonce.useWatchActiveKeyCountChanged({
- *     onActiveKeyCountChanged(args, log) {
- *       console.log('Active key count changed:', args)
- *     },
- *   })
- *
- *   return <div>Watching for active key count changes...</div>
- * }
- * ```
- *
- * @param parameters - Parameters.
- */
-export function useWatchActiveKeyCountChanged<
-  config extends Config = ResolvedRegister['config'],
->(parameters: useWatchActiveKeyCountChanged.Parameters<config> = {}) {
-  const { enabled = true, onActiveKeyCountChanged, ...rest } = parameters
-
-  const config = useConfig({ config: parameters.config })
-  const configChainId = useChainId({ config })
-  const chainId = parameters.chainId ?? configChainId
-
-  useEffect(() => {
-    if (!enabled) return
-    if (!onActiveKeyCountChanged) return
-    return watchActiveKeyCountChanged(config, {
-      ...rest,
-      chainId,
-      onActiveKeyCountChanged,
-    })
-  }, [config, enabled, onActiveKeyCountChanged, chainId, rest])
-}
-
-export declare namespace useWatchActiveKeyCountChanged {
-  type Parameters<config extends Config = Config> = UnionCompute<
-    ExactPartial<watchActiveKeyCountChanged.Parameters<config>> &
-      ConfigParameter<config> & { enabled?: boolean | undefined }
-  >
-}

package/src/wagmi/Hooks/policy.ts

@@ -14,8 +14,6 @@ import {
 import type { ExactPartial, UnionCompute } from '../../internal/types.js'
 import * as Actions from '../Actions/policy.js'
 
-export type { PolicyType } from '../Actions/policy.js'
-
 /**
  * Hook for creating a new policy.
  *

package/src/wagmi/KeyManager.ts

@@ -1,7 +1,11 @@
 import type * as Hex from 'ox/Hex'
 import * as Json from 'ox/Json'
+import {
+  type CreateStorageParameters,
+  createStorage,
+  type Storage,
+} from 'wagmi'
 import type * as Handler from '../server/Handler.js'
-import * as Storage from '../viem/Storage.js'
 
 export type KeyManager = {
   /** Function to fetch create options for WebAuthn. */
@@ -24,8 +28,7 @@ export function from<manager extends KeyManager>(manager: manager): manager {
 }
 
 /** Instantiates a key manager from a Storage instance. */
-export function fromStorage(s: Storage.Storage): KeyManager {
-  const storage = Storage.from(s, { key: 'webAuthn:publicKey' })
+export function fromStorage(storage: Storage): KeyManager {
   return from({
     async getPublicKey(parameters) {
       const publicKey = await storage.getItem(parameters.credential.id)
@@ -53,8 +56,18 @@ export function fromStorage(s: Storage.Storage): KeyManager {
  *
  * @deprecated
  */
-export function localStorage(options: Storage.localStorage.Options = {}) {
-  return fromStorage(Storage.localStorage(options))
+export function localStorage(options: localStorage.Options = {}) {
+  const { key = 'wagmi.keyManager' } = options
+  const storage = createStorage({
+    ...options,
+    key,
+    storage: typeof window !== 'undefined' ? window.localStorage : undefined,
+  })
+  return fromStorage(storage)
+}
+
+export namespace localStorage {
+  export type Options = Omit<CreateStorageParameters, 'storage'>
 }
 
 /**