@helium/blockchain-api 0.1.2 → 0.1.3

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

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

@@ -1,119 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import {
-  GetByPayerAndTagInputSchema,
-  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 and tag.
- */
-export const getByPayerAndTag = publicProcedure
-  .route({ method: "GET", path: "/transactions/payer/{payer}/tag/{tag}" })
-  .input(GetByPayerAndTagInputSchema)
-  .output(PayerBatchesOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { payer, tag, page, limit, status } = input;
-
-    await connectToDb();
-
-    if (!payer) {
-      throw errors.BAD_REQUEST({ message: "Payer is required" });
-    }
-
-    if (!tag) {
-      throw errors.BAD_REQUEST({ message: "Tag 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,
-      tag,
-      status: {
-        [Op.in]: statusFilter,
-      },
-    };
-
-    // Get total count for pagination
-    const total = await TransactionBatch.count({
-      where: whereClause,
-    });
-
-    // Find paginated transaction batches for the payer and tag
-    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,
-      },
-    };
-  });

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

@@ -1,68 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { ResubmitInputSchema, ResubmitOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import TransactionBatch from "@/lib/models/transaction-batch";
-import PendingTransaction from "@/lib/models/pending-transaction";
-import { resubmitTransactionBatch } from "@/lib/utils/transaction-resubmission";
-
-/**
- * Resubmit a batch of pending transactions that may have failed.
- */
-export const resubmit = publicProcedure
-  .route({ method: "POST", path: "/transactions/{id}/resubmit" })
-  .input(ResubmitInputSchema)
-  .output(ResubmitOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Batch not found" },
-    BAD_REQUEST: { message: "Invalid request" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { id } = input;
-
-    // Find the batch
-    const batch = await TransactionBatch.findByPk(id, {
-      include: [
-        {
-          model: PendingTransaction,
-          as: "transactions",
-          where: {
-            status: "pending",
-          },
-        },
-      ],
-    });
-
-    if (!batch) {
-      throw errors.NOT_FOUND({ message: "Batch not found" });
-    }
-
-    if (batch.status !== "pending") {
-      throw errors.BAD_REQUEST({ message: "Batch is not in pending status" });
-    }
-
-    const pendingTransactions =
-      (batch as unknown as { transactions?: PendingTransaction[] })
-        .transactions || [];
-    if (pendingTransactions.length === 0) {
-      throw errors.BAD_REQUEST({
-        message: "No pending transactions to resubmit",
-      });
-    }
-
-    // Attempt resubmission
-    const result = await resubmitTransactionBatch(batch, pendingTransactions);
-
-    if (result.success) {
-      return {
-        success: true,
-        message: "Transactions resubmitted successfully",
-        ...(result.newSignatures && { newSignatures: result.newSignatures }),
-      };
-    } else {
-      return {
-        success: false,
-        message: "Failed to resubmit transactions",
-        error: result.error,
-      };
-    }
-  });

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

@@ -1,216 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { SubmitInputSchema, SubmitOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { sequelize } from "@/lib/db";
-import { env } from "@/lib/env";
-import PendingTransaction from "@/lib/models/pending-transaction";
-import TransactionBatch from "@/lib/models/transaction-batch";
-import {
-  getCluster,
-  submitTransactionBatch,
-} from "@/lib/utils/transaction-submission";
-import { Connection, VersionedTransaction } from "@solana/web3.js";
-
-function getExplorerUrl(transaction: VersionedTransaction) {
-  const message = Buffer.from(transaction.message.serialize()).toString(
-    "base64",
-  );
-  return `https://explorer.solana.com/tx/inspector?cluster=${
-    process.env.NEXT_PUBLIC_SOLANA_CLUSTER
-  }&message=${encodeURIComponent(message)}`;
-}
-
-/**
- * Submit a batch of transactions for processing.
- */
-export const submit = publicProcedure
-  .route({ method: "POST", path: "/transactions" })
-  .input(SubmitInputSchema)
-  .output(SubmitOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-    SIMULATION_FAILED: { message: "Transaction simulation failed" },
-    CONFLICT: { message: "Duplicate transaction" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { transactions, parallel, tag } = input;
-
-    if (
-      !transactions ||
-      !Array.isArray(transactions) ||
-      transactions.length === 0
-    ) {
-      throw errors.BAD_REQUEST({
-        message: "Transactions array is required and cannot be empty",
-      });
-    }
-
-    // Extract payer from the first transaction
-    let payer: string;
-    try {
-      const firstTransaction = VersionedTransaction.deserialize(
-        Buffer.from(transactions[0].serializedTransaction, "base64"),
-      );
-      payer = firstTransaction.message.staticAccountKeys[0].toBase58();
-    } catch {
-      throw errors.BAD_REQUEST({
-        message: "Failed to decode transaction to extract payer",
-      });
-    }
-
-    if (transactions.length > 5) {
-      throw errors.BAD_REQUEST({
-        message: "Maximum of 5 transactions allowed per batch",
-      });
-    }
-
-    // Simulate transactions before submission (except for sequential batches)
-    if (parallel || transactions.length === 1) {
-      const connection = new Connection(env.SOLANA_RPC_URL);
-
-      const simulationPromises = transactions.map(async (tx, index) => {
-        try {
-          const transaction = VersionedTransaction.deserialize(
-            Buffer.from(tx.serializedTransaction, "base64"),
-          );
-          const simulation = await connection.simulateTransaction(transaction);
-
-          if (simulation.value.err) {
-            const errorMessage =
-              typeof simulation.value.err === "string"
-                ? simulation.value.err
-                : JSON.stringify(simulation.value.err);
-
-            return {
-              index,
-              error: `Transaction ${
-                index + 1
-              } simulation failed: ${errorMessage}`,
-              logs: simulation.value.logs,
-              link: getExplorerUrl(transaction),
-            };
-          }
-          return { index, success: true };
-        } catch (err) {
-          return {
-            index,
-            error: `Transaction ${index + 1} deserialization failed: ${
-              err instanceof Error ? err.message : "Unknown error"
-            }`,
-          };
-        }
-      });
-
-      const simulationResults = await Promise.all(simulationPromises);
-      const failures = simulationResults.filter((result) => "error" in result);
-
-      if (failures.length > 0) {
-        const firstFailure = failures[0];
-        throw errors.SIMULATION_FAILED({
-          message: firstFailure.error || "Transaction simulation failed",
-          data: {
-            logs: "logs" in firstFailure ? firstFailure.logs : undefined,
-            link: "link" in firstFailure ? firstFailure.link : undefined,
-          },
-        });
-      }
-    }
-
-    // Check for existing pending transaction with same tag+payer
-    if (tag) {
-      const existingBatch = await TransactionBatch.findOne({
-        where: {
-          tag,
-          payer,
-          status: "pending",
-        },
-      });
-
-      if (existingBatch) {
-        return {
-          batchId: existingBatch.id,
-          message: `Transaction with tag "${tag}" already exists and is pending`,
-        };
-      }
-    }
-
-    const serializedTransactions = transactions.map(
-      (tx) => tx.serializedTransaction,
-    );
-    const result = await submitTransactionBatch({
-      transactions: serializedTransactions,
-      parallel,
-    });
-
-    if (result.error) {
-      throw errors.BAD_REQUEST({ message: result.error });
-    }
-
-    const cluster = getCluster();
-
-    // Use database transaction to ensure data consistency
-    const dbTransaction = await sequelize.transaction();
-
-    try {
-      // Create the batch record
-      await TransactionBatch.create(
-        {
-          id: result.batchId,
-          parallel,
-          status: "pending",
-          submissionType: result.submissionType,
-          jitoBundleId: result.jitoBundleId,
-          cluster,
-          tag,
-          payer,
-        },
-        { transaction: dbTransaction },
-      );
-
-      // Create individual transaction records
-      const pendingTransactionPromises = transactions.map(async (txData, i) => {
-        const signature = result.signatures?.[i] || null;
-
-        // Decode transaction to get blockhash
-        const transaction = VersionedTransaction.deserialize(
-          Buffer.from(txData.serializedTransaction, "base64"),
-        );
-
-        return PendingTransaction.create(
-          {
-            signature: signature || `${result.batchId}-${i}`,
-            blockhash: transaction.message.recentBlockhash,
-            status: "pending",
-            type: txData.metadata?.type || "batch",
-            batchId: result.batchId,
-            payer,
-            metadata: txData.metadata,
-            serializedTransaction: txData.serializedTransaction,
-          },
-          { transaction: dbTransaction },
-        );
-      });
-
-      await Promise.all(pendingTransactionPromises);
-
-      // Commit the transaction
-      await dbTransaction.commit();
-    } catch (error: unknown) {
-      // Rollback the transaction on any error
-      await dbTransaction.rollback();
-
-      // Handle unique constraint violation for tag+payer when status is pending
-      if (
-        (error as { name?: string })?.name ===
-          "SequelizeUniqueConstraintError" &&
-        tag
-      ) {
-        throw errors.CONFLICT({
-          message: `A pending transaction with tag "${tag}" already exists for this payer`,
-        });
-      }
-      throw error;
-    }
-
-    return { batchId: result.batchId };
-  });

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

@@ -1,21 +0,0 @@
-import { submit } from "./procedures/submit";
-import { get } from "./procedures/get";
-import { resubmit } from "./procedures/resubmit";
-import { getByPayer } from "./procedures/getByPayer";
-import { getByPayerAndTag } from "./procedures/getByPayerAndTag";
-
-/**
- * Transactions router - handles transaction submission and status tracking.
- */
-export const transactionsRouter = {
-  /** Submit a batch of transactions */
-  submit,
-  /** Get transaction batch status by ID */
-  get,
-  /** Resubmit a batch of pending transactions */
-  resubmit,
-  /** Get transaction batches by payer */
-  getByPayer,
-  /** Get transaction batches by payer and tag */
-  getByPayerAndTag,
-};