@helium/blockchain-api 0.1.2 → 0.1.3

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

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

@@ -1,156 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { DeleteSplitInputSchema, DeleteSplitOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { connectToDb } from "@/lib/utils/db";
-import { AssetOwner } from "@/lib/models/hotspot";
-import { MiniFanout } from "@/lib/models/mini-fanout";
-import { Recipient } from "@/lib/models/recipient";
-import { createSolanaConnection } from "@/lib/solana";
-import { getAssetIdFromPubkey } from "@/lib/utils/hotspot-helpers";
-import {
-  init as initLd,
-  updateCompressionDestination,
-} from "@helium/lazy-distributor-sdk";
-import { init as initMiniFanout } from "@helium/mini-fanout-sdk";
-import {
-  HELIUM_COMMON_LUT,
-  HELIUM_COMMON_LUT_DEVNET,
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import { init as initTuktuk } from "@helium/tuktuk-sdk";
-import { PublicKey } from "@solana/web3.js";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-
-/**
- * Remove the split configuration from a hotspot.
- */
-export const deleteSplit = publicProcedure
-  .route({
-    method: "DELETE",
-    path: "/hotspots/wallet/{walletAddress}/{hotspotPubkey}/split",
-  })
-  .input(DeleteSplitInputSchema)
-  .output(DeleteSplitOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Hotspot not found" },
-    NO_SPLIT: { message: "Hotspot does not have a split" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress, hotspotPubkey } = input;
-
-    await connectToDb();
-
-    // Resolve hotspot pubkey to asset ID
-    const assetId = await getAssetIdFromPubkey(hotspotPubkey);
-    if (!assetId) {
-      throw errors.NOT_FOUND({ message: "Hotspot not found" });
-    }
-
-    // Find the hotspot
-    const assetOwner = await AssetOwner.findOne({
-      where: { asset: assetId },
-      include: [
-        {
-          model: Recipient,
-          as: "recipient",
-          required: true,
-          include: [
-            {
-              model: MiniFanout,
-              as: "split",
-              required: true,
-            },
-          ],
-        },
-      ],
-    });
-
-    if (!assetOwner) {
-      throw errors.NOT_FOUND({ message: "Hotspot not found" });
-    }
-
-    if (!assetOwner.recipient?.split) {
-      throw errors.NO_SPLIT({ message: "Hotspot does not have a split" });
-    }
-
-    const { provider, connection } = createSolanaConnection(walletAddress);
-    const program = await initMiniFanout(provider);
-    const miniFanoutK = new PublicKey(assetOwner.recipient.split.address);
-    const miniFanout =
-      await program.account.miniFanoutV0.fetchNullable(miniFanoutK);
-
-    if (!miniFanout) {
-      throw errors.NOT_FOUND({ message: "Fanout not found" });
-    }
-
-    const tuktukProgram = await initTuktuk(provider);
-
-    // Create the transaction to remove the mini fanout
-    const task = miniFanout.nextTask.equals(miniFanoutK)
-      ? null
-      : await tuktukProgram.account.taskV0.fetchNullable(miniFanout.nextTask);
-
-    const closeIx = await program.methods
-      .closeMiniFanoutV0()
-      .accounts({
-        miniFanout: miniFanoutK,
-        taskRentRefund: task?.rentRefund || walletAddress,
-      })
-      .instruction();
-
-    const ldProgram = await initLd(provider);
-    const setRecipientIx = await (
-      await updateCompressionDestination({
-        program: ldProgram,
-        assetId: new PublicKey(assetId),
-        lazyDistributor: new PublicKey(assetOwner.recipient.lazyDistributor),
-        destination: null,
-      })
-    ).instruction();
-
-    const draft = {
-      instructions: [closeIx, setRecipientIx],
-      feePayer: new PublicKey(walletAddress),
-      addressLookupTableAddresses: [
-        process.env.NEXT_PUBLIC_SOLANA_CLUSTER === "devnet"
-          ? HELIUM_COMMON_LUT_DEVNET
-          : HELIUM_COMMON_LUT,
-      ],
-    };
-
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(connection, {
-        ...draft,
-        instructions: await withPriorityFees({ ...draft, connection }),
-      }),
-    );
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.REMOVE_SPLIT,
-      walletAddress,
-      assetId,
-    });
-
-    return {
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction: Buffer.from(tx.serialize()).toString(
-              "base64",
-            ),
-            metadata: {
-              type: "remove_split",
-              description: "Remove split",
-            },
-          },
-        ],
-        parallel: true,
-        tag,
-      },
-    };
-  });

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

@@ -1,31 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetHotspotsInputSchema, HotspotsDataSchema } from "../schemas";
-import { getHotspotsByOwner } from "@/lib/queries/hotspots";
-import { ORPCError } from "@orpc/server";
-
-/**
- * Get hotspots by wallet address with optional filtering and pagination.
- */
-export const getHotspots = publicProcedure
-  .route({ method: "GET", path: "/hotspots/wallet/{walletAddress}" })
-  .input(GetHotspotsInputSchema)
-  .output(HotspotsDataSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid wallet address" },
-  })
-  .handler(async ({ input }) => {
-    const { walletAddress, type, page, limit } = input;
-
-    if (!walletAddress || walletAddress.length < 32) {
-      throw new ORPCError("BAD_REQUEST", { message: "Invalid wallet address" });
-    }
-
-    const hotspots = await getHotspotsByOwner({
-      owner: walletAddress,
-      type,
-      page,
-      limit,
-    });
-
-    return hotspots;
-  });

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

@@ -1,44 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import {
-  GetPendingRewardsInputSchema,
-  PendingRewardsOutputSchema,
-} from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-
-/**
- * Get pending rewards for all hotspots in a wallet.
- * Proxies to the oracle's rewards endpoint.
- */
-export const getPendingRewards = publicProcedure
-  .route({
-    method: "GET",
-    path: "/hotspots/wallet/{walletAddress}/pending-rewards",
-  })
-  .input(GetPendingRewardsInputSchema)
-  .output(PendingRewardsOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid wallet address" },
-    ORACLE_ERROR: { message: "Oracle request failed" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress } = input;
-
-    if (!walletAddress || walletAddress.length < 32) {
-      throw new ORPCError("BAD_REQUEST", { message: "Invalid wallet address" });
-    }
-
-    const oracleBase = env.ORACLE_URL;
-    const url = new URL(`${oracleBase}/rewards`);
-    url.searchParams.set("destination", walletAddress);
-
-    const oracleRes = await fetch(url.toString());
-    if (!oracleRes.ok) {
-      throw errors.ORACLE_ERROR({
-        message: `Oracle request failed (${oracleRes.status})`,
-      });
-    }
-
-    const data = await oracleRes.json();
-    return data;
-  });

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

@@ -1,88 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetSplitInputSchema, SplitResponseSchema } from "../schemas";
-import { connectToDb } from "@/lib/utils/db";
-import { AssetOwner } from "@/lib/models/hotspot";
-import { MiniFanout } from "@/lib/models/mini-fanout";
-import { Recipient } from "@/lib/models/recipient";
-import { getAssetIdFromPubkey } from "@/lib/utils/hotspot-helpers";
-
-interface MiniFanoutShare {
-  wallet: string;
-  delegate: string;
-  share?: {
-    fixed?: { amount?: string | number };
-    share?: { amount?: number };
-  };
-}
-
-/**
- * Get the split configuration for a hotspot.
- */
-export const getSplit = publicProcedure
-  .route({
-    method: "GET",
-    path: "/hotspots/wallet/{walletAddress}/{hotspotPubkey}/split",
-  })
-  .input(GetSplitInputSchema)
-  .output(SplitResponseSchema)
-  .errors({
-    NOT_FOUND: { message: "Hotspot not found or does not have a split" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress, hotspotPubkey } = input;
-
-    await connectToDb();
-
-    // Resolve hotspot pubkey to asset ID
-    const assetId = await getAssetIdFromPubkey(hotspotPubkey);
-    if (!assetId) {
-      throw errors.NOT_FOUND({ message: "Hotspot not found" });
-    }
-
-    // Look up the asset and ensure it has a mini fanout configured
-    const assetOwner = await AssetOwner.findOne({
-      where: { asset: assetId },
-      include: [
-        {
-          model: Recipient,
-          as: "recipient",
-          required: true,
-          include: [
-            {
-              model: MiniFanout,
-              as: "split",
-              required: true,
-            },
-          ],
-        },
-      ],
-    });
-
-    if (!assetOwner?.recipient?.split) {
-      throw errors.NOT_FOUND({ message: "Hotspot does not have a split" });
-    }
-
-    const shares = assetOwner.recipient.split.shares as MiniFanoutShare[];
-
-    const totalShares = shares.reduce(
-      (acc: number, share: MiniFanoutShare) =>
-        acc + (share.share?.share?.amount || 0),
-      0,
-    );
-
-    return {
-      walletAddress,
-      hotspotPubkey,
-      splitAddress: assetOwner.recipient.split.address,
-      shares: shares.map((share: MiniFanoutShare) => ({
-        wallet: share.wallet,
-        delegate: share.delegate,
-        fixed: share.share?.fixed?.amount
-          ? Number(share.share.fixed.amount)
-          : 0,
-        shares: share.share?.share?.amount
-          ? share.share.share.amount / totalShares
-          : 0,
-      })),
-    };
-  });