tapimo 0.0.2 → 0.2.0

package/src/handlers/internal/types.ts

@@ -0,0 +1,378 @@
+/** Combines members of an intersection into a readable type. */
+// https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+export type Compute<type> = { [key in keyof type]: type[key] } & unknown
+
+declare const symbol: unique symbol
+
+/**
+ * Creates a branded type of `T` with the brand `U`.
+ *
+ * @example
+ * ```ts
+ * type Result = Branded<string, 'foo'>
+ * //   ^? type Result = string & { [symbol]: 'foo' }
+ * ```
+ */
+export type Branded<T, U> = T & { [symbol]: U }
+
+/**
+ * Filters out all members of `T` that are not `P`
+ *
+ * @example
+ * ```ts
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ * ```
+ *
+ * @internal
+ */
+export type Filter<
+  T extends readonly unknown[],
+  P,
+  Acc extends readonly unknown[] = [],
+> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
+  ? [F] extends [P]
+    ? Filter<Rest, P, [...Acc, F]>
+    : Filter<Rest, P, Acc>
+  : readonly [...Acc]
+
+/**
+ * Checks if `T` can be narrowed further than `U`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ * ```
+ */
+export type IsNarrowable<T, U> =
+  IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true ? false : true
+
+/**
+ * Checks if `T` is `never`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+
+/**
+ * Removes `readonly` from all properties of an object.
+ *
+ * @internal
+ */
+export type Mutable<type extends object> = {
+  -readonly [key in keyof type]: type[key]
+}
+
+/**
+ * Evaluates boolean "or" condition for `T` properties.
+ *
+ * * @example
+ * ```ts
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ * ```
+ *
+ * @internal
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Tail]
+  ? Head extends true
+    ? true
+    : Or<Tail>
+  : false
+
+/**
+ * Checks if `T` is `undefined`
+ *
+ * @example
+ * ```ts
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @internal
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false
+
+/**
+ * Checks if type `T` is the `unknown` type.
+ *
+ * @internal
+ */
+export type IsUnknown<T> = unknown extends T ? ([T] extends [null] ? false : true) : false
+
+/** @internal */
+export type MaybePromise<T> = T | Promise<T>
+
+/**
+ * Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * ```ts
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * // { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * // { a: string, b?: number }
+ * ```
+ *
+ * @internal
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true
+  ? ExactRequired<T>
+  : T
+
+/**
+ * Assigns the properties of U onto T.
+ *
+ * @example
+ * ```ts
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * // { a: undefined, b: number, c: boolean }
+ * ```
+ *
+ * @internal
+ */
+export type Assign<T, U> = Assign_inner<T, U> & U
+
+/** @internal */
+export type Assign_inner<T, U> = {
+  [K in keyof T as K extends keyof U ? (U[K] extends void ? never : K) : K]: K extends keyof U
+    ? U[K]
+    : T[K]
+}
+
+/**
+ * Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * ```ts
+ * NoUndefined<string | undefined>
+ * // string
+ * ```
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T
+
+/**
+ * Strict version of built-in Omit type
+ *
+ * @internal
+ */
+export type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * // { a?: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & ExactPartial<Pick<T, K>>
+
+export type RecursiveArray<T> = T | readonly RecursiveArray<T>[]
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * // { a: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & ExactRequired<Pick<T, K>>
+
+/**
+ * Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * ```ts
+ * Some<[1, 2, 3], 2>
+ * // true
+ * ```
+ *
+ * @internal
+ */
+export type Some<array extends readonly unknown[], value> = array extends readonly [
+  value,
+  ...unknown[],
+]
+  ? true
+  : array extends readonly [unknown, ...infer rest]
+    ? Some<rest, value>
+    : false
+
+/**
+ * Prints custom error message
+ *
+ * @param messages - Error message
+ * @returns Custom error message
+ *
+ * @example
+ * ```ts
+ * type Result = TypeErrorMessage<'Custom error message'>
+ * //   ^? type Result = ['Error: Custom error message']
+ * ```
+ */
+export type TypeErrorMessage<messages extends string | string[]> = messages extends string
+  ? [
+      // Surrounding with array to prevent `messages` from being widened to `string`
+      `Error: ${messages}`,
+    ]
+  : {
+      [key in keyof messages]: messages[key] extends infer message extends string
+        ? `Error: ${message}`
+        : never
+    }
+
+/** @internal */
+export type UnionToTuple<
+  union,
+  ///
+  last = LastInUnion<union>,
+> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last]
+
+/** @internal */
+export type LastInUnion<U> =
+  UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer l) => 0 ? l : never
+
+/** @internal */
+export type UnionToIntersection<union> = (
+  union extends unknown ? (arg: union) => 0 : never
+) extends (arg: infer i) => 0
+  ? i
+  : never
+
+/** @internal */
+export type IsUnion<
+  union,
+  ///
+  union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never
+
+/** @internal */
+export type MaybePartial<type, enabled extends boolean | undefined> = enabled extends true
+  ? Compute<ExactPartial<type>>
+  : type
+
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined
+}
+
+/** @internal */
+export type ExactRequired<type> = {
+  [key in keyof type]-?: Exclude<type[key], undefined>
+}
+
+export type OneOf<
+  union extends object,
+  fallback extends object | undefined = undefined,
+  ///
+  keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer item
+  ? Compute<
+      item & {
+        [key in Exclude<keys, keyof item>]?: fallback extends object
+          ? key extends keyof fallback
+            ? fallback[key]
+            : undefined
+          : undefined
+      }
+    >
+  : never
+
+/** @internal */
+export type KeyofUnion<type> = type extends type ? keyof type : never
+
+/** @internal */
+export type Undefined<type> = {
+  [key in keyof type]?: undefined
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/**
+ * Loose version of {@link Omit}
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<type, Exclude<keyof type, keys>>
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+/** @internal */
+export type UnionCompute<type> = type extends object ? Compute<type> : type
+
+/** @internal */
+export type UnionLooseOmit<type, keys extends string> = type extends any
+  ? LooseOmit<type, keys>
+  : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionOmit<type, keys extends keyof type> = type extends any ? Omit<type, keys> : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any ? Pick<type, keys> : never
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any ? PartialBy<T, K> : never
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * // { a: string, b: number } | { a: string, c?: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any ? RequiredBy<T, K> : never

package/src/handlers/internal/utils.ts

@@ -0,0 +1,153 @@
+import { Hex, RpcRequest, RpcResponse } from 'ox'
+import { KeyAuthorization, Transaction as core_Transaction, TxEnvelopeTempo } from 'ox/tempo'
+import { type Client, BaseError } from 'viem'
+import * as z from 'zod/mini'
+
+export function resolveChainId(value: unknown) {
+  if (typeof value === 'number') return value
+  if (typeof value === 'bigint') return Number(value)
+  if (typeof value === 'string') {
+    if (Hex.validate(value)) return Hex.toNumber(value)
+    const n = Number(value)
+    if (Number.isFinite(n)) return n
+  }
+  return undefined
+}
+
+export function formatFillTransactionRequest(client: Client, value: Record<string, unknown>) {
+  const format = client.chain?.formatters?.transactionRequest?.format
+  if (!format) return value
+  return format({ ...value } as never, 'fillTransaction') as Record<string, unknown>
+}
+
+export function normalizeFillTransactionRequest(
+  tx: Record<string, unknown>,
+): Record<string, unknown> & { calls: unknown[] } {
+  const { to, data, value, ...rest } = tx
+  const keyAuthorization = normalizeKeyAuthorization(tx['keyAuthorization'])
+  const withKeyAuthorization = keyAuthorization ? { keyAuthorization } : {}
+  if (Array.isArray(tx['calls']) && tx['calls'].length > 0)
+    return {
+      ...tx,
+      ...withKeyAuthorization,
+      calls: tx['calls'].map((call) => ({
+        ...call,
+        value: normalizeFillValue(call.value),
+      })),
+    }
+  const call = {
+    ...(typeof to !== 'undefined' ? { to } : {}),
+    ...(typeof data !== 'undefined' ? { data } : {}),
+    ...(typeof value !== 'undefined' ? { value: normalizeFillValue(value) } : {}),
+  }
+  return { ...rest, ...withKeyAuthorization, calls: [call] }
+}
+
+/**
+ * Forwards `keyAuthorization` to the chain in RPC shape. Pass-through
+ * when already RPC; convert via `KeyAuthorization.toRpc` when internal.
+ */
+function normalizeKeyAuthorization(value: unknown) {
+  if (!value || typeof value !== 'object') return undefined
+  const ka = value as Record<string, unknown>
+  const signature = ka['signature'] as Record<string, unknown> | undefined
+  if (!signature || typeof signature !== 'object') return undefined
+  const isInternal = typeof signature['signature'] === 'object' && signature['signature'] !== null
+  return isInternal ? KeyAuthorization.toRpc(value as never) : value
+}
+
+function normalizeFillValue(value: unknown) {
+  if (typeof value !== 'string' || !value.startsWith('0x')) return value
+  return BigInt(value === '0x' ? '0x0' : value)
+}
+
+/** Returns whether a raw transaction uses a Tempo sender or fee-payer wire prefix. */
+export function isSerializedTempoTransaction(
+  value: unknown,
+): value is `0x76${string}` | `0x78${string}` {
+  if (typeof value !== 'string') return false
+  // `0x78` is Tempo's fee-payer handoff magic, not a separate EIP-2718 type.
+  return (
+    value.startsWith(TxEnvelopeTempo.serializedType) ||
+    value.startsWith(TxEnvelopeTempo.feePayerMagic)
+  )
+}
+
+export function normalizeTempoTransaction(value: Record<string, unknown> | undefined) {
+  if (!value) throw new Error('Expected `tx` in eth_fillTransaction response.')
+  return core_Transaction.fromRpc({ type: '0x76', ...value } as core_Transaction.Rpc)!
+}
+
+/** Returns a raw JSON-RPC error response object (not wrapped in a `Response`). */
+export function rpcErrorJson(request: RpcRequest.RpcRequest, error: unknown) {
+  if (error instanceof RpcResponse.InvalidParamsError)
+    return RpcResponse.from({ error }, { request })
+
+  if (error instanceof RpcResponse.MethodNotSupportedError)
+    return RpcResponse.from({ error }, { request })
+
+  if ((error as { name?: string | undefined }).name === 'ZodError')
+    return RpcResponse.from(
+      {
+        error: new RpcResponse.InvalidParamsError({
+          message: (error as Error).message,
+        }),
+      },
+      { request },
+    )
+
+  const inner = resolveError(error)
+  const message = inner.message ?? (error as Error).message
+  const code = inner.code ?? -32603
+  const data = inner.data
+  return RpcResponse.from(
+    {
+      error: { code, message, ...(data ? { data } : {}) },
+    },
+    { request },
+  )
+}
+
+export function rpcError(request: RpcRequest.RpcRequest, error: unknown) {
+  return Response.json(rpcErrorJson(request, error))
+}
+
+export function rpcResult(request: RpcRequest.RpcRequest, result: unknown) {
+  return Response.json(RpcResponse.from({ result }, { request }))
+}
+
+export const parseParams = z.readonly(z.tuple([z.record(z.string(), z.unknown())]))
+
+function resolveError(error: unknown): {
+  message?: string | undefined
+  code?: number | undefined
+  data?: unknown
+} {
+  if (!error || typeof error !== 'object') return {}
+  // Walk the `cause` chain to the deepest object that looks like an upstream
+  // JSON-RPC error (`{ code, message }`). This unwraps viem's
+  // `RpcRequestError`, whose own `message` is the verbose
+  // "RPC Request failed.\nURL: …\nRequest body: …" formatting, and surfaces
+  // the raw upstream error instead.
+  let deepest:
+    | { message?: string | undefined; code?: number | undefined; data?: unknown }
+    | undefined
+  let current: unknown = error
+  const seen = new Set<unknown>()
+  while (current && typeof current === 'object' && !seen.has(current)) {
+    seen.add(current)
+    const e = current as Record<string, unknown>
+    if (typeof e['code'] === 'number' && typeof e['message'] === 'string')
+      deepest = { code: e['code'], message: e['message'], data: e['data'] }
+    current = e['cause']
+  }
+  if (deepest) return deepest
+  if (error instanceof BaseError) {
+    const inner = error.walk(
+      (e) => typeof (e as Record<string, unknown>)['code'] === 'number',
+    ) as Record<string, unknown> | null
+    if (inner && typeof inner['code'] === 'number' && typeof inner['message'] === 'string')
+      return { message: inner['message'], code: inner['code'], data: inner['data'] }
+  }
+  return {}
+}