rise-wallet 0.1.4-beta.2 → 0.2.29-beta.1

package/src/server/Route.ts

@@ -0,0 +1,259 @@
+import { type Env, type ExecutionContext, Hono } from 'hono'
+import { cors } from 'hono/cors'
+import { poweredBy } from 'hono/powered-by'
+import type { BlankEnv, BlankSchema, Schema as hono_Schema } from 'hono/types'
+import type * as Address from 'ox/Address'
+import type * as Hex from 'ox/Hex'
+import * as RpcResponse from 'ox/RpcResponse'
+import { createClient, rpcSchema } from 'viem'
+import * as z from 'zod/mini'
+import type * as RpcSchema_relay from '../core/internal/relay/rpcSchema.js'
+import type { MaybePromise, OneOf } from '../core/internal/types.js'
+import * as Porto from '../core/Porto.js'
+import * as Key from '../viem/Key.js'
+import * as MerchantSchema from './internal/merchantSchema.js'
+import * as RequestListener from './internal/requestListener.js'
+
+/**
+ * Creates a new Route.
+ *
+ * @param options - constructor options
+ * @returns Route instance
+ */
+export function from<
+  env extends Env = BlankEnv,
+  schema extends hono_Schema = BlankSchema,
+  basePath extends string = '/',
+>(options: from.Options<basePath> = {}) {
+  return new from.Inner<env, schema, basePath>(options)
+}
+
+export namespace from {
+  export type Options<basePath extends string = '/'> =
+    Inner.ConstructorOptions<basePath>
+
+  export class Inner<
+    env extends Env = BlankEnv,
+    schema extends hono_Schema = BlankSchema,
+    basePath extends string = '/',
+  > {
+    hono: Hono<env, schema, basePath>
+
+    /**
+     * Creates a new Handler instance.
+     *
+     * @param options - constructor options
+     */
+    constructor(options: Inner.ConstructorOptions<basePath> = {}) {
+      const hono = new Hono<env, schema, basePath>().basePath(
+        options.basePath ?? '/',
+      )
+      hono.use('*', cors(options.cors))
+      hono.use('*', poweredBy({ serverName: 'Porto' }))
+
+      this.hono = hono
+    }
+
+    /**
+     * Returns a Fetch API compatible handler, used to serve requests.
+     *
+     * @param request - request object
+     * @param env - env object
+     * @param executionCtx - context of execution
+     * @returns response object
+     *
+     */
+    fetch = (
+      request: Request,
+      env?: env['Bindings'] | {} | undefined,
+      executionCtx?: ExecutionContext | undefined,
+    ) => {
+      return this.hono.fetch(request, env, executionCtx)
+    }
+
+    /**
+     * 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)
+     *
+     * @returns A Node.js request listener function.
+     */
+    get listener() {
+      return RequestListener.fromFetchHandler(this.fetch)
+    }
+  }
+
+  export declare namespace Inner {
+    type ConstructorOptions<basePath extends string = '/'> = {
+      /**
+       * Base path of the request handler.
+       */
+      basePath?: basePath | string | undefined
+      /**
+       * CORS configuration.
+       */
+      cors?: Parameters<typeof cors>[0] | undefined
+    }
+  }
+}
+
+/**
+ * Defines a Merchant RPC request handler. This will return a function that
+ * accepts a [Fetch API `Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+ * instance and returns a [Fetch API `Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+ * instance.
+ *
+ * @param options - Options.
+ * @returns Request handler.
+ */
+export function merchant(options: merchant.Options) {
+  const { address, basePath, relay = Porto.defaultConfig.relay } = options
+
+  const client = createClient({
+    rpcSchema: rpcSchema<RpcSchema_relay.Viem>(),
+    transport: relay,
+  })
+
+  const fromKey = (() => {
+    if (typeof options.key === 'string') return undefined
+    if (options.key.type === 'secp256k1') return Key.fromSecp256k1
+    if (options.key.type === 'p256') return Key.fromP256
+    throw new Error('unsupported key type')
+  })()
+  const key = fromKey
+    ? fromKey(options.key as never)
+    : Key.fromSecp256k1({
+        privateKey: options.key as Hex.Hex,
+      })
+
+  const router = from({ basePath })
+
+  router.hono.get('/', (c) => c.text('ok'))
+
+  router.hono.post('/', async (c) => {
+    let request: MerchantSchema.JsonRpcRequest = await c.req.json()
+    try {
+      request = MerchantSchema.validate(MerchantSchema.JsonRpcRequest, request)
+    } catch (e) {
+      const error = e as RpcResponse.ErrorObject
+      return c.json(
+        RpcResponse.from(
+          {
+            error: {
+              code: error.code,
+              message: error.message,
+            },
+          },
+          { request },
+        ),
+      )
+    }
+
+    switch (request.method) {
+      case 'wallet_prepareCalls': {
+        const sponsor = (() => {
+          if (typeof options.sponsor === 'function')
+            return options.sponsor(request.params[0]! as never)
+          if (typeof options.sponsor === 'boolean') return options.sponsor
+          return true
+        })()
+
+        try {
+          const result = await client.request({
+            ...request,
+            params: [
+              {
+                ...request.params[0]!,
+                capabilities: {
+                  ...request.params[0]!.capabilities,
+                  meta: {
+                    ...request.params[0]!.capabilities.meta,
+                    ...(sponsor
+                      ? {
+                          feePayer: address,
+                        }
+                      : {}),
+                  },
+                },
+              },
+            ],
+          })
+          const { capabilities } = z.decode(
+            MerchantSchema.wallet_prepareCalls.Response,
+            result,
+          )
+          const { feePayerDigest } = capabilities
+          if (!feePayerDigest) throw new Error('`feePayerDigest` is required')
+
+          const signature = sponsor
+            ? await Key.sign(key, {
+                address: null,
+                payload: feePayerDigest,
+              })
+            : undefined
+
+          const response = RpcResponse.from(
+            {
+              result: {
+                ...result,
+                capabilities: {
+                  ...result.capabilities,
+                  ...(sponsor
+                    ? {
+                        feeSignature: signature,
+                      }
+                    : {}),
+                },
+              },
+            },
+            { request },
+          )
+
+          return c.json(response)
+        } catch (e) {
+          const error = (() => {
+            const error = RpcResponse.parseError(e as Error)
+            if (error.cause && 'code' in error.cause && error.cause.code === 3)
+              return error.cause as any
+            return error
+          })()
+          return c.json(RpcResponse.from({ error }, { request }))
+        }
+      }
+
+      default: {
+        const error = new RpcResponse.MethodNotSupportedError()
+        return c.json(RpcResponse.from({ error }, { request }))
+      }
+    }
+  })
+
+  return router
+}
+
+export declare namespace merchant {
+  export type Options = {
+    /** Address of the Merchant Account. */
+    address: Address.Address
+    /** Base path of the request handler. */
+    basePath?: string | undefined
+    /** An Admin Key of the Merchant Account to use for signing. */
+    key:
+      | Hex.Hex
+      | (Pick<OneOf<Key.Secp256k1Key | Key.P256Key>, 'type'> & {
+          privateKey: Hex.Hex
+        })
+    /** Whether to sponsor calls or not, and the condition to do so. */
+    sponsor?:
+      | boolean
+      | ((
+          request: MerchantSchema.wallet_prepareCalls.Parameters,
+        ) => MaybePromise<boolean>)
+      | undefined
+    /** Relay transport override. */
+    relay?: Porto.Config['relay'] | undefined
+  }
+}

package/src/server/Router.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from 'vitest'
+import * as Key from '../viem/Key.js'
+import * as Route from './Route.js'
+import { Router } from './Router.js'
+
+test('default', async () => {
+  const router = Router()
+  const response = await router.hono.request('http://localhost')
+
+  expect(response.status).toBe(200)
+  expect(response.headers.get('access-control-allow-origin')).toBe('*')
+  expect(await response.text()).toMatchInlineSnapshot(`
+      "
+      █▀█ █▀█ █▀█ ▀█▀ █▀█
+      █▀▀ █▄█ █▀▄  █  █▄█
+      "
+    `)
+})
+
+test('behavior: route', async () => {
+  const key = Key.createSecp256k1()
+  const router = Router().route(
+    '/merchant',
+    Route.merchant({
+      address: '0x0000000000000000000000000000000000000000',
+      key: key.privateKey!(),
+    }),
+  )
+  const response = await router.hono.request('http://localhost/merchant')
+  expect(response.status).toBe(200)
+  expect(await response.text()).toMatchInlineSnapshot(`"ok"`)
+})

package/src/server/Router.ts

@@ -0,0 +1,59 @@
+import type { Env } from 'hono'
+import type { BlankEnv, BlankSchema, Schema } from 'hono/types'
+import * as Route from './Route.js'
+
+export function Router<
+  env extends Env = BlankEnv,
+  schema extends Schema = BlankSchema,
+  basePath extends string = '/',
+>(options: Router.Options<basePath> = {}) {
+  const handler = new Router.Inner<env, schema, basePath>(options)
+  handler.hono.get('/', (c) =>
+    c.text(`
+█▀█ █▀█ █▀█ ▀█▀ █▀█
+█▀▀ █▄█ █▀▄  █  █▄█
+`),
+  )
+  return handler
+}
+
+export namespace Router {
+  export type Options<basePath extends string = '/'> = Omit<
+    Inner.ConstructorOptions<basePath>,
+    'defaultPath'
+  >
+
+  export class Inner<
+    env extends Env = BlankEnv,
+    schema extends Schema = BlankSchema,
+    basePath extends string = '/',
+  > extends Route.from.Inner<env, schema, basePath> {
+    /**
+     * `.route()` allows grouping other Porto handlers in routes.
+     *
+     * @example
+     * TODO
+     *
+     * @param path - base Path
+     * @param app - other Porto handler
+     * @returns routed Porto handler
+     */
+    route<
+      path extends string,
+      env extends Env,
+      schema extends Schema,
+      subBasePath extends string,
+    >(
+      path: path,
+      app: Route.from.Inner<env, schema, subBasePath>,
+    ): Inner<env, schema, subBasePath> {
+      this.hono.route(path, app.hono)
+      return this as never
+    }
+  }
+
+  export declare namespace Inner {
+    type ConstructorOptions<basePath extends string = '/'> =
+      Route.from.Inner.ConstructorOptions<basePath>
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,2 @@
+export * as Route from './Route.js'
+export { Router } from './Router.js'

package/src/server/internal/merchantSchema.ts

@@ -0,0 +1,11 @@
+import * as z from 'zod/mini'
+import * as Rpc_relay from '../../core/internal/relay/schema/rpc.js'
+import * as RpcRequest from '../../core/internal/schema/request.js'
+
+export { wallet_prepareCalls } from '../../core/internal/relay/schema/rpc.js'
+export { validate } from '../../core/internal/schema/request.js'
+
+export const JsonRpcRequest = RpcRequest.schemaWithJsonRpc(
+  z.discriminatedUnion('method', [Rpc_relay.wallet_prepareCalls.Request]),
+)
+export type JsonRpcRequest = RpcRequest.WithDecoded<typeof JsonRpcRequest>

package/src/server/internal/requestListener.ts

@@ -0,0 +1,284 @@
+// 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.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>