@farcaster/frame-sdk 0.0.64 → 0.1.1

package/src/quickAuth.ts

@@ -1,148 +0,0 @@
-import { SignIn } from '@farcaster/frame-core'
-import type { JWTPayload } from '@farcaster/quick-auth'
-import { decodeJwt } from '@farcaster/quick-auth/decodeJwt'
-import { createLightClient } from '@farcaster/quick-auth/light'
-import * as Siwe from 'ox/Siwe'
-
-import { frameHost } from './frameHost.js'
-
-export declare namespace getToken {
-  type Options = {
-    /**
-     * Use a custom Quick Auth server, otherwise defaults to the public
-     * instance provided by Farcaster.
-     *
-     * @default https://auth.farcaster.xyz
-     */
-    quickAuthServerOrigin?: string
-
-    /**
-     * Acquire a new token even if one is already in memory and not expired.
-     *
-     * @default false
-     */
-    force?: string
-  }
-
-  type ReturnValue = { token: string }
-  type ReturnType = Promise<ReturnValue>
-
-  type ErrorType = SignIn.RejectedByUser | Error
-}
-
-export type QuickAuth = {
-  /**
-   * Returns the session token if one is present and not expired.
-   */
-  readonly token: string | undefined
-
-  /**
-   * Get a Quick Auth JWT.
-   *
-   * If a token is already in memory and not expired it will be returned unless
-   * `force` is used. Otherwise a new token will be acquired.
-   */
-  getToken: (options?: getToken.Options) => getToken.ReturnType
-
-  /**
-   * Make an authenticated fetch request. The `Authorization` header will
-   * contain `Bearer ${token}` where token is a Quick Auth session token.
-   */
-  fetch: typeof fetch
-}
-
-export const quickAuth: QuickAuth = (() => {
-  let current:
-    | {
-        token: string
-        payload: JWTPayload
-      }
-    | undefined
-  let pendingPromise: Promise<getToken.ReturnValue> | undefined = undefined
-
-  async function getTokenInner(options: getToken.Options): getToken.ReturnType {
-    const quickAuthClient = createLightClient({
-      origin: options.quickAuthServerOrigin,
-    })
-
-    const { nonce } = await quickAuthClient.generateNonce()
-    const response = await frameHost.signIn({
-      nonce,
-      acceptAuthAddress: true,
-    })
-
-    if (response.result) {
-      const parsedSiwe = Siwe.parseMessage(response.result.message)
-
-      // The Farcaster Client rendering the Mini App will set the domain
-      // based on the URL it's rendering. It should always be set.
-      if (!parsedSiwe.domain) {
-        throw new Error('Missing domain on SIWE message')
-      }
-
-      const verifyResult = await quickAuthClient.verifySiwf({
-        domain: parsedSiwe.domain,
-        message: response.result.message,
-        signature: response.result.signature,
-      })
-
-      current = {
-        token: verifyResult.token,
-        payload: decodeJwt(verifyResult.token),
-      }
-
-      return verifyResult
-    }
-
-    if (response.error.type === 'rejected_by_user') {
-      throw new SignIn.RejectedByUser()
-    }
-
-    throw new Error('Unreachable')
-  }
-
-  return {
-    get token() {
-      if (
-        current &&
-        new Date(current.payload.exp * 1000) > new Date(Date.now() + 15000)
-      ) {
-        return current.token
-      }
-
-      return undefined
-    },
-    async getToken(options = {}) {
-      const force = options.force ?? false
-
-      if (
-        current &&
-        !force &&
-        new Date(current.payload.exp * 1000) > new Date(Date.now() + 15000)
-      ) {
-        return { token: current.token }
-      }
-
-      if (!pendingPromise) {
-        pendingPromise = getTokenInner(options)
-      }
-
-      pendingPromise.finally(() => {
-        pendingPromise = undefined
-      })
-
-      return pendingPromise
-    },
-    async fetch(url, options) {
-      const { token } = await this.getToken()
-
-      const headers = new Headers(options?.headers)
-      headers.set('Authorization', `Bearer ${token}`)
-
-      return fetch(url, {
-        ...options,
-        headers,
-      })
-    },
-  }
-})()

package/src/sdk.ts

@@ -1,191 +0,0 @@
-import {
-  AddMiniApp,
-  type FrameClientEvent,
-  SignIn,
-} from '@farcaster/frame-core'
-import { createBack } from './back.ts'
-import { ethereumProvider, getEthereumProvider } from './ethereumProvider.ts'
-import { frameHost } from './frameHost.ts'
-import { quickAuth } from './quickAuth.ts'
-import { emitter } from './sdkEmitter.ts'
-import { getSolanaProvider } from './solanaProvider.ts'
-import type { FrameSDK } from './types.ts'
-
-let cachedIsInMiniAppResult: boolean | null = null
-
-/**
- * Determines if the current environment is a MiniApp context.
- *
- * @param timeoutMs - Optional timeout in milliseconds (default: 50)
- * @returns Promise resolving to boolean indicating if in MiniApp context
- */
-async function isInMiniApp(timeoutMs = 50): Promise<boolean> {
-  // Return cached result if we've already determined we are in a MiniApp
-  if (cachedIsInMiniAppResult === true) {
-    return true
-  }
-
-  // Check for SSR environment - definitely not a MiniApp
-  if (typeof window === 'undefined') {
-    return false
-  }
-
-  // Short-circuit: definitely NOT a MiniApp
-  if (!window.ReactNativeWebView && window === window.parent) {
-    return false
-  }
-
-  // At this point, we MIGHT be in a MiniApp (iframe or RN WebView)
-  // but need to verify by checking for context communication.
-  const isInMiniApp = await Promise.race([
-    frameHost.context.then((context) => !!context), // Check if context resolves to truthy
-    new Promise<boolean>((resolve) => {
-      setTimeout(() => resolve(false), timeoutMs) // Timeout resolves to false
-    }),
-  ]).catch(() => {
-    return false
-  })
-
-  // Cache the result ONLY if true (we are confirmed to be in a MiniApp)
-  if (isInMiniApp) {
-    cachedIsInMiniAppResult = true
-  }
-
-  return isInMiniApp
-}
-
-const addMiniApp = async () => {
-  const response = await frameHost.addFrame()
-  if (response.result) {
-    return response.result
-  }
-
-  if (response.error.type === 'invalid_domain_manifest') {
-    throw new AddMiniApp.InvalidDomainManifest()
-  }
-
-  if (response.error.type === 'rejected_by_user') {
-    throw new AddMiniApp.RejectedByUser()
-  }
-
-  throw new Error('Unreachable')
-}
-
-export const sdk: FrameSDK = {
-  ...emitter,
-  getCapabilities: frameHost.getCapabilities,
-  getChains: frameHost.getChains,
-  isInMiniApp,
-  context: frameHost.context,
-  back: createBack({ frameHost, emitter }),
-  quickAuth,
-  actions: {
-    setPrimaryButton: frameHost.setPrimaryButton.bind(frameHost),
-    ready: async (options = {}) => {
-      return await frameHost.ready(options)
-    },
-    close: frameHost.close.bind(frameHost),
-    viewCast: frameHost.viewCast.bind(frameHost),
-    viewProfile: frameHost.viewProfile.bind(frameHost),
-    signIn: async (options) => {
-      const response = await frameHost.signIn(options)
-      if (response.result) {
-        return response.result
-      }
-
-      if (response.error.type === 'rejected_by_user') {
-        throw new SignIn.RejectedByUser()
-      }
-
-      throw new Error('Unreachable')
-    },
-    openUrl: (urlArg: string | { url: string }) => {
-      const url = typeof urlArg === 'string' ? urlArg : urlArg.url
-      return frameHost.openUrl(url.trim())
-    },
-    addFrame: addMiniApp,
-    addMiniApp,
-    composeCast(options = {}) {
-      return frameHost.composeCast(options) as never
-    },
-    viewToken: frameHost.viewToken.bind(frameHost),
-    sendToken: frameHost.sendToken.bind(frameHost),
-    swapToken: frameHost.swapToken.bind(frameHost),
-  },
-  experimental: {
-    getSolanaProvider,
-    quickAuth(options) {
-      return quickAuth.getToken(options)
-    },
-  },
-  wallet: {
-    ethProvider: ethereumProvider,
-    getEthereumProvider,
-    getSolanaProvider,
-  },
-  haptics: {
-    impactOccurred: frameHost.impactOccurred.bind(frameHost),
-    notificationOccurred: frameHost.notificationOccurred.bind(frameHost),
-    selectionChanged: frameHost.selectionChanged.bind(frameHost),
-  },
-}
-
-// Required to pass SSR
-if (typeof document !== 'undefined') {
-  // react native webview events
-  document.addEventListener('FarcasterFrameEvent', (event) => {
-    if (event instanceof MessageEvent) {
-      const frameEvent = event.data as FrameClientEvent
-      if (frameEvent.event === 'primary_button_clicked') {
-        emitter.emit('primaryButtonClicked')
-      } else if (frameEvent.event === 'frame_added') {
-        emitter.emit('frameAdded', {
-          notificationDetails: frameEvent.notificationDetails,
-        })
-      } else if (frameEvent.event === 'frame_add_rejected') {
-        emitter.emit('frameAddRejected', { reason: frameEvent.reason })
-      } else if (frameEvent.event === 'frame_removed') {
-        emitter.emit('frameRemoved')
-      } else if (frameEvent.event === 'notifications_enabled') {
-        emitter.emit('notificationsEnabled', {
-          notificationDetails: frameEvent.notificationDetails,
-        })
-      } else if (frameEvent.event === 'notifications_disabled') {
-        emitter.emit('notificationsDisabled')
-      } else if (frameEvent.event === 'back_navigation_triggered') {
-        emitter.emit('backNavigationTriggered')
-      }
-    }
-  })
-}
-
-// Required to pass SSR
-if (typeof window !== 'undefined') {
-  // web events
-  window.addEventListener('message', (event) => {
-    if (event instanceof MessageEvent) {
-      if (event.data.type === 'frameEvent') {
-        const frameEvent = event.data.event as FrameClientEvent
-        if (frameEvent.event === 'primary_button_clicked') {
-          emitter.emit('primaryButtonClicked')
-        } else if (frameEvent.event === 'frame_added') {
-          emitter.emit('frameAdded', {
-            notificationDetails: frameEvent.notificationDetails,
-          })
-        } else if (frameEvent.event === 'frame_add_rejected') {
-          emitter.emit('frameAddRejected', { reason: frameEvent.reason })
-        } else if (frameEvent.event === 'frame_removed') {
-          emitter.emit('frameRemoved')
-        } else if (frameEvent.event === 'notifications_enabled') {
-          emitter.emit('notificationsEnabled', {
-            notificationDetails: frameEvent.notificationDetails,
-          })
-        } else if (frameEvent.event === 'notifications_disabled') {
-          emitter.emit('notificationsDisabled')
-        } else if (frameEvent.event === 'back_navigation_triggered') {
-          emitter.emit('backNavigationTriggered')
-        }
-      }
-    }
-  })
-}

package/src/sdkEmitter.ts

@@ -1,27 +0,0 @@
-import EventEmitter from 'eventemitter3'
-import type { Emitter, EventMap } from './types.ts'
-
-export function createEmitter(): Emitter {
-  const emitter = new EventEmitter<EventMap>()
-
-  return {
-    get eventNames() {
-      return emitter.eventNames.bind(emitter)
-    },
-    get listenerCount() {
-      return emitter.listenerCount.bind(emitter)
-    },
-    get listeners() {
-      return emitter.listeners.bind(emitter)
-    },
-    addListener: emitter.addListener.bind(emitter),
-    emit: emitter.emit.bind(emitter),
-    off: emitter.off.bind(emitter),
-    on: emitter.on.bind(emitter),
-    once: emitter.once.bind(emitter),
-    removeAllListeners: emitter.removeAllListeners.bind(emitter),
-    removeListener: emitter.removeListener.bind(emitter),
-  }
-}
-
-export const emitter = createEmitter()

package/src/solanaProvider.ts

@@ -1,33 +0,0 @@
-import {
-  type MiniAppHostCapability,
-  type SolanaWalletProvider,
-  type SolanaWireRequestFn,
-  createSolanaWalletProvider,
-  unwrapSolanaProviderRequest,
-} from '@farcaster/frame-core'
-
-import { frameHost } from './frameHost.ts'
-
-const { solanaProviderRequest } = frameHost
-
-let solanaProvider: SolanaWalletProvider | undefined
-if (solanaProviderRequest) {
-  solanaProvider = createSolanaWalletProvider(
-    unwrapSolanaProviderRequest(
-      solanaProviderRequest as unknown as SolanaWireRequestFn,
-    ),
-  )
-}
-
-async function getSolanaProvider(): Promise<SolanaWalletProvider | undefined> {
-  let capabilities: MiniAppHostCapability[] | undefined
-  try {
-    capabilities = await frameHost.getCapabilities()
-  } catch {}
-  if (!capabilities?.includes('wallet.getSolanaProvider')) {
-    return undefined
-  }
-  return solanaProvider
-}
-
-export { getSolanaProvider }

package/src/types.ts

@@ -1,107 +0,0 @@
-import type {
-  AddMiniApp,
-  ComposeCast,
-  Context,
-  FrameNotificationDetails,
-  GetCapabilities,
-  GetChains,
-  ImpactOccurred,
-  NotificationOccurred,
-  Ready,
-  SelectionChanged,
-  SendToken,
-  SetPrimaryButtonOptions,
-  SignIn,
-  SolanaWalletProvider,
-  SwapToken,
-  ViewCast,
-  ViewProfile,
-  ViewToken,
-} from '@farcaster/frame-core'
-import type { EventEmitter } from 'eventemitter3'
-import type * as Provider from 'ox/Provider'
-import type { Back } from './back.ts'
-import type { QuickAuth } from './quickAuth.ts'
-
-declare global {
-  interface Window {
-    // Exposed by react-native-webview
-    ReactNativeWebView: {
-      postMessage: (message: string) => void
-    }
-  }
-}
-
-/** Combines members of an intersection into a readable type. */
-// https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=v01xkqU3KO0Mg
-type Compute<type> = { [key in keyof type]: type[key] } & unknown
-
-export type EventMap = {
-  primaryButtonClicked: () => void
-  frameAdded: ({
-    notificationDetails,
-  }: {
-    notificationDetails?: FrameNotificationDetails
-  }) => void
-  frameAddRejected: ({
-    reason,
-  }: { reason: AddMiniApp.AddMiniAppRejectedReason }) => void
-  frameRemoved: () => void
-  notificationsEnabled: ({
-    notificationDetails,
-  }: {
-    notificationDetails: FrameNotificationDetails
-  }) => void
-  notificationsDisabled: () => void
-  backNavigationTriggered: () => void
-}
-
-export type Emitter = Compute<EventEmitter<EventMap>>
-
-type SetPrimaryButton = (options: SetPrimaryButtonOptions) => Promise<void>
-
-export type FrameSDK = {
-  getCapabilities: GetCapabilities
-  getChains: GetChains
-  isInMiniApp: () => Promise<boolean>
-  context: Promise<Context.FrameContext>
-  back: Back
-  quickAuth: QuickAuth
-  actions: {
-    ready: (options?: Partial<Ready.ReadyOptions>) => Promise<void>
-    openUrl: (url: string) => Promise<void>
-    close: () => Promise<void>
-    setPrimaryButton: SetPrimaryButton
-    // Deprecated in favor of addMiniApp
-    addFrame: AddMiniApp.AddMiniApp
-    addMiniApp: AddMiniApp.AddMiniApp
-    signIn: SignIn.SignIn
-    viewCast: ViewCast.ViewCast
-    viewProfile: ViewProfile.ViewProfile
-    composeCast: <close extends boolean | undefined = undefined>(
-      options?: ComposeCast.Options<close>,
-    ) => Promise<ComposeCast.Result<close>>
-    viewToken: ViewToken.ViewToken
-    sendToken: SendToken.SendToken
-    swapToken: SwapToken.SwapToken
-  }
-  experimental: {
-    getSolanaProvider: () => Promise<SolanaWalletProvider | undefined>
-
-    /**
-     * @deprecated - use `sdk.quickAuth.getToken`
-     */
-    quickAuth: QuickAuth['getToken']
-  }
-  wallet: {
-    // Deprecated in favor of getEthereumProvider
-    ethProvider: Provider.Provider
-    getEthereumProvider: () => Promise<Provider.Provider | undefined>
-    getSolanaProvider: () => Promise<SolanaWalletProvider | undefined>
-  }
-  haptics: {
-    impactOccurred: ImpactOccurred
-    notificationOccurred: NotificationOccurred
-    selectionChanged: SelectionChanged
-  }
-} & Emitter