accounts 0.5.5 → 0.5.7

package/src/server/Handler.ts

@@ -1,5 +1,6 @@
 import { Hono } from 'hono'
-import { Base64, Bytes, Hex, RpcRequest, RpcResponse } from 'ox'
+import { Base64, Bytes, Hex, RpcRequest, RpcResponse, Signature } from 'ox'
+import { Transaction as core_Transaction, TxEnvelopeTempo } from 'ox/tempo'
 import { Credential } from 'ox/webauthn'
 import { type Chain, type Client, createClient, http, type Transport } from 'viem'
 import type { LocalAccount } from 'viem/accounts'
@@ -15,7 +16,7 @@ import * as z from 'zod/mini'
 
 import * as CliAuth from './CliAuth.js'
 import * as RequestListener from './internal/requestListener.js'
-import type { Kv } from './Kv.js'
+import * as Kv from './Kv.js'
 
 export type Handler = Hono & {
   listener: (req: any, res: any) => void
@@ -228,7 +229,7 @@ export declare namespace from {
  *   chains: [tempo, tempoModerato],
  *   transports: {
  *     [tempo.id]: http('https://rpc.tempo.xyz'),
- *     [tempoModerato.id]: http('https://rpc.moderato.tempo.xyz'),
+ *     [tempoModerato.id]: http('https://rpc.testnet.tempo.xyz'),
  *   },
  * })
  * ```
@@ -240,9 +241,12 @@ export function feePayer(options: feePayer.Options) {
   const {
     account,
     chains = [tempo, tempoModerato],
+    name,
     onRequest,
     path = '/',
     transports = {},
+    url,
+    ...rest
   } = options
 
   const clients = new Map<number, Client>()
@@ -260,7 +264,13 @@ export function feePayer(options: feePayer.Options) {
     return clients.get(chains[0]!.id)!
   }
 
-  const router = from(options)
+  const sponsor = {
+    address: account.address,
+    ...(name ? { name } : {}),
+    ...(url ? { url } : {}),
+  }
+
+  const router = from(rest)
 
   router.post(path, async (c) => {
     const request = RpcRequest.from((await c.req.raw.json()) as any)
@@ -270,6 +280,7 @@ export function feePayer(options: feePayer.Options) {
 
       const method = request.method as string
       if (
+        method !== 'eth_fillTransaction' &&
         method !== 'eth_signRawTransaction' &&
         method !== 'eth_sendRawTransaction' &&
         method !== 'eth_sendRawTransactionSync'
@@ -285,14 +296,65 @@ export function feePayer(options: feePayer.Options) {
           ),
         )
 
-      const serialized = request.params?.[0] as `0x76${string}`
+      if (method === 'eth_fillTransaction') {
+        const [parameters] = z
+          .readonly(z.tuple([z.record(z.string(), z.unknown())]))
+          .parse(request.params) as [Record<string, unknown>]
+        const chainId = resolveChainId(parameters.chainId)
+        const client = getClient(chainId)
+        const transaction = await (async () => {
+          if (isPreparedFeePayerTransaction(parameters))
+            return normalizeTempoTransaction(parameters)
+
+          const fillRequest = formatFillTransactionRequest(client, {
+            ...normalizeFillTransactionRequest(parameters),
+            ...(typeof chainId !== 'undefined' ? { chainId } : {}),
+            feePayer: true,
+          })
+          const result = (await client.request({
+            method: 'eth_fillTransaction' as never,
+            params: [fillRequest],
+          })) as { tx?: Record<string, unknown> | undefined }
+          return normalizeTempoTransaction(result.tx)
+        })()
+
+        const from =
+          (transaction.from as `0x${string}` | undefined) ??
+          (typeof parameters.from === 'string' ? (parameters.from as `0x${string}`) : undefined)
+        const { signature: _, ...withoutSenderSig } = transaction as Record<string, unknown>
+        const prepared = { ...withoutSenderSig, from }
+
+        if (!prepared.from)
+          throw new RpcResponse.InvalidParamsError({
+            message: 'Transaction sender must be provided before fee payer signing.',
+          })
+        if (!account.sign) throw new Error('Fee payer account cannot sign transactions.')
+
+        const feePayerSignature = Signature.from(
+          await account.sign({
+            hash: TxEnvelopeTempo.getFeePayerSignPayload(TxEnvelopeTempo.from(prepared as never), {
+              sender: prepared.from,
+            }),
+          }),
+        )
+
+        return rpcResult(request, {
+          sponsor,
+          tx: core_Transaction.toRpc({
+            ...prepared,
+            feePayerSignature,
+          } as core_Transaction.Transaction),
+        })
+      }
+
+      const serialized = request.params?.[0] as `0x76${string}` | undefined
 
       if (!serialized?.startsWith('0x76') && !serialized?.startsWith('0x78'))
         throw new RpcResponse.InvalidParamsError({
           message: 'Only Tempo (0x76/0x78) transactions are supported.',
         })
 
-      const transaction = Transaction.deserialize(serialized) as any
+      const transaction = Transaction.deserialize(serialized)
 
       if (!transaction.signature || !transaction.from)
         throw new RpcResponse.InvalidParamsError({
@@ -300,32 +362,25 @@ export function feePayer(options: feePayer.Options) {
         })
 
       const client = getClient(transaction.chainId)
-      const serializedTransaction = await signTransaction(client, {
-        ...transaction,
-        account,
-        feePayer: account,
-      })
+      const serializedTransaction = toSerializedTransaction(
+        await signTransaction(client, {
+          ...transaction,
+          account,
+          feePayer: account,
+        } as never),
+      )
 
       if (method === 'eth_signRawTransaction')
         return Response.json(RpcResponse.from({ result: serializedTransaction }, { request }))
 
-      const result = await (client as any).request({
-        method,
+      const result = await client.request({
+        method: method as never,
         params: [serializedTransaction],
       })
 
       return Response.json(RpcResponse.from({ result }, { request }))
     } catch (error) {
-      return Response.json(
-        RpcResponse.from(
-          {
-            error: new RpcResponse.InternalError({
-              message: (error as Error).message,
-            }),
-          },
-          { request },
-        ),
-      )
+      return rpcError(request, error)
     }
   })
 
@@ -346,8 +401,12 @@ export declare namespace feePayer {
     onRequest?: (request: RpcRequest.RpcRequest) => Promise<void>
     /** Path to use for the handler. */
     path?: string | undefined
+    /** Sponsor display name returned from `eth_fillTransaction`. */
+    name?: string | undefined
     /** Transports keyed by chain ID. Defaults to `http()` for each chain. */
     transports?: Record<number, Transport> | undefined
+    /** Sponsor URL returned from `eth_fillTransaction`. */
+    url?: string | undefined
   }
 }
 
@@ -658,7 +717,7 @@ export declare namespace webAuthn {
     /** Maximum age of a challenge in seconds before it expires. @default 300 */
     challengeTtl?: number | undefined
     /** Key-value store for challenges and credentials. */
-    kv: Kv
+    kv: Kv.Kv
     /** Called after a successful registration. The returned response is merged onto the default JSON response. */
     onRegister?: (parameters: {
       credentialId: string
@@ -681,6 +740,103 @@ export declare namespace webAuthn {
   }
 }
 
+/** @internal */
+function resolveChainId(value: unknown) {
+  if (typeof value === 'number') return value
+  if (typeof value === 'bigint') return Number(value)
+  if (typeof value === 'string' && Hex.validate(value)) return Hex.toNumber(value)
+  return undefined
+}
+
+/** @internal */
+function isPreparedFeePayerTransaction(value: Record<string, unknown>) {
+  return (
+    typeof value.from === 'string' &&
+    typeof resolveChainId(value.chainId) === 'number' &&
+    typeof value.gas !== 'undefined' &&
+    typeof value.nonce !== 'undefined' &&
+    (typeof value.maxFeePerGas !== 'undefined' || typeof value.gasPrice !== 'undefined')
+  )
+}
+
+/** @internal */
+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>
+}
+
+/** @internal */
+function normalizeFillTransactionRequest(value: Record<string, unknown>) {
+  if (typeof value.to !== 'undefined' || typeof value.data !== 'undefined') return value
+  if (!Array.isArray(value.calls) || value.calls.length !== 1) return value
+  const [call] = value.calls as Array<Record<string, unknown>>
+  const { calls: _, ...rest } = value
+  return {
+    ...rest,
+    ...(typeof call?.data !== 'undefined' ? { data: call.data } : {}),
+    ...(typeof call?.to !== 'undefined' ? { to: call.to } : {}),
+    ...(typeof call?.value !== 'undefined' ? { value: normalizeFillValue(call.value) } : {}),
+  }
+}
+
+/** @internal */
+function normalizeFillValue(value: unknown) {
+  if (typeof value !== 'string' || !value.startsWith('0x')) return value
+  return BigInt(value === '0x' ? '0x0' : value)
+}
+
+/** @internal */
+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)!
+}
+
+/** @internal */
+function rpcError(request: RpcRequest.RpcRequest, error: unknown) {
+  if (error instanceof RpcResponse.InvalidParamsError)
+    return Response.json(RpcResponse.from({ error }, { request }))
+
+  if (error instanceof RpcResponse.MethodNotSupportedError)
+    return Response.json(RpcResponse.from({ error }, { request }))
+
+  if ((error as { name?: string | undefined }).name === 'ZodError')
+    return Response.json(
+      RpcResponse.from(
+        {
+          error: new RpcResponse.InvalidParamsError({
+            message: (error as Error).message,
+          }),
+        },
+        { request },
+      ),
+    )
+
+  return Response.json(
+    RpcResponse.from(
+      {
+        error: new RpcResponse.InternalError({
+          message: (error as Error).message,
+        }),
+      },
+      { request },
+    ),
+  )
+}
+
+/** @internal */
+function rpcResult(request: RpcRequest.RpcRequest, result: unknown) {
+  return Response.json(RpcResponse.from({ result }, { request }))
+}
+
+/** @internal */
+function toSerializedTransaction(value: unknown) {
+  if (typeof value === 'string') return value
+  if (value && typeof value === 'object' && 'raw' in value && typeof value.raw === 'string')
+    return value.raw
+  throw new Error('Expected a serialized transaction result.')
+}
+
 /** @internal */
 async function mergeResponse(
   json: Record<string, unknown>,

package/src/wagmi/Connector.ts

@@ -318,10 +318,10 @@ export declare namespace dialog {
  * ```
  */
 export function dangerous_secp256k1(options: dangerous_secp256k1.Options = {}) {
-  const { icon, name, rdns, ...rest } = options
+  const { icon, name, privateKey, rdns, ...rest } = options
   return setup({
     ...rest,
-    adapter: dangerous_secp256k1_adapter({ icon, name, rdns }),
+    adapter: dangerous_secp256k1_adapter({ icon, name, privateKey, rdns }),
   })
 }