@farcaster/frame-node 0.0.41 → 0.1.0

package/src/farcaster.ts

@@ -1,86 +0,0 @@
-import * as AbiParameters from 'ox/AbiParameters'
-import { z } from 'zod'
-import {
-  BaseError,
-  type VerifyAppKey,
-  type VerifyAppKeyResult,
-} from './types.ts'
-
-export const signedKeyRequestAbi = [
-  {
-    components: [
-      {
-        name: 'requestFid',
-        type: 'uint256',
-      },
-      {
-        name: 'requestSigner',
-        type: 'address',
-      },
-      {
-        name: 'signature',
-        type: 'bytes',
-      },
-      {
-        name: 'deadline',
-        type: 'uint256',
-      },
-    ],
-    name: 'SignedKeyRequest',
-    type: 'tuple',
-  },
-] as const
-
-const hubResponseSchema = z.object({
-  events: z.array(
-    z.object({
-      signerEventBody: z.object({
-        key: z.string(),
-        metadata: z.string(),
-      }),
-    }),
-  ),
-})
-
-export const createVerifyAppKeyWithHub: (
-  hubUrl: string,
-  requestOptions?: RequestInit,
-) => VerifyAppKey =
-  (hubUrl, requestOptions) =>
-  async (fid: number, appKey: string): Promise<VerifyAppKeyResult> => {
-    const url = new URL('/v1/onChainSignersByFid', hubUrl)
-    url.searchParams.append('fid', fid.toString())
-
-    const response = await fetch(url, requestOptions)
-
-    if (response.status !== 200) {
-      throw new BaseError(`Non-200 response received: ${await response.text()}`)
-    }
-
-    const responseJson = await response.json()
-    const parsedResponse = hubResponseSchema.safeParse(responseJson)
-    if (parsedResponse.error) {
-      throw new BaseError('Error parsing Hub response', parsedResponse.error)
-    }
-
-    const appKeyLower = appKey.toLowerCase()
-
-    const signerEvent = parsedResponse.data.events.find(
-      (event) => event.signerEventBody.key.toLowerCase() === appKeyLower,
-    )
-    if (!signerEvent) {
-      return { valid: false }
-    }
-
-    const decoded = AbiParameters.decode(
-      signedKeyRequestAbi,
-      Buffer.from(signerEvent.signerEventBody.metadata, 'base64'),
-    )
-    if (decoded.length !== 1) {
-      throw new BaseError('Error decoding metadata')
-    }
-
-    const appFid = Number(decoded[0].requestFid)
-
-    return { valid: true, appFid }
-  }

package/src/jfs.ts

@@ -1,151 +0,0 @@
-import {
-  type EncodedJsonFarcasterSignatureSchema,
-  encodedJsonFarcasterSignatureSchema,
-  jsonFarcasterSignatureHeaderSchema,
-} from '@farcaster/frame-core'
-import { ed25519 } from '@noble/curves/ed25519'
-import {
-  BaseError,
-  type VerifyAppKey,
-  type VerifyAppKeyResult,
-  type VerifyJfsResult,
-} from './types.ts'
-import { bytesToHex, hexToBytes } from './util.ts'
-
-export declare namespace VerifyJsonFarcasterSignature {
-  type ErrorType =
-    | InvalidJfsDataError
-    | InvalidJfsAppKeyError
-    | VerifyAppKeyError
-}
-
-export class InvalidJfsDataError<
-  C extends Error | undefined = undefined,
-> extends BaseError<C> {
-  override readonly name = 'VerifyJsonFarcasterSignature.InvalidDataError'
-}
-
-export class InvalidJfsAppKeyError<
-  C extends Error | undefined = undefined,
-> extends BaseError<C> {
-  override readonly name = 'VerifyJsonFarcasterSignature.InvalidAppKeyError'
-}
-
-export class VerifyAppKeyError<
-  C extends Error | undefined = undefined,
-> extends BaseError<C> {
-  override readonly name = 'VerifyJsonFarcasterSignature.VerifyAppKeyError'
-}
-
-export async function verifyJsonFarcasterSignature(
-  data: unknown,
-  verifyAppKey: VerifyAppKey,
-): Promise<VerifyJfsResult> {
-  //
-  // Parse, decode and validate data
-  //
-
-  const body = encodedJsonFarcasterSignatureSchema.safeParse(data)
-  if (body.success === false) {
-    throw new InvalidJfsDataError('Error parsing data', body.error)
-  }
-
-  let headerData: any
-  try {
-    headerData = JSON.parse(
-      Buffer.from(body.data.header, 'base64url').toString('utf-8'),
-    )
-  } catch (error: unknown) {
-    throw new InvalidJfsDataError('Error decoding and parsing header')
-  }
-
-  const header = jsonFarcasterSignatureHeaderSchema.safeParse(headerData)
-  if (header.success === false) {
-    throw new InvalidJfsDataError('Error parsing header', header.error)
-  }
-
-  const payload = Buffer.from(body.data.payload, 'base64url')
-
-  const signature = Buffer.from(body.data.signature, 'base64url')
-  if (signature.byteLength !== 64) {
-    throw new InvalidJfsDataError('Invalid signature length')
-  }
-
-  //
-  // Verify the signature
-  //
-
-  const fid = header.data.fid
-  const appKey = header.data.key
-  const appKeyBytes = hexToBytes(appKey)
-
-  const signedInput = new Uint8Array(
-    Buffer.from(body.data.header + '.' + body.data.payload),
-  )
-
-  let verifyResult: boolean
-  try {
-    verifyResult = ed25519.verify(signature, signedInput, appKeyBytes)
-  } catch (e) {
-    throw new InvalidJfsDataError(
-      'Error checking signature',
-      e instanceof Error ? e : undefined,
-    )
-  }
-
-  if (!verifyResult) {
-    throw new InvalidJfsDataError('Invalid signature')
-  }
-
-  //
-  // Verify that the app key belongs to the FID
-  //
-
-  let appKeyResult: VerifyAppKeyResult
-  try {
-    appKeyResult = await verifyAppKey(fid, appKey)
-  } catch (error: unknown) {
-    throw new VerifyAppKeyError(
-      'Error verifying app key',
-      error instanceof Error ? error : undefined,
-    )
-  }
-
-  if (!appKeyResult.valid) {
-    throw new InvalidJfsAppKeyError('App key not valid for FID')
-  }
-
-  return { fid, appFid: appKeyResult.appFid, payload }
-}
-
-export function createJsonFarcasterSignature({
-  fid,
-  type,
-  privateKey,
-  payload,
-}: {
-  fid: number
-  type: 'app_key'
-  privateKey: Uint8Array
-  payload: Uint8Array
-}): EncodedJsonFarcasterSignatureSchema {
-  const publicKey = ed25519.getPublicKey(privateKey)
-
-  const header = { fid, type, key: bytesToHex(publicKey) }
-  const encodedHeader = Buffer.from(JSON.stringify(header)).toString(
-    'base64url',
-  )
-  const encodedPayload = Buffer.from(payload).toString('base64url')
-  const signatureInput = new Uint8Array(
-    Buffer.from(encodedHeader + '.' + encodedPayload, 'utf-8'),
-  )
-
-  const signature = ed25519.sign(signatureInput, privateKey)
-  const encodedSignature = Buffer.from(signature).toString('base64url')
-
-  return {
-    header: encodedHeader,
-    payload: encodedPayload,
-    signature: encodedSignature,
-  }
-}

package/src/neynar.ts

@@ -1,23 +0,0 @@
-import { createVerifyAppKeyWithHub } from './farcaster.ts'
-import type { VerifyAppKey, VerifyAppKeyResult } from './types.ts'
-
-const apiKey = process.env.NEYNAR_API_KEY || ''
-
-export const verifyAppKeyWithNeynar: VerifyAppKey = async (
-  fid: number,
-  appKey: string,
-): Promise<VerifyAppKeyResult> => {
-  if (!apiKey) {
-    throw new Error(
-      'Environment variable NEYNAR_API_KEY needs to be set to use Neynar for app key verification',
-    )
-  }
-
-  const verifier = createVerifyAppKeyWithHub('https://hub-api.neynar.com', {
-    headers: {
-      'x-api-key': apiKey,
-    },
-  })
-
-  return verifier(fid, appKey)
-}

package/src/types.ts

@@ -1,32 +0,0 @@
-import type { FrameServerEvent } from '@farcaster/frame-core'
-
-export type VerifyAppKeyResult =
-  | { valid: true; appFid: number }
-  | { valid: false }
-
-export type VerifyAppKey = (
-  fid: number,
-  appKey: string,
-) => Promise<VerifyAppKeyResult>
-
-export type VerifyJfsResult = {
-  fid: number
-  appFid: number
-  payload: Uint8Array
-}
-
-export type ParseWebhookEventResult = {
-  fid: number
-  appFid: number
-  event: FrameServerEvent
-}
-
-export class BaseError<C extends Error | undefined = undefined> extends Error {
-  override name = 'BaseError'
-  cause: C
-
-  constructor(message: string, cause?: C) {
-    super(message)
-    this.cause = cause as any
-  }
-}

package/src/util.ts

@@ -1,9 +0,0 @@
-export function bytesToHex(bytes: Uint8Array): string {
-  return `0x${Buffer.from(bytes).toString('hex')}`
-}
-
-export function hexToBytes(hex: string): Uint8Array {
-  return Uint8Array.from(
-    Buffer.from(hex.startsWith('0x') ? hex.slice(2) : hex, 'hex'),
-  )
-}

package/src/webhook.ts

@@ -1,50 +0,0 @@
-import { serverEventSchema } from '@farcaster/frame-core'
-import {
-  type VerifyJsonFarcasterSignature,
-  verifyJsonFarcasterSignature,
-} from './jfs.ts'
-import {
-  BaseError,
-  type ParseWebhookEventResult,
-  type VerifyAppKey,
-} from './types.ts'
-
-export declare namespace ParseWebhookEvent {
-  type ErrorType =
-    | VerifyJsonFarcasterSignature.ErrorType
-    | InvalidEventDataError
-}
-
-export class InvalidEventDataError<
-  C extends Error | undefined = undefined,
-> extends BaseError<C> {
-  override readonly name = 'VerifyJsonFarcasterSignature.InvalidEventDataError'
-}
-
-export async function parseWebhookEvent(
-  rawData: unknown,
-  verifyAppKey: VerifyAppKey,
-): Promise<ParseWebhookEventResult> {
-  const { fid, appFid, payload } = await verifyJsonFarcasterSignature(
-    rawData,
-    verifyAppKey,
-  )
-
-  // Pase and validate event payload
-  let payloadJson: any
-  try {
-    payloadJson = JSON.parse(Buffer.from(payload).toString('utf-8'))
-  } catch (error: unknown) {
-    throw new InvalidEventDataError(
-      'Error decoding and parsing payload',
-      error instanceof Error ? error : undefined,
-    )
-  }
-
-  const event = serverEventSchema.safeParse(payloadJson)
-  if (event.success === false) {
-    throw new InvalidEventDataError('Invalid event payload', event.error)
-  }
-
-  return { fid, appFid, event: event.data }
-}