accounts 0.3.0 → 0.4.1

package/src/server/internal/requestListener.ts

@@ -0,0 +1,273 @@
+// @ts-nocheck
+// Credit: https://github.com/mjackson/remix-the-web/blob/main/packages/node-fetch-server/src/lib/request-listener.ts
+
+import type * as http from 'node:http'
+import type * as http2 from 'node:http2'
+
+export interface RequestListenerOptions {
+  /**
+   * Overrides the host portion of the incoming request URL. By default the request URL host is
+   * derived from the HTTP `Host` header.
+   *
+   * For example, if you have a `$HOST` environment variable that contains the hostname of your
+   * server, you can use it to set the host of all incoming request URLs like so:
+   *
+   * ```ts
+   * createRequestListener(handler, { host: process.env.HOST })
+   * ```
+   */
+  host?: string
+  /**
+   * An error handler that determines the response when the request handler throws an error. By
+   * default a 500 Internal Server Error response will be sent.
+   */
+  onError?: ErrorHandler
+  /**
+   * Overrides the protocol of the incoming request URL. By default the request URL protocol is
+   * derived from the connection protocol. So e.g. when serving over HTTPS (using
+   * `https.createServer()`), the request URL will begin with `https:`.
+   */
+  protocol?: string
+}
+
+/**
+ * Wraps a fetch handler in a Node.js request listener that can be used with:
+ *
+ * - [`http.createServer()`](https://nodejs.org/api/http.html#httpcreateserveroptions-requestlistener)
+ * - [`https.createServer()`](https://nodejs.org/api/https.html#httpscreateserveroptions-requestlistener)
+ * - [`http2.createServer()`](https://nodejs.org/api/http2.html#http2createserveroptions-onrequesthandler)
+ * - [`http2.createSecureServer()`](https://nodejs.org/api/http2.html#http2createsecureserveroptions-onrequesthandler)
+ *
+ * Example:
+ *
+ * ```ts
+ * import * as http from 'node:http';
+ * import { createRequestListener } from '@mjackson/node-fetch-server';
+ *
+ * async function handler(request) {
+ *   return new Response('Hello, world!');
+ * }
+ *
+ * let server = http.createServer(
+ *   createRequestListener(handler)
+ * );
+ *
+ * server.listen(3000);
+ * ```
+ *
+ * @param handler The fetch handler to use for processing incoming requests.
+ * @param options Request listener options.
+ * @returns A Node.js request listener function.
+ */
+export function fromFetchHandler(
+  handler: FetchHandler,
+  options?: RequestListenerOptions,
+): http.RequestListener {
+  const onError = options?.onError ?? defaultErrorHandler
+
+  return async (req, res) => {
+    const request = createRequest(req, res, options)
+    const client = {
+      address: req.socket.remoteAddress!,
+      family: req.socket.remoteFamily! as ClientAddress['family'],
+      port: req.socket.remotePort!,
+    }
+
+    let response: Response
+    try {
+      response = await handler(request, client)
+    } catch (error) {
+      try {
+        response = (await onError(error)) ?? internalServerError()
+      } catch (error) {
+        console.error(`There was an error in the error handler: ${error}`)
+        response = internalServerError()
+      }
+    }
+
+    await sendResponse(res, response)
+  }
+}
+
+function defaultErrorHandler(error: unknown): Response {
+  console.error(error)
+  return internalServerError()
+}
+
+function internalServerError(): Response {
+  return new Response(
+    // "Internal Server Error"
+    new Uint8Array([
+      73, 110, 116, 101, 114, 110, 97, 108, 32, 83, 101, 114, 118, 101, 114, 32, 69, 114, 114, 111,
+      114,
+    ]),
+    {
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+      status: 500,
+    },
+  )
+}
+
+export type RequestOptions = Omit<RequestListenerOptions, 'onError'>
+
+/**
+ * Creates a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request) object from
+ *
+ * - a [`http.IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage)/[`http.ServerResponse`](https://nodejs.org/api/http.html#class-httpserverresponse) pair
+ * - a [`http2.Http2ServerRequest`](https://nodejs.org/api/http2.html#class-http2http2serverrequest)/[`http2.Http2ServerResponse`](https://nodejs.org/api/http2.html#class-http2http2serverresponse) pair
+ *
+ * @param req The incoming request object.
+ * @param res The server response object.
+ * @param options
+ * @returns A request object.
+ */
+export function createRequest(
+  req: http.IncomingMessage | http2.Http2ServerRequest,
+  res: http.ServerResponse | http2.Http2ServerResponse,
+  options?: RequestOptions,
+): Request {
+  const controller = new AbortController()
+  res.on('close', () => {
+    controller.abort()
+  })
+
+  const method = req.method ?? 'GET'
+  const headers = createHeaders(req)
+
+  const protocol =
+    options?.protocol ?? ('encrypted' in req.socket && req.socket.encrypted ? 'https:' : 'http:')
+  const host = options?.host ?? headers.get('Host') ?? 'localhost'
+  const url = new URL(req.url!, `${protocol}//${host}`)
+
+  const init: RequestInit = { headers, method, signal: controller.signal }
+
+  if (method !== 'GET' && method !== 'HEAD') {
+    init.body = new ReadableStream({
+      start(controller) {
+        req.on('data', (chunk) => {
+          controller.enqueue(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength))
+        })
+        req.on('end', () => {
+          controller.close()
+        })
+      },
+    })
+
+    // init.duplex = 'half' must be set when body is a ReadableStream, and Node follows the spec.
+    // However, this property is not defined in the TypeScript types for RequestInit, so we have
+    // to cast it here in order to set it without a type error.
+    // See https://fetch.spec.whatwg.org/#dom-requestinit-duplex
+    ;(init as { duplex: 'half' }).duplex = 'half'
+  }
+
+  return new Request(url, init)
+}
+
+/**
+ * Creates a [`Headers`](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object from the headers in a Node.js
+ * [`http.IncomingMessage`](https://nodejs.org/api/http.html#class-httpincomingmessage)/[`http2.Http2ServerRequest`](https://nodejs.org/api/http2.html#class-http2http2serverrequest).
+ *
+ * @param req The incoming request object.
+ * @returns A headers object.
+ */
+export function createHeaders(req: http.IncomingMessage | http2.Http2ServerRequest): Headers {
+  const headers = new Headers()
+
+  const rawHeaders = req.rawHeaders
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    if (rawHeaders[i]?.startsWith(':')) continue
+    headers.append(rawHeaders[i]!, rawHeaders[i + 1]!)
+  }
+
+  return headers
+}
+
+/**
+ * Sends a [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) to the client using a Node.js
+ * [`http.ServerResponse`](https://nodejs.org/api/http.html#class-httpserverresponse)/[`http2.Http2ServerResponse`](https://nodejs.org/api/http2.html#class-http2http2serverresponse)
+ * object.
+ *
+ * @param res The server response object.
+ * @param response The response to send.
+ */
+export async function sendResponse(
+  res: http.ServerResponse | http2.Http2ServerResponse,
+  response: Response,
+): Promise<void> {
+  // Iterate over response.headers so we are sure to send multiple Set-Cookie headers correctly.
+  // These would incorrectly be merged into a single header if we tried to use
+  // `Object.fromEntries(response.headers.entries())`.
+  const headers: Record<string, string | string[]> = {}
+  for (const [key, value] of response.headers as any) {
+    if (key in headers) {
+      if (Array.isArray(headers[key])) {
+        headers[key].push(value)
+      } else {
+        headers[key] = [headers[key] as string, value]
+      }
+    } else {
+      headers[key] = value
+    }
+  }
+
+  ;(res as any).writeHead(response.status, headers)
+
+  if (response.body != null && res.req.method !== 'HEAD') {
+    for await (const chunk of readStream(response.body)) {
+      // @ts-expect-error - Node typings for http2 require a 2nd parameter to write but it's optional
+      res.write(chunk)
+    }
+  }
+
+  res.end()
+}
+
+export async function* readStream(stream: ReadableStream<Uint8Array>): AsyncIterable<Uint8Array> {
+  const reader = stream.getReader()
+
+  while (true) {
+    const { done, value } = await reader.read()
+    if (done) break
+    yield value
+  }
+}
+
+export interface ClientAddress {
+  /**
+   * The IP address of the client that sent the request.
+   *
+   * [Node.js Reference](https://nodejs.org/api/net.html#socketremoteaddress)
+   */
+  address: string
+  /**
+   * The family of the client IP address.
+   *
+   * [Node.js Reference](https://nodejs.org/api/net.html#socketremotefamily)
+   */
+  family: 'IPv4' | 'IPv6'
+  /**
+   * The remote port of the client that sent the request.
+   *
+   * [Node.js Reference](https://nodejs.org/api/net.html#socketremoteport)
+   */
+  port: number
+}
+
+/**
+ * A function that handles an error that occurred during request handling. May return a response to
+ * send to the client, or `undefined` to allow the server to send a default error response.
+ *
+ * [MDN `Response` Reference](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ */
+export type ErrorHandler = (error: unknown) => undefined | Response | Promise<undefined | Response>
+
+/**
+ * A function that handles an incoming request and returns a response.
+ *
+ * [MDN `Request` Reference](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ *
+ * [MDN `Response` Reference](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ */
+export type FetchHandler = (request: Request, client: ClientAddress) => Response | Promise<Response>

package/src/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.base.json",
+  "exclude": ["./**/*.test.ts"],
+  "compilerOptions": {
+    "customConditions": ["src"],
+    "moduleResolution": "nodenext",
+    "noEmit": true
+  }
+}

package/src/wagmi/Connector.ts

@@ -0,0 +1,287 @@
+import { ChainNotConfiguredError, type Connector, createConnector } from '@wagmi/core'
+import {
+  type Address,
+  numberToHex,
+  type RpcError,
+  SwitchChainError,
+  UserRejectedRequestError,
+} from 'viem'
+import * as z from 'zod/mini'
+
+import { dialog as core_dialog } from '../core/adapters/dialog.js'
+import { webAuthn as webAuthn_adapter } from '../core/adapters/webAuthn.js'
+import * as Provider from '../core/Provider.js'
+import * as Rpc from '../core/zod/rpc.js'
+
+/**
+ * Creates a wagmi connector backed by an accounts provider.
+ */
+export function setup(parameters: setup.Parameters = {} as setup.Parameters) {
+  type Properties = {
+    connect<withCapabilities extends boolean = false>(parameters?: {
+      capabilities?:
+        | NonNullable<z.output<typeof Rpc.wallet_connect.capabilities.request>>
+        | undefined
+      chainId?: number | undefined
+      isReconnecting?: boolean | undefined
+      withCapabilities?: withCapabilities | boolean | undefined
+    }): Promise<{
+      accounts: withCapabilities extends true
+        ? readonly {
+            address: Address
+            capabilities: z.output<typeof Rpc.wallet_connect.capabilities.result>
+          }[]
+        : readonly Address[]
+      chainId: number
+    }>
+  }
+  return createConnector<Provider.Provider, Properties>((wagmiConfig) => {
+    const chains = wagmiConfig.chains
+
+    let provider: Provider.Provider | undefined
+
+    let accountsChanged: Connector['onAccountsChanged'] | undefined
+    let chainChanged: Connector['onChainChanged'] | undefined
+    let connect: Connector['onConnect'] | undefined
+    let disconnect: Connector['onDisconnect'] | undefined
+
+    return {
+      async connect(params: Parameters<Properties['connect']>[0] = {}) {
+        const { isReconnecting, withCapabilities } = params
+        const capabilities = 'capabilities' in params ? params.capabilities : undefined
+
+        let accounts: readonly { address: Address; capabilities: Record<string, unknown> }[] = []
+        let currentChainId: number | undefined
+
+        if (isReconnecting)
+          accounts = await this.getAccounts()
+            .then((accounts) => accounts.map((address) => ({ address, capabilities: {} })))
+            .catch(() => [])
+
+        const provider = (await this.getProvider()) as Provider.create.ReturnType
+
+        try {
+          if (!accounts?.length && !isReconnecting) {
+            const res = await provider.request({
+              method: 'wallet_connect',
+              params: [
+                capabilities
+                  ? {
+                      capabilities: z.encode(Rpc.wallet_connect.capabilities.request, capabilities),
+                    }
+                  : {},
+              ] as never,
+            })
+            accounts = res.accounts
+          }
+
+          currentChainId ??= await this.getChainId()
+          if (!currentChainId) throw new ChainNotConfiguredError()
+
+          if (connect) {
+            provider.removeListener('connect', connect)
+            connect = undefined
+          }
+          if (!accountsChanged) {
+            accountsChanged = this.onAccountsChanged.bind(this)
+            provider.on('accountsChanged', accountsChanged as never)
+          }
+          if (!chainChanged) {
+            chainChanged = this.onChainChanged.bind(this)
+            provider.on('chainChanged', chainChanged!)
+          }
+          if (!disconnect) {
+            disconnect = this.onDisconnect.bind(this)
+            provider.on('disconnect', disconnect!)
+          }
+
+          return {
+            accounts: (withCapabilities ? accounts : accounts.map((a) => a.address)) as never,
+            chainId: currentChainId,
+          }
+        } catch (err) {
+          const error = err as RpcError
+          if (error.code === UserRejectedRequestError.code)
+            throw new UserRejectedRequestError(error)
+          throw error
+        }
+      },
+      async disconnect() {
+        const provider = (await this.getProvider()) as Provider.create.ReturnType
+
+        if (chainChanged) {
+          provider.removeListener('chainChanged', chainChanged)
+          chainChanged = undefined
+        }
+        if (disconnect) {
+          provider.removeListener('disconnect', disconnect)
+          disconnect = undefined
+        }
+        if (!connect) {
+          connect = this.onConnect?.bind(this)
+          if (connect) provider.on('connect', connect as never)
+        }
+
+        await provider.request({ method: 'wallet_disconnect' })
+      },
+      async getAccounts() {
+        const provider = (await this.getProvider()) as Provider.create.ReturnType
+        return provider.request({ method: 'eth_accounts' })
+      },
+      async getChainId() {
+        const provider = (await this.getProvider()) as Provider.create.ReturnType
+        const hexChainId = await provider.request({ method: 'eth_chainId' })
+        return Number(hexChainId)
+      },
+      async getProvider() {
+        provider ??= Provider.create({
+          ...parameters,
+          chains: chains as never,
+        })
+        return provider as never
+      },
+      icon: parameters.adapter?.icon,
+      id: parameters.adapter?.rdns ?? 'com.example',
+      async isAuthorized() {
+        try {
+          const accounts = await this.getAccounts()
+          return !!accounts.length
+        } catch {
+          return false
+        }
+      },
+      name: parameters.adapter?.name ?? 'Accounts',
+      async onAccountsChanged(accounts) {
+        wagmiConfig.emitter.emit('change', {
+          accounts: accounts as readonly Address[],
+        })
+      },
+      onChainChanged(chain) {
+        const chainId = Number(chain)
+        wagmiConfig.emitter.emit('change', { chainId })
+      },
+      async onConnect(connectInfo) {
+        const accounts = await this.getAccounts()
+        if (accounts.length === 0) return
+
+        const chainId = Number(connectInfo.chainId)
+        wagmiConfig.emitter.emit('connect', { accounts, chainId })
+
+        const provider = (await this.getProvider()) as Provider.create.ReturnType
+        if (connect) {
+          provider.removeListener('connect', connect)
+          connect = undefined
+        }
+        if (!accountsChanged) {
+          accountsChanged = this.onAccountsChanged.bind(this)
+          provider.on('accountsChanged', accountsChanged as never)
+        }
+        if (!chainChanged) {
+          chainChanged = this.onChainChanged.bind(this)
+          provider.on('chainChanged', chainChanged!)
+        }
+        if (!disconnect) {
+          disconnect = this.onDisconnect.bind(this)
+          provider.on('disconnect', disconnect!)
+        }
+      },
+      async onDisconnect(_error) {
+        const provider = (await this.getProvider()) as Provider.create.ReturnType
+
+        wagmiConfig.emitter.emit('disconnect')
+
+        if (chainChanged) {
+          provider.removeListener('chainChanged', chainChanged)
+          chainChanged = undefined
+        }
+        if (disconnect) {
+          provider.removeListener('disconnect', disconnect)
+          disconnect = undefined
+        }
+        if (!connect) {
+          connect = this.onConnect?.bind(this)
+          if (connect) provider.on('connect', connect as never)
+        }
+      },
+      async setup() {
+        if (!connect) {
+          const provider = (await this.getProvider()) as Provider.create.ReturnType
+          connect = this.onConnect?.bind(this)
+          if (connect) provider.on('connect', connect as never)
+        }
+      },
+      async switchChain({ chainId }) {
+        const chain = chains.find((x) => x.id === chainId)
+        if (!chain) throw new SwitchChainError(new ChainNotConfiguredError())
+
+        const provider = (await this.getProvider()) as Provider.create.ReturnType
+        await provider.request({
+          method: 'wallet_switchEthereumChain',
+          params: [{ chainId: numberToHex(chainId) }],
+        })
+
+        return chain
+      },
+      type: 'injected',
+    }
+  })
+}
+
+export declare namespace setup {
+  type Parameters = Provider.create.Options
+}
+
+/**
+ * Creates a wagmi connector backed by a WebAuthn adapter.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from 'wagmi'
+ * import { tempoModerato } from 'wagmi/chains'
+ * import { webAuthn } from 'accounts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempoModerato],
+ *   connectors: [webAuthn()],
+ *   transports: { [tempoModerato.id]: http() },
+ * })
+ * ```
+ */
+export function webAuthn(options: webAuthn.Options = {}) {
+  const { ceremony, icon, name, rdns, ...rest } = options
+  return setup({
+    ...rest,
+    adapter: webAuthn_adapter({ ceremony, icon, name, rdns }),
+  })
+}
+
+export declare namespace webAuthn {
+  type Options = webAuthn_adapter.Options & Omit<setup.Parameters, 'adapter'>
+}
+
+/**
+ * Creates a wagmi connector backed by a dialog adapter.
+ *
+ * @example
+ * ```ts
+ * import { createConfig, http } from 'wagmi'
+ * import { tempoModerato } from 'wagmi/chains'
+ * import { dialog } from 'accounts/wagmi'
+ *
+ * const config = createConfig({
+ *   chains: [tempoModerato],
+ *   connectors: [dialog()],
+ *   transports: { [tempoModerato.id]: http() },
+ * })
+ * ```
+ */
+export function dialog(options: dialog.Options = {}) {
+  const { dialog: dialogOption, host, icon, name, rdns } = options
+  return setup({
+    adapter: core_dialog({ dialog: dialogOption, host, icon, name, rdns }),
+  })
+}
+
+export declare namespace dialog {
+  type Options = core_dialog.Options & Omit<setup.Parameters, 'adapter'>
+}

package/src/wagmi/index.ts

@@ -0,0 +1,2 @@
+export * as Connector from './Connector.js'
+export { dialog, dialog as tempoWallet, webAuthn } from './Connector.js'