tempo.ts 0.6.2 → 0.7.0

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'