@helium/blockchain-api 0.1.2 → 0.1.3

package/src/server/api/routers/swap/procedures/getInstructions.ts

@@ -1,152 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetInstructionsInputSchema, TransactionDataSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import {
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-
-/**
- * Get swap transaction instructions from Jupiter and build a transaction.
- */
-export const getInstructions = publicProcedure
-  .route({ method: "POST", path: "/swap/instructions" })
-  .input(GetInstructionsInputSchema)
-  .output(TransactionDataSchema)
-  .errors({
-    JUPITER_ERROR: { message: "Failed to get swap instructions from Jupiter" },
-  })
-  .handler(async ({ input, errors }) => {
-    const {
-      quoteResponse,
-      userPublicKey,
-      destinationTokenAccount,
-      dynamicComputeUnitLimit,
-      prioritizationFeeLamports,
-    } = input;
-
-    // Get swap instructions from Jupiter
-    const instructionsResponse = await fetch(
-      `${env.JUPITER_API_URL}/swap/v1/swap-instructions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": env.JUPITER_API_KEY,
-        },
-        body: JSON.stringify({
-          quoteResponse,
-          userPublicKey,
-          destinationTokenAccount,
-          dynamicComputeUnitLimit,
-          prioritizationFeeLamports: prioritizationFeeLamports || {
-            priorityLevelWithMaxLamports: {
-              maxLamports: 1000000,
-              priorityLevel: "medium",
-            },
-          },
-        }),
-      },
-    );
-
-    if (!instructionsResponse.ok) {
-      const errorText = await instructionsResponse.text();
-      console.error("Jupiter API error:", errorText);
-      throw errors.JUPITER_ERROR({
-        message: `Failed to get swap instructions from Jupiter: HTTP ${instructionsResponse.status}`,
-      });
-    }
-
-    const instructions = await instructionsResponse.json();
-
-    if (instructions.error) {
-      throw errors.JUPITER_ERROR({
-        message: `Jupiter API returned error: ${instructions.error}`,
-      });
-    }
-
-    // Build the transaction using the same pattern
-    const deserializeInstruction = (instruction: {
-      programId: string;
-      accounts: { pubkey: string; isSigner: boolean; isWritable: boolean }[];
-      data: string;
-    }) => {
-      return new TransactionInstruction({
-        programId: new PublicKey(instruction.programId),
-        keys: instruction.accounts.map((key) => ({
-          pubkey: new PublicKey(key.pubkey),
-          isSigner: key.isSigner,
-          isWritable: key.isWritable,
-        })),
-        data: Buffer.from(instruction.data, "base64"),
-      });
-    };
-
-    const jupIxs = [
-      ...(instructions.setupInstructions
-        ? instructions.setupInstructions.map(
-            (instruction: {
-              programId: string;
-              accounts: {
-                pubkey: string;
-                isSigner: boolean;
-                isWritable: boolean;
-              }[];
-              data: string;
-            }) => deserializeInstruction(instruction),
-          )
-        : []),
-      // Swap instruction
-      deserializeInstruction(instructions.swapInstruction),
-      // Cleanup instruction if present
-      ...(instructions.cleanupInstruction
-        ? [deserializeInstruction(instructions.cleanupInstruction)]
-        : []),
-    ];
-
-    const draft = {
-      instructions: jupIxs,
-      feePayer: new PublicKey(userPublicKey),
-      addressLookupTableAddresses: instructions.addressLookupTableAddresses.map(
-        (address: string) => new PublicKey(address),
-      ),
-    };
-
-    const connection = new Connection(process.env.SOLANA_RPC_URL!);
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(connection, {
-        ...draft,
-        instructions: await withPriorityFees({ ...draft, connection }),
-      }),
-    );
-
-    // Generate transaction tag
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.SWAP,
-      userAddress: userPublicKey,
-      inputMint: quoteResponse.inputMint,
-      outputMint: quoteResponse.outputMint,
-      amount: quoteResponse.inAmount,
-    });
-
-    return {
-      transactions: [
-        {
-          serializedTransaction: Buffer.from(tx.serialize()).toString("base64"),
-          metadata: {
-            type: "swap",
-            description: `Swap ${quoteResponse.inAmount} ${quoteResponse.inputMint} for ${quoteResponse.outAmount} ${quoteResponse.outputMint}`,
-          },
-        },
-      ],
-      parallel: false,
-      tag,
-    };
-  });

package/src/server/api/routers/swap/procedures/getQuote.ts

@@ -1,53 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetQuoteInputSchema, QuoteResponseSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-
-/**
- * Get a quote for swapping tokens from Jupiter.
- */
-export const getQuote = publicProcedure
-  .route({ method: "GET", path: "/swap/quote" })
-  .input(GetQuoteInputSchema)
-  .output(QuoteResponseSchema)
-  .errors({
-    JUPITER_ERROR: { message: "Failed to get quote from Jupiter" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { inputMint, outputMint, amount, swapMode, slippageBps } = input;
-
-    // Get quote from Jupiter
-    const quoteUrl = new URL(`${env.JUPITER_API_URL}/swap/v1/quote`);
-    quoteUrl.searchParams.set("inputMint", inputMint);
-    quoteUrl.searchParams.set("outputMint", outputMint);
-    quoteUrl.searchParams.set("amount", amount);
-    quoteUrl.searchParams.set("swapMode", swapMode);
-    quoteUrl.searchParams.set("slippageBps", slippageBps.toString());
-
-    const quoteResponse = await fetch(quoteUrl.toString(), {
-      headers: {
-        "x-api-key": env.JUPITER_API_KEY,
-      },
-    });
-
-    if (!quoteResponse.ok) {
-      const errorText = await quoteResponse.text();
-      console.error("Jupiter API error:", errorText);
-      throw errors.JUPITER_ERROR({
-        message: `Failed to get quote from Jupiter: HTTP ${quoteResponse.status}`,
-      });
-    }
-
-    const quote = await quoteResponse.json();
-
-    // Validate the response from Jupiter
-    const responseValidation = QuoteResponseSchema.safeParse(quote);
-    if (!responseValidation.success) {
-      console.error("Invalid Jupiter response:", responseValidation.error);
-      throw errors.JUPITER_ERROR({
-        message: "Invalid response from Jupiter API",
-      });
-    }
-
-    return responseValidation.data;
-  });

package/src/server/api/routers/swap/procedures/getTokens.ts

@@ -1,88 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetTokensInputSchema, TokenListOutputSchema, Token } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { TOKEN_MINTS } from "@/lib/constants/tokens";
-
-/**
- * Get list of verified tokens available for swapping from Jupiter.
- */
-export const getTokens = publicProcedure
-  .route({ method: "GET", path: "/swap/tokens" })
-  .input(GetTokensInputSchema)
-  .output(TokenListOutputSchema)
-  .errors({
-    JUPITER_ERROR: { message: "Failed to fetch tokens from Jupiter" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { limit } = input;
-
-    // Use Jupiter's Token API V2 endpoint for verified tokens
-    const jupiterUrl = new URL(`${env.JUPITER_API_URL}/tokens/v2/tag`);
-    jupiterUrl.searchParams.set("query", "verified");
-
-    const jupiterResponse = await fetch(jupiterUrl.toString(), {
-      headers: {
-        "User-Agent": "my-helium-api/1.0",
-        "x-api-key": env.JUPITER_API_KEY,
-      },
-    });
-
-    if (!jupiterResponse.ok) {
-      const errorText = await jupiterResponse.text();
-      console.error("Jupiter Token API error:", errorText);
-      throw errors.JUPITER_ERROR({
-        message: `Failed to fetch tokens from Jupiter: HTTP ${jupiterResponse.status}`,
-      });
-    }
-
-    const jupiterTokens: {
-      id: string;
-      symbol: string;
-      name: string;
-      decimals: number;
-      icon?: string;
-      tags?: string[];
-    }[] = await jupiterResponse.json();
-
-    // Transform the V2 response format to our expected format
-    const validatedTokens: Token[] = jupiterTokens
-      .slice(0, limit)
-      .map((token) => ({
-        address: token.id,
-        symbol: token.symbol,
-        name: token.name,
-        decimals: token.decimals,
-        logoURI: token.icon,
-        tags: token.tags || [],
-      }));
-
-    // Add HNT token at the top if it's not already in the list
-    const hntToken: Token = {
-      address: TOKEN_MINTS.HNT,
-      symbol: "HNT",
-      name: "Helium",
-      decimals: 8,
-      logoURI: "https://cryptologos.cc/logos/helium-hnt-logo.png",
-      tags: ["helium", "iot", "crypto"],
-    };
-
-    // Check if HNT is already in the list
-    const hasHNT = validatedTokens.some((token) => token.symbol === "HNT");
-
-    // Add HNT at the top if not present
-    if (!hasHNT) {
-      validatedTokens.unshift(hntToken);
-    } else {
-      // Move HNT to the top if it exists
-      const hntIndex = validatedTokens.findIndex(
-        (token) => token.symbol === "HNT",
-      );
-      if (hntIndex > 0) {
-        const hnt = validatedTokens.splice(hntIndex, 1)[0];
-        validatedTokens.unshift(hnt);
-      }
-    }
-
-    return { tokens: validatedTokens };
-  });

package/src/server/api/routers/swap/router.ts

@@ -1,15 +0,0 @@
-import { getTokens } from "./procedures/getTokens";
-import { getQuote } from "./procedures/getQuote";
-import { getInstructions } from "./procedures/getInstructions";
-
-/**
- * Swap router - handles token swap operations via Jupiter.
- */
-export const swapRouter = {
-  /** Get list of verified tokens available for swapping */
-  getTokens,
-  /** Get a quote for swapping tokens */
-  getQuote,
-  /** Get swap transaction instructions */
-  getInstructions,
-};

package/src/server/api/routers/swap/schemas.ts

@@ -1,96 +0,0 @@
-import { z } from "zod";
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-export const GetTokensInputSchema = z.object({
-  limit: z.coerce.number().int().min(1).max(100).default(50),
-});
-
-export const GetQuoteInputSchema = z.object({
-  inputMint: z.string().min(1),
-  outputMint: z.string().min(1),
-  amount: z.string().min(1),
-  swapMode: z.enum(["ExactIn", "ExactOut"]).default("ExactIn"),
-  slippageBps: z.coerce.number().min(0).max(10000).default(50),
-});
-
-export const QuoteResponseSchema = z
-  .object({
-    inputMint: z.string(),
-    inAmount: z.string(),
-    outputMint: z.string(),
-    outAmount: z.string(),
-    otherAmountThreshold: z.string(),
-    swapMode: z.string(),
-    slippageBps: z.number(),
-    platformFee: z.unknown().optional(),
-    priceImpactPct: z.string(),
-    routePlan: z.array(z.unknown()),
-    contextSlot: z.number().optional(),
-    timeTaken: z.number().optional(),
-  })
-  .passthrough(); // Allow additional fields from Jupiter that we don't explicitly define
-
-export const GetInstructionsInputSchema = z.object({
-  quoteResponse: QuoteResponseSchema,
-  userPublicKey: z.string().min(1),
-  destinationTokenAccount: z.string().optional(),
-  dynamicComputeUnitLimit: z.boolean().default(true),
-  prioritizationFeeLamports: z
-    .object({
-      priorityLevelWithMaxLamports: z.object({
-        maxLamports: z.number().default(1000000),
-        priorityLevel: z.enum(["low", "medium", "high"]).default("medium"),
-      }),
-    })
-    .optional(),
-});
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-export const TokenSchema = z.object({
-  address: z.string(),
-  symbol: z.string(),
-  name: z.string(),
-  decimals: z.number(),
-  logoURI: z.string().optional(),
-  tags: z.array(z.string()).optional(),
-});
-
-export const TokenListOutputSchema = z.object({
-  tokens: z.array(TokenSchema),
-});
-
-export const TransactionMetadataSchema = z
-  .object({
-    type: z.string(),
-    description: z.string(),
-  })
-  .catchall(z.unknown());
-
-export const TransactionItemSchema = z.object({
-  serializedTransaction: z.string(),
-  metadata: TransactionMetadataSchema.optional(),
-});
-
-export const TransactionDataSchema = z.object({
-  transactions: z.array(TransactionItemSchema),
-  parallel: z.boolean(),
-  tag: z.string().optional(),
-});
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-export type GetTokensInput = z.infer<typeof GetTokensInputSchema>;
-export type GetQuoteInput = z.infer<typeof GetQuoteInputSchema>;
-export type GetInstructionsInput = z.infer<typeof GetInstructionsInputSchema>;
-export type QuoteResponse = z.infer<typeof QuoteResponseSchema>;
-export type Token = z.infer<typeof TokenSchema>;
-export type TokenListOutput = z.infer<typeof TokenListOutputSchema>;
-export type TransactionData = z.infer<typeof TransactionDataSchema>;

package/src/server/api/routers/tokens/procedures/createHntAccount.ts

@@ -1,87 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import {
-  CreateHntAccountInputSchema,
-  CreateHntAccountOutputSchema,
-} from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { PublicKey, Connection } from "@solana/web3.js";
-import {
-  createAssociatedTokenAccountIdempotentInstruction,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token";
-import {
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-  HNT_MINT,
-} from "@helium/spl-utils";
-import { env } from "@/lib/env";
-
-/**
- * Create an HNT token account for a wallet.
- */
-export const createHntAccount = publicProcedure
-  .route({ method: "POST", path: "/tokens/{walletAddress}/hnt-account/create" })
-  .input(CreateHntAccountInputSchema)
-  .output(CreateHntAccountOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Wallet address is required" },
-  })
-  .handler(async ({ input }) => {
-    const { walletAddress } = input;
-
-    if (!walletAddress) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Wallet address is required",
-      });
-    }
-
-    const wallet = new PublicKey(walletAddress);
-
-    // Get the associated token account address for HNT
-    const hntTokenAccount = getAssociatedTokenAddressSync(
-      HNT_MINT,
-      wallet,
-      true, // allowOwnerOffCurve
-    );
-
-    // Create instruction to create the associated token account
-    const createAccountInstruction =
-      createAssociatedTokenAccountIdempotentInstruction(
-        wallet, // payer
-        hntTokenAccount, // associated token account
-        wallet, // owner
-        HNT_MINT, // mint
-      );
-
-    const draft = {
-      instructions: [createAccountInstruction],
-      feePayer: wallet,
-      addressLookupTableAddresses: [] as PublicKey[],
-    };
-
-    const connection = new Connection(env.SOLANA_RPC_URL);
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(connection, {
-        ...draft,
-        instructions: await withPriorityFees({ ...draft, connection }),
-      }),
-    );
-
-    return {
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction: Buffer.from(tx.serialize()).toString(
-              "base64",
-            ),
-            metadata: {
-              type: "hnt-token-account",
-              description: "Create HNT token account",
-            },
-          },
-        ],
-        parallel: false,
-      },
-    };
-  });

package/src/server/api/routers/tokens/procedures/getBalances.ts

@@ -1,27 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetBalancesInputSchema, TokenBalanceDataSchema } from "../schemas";
-import { getTokenBalances } from "@/lib/queries/tokens";
-import { ORPCError } from "@orpc/server";
-
-/**
- * Get token balances for a wallet address.
- */
-export const getBalances = publicProcedure
-  .route({ method: "GET", path: "/tokens/{walletAddress}" })
-  .input(GetBalancesInputSchema)
-  .output(TokenBalanceDataSchema)
-  .errors({
-    BAD_REQUEST: { message: "Wallet address is required" },
-  })
-  .handler(async ({ input }) => {
-    const { walletAddress } = input;
-
-    if (!walletAddress) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Wallet address is required",
-      });
-    }
-
-    const tokenBalances = await getTokenBalances({ walletAddress });
-    return tokenBalances;
-  });

package/src/server/api/routers/tokens/procedures/transfer.ts

@@ -1,159 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { TransferInputSchema, TransferOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { PublicKey, SystemProgram, Connection } from "@solana/web3.js";
-import {
-  createAssociatedTokenAccountIdempotentInstruction,
-  createTransferCheckedInstruction,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token";
-import {
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-import { TOKEN_MINTS } from "@/lib/constants/tokens";
-
-/**
- * Create a transaction to transfer tokens (SOL or SPL tokens).
- */
-export const transfer = publicProcedure
-  .route({ method: "POST", path: "/tokens/{walletAddress}/transfer" })
-  .input(TransferInputSchema)
-  .output(TransferOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-    INSUFFICIENT_FUNDS: { message: "Insufficient balance" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress, mint, destination, amount, decimals } = input;
-
-    if (!destination || !amount) {
-      throw errors.BAD_REQUEST({
-        message: "Destination and amount are required",
-      });
-    }
-
-    const feePayer = new PublicKey(walletAddress);
-    const destKey = new PublicKey(destination);
-    const connection = new Connection(process.env.SOLANA_RPC_URL!);
-
-    const isSol = !mint || mint === "SOL" || mint === TOKEN_MINTS.WSOL;
-
-    const instructions: (
-      | ReturnType<typeof SystemProgram.transfer>
-      | ReturnType<typeof createAssociatedTokenAccountIdempotentInstruction>
-      | ReturnType<typeof createTransferCheckedInstruction>
-    )[] = [];
-
-    if (isSol) {
-      // Native SOL transfer
-      const normalized = (amount || "").trim();
-      const lamports = Math.round(parseFloat(normalized) * 1e9);
-      if (!Number.isFinite(lamports) || lamports <= 0) {
-        throw errors.BAD_REQUEST({ message: "Amount must be greater than 0" });
-      }
-
-      // Ensure sender has sufficient SOL balance before creating tx
-      const balance = await connection.getBalance(feePayer);
-      if (balance < lamports) {
-        throw errors.INSUFFICIENT_FUNDS({
-          message: "Insufficient SOL balance",
-          data: {
-            balance,
-            required: lamports,
-          },
-        });
-      }
-
-      instructions.push(
-        SystemProgram.transfer({
-          fromPubkey: feePayer,
-          toPubkey: destKey,
-          lamports,
-        }),
-      );
-    } else {
-      if (!decimals || decimals < 0) {
-        throw errors.BAD_REQUEST({ message: "Token decimals are required" });
-      }
-
-      const mintKey = new PublicKey(mint!);
-      const senderAta = getAssociatedTokenAddressSync(mintKey, feePayer, true);
-      const destAta = getAssociatedTokenAddressSync(mintKey, destKey, true);
-      const normalized = (amount || "").trim();
-      const rawAmount = Math.round(
-        parseFloat(normalized) * Math.pow(10, decimals),
-      );
-
-      if (!Number.isFinite(rawAmount) || rawAmount <= 0) {
-        throw errors.BAD_REQUEST({ message: "Amount must be greater than 0" });
-      }
-
-      // Ensure destination ATA exists
-      instructions.push(
-        createAssociatedTokenAccountIdempotentInstruction(
-          feePayer,
-          destAta,
-          destKey,
-          mintKey,
-        ),
-      );
-
-      instructions.push(
-        createTransferCheckedInstruction(
-          senderAta,
-          mintKey,
-          destAta,
-          feePayer,
-          rawAmount,
-          decimals,
-        ),
-      );
-    }
-
-    const draft = {
-      instructions,
-      feePayer,
-      addressLookupTableAddresses: [] as PublicKey[],
-    };
-
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(connection, {
-        ...draft,
-        instructions: await withPriorityFees({ ...draft, connection }),
-      }),
-    );
-
-    const tokenSymbol = isSol ? "SOL" : "Token";
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.TOKEN_TRANSFER,
-      walletAddress,
-      destination,
-      mint: mint || "SOL",
-      amount,
-    });
-
-    return {
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction: Buffer.from(tx.serialize()).toString(
-              "base64",
-            ),
-            metadata: {
-              type: "token_transfer",
-              description: `Transfer ${tokenSymbol}`,
-            },
-          },
-        ],
-        parallel: false,
-        tag,
-      },
-    };
-  });

package/src/server/api/routers/tokens/router.ts

@@ -1,15 +0,0 @@
-import { getBalances } from "./procedures/getBalances";
-import { transfer } from "./procedures/transfer";
-import { createHntAccount } from "./procedures/createHntAccount";
-
-/**
- * Tokens router - handles all token-related operations.
- */
-export const tokensRouter = {
-  /** Get token balances for a wallet */
-  getBalances,
-  /** Create a transaction to transfer tokens */
-  transfer,
-  /** Create an HNT token account for a wallet */
-  createHntAccount,
-};