@gemini-wallet/core/src/types.ts

Core SDK for Gemini Wallet integration with popup communication

import { EventEmitter } from "eventemitter3";
import type {
  Address,
  Hex,
  SignMessageParameters,
  SignTypedDataParameters,
  TransactionRequest,
} from "viem";

import { type IStorage } from "./storage/storageInterface";

export enum GeminiSdkEvent {
  // Popup events
  POPUP_LOADED = "POPUP_LOADED",
  POPUP_UNLOADED = "POPUP_UNLOADED",
  POPUP_APP_CONTEXT = "POPUP_APP_CONTEXT",

  // SDK events
  SDK_CONNECT = "SDK_CONNECT",
  SDK_DISCONNECT = "SDK_DISCONNECT",
  SDK_SEND_TRANSACTION = "SDK_SEND_TRANSACTION",
  SDK_SIGN_DATA = "SDK_SIGN_DATA",
  SDK_SIGN_TYPED_DATA = "SDK_SIGN_TYPED_DATA",
  SDK_SWITCH_CHAIN = "SDK_SWITCH_CHAIN",
  SDK_OPEN_SETTINGS = "SDK_OPEN_SETTINGS",
}

export interface AppMetadata {
  appName?: string;
  appLogoUrl?: string;
  name?: string;
  description?: string;
  url?: string;
  icons?: string[];
}

export interface AppContext {
  appMetadata: AppMetadata;
  origin: string;
  sdkVersion: string;
}

export interface Chain {
  id: number;
  rpcUrl?: string;
}

export enum PlatformType {
  WEB = "WEB",
  REACT_NATIVE = "REACT_NATIVE",
}

export type GeminiProviderConfig = {
  appMetadata: AppMetadata;
  chain: Chain;
  platform?: PlatformType;
  onDisconnectCallback?: () => void;
  storage?: IStorage;
};

export interface RpcRequestArgs {
  readonly method: string;
  readonly params?: readonly unknown[] | object | Hex[];
}

export interface ProviderRpcError extends Error {
  code: number;
  data?: unknown;
  message: string;
}

export type ProviderEventMap = {
  accountsChanged: string[];
  chainChanged: string; // hex string
  connect: {
    readonly chainId: string;
  };
  disconnect: ProviderRpcError;
};

export type ProviderEventCallback = ProviderInterface["emit"];

export class ProviderEventEmitter extends EventEmitter<
  keyof ProviderEventMap
> {}

export interface ProviderInterface extends ProviderEventEmitter {
  disconnect(): Promise<void>;
  emit<K extends keyof ProviderEventMap>(
    event: K,
    ...args: [ProviderEventMap[K]]
  ): boolean;
  on<K extends keyof ProviderEventMap>(
    event: K,
    listener: (_: ProviderEventMap[K]) => void,
  ): this;
  request(args: RpcRequestArgs): Promise<any>;
}

export interface GeminiSdkMessage {
  chainId: number;
  data?: unknown;
  event: GeminiSdkEvent;
  origin: string;
  requestId?: string;
  wcData?: any;
}

export interface GeminiSdkMessageResponse {
  data?: unknown;
  event: GeminiSdkEvent;
  requestId?: string;
}

export interface ConnectResponse
  extends Omit<GeminiSdkMessageResponse, "data"> {
  data: { address: Address };
}

export interface SendTransactionResponse
  extends Omit<GeminiSdkMessageResponse, "data"> {
  data: { hash?: Hex; error?: string };
}

export interface SignMessageResponse
  extends Omit<GeminiSdkMessageResponse, "data"> {
  data: { hash?: Hex; error?: string };
}

export interface SignTypedDataResponse
  extends Omit<GeminiSdkMessageResponse, "data"> {
  data: { hash?: Hex; error?: string };
}

export interface SwitchChainResponse
  extends Omit<GeminiSdkMessageResponse, "data"> {
  data: { chainId?: number; error?: string };
}

export interface GeminiSdkSendTransaction
  extends Omit<GeminiSdkMessage, "data"> {
  data: TransactionRequest;
}

export interface GeminiSdkSignMessage extends Omit<GeminiSdkMessage, "data"> {
  data: SignMessageParameters;
}

export interface GeminiSdkSignTypedData extends Omit<GeminiSdkMessage, "data"> {
  data: SignTypedDataParameters;
}

export interface GeminiSdkSwitchChain extends Omit<GeminiSdkMessage, "data"> {
  data: number;
}

export interface GeminiSdkAppContextMessage
  extends Omit<GeminiSdkMessage, "data"> {
  data: AppContext;
}

export interface ReverseEnsResponse {
  address: Address;
  name: string | null;
}