tempo.ts 0.6.1 → 0.7.0

package/src/wagmi/Connector.ts

@@ -1,5 +1,4 @@
 import * as Address from 'ox/Address'
-import * as Bytes from 'ox/Bytes'
 import type * as Hex from 'ox/Hex'
 import {
   createClient,
@@ -12,8 +11,10 @@ import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
 import { ChainNotConfiguredError, createConnector } from 'wagmi'
 import * as Account from '../viem/Account.js'
 import type * as tempo_Chain from '../viem/Chain.js'
+import { normalizeValue } from '../viem/internal/utils.js'
 import { walletNamespaceCompat } from '../viem/Transport.js'
 import * as WebAuthnP256 from '../viem/WebAuthnP256.js'
+import type * as KeyManager from './KeyManager.js'
 
 type Chain = ReturnType<ReturnType<typeof tempo_Chain.define>>
 
@@ -195,7 +196,7 @@ export declare namespace dangerous_secp256k1 {
  *
  * @returns Connector.
  */
-export function webAuthn(options: webAuthn.Parameters = {}) {
+export function webAuthn(options: webAuthn.Parameters) {
   let account: Account.Account | undefined
 
   type Properties = {
@@ -219,7 +220,6 @@ export function webAuthn(options: webAuthn.Parameters = {}) {
   type StorageItem = {
     'webAuthn.activeCredential': WebAuthnP256.P256Credential
     'webAuthn.lastActiveCredential': WebAuthnP256.P256Credential
-    [key: `webAuthn.${string}.publicKey`]: Hex.Hex
   }
 
   return createConnector<Provider, Properties, StorageItem>((config) => ({
@@ -246,22 +246,23 @@ export function webAuthn(options: webAuthn.Parameters = {}) {
             typeof parameters.capabilities?.createAccount === 'boolean'
               ? {}
               : parameters.capabilities?.createAccount
-          const challenge = await options.createOptions?.getChallenge?.()
+          const createOptions_remote = await options.keyManager.getChallenge?.()
           credential = await WebAuthnP256.createCredential({
             ...(options.createOptions ?? {}),
-            challenge: challenge
-              ? new Uint8Array(Bytes.fromHex(challenge))
-              : undefined,
             label:
               createOptions.label ??
               options.createOptions?.label ??
               `Account ${new Date().toISOString().split('T')[0]}`,
-            rpId: options.createOptions?.rpId ?? options.rpId,
+            rpId:
+              createOptions_remote?.rp?.id ??
+              options.createOptions?.rpId ??
+              options.rpId,
+            ...(createOptions_remote ?? {}),
+          })
+          await options.keyManager.setPublicKey({
+            credential: credential.raw,
+            publicKey: credential.publicKey,
           })
-          config.storage?.setItem(
-            `webAuthn.${credential.id}.publicKey`,
-            credential.publicKey,
-          )
         } else {
           // Load credential (log in)
           credential = (await config.storage?.getItem(
@@ -278,19 +279,11 @@ export function webAuthn(options: webAuthn.Parameters = {}) {
             // biome-ignore lint/suspicious/noTsIgnore: _
             // @ts-ignore
             async getPublicKey(credential) {
-              {
-                const publicKey =
-                  await options.getOptions?.getPublicKey?.(credential)
-                if (publicKey) return publicKey
-              }
-
-              {
-                const publicKey = await config.storage?.getItem(
-                  `webAuthn.${credential.id}.publicKey`,
-                )
-                if (!publicKey) throw new Error('publicKey not found')
-                return publicKey as Hex.Hex
-              }
+              const publicKey = await options.keyManager.getPublicKey({
+                credential,
+              })
+              if (!publicKey) throw new Error('publicKey not found.')
+              return publicKey
             },
             rpId: options.getOptions?.rpId ?? options.rpId,
           })
@@ -380,49 +373,22 @@ export function webAuthn(options: webAuthn.Parameters = {}) {
   }))
 }
 
-export declare namespace webAuthn {
+export namespace webAuthn {
   export type Parameters = {
     /** Options for WebAuthn registration. */
     createOptions?:
-      | (Pick<
+      | Pick<
           WebAuthnP256.createCredential.Parameters,
           'createFn' | 'label' | 'rpId' | 'userId' | 'timeout'
-        > & {
-          /** Function to fetch a challenge to sign over at registration. */
-          getChallenge?: (() => Promise<Hex.Hex>) | undefined
-        })
+        >
       | undefined
     /** Options for WebAuthn authentication. */
     getOptions?:
-      | (Pick<WebAuthnP256.getCredential.Parameters, 'getFn' | 'rpId'> & {
-          /** Function to fetch the public key for a credential. */
-          getPublicKey?:
-            | WebAuthnP256.getCredential.Parameters['getPublicKey']
-            | undefined
-        })
+      | Pick<WebAuthnP256.getCredential.Parameters, 'getFn' | 'rpId'>
       | undefined
+    /** Public key manager. */
+    keyManager: KeyManager.KeyManager
     /** The RP ID to use for 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
- */
-export 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/amm.test.ts

@@ -1,9 +1,8 @@
-import { getConnectorClient } from '@wagmi/core'
 import { type Address, parseUnits } from 'viem'
 import { describe, expect, test, vi } from 'vitest'
 import { useConnect } from 'wagmi'
 import { addresses } from '../../../test/config.js'
-import { accounts, setupPoolWithLiquidity } from '../../../test/viem/config.js'
+import { accounts } from '../../../test/viem/config.js'
 import { config, renderHook } from '../../../test/wagmi/config.js'
 import * as hooks from './amm.js'
 import * as tokenHooks from './token.js'
@@ -20,7 +19,7 @@ describe('usePool', () => {
     )
 
     await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy(), {
-      timeout: 5_000,
+      timeout: 10_000,
     })
 
     expect(result.current.data).toMatchInlineSnapshot(`
@@ -151,14 +150,9 @@ describe('useMintSync', () => {
 
     // Add liquidity to pool
     const data = await result.current.mintSync.mutateAsync({
-      userToken: {
-        address: token,
-        amount: parseUnits('100', 6),
-      },
-      validatorToken: {
-        address: addresses.alphaUsd,
-        amount: parseUnits('100', 6),
-      },
+      userTokenAddress: token,
+      validatorTokenAddress: addresses.alphaUsd,
+      validatorTokenAmount: parseUnits('100', 6),
       to: account.address,
     })
 
@@ -167,134 +161,10 @@ describe('useMintSync', () => {
     )
 
     expect(data.receipt).toBeDefined()
-    expect(data.amountUserToken).toBe(parseUnits('100', 6))
     expect(data.amountValidatorToken).toBe(parseUnits('100', 6))
   })
 })
 
-describe('useBurnSync', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      burnSync: hooks.useBurnSync(),
-      getLiquidityBalance: hooks.useLiquidityBalance,
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const client = await getConnectorClient(config)
-    const { tokenAddress } = await setupPoolWithLiquidity(client)
-
-    // Get LP balance before burn
-    const { result: balanceResult } = await renderHook(() =>
-      result.current.getLiquidityBalance({
-        userToken: tokenAddress,
-        validatorToken: addresses.alphaUsd,
-        address: account.address,
-      }),
-    )
-
-    await vi.waitFor(() => expect(balanceResult.current.isSuccess).toBeTruthy())
-
-    const lpBalanceBefore = balanceResult.current.data!
-
-    // Burn half of LP tokens
-    const data = await result.current.burnSync.mutateAsync({
-      userToken: tokenAddress,
-      validatorToken: addresses.alphaUsd,
-      liquidity: lpBalanceBefore / 2n,
-      to: account.address,
-    })
-
-    await vi.waitFor(() =>
-      expect(result.current.burnSync.isSuccess).toBeTruthy(),
-    )
-
-    expect(data.receipt).toBeDefined()
-    expect(data.liquidity).toBe(lpBalanceBefore / 2n)
-  })
-})
-
-describe('useRebalanceSwapSync', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      rebalanceSwapSync: hooks.useRebalanceSwapSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const client = await getConnectorClient(config)
-    const { tokenAddress } = await setupPoolWithLiquidity(client)
-
-    const account2 = accounts[1]
-
-    // Perform rebalance swap
-    const data = await result.current.rebalanceSwapSync.mutateAsync({
-      userToken: tokenAddress,
-      validatorToken: addresses.alphaUsd,
-      amountOut: parseUnits('10', 6),
-      to: account2.address,
-    })
-
-    await vi.waitFor(() =>
-      expect(result.current.rebalanceSwapSync.isSuccess).toBeTruthy(),
-    )
-
-    expect(data.receipt).toBeDefined()
-    expect(data.amountOut).toBe(parseUnits('10', 6))
-    expect(data.swapper).toBe(account.address)
-  })
-})
-
-describe('useWatchRebalanceSwap', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      rebalanceSwapSync: hooks.useRebalanceSwapSync(),
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const client = await getConnectorClient(config)
-    const { tokenAddress } = await setupPoolWithLiquidity(client)
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchRebalanceSwap({
-        onRebalanceSwap(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    const account2 = accounts[1]
-
-    // Perform rebalance swap
-    await connectResult.current.rebalanceSwapSync.mutateAsync({
-      userToken: tokenAddress,
-      validatorToken: addresses.alphaUsd,
-      amountOut: parseUnits('10', 6),
-      to: account2.address,
-    })
-
-    await vi.waitUntil(() => events.length >= 1)
-
-    expect(events.length).toBeGreaterThanOrEqual(1)
-    expect(events[0]?.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
-    expect(events[0]?.validatorToken.toLowerCase()).toBe(
-      addresses.alphaUsd.toLowerCase(),
-    )
-    expect(events[0]?.amountOut).toBe(parseUnits('10', 6))
-  })
-})
-
 describe('useWatchMint', () => {
   test('default', async () => {
     const { result: connectResult } = await renderHook(() => ({
@@ -341,14 +211,9 @@ describe('useWatchMint', () => {
 
     // Add liquidity to pool
     await connectResult.current.mintSync.mutateAsync({
-      userToken: {
-        address: token,
-        amount: parseUnits('100', 6),
-      },
-      validatorToken: {
-        address: addresses.alphaUsd,
-        amount: parseUnits('100', 6),
-      },
+      userTokenAddress: token,
+      validatorTokenAddress: addresses.alphaUsd,
+      validatorTokenAmount: parseUnits('100', 6),
       to: account.address,
     })
 
@@ -359,63 +224,6 @@ describe('useWatchMint', () => {
     expect(events[0]?.validatorToken.address.toLowerCase()).toBe(
       addresses.alphaUsd.toLowerCase(),
     )
-    expect(events[0]?.userToken.amount).toBe(parseUnits('100', 6))
     expect(events[0]?.validatorToken.amount).toBe(parseUnits('100', 6))
   })
 })
-
-describe('useWatchBurn', () => {
-  test('default', async () => {
-    const { result: connectResult } = await renderHook(() => ({
-      connect: useConnect(),
-      burnSync: hooks.useBurnSync(),
-      getLiquidityBalance: hooks.useLiquidityBalance,
-    }))
-
-    await connectResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const client = await getConnectorClient(config)
-    const { tokenAddress } = await setupPoolWithLiquidity(client)
-
-    // Get LP balance
-    const { result: balanceResult } = await renderHook(() =>
-      connectResult.current.getLiquidityBalance({
-        userToken: tokenAddress,
-        validatorToken: addresses.alphaUsd,
-        address: account.address,
-      }),
-    )
-
-    await vi.waitFor(() => expect(balanceResult.current.isSuccess).toBeTruthy())
-
-    const lpBalance = balanceResult.current.data!
-
-    const events: any[] = []
-    await renderHook(() =>
-      hooks.useWatchBurn({
-        onBurn(args) {
-          events.push(args)
-        },
-      }),
-    )
-
-    // Burn LP tokens
-    await connectResult.current.burnSync.mutateAsync({
-      userToken: tokenAddress,
-      validatorToken: addresses.alphaUsd,
-      liquidity: lpBalance / 2n,
-      to: account.address,
-    })
-
-    await vi.waitUntil(() => events.length >= 1)
-
-    expect(events.length).toBeGreaterThanOrEqual(1)
-    expect(events[0]?.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
-    expect(events[0]?.validatorToken.toLowerCase()).toBe(
-      addresses.alphaUsd.toLowerCase(),
-    )
-    expect(events[0]?.liquidity).toBe(lpBalance / 2n)
-  })
-})