@farcaster/frame-node 0.0.10 → 0.0.12

package/esm/util.js

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

package/esm/webhook.d.ts

@@ -1,9 +1,20 @@
-import { VerifyJsonFarcasterSignature } from "./jfs";
-import { BaseError, ParseWebhookEventResult, VerifyAppKey } from "./types";
+import type { VerifyJsonFarcasterSignature } from './jfs'
+import {
+  BaseError,
+  type ParseWebhookEventResult,
+  type VerifyAppKey,
+} from './types'
 export declare namespace ParseWebhookEvent {
-    type ErrorType = VerifyJsonFarcasterSignature.ErrorType | InvalidEventDataError;
+  type ErrorType =
+    | VerifyJsonFarcasterSignature.ErrorType
+    | InvalidEventDataError
 }
-export declare class InvalidEventDataError<C extends Error | undefined = undefined> extends BaseError<C> {
-    readonly name = "VerifyJsonFarcasterSignature.InvalidEventDataError";
+export declare class InvalidEventDataError<
+  C extends Error | undefined = undefined,
+> extends BaseError<C> {
+  readonly name = 'VerifyJsonFarcasterSignature.InvalidEventDataError'
 }
-export declare function parseWebhookEvent(rawData: unknown, verifyAppKey: VerifyAppKey): Promise<ParseWebhookEventResult>;
+export declare function parseWebhookEvent(
+  rawData: unknown,
+  verifyAppKey: VerifyAppKey,
+): Promise<ParseWebhookEventResult>

package/esm/webhook.js

@@ -1,22 +1,27 @@
-import { serverEventSchema } from "@farcaster/frame-core";
-import { verifyJsonFarcasterSignature, } from "./jfs";
-import { BaseError } from "./types";
+import { serverEventSchema } from '@farcaster/frame-core'
+import { verifyJsonFarcasterSignature } from './jfs'
+import { BaseError } from './types'
 export class InvalidEventDataError extends BaseError {
-    name = "VerifyJsonFarcasterSignature.InvalidEventDataError";
+  name = 'VerifyJsonFarcasterSignature.InvalidEventDataError'
 }
 export async function parseWebhookEvent(rawData, verifyAppKey) {
-    const { fid, appFid, payload } = await verifyJsonFarcasterSignature(rawData, verifyAppKey);
-    // Pase and validate event payload
-    let payloadJson;
-    try {
-        payloadJson = JSON.parse(Buffer.from(payload).toString("utf-8"));
-    }
-    catch (error) {
-        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 };
+  const { fid, appFid, payload } = await verifyJsonFarcasterSignature(
+    rawData,
+    verifyAppKey,
+  )
+  // Pase and validate event payload
+  let payloadJson
+  try {
+    payloadJson = JSON.parse(Buffer.from(payload).toString('utf-8'))
+  } catch (error) {
+    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 }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@farcaster/frame-node",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "main": "dist/index.js",
   "module": "esm/index.js",
   "files": [
@@ -9,15 +9,17 @@
     "src"
   ],
   "devDependencies": {
+    "@types/node": "^22.10.2",
     "@vitest/coverage-v8": "^2.1.8",
-    "tsup": "^8.3.5",
-    "typescript": "^5.6.3",
+    "typescript": "^5.7.2",
     "vitest": "^2.1.8",
     "@farcaster/tsconfig": "0.0.2"
   },
   "dependencies": {
-    "ox": "^0.4.0",
-    "@farcaster/frame-core": "0.0.21"
+    "@noble/curves": "^1.7.0",
+    "ox": "^0.4.4",
+    "zod": "^3.24.1",
+    "@farcaster/frame-core": "0.0.23"
   },
   "publishConfig": {
     "access": "public"

package/src/farcaster.ts

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

package/src/index.ts

@@ -1,7 +1,7 @@
-export * from "@farcaster/frame-core";
-export * from "./jfs";
-export * from "./neynar";
-export * from "./farcaster";
-export * from "./types";
-export * from "./webhook";
-export * from "./util";
+export * from '@farcaster/frame-core'
+export * from './jfs'
+export * from './neynar'
+export * from './farcaster'
+export * from './types'
+export * from './webhook'
+export * from './util'

package/src/jfs.ts

@@ -1,35 +1,40 @@
 import {
-  EncodedJsonFarcasterSignatureSchema,
+  type EncodedJsonFarcasterSignatureSchema,
   encodedJsonFarcasterSignatureSchema,
   jsonFarcasterSignatureHeaderSchema,
-} from "@farcaster/frame-core";
-import { ed25519 } from "@noble/curves/ed25519";
-import { BaseError, VerifyAppKey, VerifyJfsResult } from "./types";
-import { bytesToHex, hexToBytes } from "./util";
+} from '@farcaster/frame-core'
+import { ed25519 } from '@noble/curves/ed25519'
+import {
+  BaseError,
+  type VerifyAppKey,
+  type VerifyAppKeyResult,
+  type VerifyJfsResult,
+} from './types'
+import { bytesToHex, hexToBytes } from './util'
 
 export declare namespace VerifyJsonFarcasterSignature {
   type ErrorType =
     | InvalidJfsDataError
     | InvalidJfsAppKeyError
-    | VerifyAppKeyError;
+    | VerifyAppKeyError
 }
 
 export class InvalidJfsDataError<
   C extends Error | undefined = undefined,
 > extends BaseError<C> {
-  override readonly name = "VerifyJsonFarcasterSignature.InvalidDataError";
+  override readonly name = 'VerifyJsonFarcasterSignature.InvalidDataError'
 }
 
 export class InvalidJfsAppKeyError<
   C extends Error | undefined = undefined,
 > extends BaseError<C> {
-  override readonly name = "VerifyJsonFarcasterSignature.InvalidAppKeyError";
+  override readonly name = 'VerifyJsonFarcasterSignature.InvalidAppKeyError'
 }
 
 export class VerifyAppKeyError<
   C extends Error | undefined = undefined,
 > extends BaseError<C> {
-  override readonly name = "VerifyJsonFarcasterSignature.VerifyAppKeyError";
+  override readonly name = 'VerifyJsonFarcasterSignature.VerifyAppKeyError'
 }
 
 export async function verifyJsonFarcasterSignature(
@@ -40,77 +45,77 @@ export async function verifyJsonFarcasterSignature(
   // Parse, decode and validate data
   //
 
-  const body = encodedJsonFarcasterSignatureSchema.safeParse(data);
+  const body = encodedJsonFarcasterSignatureSchema.safeParse(data)
   if (body.success === false) {
-    throw new InvalidJfsDataError("Error parsing data", body.error);
+    throw new InvalidJfsDataError('Error parsing data', body.error)
   }
 
-  let headerData;
+  let headerData: any
   try {
     headerData = JSON.parse(
-      Buffer.from(body.data.header, "base64url").toString("utf-8"),
-    );
+      Buffer.from(body.data.header, 'base64url').toString('utf-8'),
+    )
   } catch (error: unknown) {
-    throw new InvalidJfsDataError("Error decoding and parsing header");
+    throw new InvalidJfsDataError('Error decoding and parsing header')
   }
 
-  const header = jsonFarcasterSignatureHeaderSchema.safeParse(headerData);
+  const header = jsonFarcasterSignatureHeaderSchema.safeParse(headerData)
   if (header.success === false) {
-    throw new InvalidJfsDataError("Error parsing header", header.error);
+    throw new InvalidJfsDataError('Error parsing header', header.error)
   }
 
-  const payload = Buffer.from(body.data.payload, "base64url");
+  const payload = Buffer.from(body.data.payload, 'base64url')
 
-  const signature = Buffer.from(body.data.signature, "base64url");
+  const signature = Buffer.from(body.data.signature, 'base64url')
   if (signature.byteLength !== 64) {
-    throw new InvalidJfsDataError("Invalid signature length");
+    throw new InvalidJfsDataError('Invalid signature length')
   }
 
   //
   // Verify the signature
   //
 
-  const fid = header.data.fid;
-  const appKey = header.data.key;
-  const appKeyBytes = hexToBytes(appKey);
+  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),
-  );
+    Buffer.from(body.data.header + '.' + body.data.payload),
+  )
 
-  let verifyResult;
+  let verifyResult: boolean
   try {
-    verifyResult = ed25519.verify(signature, signedInput, appKeyBytes);
+    verifyResult = ed25519.verify(signature, signedInput, appKeyBytes)
   } catch (e) {
     throw new InvalidJfsDataError(
-      "Error checking signature",
+      'Error checking signature',
       e instanceof Error ? e : undefined,
-    );
+    )
   }
 
   if (!verifyResult) {
-    throw new InvalidJfsDataError("Invalid signature");
+    throw new InvalidJfsDataError('Invalid signature')
   }
 
   //
   // Verify that the app key belongs to the FID
   //
 
-  let appKeyResult;
+  let appKeyResult: VerifyAppKeyResult
   try {
-    appKeyResult = await verifyAppKey(fid, appKey);
+    appKeyResult = await verifyAppKey(fid, appKey)
   } catch (error: unknown) {
     throw new VerifyAppKeyError(
-      "Error verifying app key",
+      'Error verifying app key',
       error instanceof Error ? error : undefined,
-    );
+    )
   }
 
   if (!appKeyResult.valid) {
-    throw new InvalidJfsAppKeyError("App key not valid for FID");
+    throw new InvalidJfsAppKeyError('App key not valid for FID')
   }
 
-  return { fid, appFid: appKeyResult.appFid, payload };
+  return { fid, appFid: appKeyResult.appFid, payload }
 }
 
 export function createJsonFarcasterSignature({
@@ -119,28 +124,28 @@ export function createJsonFarcasterSignature({
   privateKey,
   payload,
 }: {
-  fid: number;
-  type: "app_key";
-  privateKey: Uint8Array;
-  payload: Uint8Array;
+  fid: number
+  type: 'app_key'
+  privateKey: Uint8Array
+  payload: Uint8Array
 }): EncodedJsonFarcasterSignatureSchema {
-  const publicKey = ed25519.getPublicKey(privateKey);
+  const publicKey = ed25519.getPublicKey(privateKey)
 
-  const header = { fid, type, key: bytesToHex(publicKey) };
+  const header = { fid, type, key: bytesToHex(publicKey) }
   const encodedHeader = Buffer.from(JSON.stringify(header)).toString(
-    "base64url",
-  );
-  const encodedPayload = Buffer.from(payload).toString("base64url");
+    'base64url',
+  )
+  const encodedPayload = Buffer.from(payload).toString('base64url')
   const signatureInput = new Uint8Array(
-    Buffer.from(encodedHeader + "." + encodedPayload, "utf-8"),
-  );
+    Buffer.from(encodedHeader + '.' + encodedPayload, 'utf-8'),
+  )
 
-  const signature = ed25519.sign(signatureInput, privateKey);
-  const encodedSignature = Buffer.from(signature).toString("base64url");
+  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 +1,23 @@
-import { createVerifyAppKeyWithHub } from "./farcaster";
-import { VerifyAppKey, VerifyAppKeyResult } from "./types";
+import { createVerifyAppKeyWithHub } from './farcaster'
+import type { VerifyAppKey, VerifyAppKeyResult } from './types'
 
-const apiKey = process.env.NEYNAR_API_KEY || "";
+const apiKey = process.env.NEYNAR_API_KEY || ''
 
 export const verifyAppKeyWithNeynar: VerifyAppKey = async (
   fid: number,
-  appKey: string
+  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"
-    );
+      'Environment variable NEYNAR_API_KEY needs to be set to use Neynar for app key verification',
+    )
   }
 
-  const verifier = createVerifyAppKeyWithHub("https://hub-api.neynar.com", {
+  const verifier = createVerifyAppKeyWithHub('https://hub-api.neynar.com', {
     headers: {
-      "x-api-key": apiKey,
+      'x-api-key': apiKey,
     },
-  });
+  })
 
-  return verifier(fid, appKey);
-};
+  return verifier(fid, appKey)
+}

package/src/types.ts

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

package/src/util.ts

@@ -1,9 +1,9 @@
 export function bytesToHex(bytes: Uint8Array): string {
-  return `0x${Buffer.from(bytes).toString("hex")}`;
+  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"),
-  );
+    Buffer.from(hex.startsWith('0x') ? hex.slice(2) : hex, 'hex'),
+  )
 }

package/src/webhook.ts

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