@helium/blockchain-api 0.1.1 → 0.1.3

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

@@ -1,157 +0,0 @@
-import { z } from "zod";
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-export const InitKycInputSchema = z.object({
-  type: z.enum(["individual", "business"]).optional(),
-});
-
-export const CreateBankAccountInputSchema = z.object({
-  currency: z.string(),
-  account_type: z.string(),
-  bank_name: z.string(),
-  account_name: z.string(),
-  first_name: z.string().optional(),
-  last_name: z.string().optional(),
-  account_owner_name: z.string().optional(),
-  business_name: z.string().optional(),
-  account: z.object({
-    account_number: z.string(),
-    routing_number: z.string(),
-    checking_or_savings: z.string(),
-  }),
-  address: z.object({
-    street_line_1: z.string(),
-    line2: z.string().optional(),
-    city: z.string(),
-    state: z.string(),
-    postal_code: z.string(),
-    country: z.string(),
-  }),
-});
-
-export const GetBankAccountInputSchema = z.object({
-  id: z.string(),
-});
-
-export const DeleteBankAccountInputSchema = z.object({
-  id: z.number(),
-});
-
-export const GetSendQuoteInputSchema = z.object({
-  id: z.string(),
-  usdAmount: z.string(),
-});
-
-export const SendFundsInputSchema = z.object({
-  id: z.string(),
-  userAddress: z.string(),
-  quoteResponse: 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
-});
-
-export const GetTransferInputSchema = z.object({
-  id: z.string(),
-});
-
-export const UpdateTransferInputSchema = z.object({
-  id: z.string(),
-  solanaSignature: z.string(),
-});
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-export const KycStatusOutputSchema = z.object({
-  kycStatus: z.string(),
-  tosStatus: z.string(),
-  tosLink: z.string().nullable(),
-  kycLink: z.string().nullable(),
-  kycLinkId: z.string().nullable(),
-  accountType: z.string().optional(),
-  rejectionReasons: z.array(z.string()).optional(),
-});
-
-export const FeesOutputSchema = z.object({
-  developer_fee: z.string(),
-  developer_fee_percent: z.number(),
-});
-
-export const BankAccountSchema = z
-  .object({
-    id: z.number().optional(),
-    bridgeUserId: z.number().optional(),
-    bridgeExternalAccountId: z.string().optional(),
-    accountName: z.string().optional(),
-    bankName: z.string().optional(),
-    lastFourDigits: z.string().optional(),
-    routingNumber: z.string().optional(),
-    accountType: z.string().optional(),
-    createdAt: z.union([z.string(), z.date()]).optional(),
-    updatedAt: z.union([z.string(), z.date()]).optional(),
-  })
-  .passthrough();
-
-export const BankAccountListOutputSchema = z.array(BankAccountSchema);
-
-export const DeleteBankAccountOutputSchema = z.object({
-  success: z.boolean(),
-});
-
-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 SendFundsOutputSchema = z.object({
-  bridgeTransfer: z.unknown(),
-  transactionData: TransactionDataSchema,
-});
-
-export const UpdateTransferOutputSchema = z.object({
-  success: z.boolean(),
-});
-
-// Quote response is pass-through from Jupiter
-export const QuoteOutputSchema = z.unknown();
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-export type InitKycInput = z.infer<typeof InitKycInputSchema>;
-export type CreateBankAccountInput = z.infer<
-  typeof CreateBankAccountInputSchema
->;
-export type KycStatusOutput = z.infer<typeof KycStatusOutputSchema>;
-export type FeesOutput = z.infer<typeof FeesOutputSchema>;

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

@@ -1,41 +0,0 @@
-import { z } from "zod";
-import { publicProcedure } from "../../procedures";
-import { connectToDb } from "@/lib/utils/db";
-
-// ============================================================================
-// Schemas
-// ============================================================================
-
-const HealthResponseSchema = z.object({
-  ok: z.boolean(),
-  error: z.string().optional(),
-});
-
-// ============================================================================
-// Procedures
-// ============================================================================
-
-/**
- * Health check procedure.
- * Verifies API and database connectivity.
- */
-const check = publicProcedure
-  .route({ method: "GET", path: "/health" })
-  .output(HealthResponseSchema)
-  .handler(async () => {
-    try {
-      await connectToDb();
-      return { ok: true };
-    } catch (error) {
-      console.error("Health check failed:", error);
-      return { ok: false, error: "Database connection failed" };
-    }
-  });
-
-// ============================================================================
-// Router Export
-// ============================================================================
-
-export const healthRouter = {
-  check,
-};

package/src/server/api/routers/hotspots/procedures/claimRewards.ts

@@ -1,258 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { ClaimRewardsInputSchema, ClaimRewardsOutputSchema } from "../schemas";
-import { getSingleton } from "@helium/account-fetch-cache";
-import {
-  getHotspotsByOwner,
-  getNumRecipientsNeeded,
-} from "@/lib/queries/hotspots";
-import { env } from "@/lib/env";
-import { createSolanaConnection } from "@/lib/solana";
-import { init as initLd } from "@helium/lazy-distributor-sdk";
-import {
-  formBulkTransactions,
-  getBulkRewards,
-} from "@/utils/distributorOracle";
-import {
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  SystemProgram,
-  TransactionInstruction,
-  VersionedTransaction,
-} from "@solana/web3.js";
-import * as anchor from "@coral-xyz/anchor";
-import {
-  customSignerKey,
-  init as initTuktuk,
-  nextAvailableTaskIds,
-  taskKey,
-  taskQueueAuthorityKey,
-} from "@helium/tuktuk-sdk";
-import {
-  HELIUM_COMMON_LUT,
-  HELIUM_COMMON_LUT_DEVNET,
-  HNT_MINT,
-  batchInstructionsToTxsWithPriorityFee,
-  toVersionedTx,
-} from "@helium/spl-utils";
-import { HNT_LAZY_DISTRIBUTOR_ADDRESS } from "@/lib/constants/lazy-distributor";
-import { getAssociatedTokenAddressSync } from "@solana/spl-token";
-
-const MIN_RENT = 0.00089088;
-const RECIPIENT_RENT = 0.00242208;
-const ATA_RENT = 0.002039 * LAMPORTS_PER_SOL;
-const MIN_RENT_LAMPORTS = Math.ceil(MIN_RENT * LAMPORTS_PER_SOL);
-const RECIPIENT_RENT_LAMPORTS = Math.ceil(RECIPIENT_RENT * LAMPORTS_PER_SOL);
-const ATA_RENT_LAMPORTS = Math.ceil(ATA_RENT);
-
-const HPL_CRONS_PROGRAM_ID = new PublicKey(
-  "hcrLPFgFUY6sCUKzqLWxXx5bntDiDCrAZVcrXfx9AHu",
-);
-const TASK_QUEUE_ID = new PublicKey(
-  process.env.HPL_CRONS_TASK_QUEUE ||
-    "H39gEszvsi6AT4rYBiJTuZHJSF5hMHy6CKGTd7wzhsg7",
-);
-
-/**
- * Create transactions to claim rewards for all hotspots in a wallet.
- * For wallets with 3 or fewer hotspots, returns direct claim transactions.
- * For larger wallets, creates a Tuktuk task to process claims.
- */
-export const claimRewards = publicProcedure
-  .route({ method: "POST", path: "/hotspots/wallet/{walletAddress}/claim" })
-  .input(ClaimRewardsInputSchema)
-  .output(ClaimRewardsOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-    INSUFFICIENT_FUNDS: {
-      message: "Insufficient SOL balance to fund claim task",
-    },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress } = input;
-
-    // Single query: fetch up to 3 hotspots and total count
-    const hotspotsData = await getHotspotsByOwner({
-      owner: walletAddress,
-      page: 1,
-      limit: 3,
-    });
-    const { total } = hotspotsData;
-
-    // For small wallets, request direct claim transactions
-    if (total <= 3) {
-      const assets = hotspotsData.hotspots.map((h) => new PublicKey(h.asset));
-      const entityKeys = hotspotsData.hotspots.map((h) => h.entityKey);
-
-      // Initialize programs
-      const { provider } = createSolanaConnection(walletAddress);
-      const ldProgram = await initLd(provider);
-
-      // Fetch oracle rewards for these entity keys
-      const rewards = await getBulkRewards(
-        ldProgram,
-        new PublicKey(HNT_LAZY_DISTRIBUTOR_ADDRESS),
-        entityKeys,
-      );
-
-      // Build and sign transactions via oracle
-      const vtxs: VersionedTransaction[] = await formBulkTransactions({
-        program: ldProgram,
-        rewards,
-        assets,
-        lazyDistributor: new PublicKey(HNT_LAZY_DISTRIBUTOR_ADDRESS),
-        assetEndpoint: env.ASSET_ENDPOINT,
-        skipOracleSign: false,
-      });
-
-      const singleton = await getSingleton(provider.connection);
-      singleton.close();
-
-      const txs = vtxs.map((tx) =>
-        Buffer.from(tx.serialize()).toString("base64"),
-      );
-
-      return {
-        transactionData: {
-          transactions: txs.map((serialized) => ({
-            serializedTransaction: serialized,
-            metadata: {
-              type: "claim_rewards",
-              description: "Claim hotspot rewards",
-            },
-          })),
-          parallel: true,
-          tag: `claim_rewards:${walletAddress}`,
-        },
-      };
-    }
-
-    // For larger wallets, queue a Tuktuk claim task via HPL Crons
-    const { provider } = createSolanaConnection(walletAddress);
-    anchor.setProvider(provider);
-
-    const tuktukProgram = await initTuktuk(provider);
-    const taskQueueAcc =
-      await tuktukProgram.account.taskQueueV0.fetch(TASK_QUEUE_ID);
-    const [taskId] = nextAvailableTaskIds(taskQueueAcc.taskBitmap, 1);
-
-    const queueAuthority = PublicKey.findProgramAddressSync(
-      [Buffer.from("queue_authority")],
-      HPL_CRONS_PROGRAM_ID,
-    )[0];
-
-    const idl = await anchor.Program.fetchIdl(HPL_CRONS_PROGRAM_ID, provider);
-    const hplCronsProgram = new anchor.Program(
-      idl as anchor.Idl,
-      provider,
-    ) as anchor.Program<anchor.Idl>;
-
-    const instructions: TransactionInstruction[] = [];
-
-    const pdaWallet = customSignerKey(TASK_QUEUE_ID, [
-      Buffer.from("claim_payer"),
-      new PublicKey(walletAddress).toBuffer(),
-    ])[0];
-    const pdaWalletBalanceLamports =
-      await provider.connection.getBalance(pdaWallet);
-    const ata = getAssociatedTokenAddressSync(
-      HNT_MINT,
-      new PublicKey(walletAddress),
-      true,
-    );
-    const minCrankReward = taskQueueAcc?.minCrankReward?.toNumber() || 10000;
-    const account = await provider.connection.getAccountInfo(ata);
-    const pdaWalletFundingNeededLamports =
-      MIN_RENT_LAMPORTS +
-      (account ? 0 : ATA_RENT_LAMPORTS) +
-      // Actual claim txs
-      20000 * (total || 1) +
-      // Requeue transactions (5 queues per tx)
-      minCrankReward * Math.ceil((total || 1) / 5);
-    const pdaWalletLamportsShortfall = Math.max(
-      0,
-      pdaWalletFundingNeededLamports - pdaWalletBalanceLamports,
-    );
-
-    const hotspotsNeedingRecipient =
-      await getNumRecipientsNeeded(walletAddress);
-    console.log(
-      `[PDA WALLET ${pdaWallet.toBase58()}] Hotspots needing recipient: ${hotspotsNeedingRecipient}, shortfall: ${pdaWalletLamportsShortfall}`,
-    );
-
-    if (pdaWalletLamportsShortfall > 0 || hotspotsNeedingRecipient > 0) {
-      const requiredLamports =
-        pdaWalletLamportsShortfall +
-        hotspotsNeedingRecipient * RECIPIENT_RENT_LAMPORTS;
-      // Ensure the user's wallet has enough SOL to fund PDA and recipients before returning tx
-      const senderBalance = await provider.connection.getBalance(
-        new PublicKey(walletAddress),
-      );
-      if (senderBalance < requiredLamports) {
-        throw errors.INSUFFICIENT_FUNDS({
-          message: "Insufficient SOL balance to fund claim task",
-          data: {
-            balance: senderBalance,
-            required: requiredLamports,
-          },
-        });
-      }
-      instructions.push(
-        SystemProgram.transfer({
-          fromPubkey: new PublicKey(walletAddress),
-          toPubkey: pdaWallet,
-          lamports: requiredLamports,
-        }),
-      );
-    }
-
-    const ix = await hplCronsProgram.methods
-      .queueWalletClaimV0({ freeTaskId: taskId })
-      .accountsStrict({
-        task: taskKey(TASK_QUEUE_ID, taskId)[0],
-        wallet: new PublicKey(walletAddress),
-        taskQueue: TASK_QUEUE_ID,
-        payer: provider.wallet.publicKey,
-        systemProgram: SystemProgram.programId,
-        queueAuthority,
-        tuktukProgram: tuktukProgram.programId,
-        pdaWallet: customSignerKey(TASK_QUEUE_ID, [
-          Buffer.from("claim_payer"),
-          new PublicKey(walletAddress).toBuffer(),
-        ])[0],
-        taskQueueAuthority: taskQueueAuthorityKey(
-          TASK_QUEUE_ID,
-          queueAuthority,
-        )[0],
-      })
-      .instruction();
-
-    instructions.push(ix);
-    const vtxs = (
-      await batchInstructionsToTxsWithPriorityFee(provider, instructions, {
-        addressLookupTableAddresses: [
-          process.env.NEXT_PUBLIC_SOLANA_CLUSTER?.trim() === "devnet"
-            ? HELIUM_COMMON_LUT_DEVNET
-            : HELIUM_COMMON_LUT,
-        ],
-      })
-    ).map((tx) => toVersionedTx(tx));
-
-    const txs: Array<string> = vtxs.map((tx) =>
-      Buffer.from(tx.serialize()).toString("base64"),
-    );
-
-    return {
-      transactionData: {
-        transactions: txs.map((serialized) => ({
-          serializedTransaction: serialized,
-          metadata: {
-            type: "queue_wallet_claim",
-            description: "Queue wallet claim task via Tuktuk",
-            taskIds: [taskId],
-          },
-        })),
-        parallel: true,
-        tag: `claim_rewards_tuktuk:${walletAddress}`,
-      },
-    };
-  });

package/src/server/api/routers/hotspots/procedures/createSplit.ts

@@ -1,253 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { CreateSplitInputSchema, CreateSplitOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { createSolanaConnection } from "@/lib/solana";
-import { connectToDb } from "@/lib/utils/db";
-import { scheduleToUtcCron } from "@/lib/utils/misc";
-import { getAssetIdFromPubkey } from "@/lib/utils/hotspot-helpers";
-import {
-  initializeCompressionRecipient,
-  init as initLd,
-  recipientKey,
-  updateCompressionDestination,
-} from "@helium/lazy-distributor-sdk";
-import { init as initMiniFanout } from "@helium/mini-fanout-sdk";
-import {
-  batchInstructionsToTxsWithPriorityFee,
-  HELIUM_COMMON_LUT,
-  HELIUM_COMMON_LUT_DEVNET,
-  HNT_MINT,
-  toVersionedTx,
-} from "@helium/spl-utils";
-import {
-  init as initTuktuk,
-  nextAvailableTaskIds,
-  taskKey,
-} from "@helium/tuktuk-sdk";
-import {
-  PublicKey,
-  SystemProgram,
-  TransactionInstruction,
-} from "@solana/web3.js";
-import BN from "bn.js";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-import {
-  getCluster,
-  getJitoTipTransaction,
-  shouldUseJitoBundle,
-} from "@/lib/utils/transaction-submission";
-
-const TASK_QUEUE_ID = new PublicKey(
-  "H39gEszvsi6AT4rYBiJTuZHJSF5hMHy6CKGTd7wzhsg7",
-);
-const FANOUT_FUNDING_AMOUNT = 10000000; // 0.01 SOL
-
-/**
- * Create a split configuration for a hotspot with reward distribution.
- */
-export const createSplit = publicProcedure
-  .route({
-    method: "POST",
-    path: "/hotspots/wallet/{walletAddress}/{hotspotPubkey}/split",
-  })
-  .input(CreateSplitInputSchema)
-  .output(CreateSplitOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Hotspot not found" },
-    BAD_REQUEST: { message: "Invalid request" },
-    INSUFFICIENT_FUNDS: {
-      message: "Insufficient SOL balance to fund split setup",
-    },
-  })
-  .handler(async ({ input, errors }) => {
-    const {
-      walletAddress,
-      hotspotPubkey,
-      rewardsSplit,
-      schedule,
-      lazyDistributor,
-    } = input;
-
-    await connectToDb();
-
-    // Resolve hotspot pubkey to asset ID
-    const assetId = await getAssetIdFromPubkey(hotspotPubkey);
-    if (!assetId) {
-      throw errors.NOT_FOUND({ message: "Hotspot not found" });
-    }
-
-    if (!rewardsSplit?.length) {
-      throw errors.BAD_REQUEST({
-        message: "At least one reward split is required",
-      });
-    }
-
-    if (!schedule?.frequency || !schedule?.time || !schedule?.timezone) {
-      throw errors.BAD_REQUEST({
-        message: "Schedule frequency, time, and timezone are required",
-      });
-    }
-
-    // Build connection and programs
-    const { provider, wallet } = createSolanaConnection(walletAddress);
-    const miniFanoutProgram = await initMiniFanout(provider);
-    const tuktukProgram = await initTuktuk(provider);
-    const ldProgram = await initLd(provider);
-
-    // Convert schedule to UTC cron string
-    const rewardsSchedule = scheduleToUtcCron(schedule);
-
-    // Ensure Lazy Distributor Recipient exists for the asset
-    const recipientK = recipientKey(
-      new PublicKey(lazyDistributor),
-      new PublicKey(assetId),
-    )[0];
-    const recipientAcc =
-      await ldProgram.account.recipientV0.fetchNullable(recipientK);
-    const instructions: TransactionInstruction[] = [];
-
-    if (!recipientAcc) {
-      instructions.push(
-        await (
-          await initializeCompressionRecipient({
-            program: ldProgram,
-            assetId: new PublicKey(assetId),
-            payer: wallet.publicKey,
-            assetEndpoint: env.SOLANA_RPC_URL,
-            lazyDistributor: new PublicKey(lazyDistributor),
-          })
-        ).instruction(),
-      );
-    }
-
-    const oracleSigner = new PublicKey(process.env.ORACLE_SIGNER!);
-    const oracleUrl = process.env.ORACLE_URL!;
-
-    const { instruction: initIx, pubkeys } = await miniFanoutProgram.methods
-      .initializeMiniFanoutV0({
-        seed: new PublicKey(assetId).toBuffer(),
-        shares: rewardsSplit.map((split) => ({
-          wallet: new PublicKey(split.address),
-          share:
-            split.type === "fixed"
-              ? { fixed: { amount: new BN(split.amount) } }
-              : { share: { amount: split.amount } },
-        })),
-        schedule: rewardsSchedule,
-        preTask: {
-          remoteV0: {
-            url: `${oracleUrl}/v1/tuktuk/asset/${assetId}`,
-            signer: oracleSigner,
-          },
-        },
-      })
-      .accounts({
-        payer: wallet.publicKey,
-        owner: wallet.publicKey,
-        taskQueue: TASK_QUEUE_ID,
-        rentRefund: wallet.publicKey,
-        mint: HNT_MINT,
-      })
-      .prepare();
-    instructions.push(initIx);
-
-    // Ensure the user's wallet has enough SOL to fund the mini fanout rent
-    const balance = await provider.connection.getBalance(
-      new PublicKey(walletAddress),
-    );
-    if (balance < FANOUT_FUNDING_AMOUNT) {
-      throw errors.INSUFFICIENT_FUNDS({
-        message: "Insufficient SOL balance to fund split setup",
-        data: {
-          balance,
-          required: FANOUT_FUNDING_AMOUNT,
-        },
-      });
-    }
-
-    instructions.push(
-      SystemProgram.transfer({
-        fromPubkey: wallet.publicKey,
-        toPubkey: pubkeys.miniFanout!,
-        lamports: FANOUT_FUNDING_AMOUNT,
-      }),
-    );
-
-    const taskQueueAcc =
-      await tuktukProgram.account.taskQueueV0.fetchNullable(TASK_QUEUE_ID);
-    const [taskId, preTaskId] = nextAvailableTaskIds(
-      taskQueueAcc!.taskBitmap,
-      2,
-    );
-
-    // Schedule a task for the mini fanout
-    const scheduleIx = await (
-      await miniFanoutProgram.methods
-        .scheduleTaskV0({
-          program: miniFanoutProgram,
-          miniFanout: pubkeys.miniFanout!,
-          taskId,
-          preTaskId,
-        })
-        .accounts({
-          taskQueue: TASK_QUEUE_ID,
-          payer: wallet.publicKey,
-          miniFanout: pubkeys.miniFanout!,
-          task: taskKey(TASK_QUEUE_ID, taskId)[0],
-          preTask: taskKey(TASK_QUEUE_ID, preTaskId)[0],
-          nextTask: pubkeys.miniFanout!,
-          nextPreTask: pubkeys.miniFanout!,
-        })
-    ).instruction();
-    instructions.push(scheduleIx);
-
-    // Point hotspot rewards destination to the mini fanout
-    const setRecipientIx = await (
-      await updateCompressionDestination({
-        program: ldProgram,
-        assetId: new PublicKey(assetId),
-        lazyDistributor: new PublicKey(lazyDistributor),
-        destination: pubkeys.miniFanout!,
-      })
-    ).instruction();
-    instructions.push(setRecipientIx);
-
-    const txs = (
-      await batchInstructionsToTxsWithPriorityFee(provider, instructions, {
-        addressLookupTableAddresses: [
-          process.env.NEXT_PUBLIC_SOLANA_CLUSTER === "devnet"
-            ? HELIUM_COMMON_LUT_DEVNET
-            : HELIUM_COMMON_LUT,
-        ],
-      })
-    ).map((tx) => toVersionedTx(tx));
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.ADD_SPLIT,
-      walletAddress,
-      assetId,
-      lazyDistributor,
-    });
-
-    if (shouldUseJitoBundle(txs.length, getCluster())) {
-      txs.push(await getJitoTipTransaction(new PublicKey(walletAddress)));
-    }
-
-    return {
-      transactionData: {
-        transactions: txs.map((tx) => ({
-          serializedTransaction: Buffer.from(tx.serialize()).toString("base64"),
-          metadata: {
-            type: "add_split",
-            description: "Create split",
-          },
-        })),
-        parallel: true,
-        tag,
-      },
-    };
-  });