@helium/blockchain-api 0.1.1 → 0.1.3

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,
-};

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

@@ -1,80 +0,0 @@
-import { z } from "zod";
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-export const GetBalancesInputSchema = z.object({
-  walletAddress: z.string().min(32),
-});
-
-export const TransferInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  mint: z.string().nullable().optional(),
-  destination: z.string().min(32),
-  amount: z.string(),
-  decimals: z.number().optional(),
-});
-
-export const CreateHntAccountInputSchema = z.object({
-  walletAddress: z.string().min(32),
-});
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-export const TokenAccountSchema = z.object({
-  mint: z.string(),
-  address: z.string(),
-  balance: z.string(),
-  decimals: z.number(),
-  uiAmount: z.number(),
-  symbol: z.string().optional(),
-  name: z.string().optional(),
-  logoURI: z.string().optional(),
-  priceUsd: z.number().optional(),
-  balanceUsd: z.number().optional(),
-});
-
-export const TokenBalanceDataSchema = z.object({
-  totalBalanceUsd: z.number(),
-  solBalance: z.number(),
-  solBalanceUsd: z.number(),
-  tokens: z.array(TokenAccountSchema),
-});
-
-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(),
-});
-
-export const TransferOutputSchema = z.object({
-  transactionData: TransactionDataSchema,
-});
-
-export const CreateHntAccountOutputSchema = z.object({
-  transactionData: TransactionDataSchema,
-});
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-export type GetBalancesInput = z.infer<typeof GetBalancesInputSchema>;
-export type TransferInput = z.infer<typeof TransferInputSchema>;
-export type CreateHntAccountInput = z.infer<typeof CreateHntAccountInputSchema>;
-export type TokenBalanceData = z.infer<typeof TokenBalanceDataSchema>;

package/src/server/api/routers/transactions/procedures/get.ts

@@ -1,46 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetInputSchema, BatchStatusOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import PendingTransaction from "@/lib/models/pending-transaction";
-import TransactionBatch from "@/lib/models/transaction-batch";
-import { checkAndUpdateBatchStatus } from "@/lib/utils/transaction-status-checker";
-
-/**
- * Get transaction batch status by ID.
- */
-export const get = publicProcedure
-  .route({ method: "GET", path: "/transactions/{id}" })
-  .input(GetInputSchema)
-  .output(BatchStatusOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Batch not found" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { id, commitment } = input;
-
-    // First check if this is a batch ID
-    const batch = await TransactionBatch.findByPk(id, {
-      include: [
-        {
-          model: PendingTransaction,
-          as: "transactions",
-        },
-      ],
-    });
-
-    if (!batch) {
-      throw errors.NOT_FOUND({ message: "Batch not found" });
-    }
-
-    const result = await checkAndUpdateBatchStatus(batch, commitment);
-
-    return {
-      batchId: batch.id,
-      status: result.batchStatus,
-      submissionType: batch.submissionType,
-      parallel: batch.parallel,
-      transactions: result.transactionStatuses,
-      jitoBundleId: batch.jitoBundleId,
-      jitoBundleStatus: result.jitoBundleStatus,
-    };
-  });

package/src/server/api/routers/transactions/procedures/getByPayer.ts

@@ -1,111 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetByPayerInputSchema, PayerBatchesOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import PendingTransaction from "@/lib/models/pending-transaction";
-import TransactionBatch, { BatchStatus } from "@/lib/models/transaction-batch";
-import { connectToDb } from "@/lib/utils/db";
-import { Op } from "sequelize";
-
-/**
- * Get transaction batches by payer address.
- */
-export const getByPayer = publicProcedure
-  .route({ method: "GET", path: "/transactions/payer/{payer}" })
-  .input(GetByPayerInputSchema)
-  .output(PayerBatchesOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { payer, page, limit, status } = input;
-
-    await connectToDb();
-
-    if (!payer) {
-      throw errors.BAD_REQUEST({ message: "Payer is required" });
-    }
-
-    // Parse status filter
-    let statusFilter: BatchStatus[] = ["pending"];
-
-    if (status) {
-      const requestedStatuses = status
-        .split(",")
-        .map((s) => s.trim()) as BatchStatus[];
-      const validStatuses: BatchStatus[] = [
-        "pending",
-        "confirmed",
-        "failed",
-        "expired",
-        "partial",
-      ];
-      statusFilter = requestedStatuses.filter((s) => validStatuses.includes(s));
-
-      if (statusFilter.length === 0) {
-        throw errors.BAD_REQUEST({
-          message:
-            "Invalid status filter. Valid values: pending, confirmed, failed, expired, partial",
-        });
-      }
-    }
-
-    const offset = (page - 1) * limit;
-
-    // Build where clause
-    const whereClause = {
-      payer,
-      status: {
-        [Op.in]: statusFilter,
-      },
-    };
-
-    // Get total count for pagination
-    const total = await TransactionBatch.count({
-      where: whereClause,
-    });
-
-    // Find paginated transaction batches for the payer
-    const batches = await TransactionBatch.findAll({
-      where: whereClause,
-      include: [
-        {
-          model: PendingTransaction,
-          as: "transactions",
-        },
-      ],
-      order: [["createdAt", "DESC"]],
-      limit,
-      offset,
-    });
-
-    const batchSummaries = batches.map((batch) => ({
-      batchId: batch.id,
-      tag: batch.tag || undefined,
-      status: batch.status,
-      submissionType: batch.submissionType,
-      parallel: batch.parallel,
-      createdAt: batch.createdAt.toISOString(),
-      updatedAt: batch.updatedAt.toISOString(),
-      transactions:
-        (
-          batch as unknown as { transactions?: { metadata?: unknown }[] }
-        ).transactions?.map((tx) => ({
-          metadata: tx.metadata as
-            | { type: string; description: string }
-            | undefined,
-        })) || [],
-    }));
-
-    const totalPages = Math.ceil(total / limit);
-
-    return {
-      payer,
-      batches: batchSummaries,
-      pagination: {
-        page,
-        limit,
-        total,
-        totalPages,
-      },
-    };
-  });