tempo.ts 0.6.2 → 0.7.1

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

@@ -1,125 +1,9 @@
-import { type Address, parseUnits } from 'viem'
+import type { Address } from 'viem'
 import { describe, expect, test, vi } from 'vitest'
 import { useConnect } from 'wagmi'
 import { config, renderHook, setupToken } from '../../../test/wagmi/config.js'
 import * as hooks from './reward.js'
 
-describe('useCancelSync', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      cancel: hooks.useCancelSync(),
-      connect: useConnect(),
-      start: hooks.useStartSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    // Start a reward stream
-    const { id: streamId } = await result.current.start.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 3600,
-      token,
-    })
-
-    // Cancel the stream
-    await result.current.cancel.mutateAsync({
-      id: streamId,
-      token,
-    })
-
-    await vi.waitFor(() => expect(result.current.cancel.isSuccess).toBeTruthy())
-  })
-})
-
-describe('useGetStream', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      getStream: hooks.useGetStream(),
-      startSync: hooks.useStartSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    const { id: streamId } = await result.current.startSync.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 10,
-      token,
-    })
-
-    // Update the hook to query the stream
-    const { result: streamResult } = await renderHook(() =>
-      hooks.useGetStream({
-        id: streamId,
-        token,
-      }),
-    )
-
-    await vi.waitFor(() => expect(streamResult.current.isSuccess).toBeTruthy())
-
-    expect(streamResult.current.data?.funder).toBeDefined()
-    expect(streamResult.current.data?.amountTotal).toBe(parseUnits('100', 6))
-  })
-
-  test('reactivity: id and token parameters', async () => {
-    const { result: setupResult } = await renderHook(() => ({
-      connect: useConnect(),
-      startSync: hooks.useStartSync(),
-    }))
-
-    await setupResult.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    const { id } = await setupResult.current.startSync.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 10,
-      token,
-    })
-
-    const { result, rerender } = await renderHook(
-      (props) =>
-        hooks.useGetStream({
-          id: props?.id,
-          token: props?.token,
-        }),
-      {
-        initialProps: {
-          id: undefined as bigint | undefined,
-          token: undefined as Address | undefined,
-        },
-      },
-    )
-
-    await vi.waitFor(() => result.current.fetchStatus === 'idle')
-
-    // Should be disabled when parameters are undefined
-    expect(result.current.data).toBeUndefined()
-    expect(result.current.isPending).toBe(true)
-    expect(result.current.isEnabled).toBe(false)
-
-    // Set parameters
-    rerender({ id, token })
-
-    await vi.waitFor(() => expect(result.current.isSuccess).toBeTruthy())
-
-    // Should now be enabled and have data
-    expect(result.current.isEnabled).toBe(true)
-    expect(result.current.data).toBeDefined()
-    expect(result.current.data?.amountTotal).toBe(parseUnits('100', 6))
-  })
-})
-
 describe('useGetTotalPerSecond', () => {
   test('default', async () => {
     const { token } = await setupToken()
@@ -192,28 +76,3 @@ describe('useSetRecipientSync', () => {
     )
   })
 })
-
-describe('useStartSync', () => {
-  test('default', async () => {
-    const { result } = await renderHook(() => ({
-      connect: useConnect(),
-      start: hooks.useStartSync(),
-    }))
-
-    await result.current.connect.connectAsync({
-      connector: config.connectors[0]!,
-    })
-
-    const { token } = await setupToken()
-
-    const { id } = await result.current.start.mutateAsync({
-      amount: parseUnits('100', 6),
-      seconds: 10,
-      token,
-    })
-
-    expect(id).toBeGreaterThan(0n)
-
-    await vi.waitFor(() => expect(result.current.start.isSuccess).toBeTruthy())
-  })
-})

package/src/wagmi/Hooks/reward.ts

@@ -12,140 +12,6 @@ import {
 import type { ExactPartial } from '../../internal/types.js'
 import * as Actions from '../Actions/reward.js'
 
-/**
- * Hook for canceling an active reward stream.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { mutate: cancel } = Hooks.reward.useCancel()
- *
- *   return (
- *     <button onClick={() => cancel({
- *       id: 1n,
- *       token: '0x20c0000000000000000000000000000000000001'
- *     })}>
- *       Cancel Stream
- *     </button>
- *   )
- * }
- * ```
- *
- * @param parameters - Parameters.
- * @returns Mutation result.
- */
-export function useCancel<
-  config extends Config = ResolvedRegister['config'],
-  context = unknown,
->(
-  parameters: useCancel.Parameters<config, context> = {},
-): useCancel.ReturnType<config, context> {
-  const { mutation } = parameters
-  const config = useConfig(parameters)
-  return useMutation({
-    ...mutation,
-    async mutationFn(variables) {
-      return Actions.cancel(config, variables as never)
-    },
-    mutationKey: ['cancel'],
-  }) as never
-}
-
-export declare namespace useCancel {
-  type Parameters<
-    config extends Config = Config,
-    context = unknown,
-  > = ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          Actions.cancel.ReturnValue,
-          Actions.cancel.ErrorType,
-          Actions.cancel.Parameters<config>,
-          context
-        >
-      | undefined
-  }
-
-  type ReturnType<
-    config extends Config = Config,
-    context = unknown,
-  > = UseMutationResult<
-    Actions.cancel.ReturnValue,
-    Actions.cancel.ErrorType,
-    Actions.cancel.Parameters<config>,
-    context
-  >
-}
-
-/**
- * Hook for canceling an active reward stream and waiting for confirmation.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { mutate: cancelSync } = Hooks.reward.useCancelSync()
- *
- *   return (
- *     <button onClick={() => cancelSync({
- *       id: 1n,
- *       token: '0x20c0000000000000000000000000000000000001'
- *     })}>
- *       Cancel Stream
- *     </button>
- *   )
- * }
- * ```
- *
- * @param parameters - Parameters.
- * @returns Mutation result.
- */
-export function useCancelSync<
-  config extends Config = ResolvedRegister['config'],
-  context = unknown,
->(
-  parameters: useCancelSync.Parameters<config, context> = {},
-): useCancelSync.ReturnType<config, context> {
-  const { mutation } = parameters
-  const config = useConfig(parameters)
-  return useMutation({
-    ...mutation,
-    async mutationFn(variables) {
-      return Actions.cancelSync(config, variables as never)
-    },
-    mutationKey: ['cancelSync'],
-  }) as never
-}
-
-export declare namespace useCancelSync {
-  type Parameters<
-    config extends Config = Config,
-    context = unknown,
-  > = ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          Actions.cancelSync.ReturnValue,
-          Actions.cancelSync.ErrorType,
-          Actions.cancelSync.Parameters<config>,
-          context
-        >
-      | undefined
-  }
-
-  type ReturnType<
-    config extends Config = Config,
-    context = unknown,
-  > = UseMutationResult<
-    Actions.cancelSync.ReturnValue,
-    Actions.cancelSync.ErrorType,
-    Actions.cancelSync.Parameters<config>,
-    context
-  >
-}
-
 /**
  * Hook for claiming accumulated rewards.
  *
@@ -278,68 +144,6 @@ export declare namespace useClaimSync {
   >
 }
 
-/**
- * Hook for getting a reward stream by its ID.
- *
- * @example
- * ```tsx
- * import { Hooks } from 'tempo.ts/wagmi'
- *
- * function App() {
- *   const { data, isLoading } = Hooks.reward.useGetStream({
- *     id: 1n,
- *     token: '0x20c0000000000000000000000000000000000001',
- *   })
- *
- *   if (isLoading) return <div>Loading...</div>
- *   return <div>Funder: {data?.funder}</div>
- * }
- * ```
- *
- * @param parameters - Parameters.
- * @returns Query result with stream details.
- */
-export function useGetStream<
-  config extends Config = ResolvedRegister['config'],
-  selectData = Actions.getStream.ReturnValue,
->(parameters: useGetStream.Parameters<config, selectData> = {}) {
-  const { id, query = {}, token } = parameters
-
-  const config = useConfig(parameters)
-  const chainId = useChainId({ config })
-
-  const options = Actions.getStream.queryOptions(config, {
-    ...parameters,
-    chainId: parameters.chainId ?? chainId,
-    query: undefined,
-  } as never)
-  const enabled = Boolean(id !== undefined && token && (query.enabled ?? true))
-
-  return useQuery({ ...query, ...options, enabled })
-}
-
-export declare namespace useGetStream {
-  export type Parameters<
-    config extends Config = ResolvedRegister['config'],
-    selectData = Actions.getStream.ReturnValue,
-  > = ConfigParameter<config> &
-    QueryParameter<
-      Actions.getStream.ReturnValue,
-      DefaultError,
-      selectData,
-      Actions.getStream.QueryKey<config>
-    > &
-    ExactPartial<
-      Omit<
-        Actions.getStream.queryOptions.Parameters<config, selectData>,
-        'query'
-      >
-    >
-
-  export type ReturnValue<selectData = Actions.getStream.ReturnValue> =
-    UseQueryReturnType<selectData, Error>
-}
-
 /**
  * Hook for getting the total reward per second rate.
  *

package/src/wagmi/KeyManager.ts

@@ -0,0 +1,159 @@
+import type * as Hex from 'ox/Hex'
+import * as Json from 'ox/Json'
+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. */
+  getChallenge?:
+    | (() => Promise<Handler.keyManager.ChallengeResponse>)
+    | undefined
+  /** Function to fetch the public key for a credential. */
+  getPublicKey: (
+    parameters: Handler.keyManager.GetPublicKeyParameters,
+  ) => Promise<Hex.Hex>
+  /** Function to set the public key for a credential. */
+  setPublicKey: (
+    parameters: Handler.keyManager.SetPublicKeyParameters,
+  ) => Promise<void>
+}
+
+/** Instantiates a key manager. */
+export function from<manager extends KeyManager>(manager: manager): manager {
+  return manager
+}
+
+/** Instantiates a key manager from a Storage instance. */
+export function fromStorage(s: Storage.Storage): KeyManager {
+  const storage = Storage.from(s, { key: 'webAuthn:publicKey' })
+  return from({
+    async getPublicKey(parameters) {
+      const publicKey = await storage.getItem(parameters.credential.id)
+      if (!publicKey) throw new Error('publicKey not found.')
+      return publicKey as Hex.Hex
+    },
+    async setPublicKey(parameters) {
+      await storage.setItem(parameters.credential.id, parameters.publicKey)
+    },
+  })
+}
+
+/**
+ * Instantiates a key manager from a localStorage instance.
+ *
+ * WARNING: Do not use this in production.
+ * This is because we are unable to extract a user's public key after the registration
+ * process. If a user clears their storage, or visits the website on a different device,
+ * they will not be able to access their account.
+ *
+ * Instead, we recommend to set up a remote store such as [`KeyManager.http`](#http) to register
+ * public keys against their WebAuthn credential.
+ *
+ * @see {@link http}
+ *
+ * @deprecated
+ */
+export function localStorage(options: Storage.localStorage.Options = {}) {
+  return fromStorage(Storage.localStorage(options))
+}
+
+/**
+ * Instantiates a key manager that uses HTTP endpoints for credential management.
+ *
+ * @example
+ * ```tsx
+ * import { KeyManager } from 'tempo.ts/wagmi'
+ *
+ * const keyManager = KeyManager.http('https://api.example.com')
+ * ```
+ *
+ * @param url - The URL to use for the HTTP endpoints.
+ * @param options - Configuration options for HTTP endpoints.
+ * @returns A KeyManager instance that uses HTTP for credential operations.
+ */
+export function http(
+  url:
+    | string
+    | {
+        getChallenge?: string | Request | undefined
+        getPublicKey?: string | Request | undefined
+        setPublicKey?: string | Request | undefined
+      },
+  options: http.Options = {},
+): KeyManager {
+  const { fetch: fetchFn = globalThis.fetch } = options
+  const { getChallenge, getPublicKey, setPublicKey } = (() => {
+    const base = typeof url === 'string' ? url : ''
+    const urls = typeof url === 'object' ? url : {}
+    return {
+      getChallenge: urls.getChallenge ?? `${base}/challenge`,
+      getPublicKey: urls.getPublicKey ?? `${base}/:credentialId`,
+      setPublicKey: urls.setPublicKey ?? `${base}/:credentialId`,
+    }
+  })()
+
+  return from({
+    async getChallenge() {
+      const request =
+        getChallenge instanceof Request
+          ? getChallenge
+          : new Request(getChallenge)
+
+      const response = await fetchFn(request)
+
+      if (!response.ok)
+        throw new Error(`Failed to get create options: ${response.statusText}`)
+      return await response.json()
+    },
+
+    async getPublicKey(parameters) {
+      const request =
+        getPublicKey instanceof Request
+          ? getPublicKey
+          : new Request(getPublicKey)
+
+      const response = await fetchFn(
+        new Request(
+          request.url.replace(':credentialId', parameters.credential.id),
+          request,
+        ),
+      )
+
+      if (!response.ok)
+        throw new Error(`Failed to get public key: ${response.statusText}`)
+      const data = await response.json()
+      return data.publicKey as Hex.Hex
+    },
+
+    async setPublicKey(parameters) {
+      const request =
+        setPublicKey instanceof Request
+          ? setPublicKey
+          : new Request(setPublicKey)
+
+      const response = await fetchFn(
+        new Request(
+          request.url.replace(':credentialId', parameters.credential.id),
+          request,
+        ),
+        {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: Json.stringify(parameters),
+        },
+      )
+
+      if (!response.ok)
+        throw new Error(`Failed to set public key: ${response.statusText}`)
+    },
+  })
+}
+
+export namespace http {
+  export type Options = {
+    /** Custom fetch function. @default `globalThis.fetch`. */
+    fetch?: typeof fetch | undefined
+  }
+}

package/src/wagmi/index.ts

@@ -1,3 +1,4 @@
 export * as Actions from './Actions/index.js'
 export { dangerous_secp256k1, webAuthn } from './Connector.js'
 export * as Hooks from './Hooks/index.js'
+export * as KeyManager from './KeyManager.js'