@helium/blockchain-api 0.1.1 → 0.1.3

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

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

@@ -1,119 +0,0 @@
-import { z } from "zod";
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-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 SubmitInputSchema = z.object({
-  transactions: z.array(TransactionItemSchema),
-  parallel: z.boolean(),
-  tag: z.string().optional(),
-});
-
-export const GetInputSchema = z.object({
-  id: z.string(),
-  commitment: z.enum(["confirmed", "finalized"]),
-});
-
-export const ResubmitInputSchema = z.object({
-  id: z.string(),
-});
-
-export const GetByPayerInputSchema = z.object({
-  payer: z.string().min(32),
-  page: z.coerce.number().int().min(1).default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(20),
-  status: z.string().optional().default("pending"),
-});
-
-export const GetByPayerAndTagInputSchema = z.object({
-  payer: z.string().min(32),
-  tag: z.string(),
-  page: z.coerce.number().int().min(1).default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(20),
-  status: z.string().optional().default("pending"),
-});
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-export const SubmitOutputSchema = z.object({
-  batchId: z.string(),
-  message: z.string().optional(),
-});
-
-export const TransactionStatusSchema = z.object({
-  signature: z.string(),
-  status: z.string(),
-  transaction: z.unknown().optional(),
-});
-
-export const BatchStatusOutputSchema = z.object({
-  batchId: z.string(),
-  status: z.string(),
-  submissionType: z.string(),
-  parallel: z.boolean(),
-  transactions: z.array(TransactionStatusSchema),
-  jitoBundleId: z.string().optional(),
-  jitoBundleStatus: z.unknown().optional(),
-});
-
-export const ResubmitOutputSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  error: z.string().optional(),
-  newSignatures: z.array(z.string()).optional(),
-});
-
-export const PayerBatchSummarySchema = z.object({
-  batchId: z.string(),
-  tag: z.string().optional(),
-  status: z.string(),
-  submissionType: z.string(),
-  parallel: z.boolean(),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  transactions: z.array(
-    z.object({
-      metadata: TransactionMetadataSchema.optional(),
-    }),
-  ),
-});
-
-export const PayerBatchesOutputSchema = z.object({
-  payer: z.string(),
-  batches: z.array(PayerBatchSummarySchema),
-  pagination: z.object({
-    page: z.number(),
-    limit: z.number(),
-    total: z.number(),
-    totalPages: z.number(),
-  }),
-});
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-export type SubmitInput = z.infer<typeof SubmitInputSchema>;
-export type GetInput = z.infer<typeof GetInputSchema>;
-export type ResubmitInput = z.infer<typeof ResubmitInputSchema>;
-export type GetByPayerInput = z.infer<typeof GetByPayerInputSchema>;
-export type GetByPayerAndTagInput = z.infer<typeof GetByPayerAndTagInputSchema>;
-export type SubmitOutput = z.infer<typeof SubmitOutputSchema>;
-export type BatchStatusOutput = z.infer<typeof BatchStatusOutputSchema>;
-export type ResubmitOutput = z.infer<typeof ResubmitOutputSchema>;
-export type PayerBatchesOutput = z.infer<typeof PayerBatchesOutputSchema>;

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

@@ -1,75 +0,0 @@
-import { z } from "zod";
-import { publicProcedure } from "../../procedures";
-import { BridgeUser } from "@/lib/models/bridge-user";
-import { ORPCError } from "@orpc/server";
-
-// ============================================================================
-// Schemas
-// ============================================================================
-
-const BridgeWebhookInputSchema = z.object({
-  type: z.string(),
-  kyc_link_id: z.string().optional(),
-  kyc_status: z.string().optional(),
-  tos_status: z.string().optional(),
-  customer_id: z.string().optional(),
-});
-
-const BridgeWebhookOutputSchema = z.object({
-  success: z.boolean(),
-  error: z.string().optional(),
-});
-
-// ============================================================================
-// Procedures
-// ============================================================================
-
-/**
- * Bridge webhook handler for KYC/ToS status updates.
- */
-const bridge = publicProcedure
-  .route({ method: "POST", path: "/webhooks/bridge" })
-  .input(BridgeWebhookInputSchema)
-  .output(BridgeWebhookOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Bridge user not found" },
-    INVALID_PAYLOAD: { message: "Invalid webhook payload" },
-  })
-  .handler(async ({ input, errors }) => {
-    const data = input;
-
-    // Handle KYC link status updates
-    if (data.type === "kyc_link.status_updated") {
-      const bridgeUser = await BridgeUser.findOne({
-        where: { kycLinkId: data.kyc_link_id },
-      });
-
-      if (!bridgeUser) {
-        console.error(
-          "Bridge user not found for KYC link ID:",
-          data.kyc_link_id,
-        );
-        throw errors.NOT_FOUND({ message: "Bridge user not found" });
-      }
-
-      // Update statuses
-      await bridgeUser.update({
-        kycStatus: data.kyc_status,
-        tosStatus: data.tos_status,
-        bridgeCustomerId: data.customer_id,
-      });
-
-      return { success: true };
-    }
-
-    // Handle other webhook types here
-    return { success: true };
-  });
-
-// ============================================================================
-// Router Export
-// ============================================================================
-
-export const webhooksRouter = {
-  bridge,
-};