@helium/blockchain-api 0.1.1 → 0.1.3

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

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

@@ -1,204 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import {
-  TransferHotspotInputSchema,
-  TransferHotspotOutputSchema,
-} from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { Connection, PublicKey } from "@solana/web3.js";
-import { env } from "@/lib/env";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-import {
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-  proofArgsAndAccounts,
-  type Asset,
-} from "@helium/spl-utils";
-import {
-  PROGRAM_ID as BUBBLEGUM_PROGRAM_ID,
-  createTransferInstruction,
-} from "@metaplex-foundation/mpl-bubblegum";
-import {
-  SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
-  SPL_NOOP_PROGRAM_ID,
-} from "@solana/spl-account-compression";
-import { entityCreatorKey } from "@helium/helium-entity-manager-sdk";
-import { daoKey } from "@helium/helium-sub-daos-sdk";
-import { HNT_MINT } from "@helium/spl-utils";
-import { getAssetIdFromPubkey } from "@/lib/utils/hotspot-helpers";
-
-const DAO_KEY = daoKey(HNT_MINT)[0];
-
-async function getBubblegumAuthorityPDA(
-  merkleRollPubKey: PublicKey,
-): Promise<PublicKey> {
-  const [bubblegumAuthorityPDAKey] = await PublicKey.findProgramAddress(
-    [merkleRollPubKey.toBuffer()],
-    BUBBLEGUM_PROGRAM_ID,
-  );
-  return bubblegumAuthorityPDAKey;
-}
-
-function validateHeliumHotspot(asset: Asset): boolean {
-  const heliumEntityCreator = entityCreatorKey(DAO_KEY)[0].toBase58();
-
-  return (
-    asset.creators?.some((creator) => {
-      const address =
-        typeof creator.address === "string"
-          ? creator.address
-          : creator.address.toBase58();
-      return address === heliumEntityCreator && creator.verified;
-    }) || false
-  );
-}
-
-/**
- * Create a transaction to transfer a hotspot to a new owner.
- */
-export const transferHotspot = publicProcedure
-  .route({
-    method: "POST",
-    path: "/hotspots/wallet/{walletAddress}/{hotspotPubkey}/transfer",
-  })
-  .input(TransferHotspotInputSchema)
-  .output(TransferHotspotOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Hotspot not found" },
-    BAD_REQUEST: { message: "Invalid request" },
-    FORBIDDEN: { message: "Wallet is not the owner of this hotspot" },
-    INVALID_HOTSPOT: { message: "Asset is not a valid Helium hotspot" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress, hotspotPubkey, recipient } = input;
-
-    // Resolve hotspot pubkey to asset ID
-    const assetId = await getAssetIdFromPubkey(hotspotPubkey);
-    if (!assetId) {
-      throw errors.NOT_FOUND({ message: "Hotspot not found" });
-    }
-
-    // Validate public keys
-    let payerPubkey: PublicKey;
-    let recipientPubkey: PublicKey;
-
-    try {
-      payerPubkey = new PublicKey(walletAddress);
-      recipientPubkey = new PublicKey(recipient);
-    } catch {
-      throw errors.BAD_REQUEST({ message: "Invalid public key format" });
-    }
-
-    const connection = new Connection(env.SOLANA_RPC_URL);
-    const assetEndpoint = env.ASSET_ENDPOINT || connection.rpcEndpoint;
-    const assetPubkey = new PublicKey(assetId);
-
-    const { asset, args, accounts, remainingAccounts } =
-      await proofArgsAndAccounts({
-        connection,
-        assetId: assetPubkey,
-        assetEndpoint,
-      });
-
-    if (!asset) {
-      throw errors.NOT_FOUND({ message: "Asset not found" });
-    }
-
-    // Validate asset is a Helium hotspot
-    if (!validateHeliumHotspot(asset)) {
-      throw errors.INVALID_HOTSPOT({
-        message: "Asset is not a valid Helium hotspot",
-      });
-    }
-
-    // Validate ownership
-    const ownerAddress =
-      typeof asset.ownership.owner === "string"
-        ? asset.ownership.owner
-        : asset.ownership.owner.toBase58();
-
-    if (ownerAddress !== walletAddress) {
-      throw errors.FORBIDDEN({
-        message: "Wallet is not the owner of this hotspot",
-      });
-    }
-
-    const leafOwner =
-      typeof asset.ownership.owner === "string"
-        ? new PublicKey(asset.ownership.owner)
-        : asset.ownership.owner;
-
-    const leafDelegate = asset.ownership.delegate
-      ? typeof asset.ownership.delegate === "string"
-        ? new PublicKey(asset.ownership.delegate)
-        : asset.ownership.delegate
-      : leafOwner;
-
-    const merkleTree = accounts.merkleTree;
-    const treeAuthority = await getBubblegumAuthorityPDA(merkleTree);
-
-    const transferInstruction = createTransferInstruction(
-      {
-        treeAuthority,
-        leafOwner,
-        leafDelegate,
-        newLeafOwner: recipientPubkey,
-        merkleTree,
-        logWrapper: SPL_NOOP_PROGRAM_ID,
-        compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
-        anchorRemainingAccounts: remainingAccounts,
-      },
-      {
-        ...args,
-        nonce: args.index,
-      },
-    );
-
-    const instructionsWithFees = await withPriorityFees({
-      connection,
-      instructions: [transferInstruction],
-      feePayer: payerPubkey,
-    });
-
-    const draft = await populateMissingDraftInfo(connection, {
-      instructions: instructionsWithFees,
-      feePayer: payerPubkey,
-    });
-
-    const versionedTx = toVersionedTx(draft);
-    const serializedTransaction = Buffer.from(versionedTx.serialize()).toString(
-      "base64",
-    );
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.HOTSPOT_TRANSFER,
-      walletAddress,
-      assetId,
-      recipient,
-      timestamp: Date.now(),
-    });
-
-    const hotspotName = asset.content?.metadata?.name || "Hotspot";
-
-    return {
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction,
-            metadata: {
-              type: TRANSACTION_TYPES.HOTSPOT_TRANSFER,
-              description: `Transfer ${hotspotName} to ${recipient.slice(
-                0,
-                4,
-              )}...${recipient.slice(-4)}`,
-            },
-          },
-        ],
-        parallel: false,
-        tag,
-      },
-    };
-  });