tempo.ts 0.6.2 → 0.7.1

package/src/wagmi/Actions/reward.ts

@@ -5,118 +5,6 @@ import type { Account } from 'viem'
 import type { RequiredBy, UnionOmit } from '../../internal/types.js'
 import * as viem_Actions from '../../viem/Actions/reward.js'
 
-/**
- * Cancels an active reward stream and refunds remaining tokens.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const hash = await Actions.reward.cancel(config, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction hash.
- */
-export async function cancel<config extends Config>(
-  config: config,
-  parameters: cancel.Parameters<config>,
-): Promise<viem_Actions.cancel.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.cancel(client, parameters as never)
-}
-
-export declare namespace cancel {
-  export type Parameters<config extends Config = Config> =
-    ChainIdParameter<config> &
-      ConnectorParameter &
-      UnionOmit<
-        viem_Actions.cancel.Parameters<config['chains'][number], Account>,
-        'chain'
-      >
-
-  export type ReturnValue = viem_Actions.cancel.ReturnValue
-
-  export type ErrorType = viem_Actions.cancel.ErrorType
-}
-
-/**
- * Cancels an active reward stream and waits for confirmation.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const result = await Actions.reward.cancelSync(config, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The transaction receipt and event data.
- */
-export async function cancelSync<config extends Config>(
-  config: config,
-  parameters: cancelSync.Parameters<config>,
-): Promise<viem_Actions.cancelSync.ReturnValue> {
-  const { account, chainId, connector } = parameters
-
-  const client = await getConnectorClient(config, {
-    account,
-    assertChainId: false,
-    chainId,
-    connector,
-  })
-
-  return viem_Actions.cancelSync(client, parameters as never)
-}
-
-export declare namespace cancelSync {
-  export type Parameters<config extends Config = Config> =
-    ChainIdParameter<config> &
-      ConnectorParameter &
-      UnionOmit<
-        viem_Actions.cancelSync.Parameters<config['chains'][number], Account>,
-        'chain'
-      >
-
-  export type ReturnValue = viem_Actions.cancelSync.ReturnValue
-
-  export type ErrorType = viem_Actions.cancelSync.ErrorType
-}
-
 /**
  * Claims accumulated rewards for a recipient.
  *
@@ -227,97 +115,6 @@ export declare namespace claimSync {
   export type ErrorType = viem_Actions.claimSync.ErrorType
 }
 
-/**
- * Gets a reward stream by its ID.
- *
- * @example
- * ```ts
- * import { createConfig, http } from '@wagmi/core'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions } from 'tempo.ts/wagmi'
- *
- * const config = createConfig({
- *   chains: [tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })],
- *   transports: {
- *     [tempo.id]: http(),
- *   },
- * })
- *
- * const stream = await Actions.reward.getStream(config, {
- *   id: 1n,
- *   token: '0x20c0000000000000000000000000000000000001',
- * })
- * ```
- *
- * @param config - Config.
- * @param parameters - Parameters.
- * @returns The reward stream details.
- */
-export function getStream<config extends Config>(
-  config: config,
-  parameters: getStream.Parameters<config>,
-) {
-  const { chainId, ...rest } = parameters
-  const client = config.getClient({ chainId })
-  return viem_Actions.getStream(client, rest)
-}
-
-export namespace getStream {
-  export type Parameters<config extends Config> = ChainIdParameter<config> &
-    viem_Actions.getStream.Parameters
-
-  export type ReturnValue = viem_Actions.getStream.ReturnValue
-
-  export function queryKey<config extends Config>(
-    parameters: Parameters<config>,
-  ) {
-    return ['getStream', parameters] as const
-  }
-
-  export type QueryKey<config extends Config> = ReturnType<
-    typeof queryKey<config>
-  >
-
-  export function queryOptions<config extends Config, selectData = ReturnValue>(
-    config: Config,
-    parameters: queryOptions.Parameters<config, selectData>,
-  ): queryOptions.ReturnValue<config, selectData> {
-    const { query, ...rest } = parameters
-    return {
-      ...query,
-      queryKey: queryKey(rest),
-      async queryFn({ queryKey }) {
-        const [, parameters] = queryKey
-        return await getStream(config, parameters)
-      },
-    }
-  }
-
-  export declare namespace queryOptions {
-    export type Parameters<
-      config extends Config,
-      selectData = getStream.ReturnValue,
-    > = getStream.Parameters<config> & {
-      query?:
-        | Omit<ReturnValue<config, selectData>, 'queryKey' | 'queryFn'>
-        | undefined
-    }
-
-    export type ReturnValue<
-      config extends Config,
-      selectData = getStream.ReturnValue,
-    > = RequiredBy<
-      Query.QueryOptions<
-        getStream.ReturnValue,
-        Query.DefaultError,
-        selectData,
-        getStream.QueryKey<config>
-      >,
-      'queryKey' | 'queryFn'
-    >
-  }
-}
-
 /**
  * Gets the total reward per second rate for all active streams.
  *

package/src/wagmi/Connector.test.ts

@@ -3,6 +3,7 @@ import { cdp } from 'vitest/browser'
 import { useAccount, useConnect } from 'wagmi'
 import { renderHook } from '../../test/wagmi/config.js'
 import { webAuthn } from './Connector.js'
+import * as KeyManager from './KeyManager.js'
 
 async function setupWebAuthn() {
   const client = cdp()
@@ -39,7 +40,9 @@ test('connect', async (context) => {
   expect(result.current.useAccount.status).toEqual('disconnected')
 
   result.current.useConnect.connect({
-    connector: webAuthn(),
+    connector: webAuthn({
+      keyManager: KeyManager.localStorage(),
+    }),
     capabilities: { createAccount: { label: 'Test Account' } },
   })
 

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