@helium/blockchain-api 0.1.1 → 0.1.3

package/src/server/api/errors.ts

@@ -1,152 +0,0 @@
-import { z } from "zod";
-
-/**
- * Global error definitions for the ORPC API.
- * These can be used across all routers for consistent error handling.
- */
-
-/** Authentication required error */
-export const UNAUTHORIZED = {
-  status: 401,
-  message: "Authentication required. Please sign in to continue.",
-} as const;
-
-/** Insufficient permissions error */
-export const FORBIDDEN = {
-  status: 403,
-  message: "You do not have permission to access this resource.",
-} as const;
-
-/** Resource not found error */
-export const NOT_FOUND = {
-  status: 404,
-  message: "The requested resource was not found.",
-} as const;
-
-/** Input validation failed error */
-export const VALIDATION_ERROR = {
-  status: 400,
-  message: "Invalid input data provided.",
-  data: z.object({
-    fields: z.array(z.string()).optional(),
-  }),
-} as const;
-
-/** Insufficient Solana balance error */
-export const INSUFFICIENT_FUNDS = {
-  status: 400,
-  message: "Insufficient SOL balance to complete this transaction.",
-  data: z.object({
-    required: z.number(),
-    available: z.number(),
-  }),
-} as const;
-
-/** Solana transaction failed error */
-export const TRANSACTION_FAILED = {
-  status: 500,
-  message: "Transaction failed to execute.",
-  data: z.object({
-    logs: z.array(z.string()).optional(),
-    signature: z.string().optional(),
-  }),
-} as const;
-
-/** Transaction simulation failed error */
-export const SIMULATION_FAILED = {
-  status: 400,
-  message: "Transaction simulation failed.",
-  data: z.object({
-    logs: z.array(z.string()).optional(),
-    link: z.string().optional(),
-  }),
-} as const;
-
-/** External API error (Jupiter, Bridge, Oracle, etc.) */
-export const EXTERNAL_API_ERROR = {
-  status: 502,
-  message: "External service request failed.",
-  data: z.object({
-    service: z.string(),
-    statusCode: z.number().optional(),
-    details: z.string().optional(),
-  }),
-} as const;
-
-/** Rate limit exceeded error */
-export const RATE_LIMITED = {
-  status: 429,
-  message: "Too many requests. Please try again later.",
-} as const;
-
-/** Duplicate resource error */
-export const CONFLICT = {
-  status: 409,
-  message: "A resource with this identifier already exists.",
-  data: z.object({
-    existingId: z.string().optional(),
-  }),
-} as const;
-
-/** Asset not owned by wallet error */
-export const NOT_OWNER = {
-  status: 403,
-  message: "You do not own this asset.",
-  data: z.object({
-    owner: z.string(),
-    wallet: z.string(),
-  }),
-} as const;
-
-/** Invalid Helium hotspot error */
-export const INVALID_HOTSPOT = {
-  status: 400,
-  message: "The specified asset is not a valid Helium hotspot.",
-} as const;
-
-/** KYC/Compliance error */
-export const KYC_REQUIRED = {
-  status: 403,
-  message: "KYC verification is required to perform this action.",
-  data: z.object({
-    kycStatus: z.string(),
-    kycLink: z.string().optional(),
-  }),
-} as const;
-
-/**
- * Common error definitions that can be spread into procedure error configs.
- * Usage: .errors({ ...commonErrors, CUSTOM_ERROR: { ... } })
- */
-export const commonErrors = {
-  UNAUTHORIZED,
-  FORBIDDEN,
-  NOT_FOUND,
-  VALIDATION_ERROR,
-} as const;
-
-/**
- * Solana-specific error definitions for transaction-related procedures.
- */
-export const solanaErrors = {
-  INSUFFICIENT_FUNDS,
-  TRANSACTION_FAILED,
-  SIMULATION_FAILED,
-} as const;
-
-/**
- * Hotspot-specific error definitions.
- */
-export const hotspotErrors = {
-  NOT_OWNER,
-  INVALID_HOTSPOT,
-  NOT_FOUND,
-} as const;
-
-/**
- * Fiat/offramp-specific error definitions.
- */
-export const fiatErrors = {
-  KYC_REQUIRED,
-  EXTERNAL_API_ERROR,
-} as const;

package/src/server/api/index.ts

@@ -1,40 +0,0 @@
-import { createRouterClient } from "@orpc/server";
-import { healthRouter } from "./routers/health/router";
-import { hotspotsRouter } from "./routers/hotspots/router";
-import { tokensRouter } from "./routers/tokens/router";
-import { swapRouter } from "./routers/swap/router";
-import { transactionsRouter } from "./routers/transactions/router";
-import { welcomePacksRouter } from "./routers/welcomePacks/router";
-import { fiatRouter } from "./routers/fiat/router";
-import { webhooksRouter } from "./routers/webhooks/router";
-
-/**
- * Main ORPC router combining all domain-specific routers.
- *
- * This router provides both REST endpoints (via OpenAPIHandler) and
- * RPC endpoints (via RPCHandler) from the same procedure definitions.
- */
-export const appRouter = {
-  /** Health check procedures */
-  health: healthRouter,
-  /** Hotspot management procedures */
-  hotspots: hotspotsRouter,
-  /** Token balance and transfer procedures */
-  tokens: tokensRouter,
-  /** Token swap procedures via Jupiter */
-  swap: swapRouter,
-  /** Transaction submission and tracking procedures */
-  transactions: transactionsRouter,
-  /** Welcome pack management procedures */
-  welcomePacks: welcomePacksRouter,
-  /** Fiat offramp and bank account procedures */
-  fiat: fiatRouter,
-  /** Webhook handler procedures */
-  webhooks: webhooksRouter,
-};
-
-/** Type of the main router for client-side type inference */
-export type ORPCRouter = typeof appRouter;
-
-/** Server-side router client for direct procedure calls */
-export const api = createRouterClient(appRouter);

package/src/server/api/procedures.ts

@@ -1,144 +0,0 @@
-import { ORPCError, os } from "@orpc/server";
-import { cookies } from "next/headers";
-import { privy } from "@/lib/privy";
-import { env } from "@/lib/env";
-import type { User } from "@privy-io/server-auth";
-
-/**
- * Session context provided to authenticated procedures.
- */
-export interface SessionContext {
-  /** Privy user ID */
-  userId: string;
-  /** User's wallet address (if available) */
-  walletAddress: string | null;
-  /** Full Privy user object */
-  user: User;
-}
-
-/**
- * Base context available to all procedures.
- */
-export interface BaseContext {
-  /** Session data (null if not authenticated) */
-  session: SessionContext | null;
-}
-
-/**
- * Context available to authenticated procedures.
- */
-export interface AuthenticatedContext extends BaseContext {
-  session: SessionContext;
-}
-
-/**
- * Middleware for timing procedure execution and adding an artificial delay in development.
- *
- * You can remove this if you don't like it, but it can help catch unwanted waterfalls by simulating
- * network latency that would occur in production but not in local development.
- */
-const timingMiddleware = os.middleware(async ({ next, path }) => {
-  const start = Date.now();
-
-  if (env.NODE_ENV === "development") {
-    // artificial delay in dev
-    const waitMs = Math.floor(Math.random() * 400) + 100;
-    await new Promise((resolve) => setTimeout(resolve, waitMs));
-  }
-
-  const result = await next();
-
-  const end = Date.now();
-  console.log(`[ORPC] ${path.join(".")} took ${end - start}ms to execute`);
-
-  return result;
-});
-
-/**
- * Authentication middleware that extracts Privy session from cookies.
- * Sets session to null if not authenticated (allows public procedures to check auth status).
- */
-const authMiddleware = os.middleware(async ({ next }) => {
-  let session: SessionContext | null = null;
-
-  try {
-    const cookieStore = await cookies();
-    const idToken = cookieStore.get("privy-id-token")?.value;
-
-    if (idToken) {
-      const privyUser = await privy.getUser({ idToken });
-
-      if (privyUser) {
-        session = {
-          userId: privyUser.id,
-          walletAddress: privyUser.wallet?.address ?? null,
-          user: privyUser,
-        };
-      }
-    }
-  } catch (error) {
-    // Auth failed - session remains null
-    console.error("[ORPC] Auth middleware error:", error);
-  }
-
-  return next({
-    context: {
-      session,
-    } satisfies BaseContext,
-  });
-});
-
-/**
- * Public (unauthenticated) procedure
- *
- * This is the base piece you use to build new queries and mutations on your API. It does not
- * guarantee that a user querying is authorized, but you can still access user session data if they
- * are logged in.
- */
-export const publicProcedure = os.use(timingMiddleware).use(authMiddleware);
-
-/**
- * Protected (authenticated) procedure
- *
- * If you want a query or mutation to ONLY be accessible to logged in users, use this. It verifies
- * the session is valid and guarantees `context.session` is not null.
- */
-export const protectedProcedure = publicProcedure.use(
-  async ({ context, next }) => {
-    if (!context.session) {
-      throw new ORPCError("UNAUTHORIZED", {
-        message: "You must be logged in to access this resource.",
-      });
-    }
-
-    return next({
-      context: {
-        ...context,
-        session: context.session,
-      } satisfies AuthenticatedContext,
-    });
-  },
-);
-
-/**
- * Wallet-required procedure
- *
- * Use this for procedures that require the user to have a connected wallet.
- * Extends protectedProcedure and additionally verifies wallet is present.
- */
-export const walletProcedure = protectedProcedure.use(
-  async ({ context, next }) => {
-    if (!context.session.walletAddress) {
-      throw new ORPCError("FORBIDDEN", {
-        message: "A connected wallet is required to perform this action.",
-      });
-    }
-
-    return next({
-      context: {
-        ...context,
-        walletAddress: context.session.walletAddress,
-      },
-    });
-  },
-);