@helium/blockchain-api 0.1.1 → 0.1.3

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

package/src/server/api/routers/swap/procedures/getInstructions.ts

@@ -1,152 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetInstructionsInputSchema, TransactionDataSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import {
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-
-/**
- * Get swap transaction instructions from Jupiter and build a transaction.
- */
-export const getInstructions = publicProcedure
-  .route({ method: "POST", path: "/swap/instructions" })
-  .input(GetInstructionsInputSchema)
-  .output(TransactionDataSchema)
-  .errors({
-    JUPITER_ERROR: { message: "Failed to get swap instructions from Jupiter" },
-  })
-  .handler(async ({ input, errors }) => {
-    const {
-      quoteResponse,
-      userPublicKey,
-      destinationTokenAccount,
-      dynamicComputeUnitLimit,
-      prioritizationFeeLamports,
-    } = input;
-
-    // Get swap instructions from Jupiter
-    const instructionsResponse = await fetch(
-      `${env.JUPITER_API_URL}/swap/v1/swap-instructions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": env.JUPITER_API_KEY,
-        },
-        body: JSON.stringify({
-          quoteResponse,
-          userPublicKey,
-          destinationTokenAccount,
-          dynamicComputeUnitLimit,
-          prioritizationFeeLamports: prioritizationFeeLamports || {
-            priorityLevelWithMaxLamports: {
-              maxLamports: 1000000,
-              priorityLevel: "medium",
-            },
-          },
-        }),
-      },
-    );
-
-    if (!instructionsResponse.ok) {
-      const errorText = await instructionsResponse.text();
-      console.error("Jupiter API error:", errorText);
-      throw errors.JUPITER_ERROR({
-        message: `Failed to get swap instructions from Jupiter: HTTP ${instructionsResponse.status}`,
-      });
-    }
-
-    const instructions = await instructionsResponse.json();
-
-    if (instructions.error) {
-      throw errors.JUPITER_ERROR({
-        message: `Jupiter API returned error: ${instructions.error}`,
-      });
-    }
-
-    // Build the transaction using the same pattern
-    const deserializeInstruction = (instruction: {
-      programId: string;
-      accounts: { pubkey: string; isSigner: boolean; isWritable: boolean }[];
-      data: string;
-    }) => {
-      return new TransactionInstruction({
-        programId: new PublicKey(instruction.programId),
-        keys: instruction.accounts.map((key) => ({
-          pubkey: new PublicKey(key.pubkey),
-          isSigner: key.isSigner,
-          isWritable: key.isWritable,
-        })),
-        data: Buffer.from(instruction.data, "base64"),
-      });
-    };
-
-    const jupIxs = [
-      ...(instructions.setupInstructions
-        ? instructions.setupInstructions.map(
-            (instruction: {
-              programId: string;
-              accounts: {
-                pubkey: string;
-                isSigner: boolean;
-                isWritable: boolean;
-              }[];
-              data: string;
-            }) => deserializeInstruction(instruction),
-          )
-        : []),
-      // Swap instruction
-      deserializeInstruction(instructions.swapInstruction),
-      // Cleanup instruction if present
-      ...(instructions.cleanupInstruction
-        ? [deserializeInstruction(instructions.cleanupInstruction)]
-        : []),
-    ];
-
-    const draft = {
-      instructions: jupIxs,
-      feePayer: new PublicKey(userPublicKey),
-      addressLookupTableAddresses: instructions.addressLookupTableAddresses.map(
-        (address: string) => new PublicKey(address),
-      ),
-    };
-
-    const connection = new Connection(process.env.SOLANA_RPC_URL!);
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(connection, {
-        ...draft,
-        instructions: await withPriorityFees({ ...draft, connection }),
-      }),
-    );
-
-    // Generate transaction tag
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.SWAP,
-      userAddress: userPublicKey,
-      inputMint: quoteResponse.inputMint,
-      outputMint: quoteResponse.outputMint,
-      amount: quoteResponse.inAmount,
-    });
-
-    return {
-      transactions: [
-        {
-          serializedTransaction: Buffer.from(tx.serialize()).toString("base64"),
-          metadata: {
-            type: "swap",
-            description: `Swap ${quoteResponse.inAmount} ${quoteResponse.inputMint} for ${quoteResponse.outAmount} ${quoteResponse.outputMint}`,
-          },
-        },
-      ],
-      parallel: false,
-      tag,
-    };
-  });

package/src/server/api/routers/swap/procedures/getQuote.ts

@@ -1,53 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetQuoteInputSchema, QuoteResponseSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-
-/**
- * Get a quote for swapping tokens from Jupiter.
- */
-export const getQuote = publicProcedure
-  .route({ method: "GET", path: "/swap/quote" })
-  .input(GetQuoteInputSchema)
-  .output(QuoteResponseSchema)
-  .errors({
-    JUPITER_ERROR: { message: "Failed to get quote from Jupiter" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { inputMint, outputMint, amount, swapMode, slippageBps } = input;
-
-    // Get quote from Jupiter
-    const quoteUrl = new URL(`${env.JUPITER_API_URL}/swap/v1/quote`);
-    quoteUrl.searchParams.set("inputMint", inputMint);
-    quoteUrl.searchParams.set("outputMint", outputMint);
-    quoteUrl.searchParams.set("amount", amount);
-    quoteUrl.searchParams.set("swapMode", swapMode);
-    quoteUrl.searchParams.set("slippageBps", slippageBps.toString());
-
-    const quoteResponse = await fetch(quoteUrl.toString(), {
-      headers: {
-        "x-api-key": env.JUPITER_API_KEY,
-      },
-    });
-
-    if (!quoteResponse.ok) {
-      const errorText = await quoteResponse.text();
-      console.error("Jupiter API error:", errorText);
-      throw errors.JUPITER_ERROR({
-        message: `Failed to get quote from Jupiter: HTTP ${quoteResponse.status}`,
-      });
-    }
-
-    const quote = await quoteResponse.json();
-
-    // Validate the response from Jupiter
-    const responseValidation = QuoteResponseSchema.safeParse(quote);
-    if (!responseValidation.success) {
-      console.error("Invalid Jupiter response:", responseValidation.error);
-      throw errors.JUPITER_ERROR({
-        message: "Invalid response from Jupiter API",
-      });
-    }
-
-    return responseValidation.data;
-  });

package/src/server/api/routers/swap/procedures/getTokens.ts

@@ -1,88 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetTokensInputSchema, TokenListOutputSchema, Token } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { TOKEN_MINTS } from "@/lib/constants/tokens";
-
-/**
- * Get list of verified tokens available for swapping from Jupiter.
- */
-export const getTokens = publicProcedure
-  .route({ method: "GET", path: "/swap/tokens" })
-  .input(GetTokensInputSchema)
-  .output(TokenListOutputSchema)
-  .errors({
-    JUPITER_ERROR: { message: "Failed to fetch tokens from Jupiter" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { limit } = input;
-
-    // Use Jupiter's Token API V2 endpoint for verified tokens
-    const jupiterUrl = new URL(`${env.JUPITER_API_URL}/tokens/v2/tag`);
-    jupiterUrl.searchParams.set("query", "verified");
-
-    const jupiterResponse = await fetch(jupiterUrl.toString(), {
-      headers: {
-        "User-Agent": "my-helium-api/1.0",
-        "x-api-key": env.JUPITER_API_KEY,
-      },
-    });
-
-    if (!jupiterResponse.ok) {
-      const errorText = await jupiterResponse.text();
-      console.error("Jupiter Token API error:", errorText);
-      throw errors.JUPITER_ERROR({
-        message: `Failed to fetch tokens from Jupiter: HTTP ${jupiterResponse.status}`,
-      });
-    }
-
-    const jupiterTokens: {
-      id: string;
-      symbol: string;
-      name: string;
-      decimals: number;
-      icon?: string;
-      tags?: string[];
-    }[] = await jupiterResponse.json();
-
-    // Transform the V2 response format to our expected format
-    const validatedTokens: Token[] = jupiterTokens
-      .slice(0, limit)
-      .map((token) => ({
-        address: token.id,
-        symbol: token.symbol,
-        name: token.name,
-        decimals: token.decimals,
-        logoURI: token.icon,
-        tags: token.tags || [],
-      }));
-
-    // Add HNT token at the top if it's not already in the list
-    const hntToken: Token = {
-      address: TOKEN_MINTS.HNT,
-      symbol: "HNT",
-      name: "Helium",
-      decimals: 8,
-      logoURI: "https://cryptologos.cc/logos/helium-hnt-logo.png",
-      tags: ["helium", "iot", "crypto"],
-    };
-
-    // Check if HNT is already in the list
-    const hasHNT = validatedTokens.some((token) => token.symbol === "HNT");
-
-    // Add HNT at the top if not present
-    if (!hasHNT) {
-      validatedTokens.unshift(hntToken);
-    } else {
-      // Move HNT to the top if it exists
-      const hntIndex = validatedTokens.findIndex(
-        (token) => token.symbol === "HNT",
-      );
-      if (hntIndex > 0) {
-        const hnt = validatedTokens.splice(hntIndex, 1)[0];
-        validatedTokens.unshift(hnt);
-      }
-    }
-
-    return { tokens: validatedTokens };
-  });