@helium/blockchain-api 0.1.2 → 0.1.3

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

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

@@ -1,201 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import {
-  UpdateRewardsDestinationInputSchema,
-  UpdateRewardsDestinationOutputSchema,
-} from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { PublicKey, TransactionInstruction } from "@solana/web3.js";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-import {
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-  proofArgsAndAccounts,
-} from "@helium/spl-utils";
-import {
-  init as initLazy,
-  initializeCompressionRecipient,
-  recipientKey,
-} from "@helium/lazy-distributor-sdk";
-import { createSolanaConnection } from "@/lib/solana";
-import { env } from "@/lib/env";
-import { getAssetIdFromPubkey } from "@/lib/utils/hotspot-helpers";
-
-async function exists(
-  connection: { getAccountInfo: (account: PublicKey) => Promise<unknown> },
-  account: PublicKey,
-): Promise<boolean> {
-  return Boolean(await connection.getAccountInfo(account));
-}
-
-/**
- * Update the rewards destination for a hotspot across one or more lazy distributors.
- */
-export const updateRewardsDestination = publicProcedure
-  .route({
-    method: "POST",
-    path: "/hotspots/wallet/{walletAddress}/{hotspotPubkey}/update-rewards-destination",
-  })
-  .input(UpdateRewardsDestinationInputSchema)
-  .output(UpdateRewardsDestinationOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Hotspot not found" },
-    BAD_REQUEST: { message: "Invalid request" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress, hotspotPubkey, lazyDistributors, destination } =
-      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 assetPubkey: PublicKey;
-    let destinationPubkey: PublicKey;
-    const lazyDistributorPubkeys: PublicKey[] = [];
-
-    try {
-      assetPubkey = new PublicKey(assetId);
-      destinationPubkey = new PublicKey(destination);
-
-      for (const ld of lazyDistributors) {
-        lazyDistributorPubkeys.push(new PublicKey(ld));
-      }
-    } catch {
-      throw errors.BAD_REQUEST({ message: "Invalid public key format" });
-    }
-
-    // Create connection and provider
-    const { connection, provider, wallet } =
-      createSolanaConnection(walletAddress);
-
-    // Check if destination exists
-    const destinationExists = await exists(connection, destinationPubkey);
-
-    const program = await initLazy(provider);
-
-    // Get proof args and accounts for the asset
-    const assetEndpoint =
-      env.ASSET_ENDPOINT || program.provider.connection.rpcEndpoint;
-
-    const {
-      asset: {
-        ownership: { owner },
-      },
-      args,
-      accounts,
-      remainingAccounts,
-    } = await proofArgsAndAccounts({
-      connection: program.provider.connection,
-      assetId: assetPubkey,
-      assetEndpoint,
-    });
-
-    // Build instructions for each lazy distributor
-    const instructions: TransactionInstruction[] = (
-      await Promise.all(
-        lazyDistributorPubkeys.map(async (lazy) => {
-          const [recipientPk] = recipientKey(lazy, assetPubkey);
-          const recipientExists = await exists(connection, recipientPk);
-
-          const ixs: TransactionInstruction[] = [];
-
-          // Initialize recipient if it doesn't exist
-          if (!recipientExists) {
-            ixs.push(
-              await (
-                await initializeCompressionRecipient({
-                  program,
-                  assetId: assetPubkey,
-                  lazyDistributor: lazy,
-                  payer: wallet.publicKey,
-                })
-              ).instruction(),
-            );
-          }
-
-          // Create update compression destination instruction
-          ixs.push(
-            await program.methods
-              .updateCompressionDestinationV0({
-                ...args,
-              })
-              .accountsPartial({
-                ...accounts,
-                owner,
-                recipient: recipientKey(lazy, assetPubkey)[0],
-                destination:
-                  destination === PublicKey.default.toBase58()
-                    ? PublicKey.default
-                    : destinationPubkey,
-              })
-              .remainingAccounts(remainingAccounts)
-              .instruction(),
-          );
-
-          return ixs;
-        }),
-      )
-    ).flat();
-
-    // Add priority fees
-    const instructionsWithFees = await withPriorityFees({
-      connection,
-      instructions,
-      feePayer: wallet.publicKey,
-    });
-
-    // Populate missing transaction info
-    const draft = await populateMissingDraftInfo(connection, {
-      instructions: instructionsWithFees,
-      feePayer: wallet.publicKey,
-    });
-
-    // Convert to versioned transaction
-    const versionedTx = toVersionedTx(draft);
-    const serializedTransaction = Buffer.from(versionedTx.serialize()).toString(
-      "base64",
-    );
-
-    // Generate transaction tag for deduplication
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.UPDATE_REWARDS_DESTINATION,
-      walletAddress,
-      assetId,
-      destination,
-      lazyDistributors: lazyDistributors.join(","),
-      timestamp: Date.now(),
-    });
-
-    return {
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction,
-            metadata: {
-              type: TRANSACTION_TYPES.UPDATE_REWARDS_DESTINATION,
-              description: destinationExists
-                ? `Update rewards destination to ${destination.slice(
-                    0,
-                    4,
-                  )}...${destination.slice(-4)}`
-                : `Update rewards destination to ${destination.slice(
-                    0,
-                    4,
-                  )}...${destination.slice(
-                    -4,
-                  )} (Warning: destination account does not exist)`,
-            },
-          },
-        ],
-        parallel: false,
-        tag,
-      },
-    };
-  });

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

@@ -1,30 +0,0 @@
-import { getHotspots } from "./procedures/getHotspots";
-import { claimRewards } from "./procedures/claimRewards";
-import { getPendingRewards } from "./procedures/getPendingRewards";
-import { transferHotspot } from "./procedures/transferHotspot";
-import { updateRewardsDestination } from "./procedures/updateRewardsDestination";
-import { getSplit } from "./procedures/getSplit";
-import { createSplit } from "./procedures/createSplit";
-import { deleteSplit } from "./procedures/deleteSplit";
-
-/**
- * Hotspots router - handles all hotspot-related operations.
- */
-export const hotspotsRouter = {
-  /** Get hotspots by wallet address with filtering and pagination */
-  getHotspots,
-  /** Create transactions to claim rewards for hotspots */
-  claimRewards,
-  /** Get pending rewards for all hotspots in a wallet */
-  getPendingRewards,
-  /** Create a transaction to transfer a hotspot to a new owner */
-  transferHotspot,
-  /** Update the rewards destination for a hotspot */
-  updateRewardsDestination,
-  /** Get the split configuration for a hotspot */
-  getSplit,
-  /** Create a split configuration for a hotspot */
-  createSplit,
-  /** Remove the split configuration from a hotspot */
-  deleteSplit,
-};

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

@@ -1,182 +0,0 @@
-import { z } from "zod";
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-export const HotspotTypeSchema = z.enum(["iot", "mobile", "all"]);
-
-export const GetHotspotsInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  type: HotspotTypeSchema.optional(),
-  page: z.coerce.number().int().min(1).default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(10),
-});
-
-export const ClaimRewardsInputSchema = z.object({
-  walletAddress: z.string().min(32),
-});
-
-export const GetPendingRewardsInputSchema = z.object({
-  walletAddress: z.string().min(32),
-});
-
-export const TransferHotspotInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
-  recipient: z.string().min(32),
-});
-
-export const UpdateRewardsDestinationInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
-  destination: z.string().min(32),
-  lazyDistributors: z.array(z.string().min(32)).min(1),
-});
-
-export const GetSplitInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
-});
-
-export const RewardSplitInputSchema = z.object({
-  address: z.string().min(32),
-  type: z.enum(["percentage", "fixed"]),
-  amount: z.number(),
-});
-
-export const ScheduleInputSchema = z.object({
-  frequency: z.enum(["daily", "weekly", "monthly"]),
-  time: z.string(),
-  timezone: z.string(),
-  dayOfWeek: z.string().optional(),
-  dayOfMonth: z.string().optional(),
-});
-
-export const CreateSplitInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
-  rewardsSplit: z.array(RewardSplitInputSchema),
-  schedule: ScheduleInputSchema,
-  lazyDistributor: z.string().min(32),
-});
-
-export const DeleteSplitInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
-});
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-export const DeviceTypeSchema = z.enum([
-  "iot-gateway",
-  "wifiIndoor",
-  "wifiOutdoor",
-  "wifiDataOnly",
-  "cbrs",
-]);
-
-export const HotspotSharesSchema = z.object({
-  fixed: z.string().optional(),
-  percentage: z.number().optional(),
-});
-
-export const HotspotSchema = z.object({
-  address: z.string(),
-  entityKey: z.string(),
-  name: z.string(),
-  type: HotspotTypeSchema,
-  deviceType: DeviceTypeSchema,
-  city: z.string().optional(),
-  state: z.string().optional(),
-  country: z.string().optional(),
-  asset: z.string(),
-  isOnline: z.boolean().optional(),
-  owner: z.string().optional(),
-  shares: HotspotSharesSchema.optional(),
-  ownershipType: z.string(),
-});
-
-export const HotspotsDataSchema = z.object({
-  hotspots: z.array(HotspotSchema),
-  total: z.number(),
-  page: z.number(),
-  totalPages: z.number(),
-});
-
-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 ClaimRewardsOutputSchema = z.object({
-  transactionData: TransactionDataSchema,
-});
-
-export const TransferHotspotOutputSchema = z.object({
-  transactionData: TransactionDataSchema,
-});
-
-export const UpdateRewardsDestinationOutputSchema = z.object({
-  transactionData: TransactionDataSchema,
-});
-
-export const SplitShareSchema = z.object({
-  wallet: z.string(),
-  delegate: z.string(),
-  fixed: z.number(),
-  shares: z.number(),
-});
-
-export const SplitResponseSchema = z.object({
-  walletAddress: z.string(),
-  hotspotPubkey: z.string(),
-  splitAddress: z.string(),
-  shares: z.array(SplitShareSchema),
-});
-
-export const CreateSplitOutputSchema = z.object({
-  transactionData: TransactionDataSchema,
-});
-
-export const DeleteSplitOutputSchema = z.object({
-  transactionData: TransactionDataSchema,
-});
-
-// Pending rewards - proxied from oracle, so we use any for flexibility
-export const PendingRewardsOutputSchema = z.any();
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-export type GetHotspotsInput = z.infer<typeof GetHotspotsInputSchema>;
-export type ClaimRewardsInput = z.infer<typeof ClaimRewardsInputSchema>;
-export type GetPendingRewardsInput = z.infer<
-  typeof GetPendingRewardsInputSchema
->;
-export type TransferHotspotInput = z.infer<typeof TransferHotspotInputSchema>;
-export type UpdateRewardsDestinationInput = z.infer<
-  typeof UpdateRewardsDestinationInputSchema
->;
-export type GetSplitInput = z.infer<typeof GetSplitInputSchema>;
-export type CreateSplitInput = z.infer<typeof CreateSplitInputSchema>;
-export type DeleteSplitInput = z.infer<typeof DeleteSplitInputSchema>;
-export type HotspotsData = z.infer<typeof HotspotsDataSchema>;
-export type Hotspot = z.infer<typeof HotspotSchema>;
-export type SplitResponse = z.infer<typeof SplitResponseSchema>;