@helium/blockchain-api 0.1.1 → 0.1.3

package/src/server/api/routers/welcomePacks/procedures/claim.ts

@@ -1,157 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { ClaimInputSchema, ClaimOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { createSolanaConnection, loadKeypair } from "@/lib/solana";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-import {
-  getAsset,
-  getAssetProof,
-  HELIUM_COMMON_LUT,
-  HELIUM_COMMON_LUT_DEVNET,
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import { init as initTuktuk } from "@helium/tuktuk-sdk";
-import { claimWelcomePack, init } from "@helium/welcome-pack-sdk";
-import {
-  createAssociatedTokenAccountIdempotentInstruction,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token";
-import { PublicKey } from "@solana/web3.js";
-import BN from "bn.js";
-
-/**
- * Claim a welcome pack.
- */
-export const claim = publicProcedure
-  .route({
-    method: "POST",
-    path: "/welcome-packs/{packAddress}/claim/{walletAddress}",
-  })
-  .input(ClaimInputSchema)
-  .output(ClaimOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-    EXPIRED: { message: "Invite has expired" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { packAddress, walletAddress, signature, expirationTs } = input;
-
-    if (!packAddress || !walletAddress) {
-      throw errors.BAD_REQUEST({
-        message: "Pack address and wallet address are required",
-      });
-    }
-
-    // Verify expiration
-    const currentTs = Math.floor(Date.now() / 1000);
-    if (currentTs > parseInt(expirationTs)) {
-      throw errors.EXPIRED({ message: "Invite has expired" });
-    }
-
-    const signatureBytes = Buffer.from(signature, "base64");
-
-    const feePayerWallet = loadKeypair(process.env.FEE_PAYER_WALLET_PATH!);
-
-    // Initialize connection and programs
-    const { provider } = createSolanaConnection(
-      feePayerWallet.publicKey.toString(),
-    );
-    const program = await init(provider);
-    const tuktukProgram = await initTuktuk(provider);
-    const welcomePack = await program.account.welcomePackV0.fetch(
-      new PublicKey(packAddress),
-    );
-
-    // Prepare claim transaction
-    const {
-      instruction: ix,
-      pubkeys: { rewardsMint },
-    } = await (
-      await claimWelcomePack({
-        program,
-        claimer: new PublicKey(walletAddress),
-        tuktukProgram,
-        taskQueue: new PublicKey(process.env.HPL_CRONS_TASK_QUEUE!),
-        welcomePack: new PublicKey(packAddress),
-        claimApproval: {
-          uniqueId: welcomePack.uniqueId,
-          expirationTimestamp: new BN(parseInt(expirationTs)),
-        },
-        claimApprovalSignature: signatureBytes,
-        payer: feePayerWallet.publicKey,
-        getAssetFn: (_, assetId) =>
-          getAsset(
-            env.ASSET_ENDPOINT || program.provider.connection.rpcEndpoint,
-            assetId,
-          ),
-        getAssetProofFn: (_, assetId) =>
-          getAssetProof(
-            env.ASSET_ENDPOINT || program.provider.connection.rpcEndpoint,
-            assetId,
-          ),
-      })
-    ).prepare();
-
-    const draft = {
-      instructions: [
-        ix,
-        createAssociatedTokenAccountIdempotentInstruction(
-          new PublicKey(walletAddress),
-          getAssociatedTokenAddressSync(
-            rewardsMint!,
-            new PublicKey(walletAddress),
-            true,
-          ),
-          new PublicKey(walletAddress),
-          rewardsMint!,
-        ),
-      ],
-      feePayer: feePayerWallet.publicKey,
-      addressLookupTableAddresses: [
-        process.env.NEXT_PUBLIC_SOLANA_CLUSTER!.trim() === "devnet"
-          ? HELIUM_COMMON_LUT_DEVNET
-          : HELIUM_COMMON_LUT,
-      ],
-    };
-
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(provider.connection, {
-        ...draft,
-        instructions: await withPriorityFees({
-          ...draft,
-          connection: provider.connection,
-        }),
-      }),
-    );
-    tx.sign([feePayerWallet]);
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.WELCOME_PACK_CLAIM,
-      packAddress,
-      walletAddress,
-    });
-
-    return {
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction: Buffer.from(tx.serialize()).toString(
-              "base64",
-            ),
-            metadata: {
-              type: "welcome_pack_claim",
-              description: "Claim welcome pack",
-            },
-          },
-        ],
-        parallel: true,
-        tag,
-      },
-    };
-  });

package/src/server/api/routers/welcomePacks/procedures/create.ts

@@ -1,247 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { CreateInputSchema, CreateOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { WelcomePackWithStatus } from "@/lib/models/welcome-pack";
-import { createSolanaConnection } from "@/lib/solana";
-import { scheduleToUtcCron } from "@/lib/utils/misc";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-import {
-  initializeCompressionRecipient,
-  init as initLd,
-  recipientKey,
-} from "@helium/lazy-distributor-sdk";
-import {
-  getAsset,
-  getAssetProof,
-  HELIUM_COMMON_LUT,
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import { init, initializeWelcomePack } from "@helium/welcome-pack-sdk";
-import {
-  LAMPORTS_PER_SOL,
-  PublicKey,
-  TransactionInstruction,
-} from "@solana/web3.js";
-import BN from "bn.js";
-
-function solToLamports(sol: number): BN {
-  return new BN(sol * LAMPORTS_PER_SOL);
-}
-
-/**
- * Create a new welcome pack.
- */
-export const create = publicProcedure
-  .route({ method: "POST", path: "/welcome-packs/wallet/{walletAddress}" })
-  .input(CreateInputSchema)
-  .output(CreateOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-  })
-  .handler(async ({ input, errors }) => {
-    const {
-      walletAddress,
-      assetId,
-      solAmount,
-      rentRefund,
-      assetReturnAddress,
-      rewardsSplit,
-      schedule,
-      lazyDistributor,
-    } = input;
-
-    if (!assetId) {
-      throw errors.BAD_REQUEST({ message: "Asset ID is required" });
-    }
-
-    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",
-      });
-    }
-
-    if (!rentRefund || !assetReturnAddress) {
-      throw errors.BAD_REQUEST({ message: "Return addresses are required" });
-    }
-
-    if (!solAmount || solAmount <= 0) {
-      throw errors.BAD_REQUEST({
-        message: "SOL amount must be greater than 0",
-      });
-    }
-
-    // Validate reward splits
-    for (const split of rewardsSplit) {
-      if (!split.address || !split.amount || !split.type) {
-        throw errors.BAD_REQUEST({
-          message: "Each reward split must have an address, amount, and type",
-        });
-      }
-
-      if (
-        split.type === "percentage" &&
-        (split.amount < 0 || split.amount > 100)
-      ) {
-        throw errors.BAD_REQUEST({
-          message: "Percentage rewards must be between 0 and 100",
-        });
-      }
-
-      if (split.type === "fixed" && split.amount <= 0) {
-        throw errors.BAD_REQUEST({
-          message: "Fixed rewards must be greater than 0",
-        });
-      }
-    }
-
-    const { connection, provider, wallet } =
-      createSolanaConnection(walletAddress);
-    const program = await init(provider);
-    const ldProgram = await initLd(provider);
-
-    const rewardsSchedule = scheduleToUtcCron(schedule);
-
-    const recipientK = recipientKey(
-      new PublicKey(lazyDistributor),
-      new PublicKey(assetId),
-    )[0];
-    const recipient =
-      await ldProgram.account.recipientV0.fetchNullable(recipientK);
-    const instructions: TransactionInstruction[] = [];
-
-    if (!recipient) {
-      instructions.push(
-        await (
-          await initializeCompressionRecipient({
-            program: ldProgram,
-            assetId: new PublicKey(assetId),
-            payer: wallet.publicKey,
-            assetEndpoint: env.ASSET_ENDPOINT,
-            lazyDistributor: new PublicKey(lazyDistributor),
-          })
-        ).instruction(),
-      );
-    }
-
-    const { instruction: ix, pubkeys } = await (
-      await initializeWelcomePack({
-        program,
-        assetId: new PublicKey(assetId),
-        owner: new PublicKey(walletAddress),
-        solAmount: solToLamports(solAmount),
-        rentRefund: new PublicKey(rentRefund),
-        assetReturnAddress: new PublicKey(assetReturnAddress),
-        rewardsSplit: rewardsSplit.map((split) =>
-          split.type === "percentage"
-            ? {
-                share: { share: { amount: split.amount } },
-                wallet: new PublicKey(split.address),
-              }
-            : {
-                share: { fixed: { amount: new BN(split.amount) } },
-                wallet: new PublicKey(split.address),
-              },
-        ),
-        rewardsSchedule,
-        getAssetFn: (_, assetId) =>
-          getAsset(
-            env.ASSET_ENDPOINT || program.provider.connection.rpcEndpoint,
-            assetId,
-          ),
-        getAssetProofFn: (_, assetId) =>
-          getAssetProof(
-            env.ASSET_ENDPOINT || program.provider.connection.rpcEndpoint,
-            assetId,
-          ),
-        assetEndpoint: env.ASSET_ENDPOINT,
-        lazyDistributor: new PublicKey(lazyDistributor),
-      })
-    ).prepare();
-    instructions.push(ix);
-
-    const draft = {
-      instructions,
-      feePayer: new PublicKey(walletAddress),
-      addressLookupTableAddresses: [HELIUM_COMMON_LUT],
-    };
-
-    let instructionsWithFees: TransactionInstruction[];
-    try {
-      instructionsWithFees = await withPriorityFees({ ...draft, connection });
-    } catch {
-      instructionsWithFees = draft.instructions;
-    }
-
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(connection, {
-        ...draft,
-        instructions: instructionsWithFees,
-      }),
-    );
-
-    const userWelcomePacksAccount =
-      await program.account.userWelcomePacksV0.fetchNullable(
-        new PublicKey(pubkeys.userWelcomePacks!),
-      );
-    const lazyDistributorAcc =
-      await ldProgram.account.lazyDistributorV0.fetch(lazyDistributor);
-
-    const welcomePack: WelcomePackWithStatus = {
-      address: pubkeys.welcomePack!.toBase58(),
-      id: userWelcomePacksAccount?.nextId || 0,
-      uniqueId: `${userWelcomePacksAccount?.nextUniqueId || 0}`,
-      owner: walletAddress,
-      rewardsSplit: rewardsSplit.map((split) => ({
-        address: split.address,
-        amount: split.amount,
-        type: split.type,
-      })),
-      rewardsSchedule,
-      solAmount: solAmount.toString(),
-      assetReturnAddress,
-      asset: assetId,
-      lazyDistributor,
-      loading: true,
-      rewardsMint: lazyDistributorAcc.rewardsMint.toBase58(),
-      rentRefund: rentRefund.toString(),
-      bumpSeed: 0,
-      hotspot: null,
-    };
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.WELCOME_PACK_CREATE,
-      walletAddress,
-      assetId,
-    });
-
-    return {
-      welcomePack,
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction: Buffer.from(tx.serialize()).toString(
-              "base64",
-            ),
-            metadata: {
-              type: "welcome_pack_create",
-              description: "Create welcome pack",
-            },
-          },
-        ],
-        parallel: true,
-        tag,
-      },
-    };
-  });

package/src/server/api/routers/welcomePacks/procedures/deletePack.ts

@@ -1,118 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { DeleteInputSchema, DeleteOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { env } from "@/lib/env";
-import { createSolanaConnection } from "@/lib/solana";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-import {
-  getAsset,
-  getAssetProof,
-  HELIUM_COMMON_LUT,
-  HELIUM_COMMON_LUT_DEVNET,
-  populateMissingDraftInfo,
-  toVersionedTx,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import {
-  closeWelcomePack,
-  init,
-  welcomePackKey,
-} from "@helium/welcome-pack-sdk";
-import { PublicKey } from "@solana/web3.js";
-
-/**
- * Delete a welcome pack.
- */
-export const deletePack = publicProcedure
-  .route({
-    method: "DELETE",
-    path: "/welcome-packs/wallet/{walletAddress}/{packId}",
-  })
-  .input(DeleteInputSchema)
-  .output(DeleteOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress, packId } = input;
-
-    if (!walletAddress) {
-      throw errors.BAD_REQUEST({ message: "Wallet address is required" });
-    }
-
-    if (!packId) {
-      throw errors.BAD_REQUEST({ message: "Pack ID is required" });
-    }
-
-    const { provider } = createSolanaConnection(walletAddress);
-    const program = await init(provider);
-
-    const welcomePackK = welcomePackKey(
-      new PublicKey(walletAddress),
-      Number(packId),
-    )[0];
-
-    const { instruction: ix } = await (
-      await closeWelcomePack({
-        program,
-        welcomePack: welcomePackK,
-        getAssetFn: (_, assetId) =>
-          getAsset(
-            env.ASSET_ENDPOINT || program.provider.connection.rpcEndpoint,
-            assetId,
-          ),
-        getAssetProofFn: (_, assetId) =>
-          getAssetProof(
-            env.ASSET_ENDPOINT || program.provider.connection.rpcEndpoint,
-            assetId,
-          ),
-      })
-    ).prepare();
-
-    const draft = {
-      instructions: [ix],
-      feePayer: new PublicKey(walletAddress),
-      addressLookupTableAddresses: [
-        process.env.NEXT_PUBLIC_SOLANA_CLUSTER === "devnet"
-          ? HELIUM_COMMON_LUT_DEVNET
-          : HELIUM_COMMON_LUT,
-      ],
-    };
-
-    const tx = toVersionedTx(
-      await populateMissingDraftInfo(provider.connection, {
-        ...draft,
-        instructions: await withPriorityFees({
-          ...draft,
-          connection: provider.connection,
-        }),
-      }),
-    );
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.WELCOME_PACK_DELETE,
-      walletAddress,
-      packId,
-    });
-
-    return {
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction: Buffer.from(tx.serialize()).toString(
-              "base64",
-            ),
-            metadata: {
-              type: "welcome_pack_delete",
-              description: "Delete welcome pack",
-            },
-          },
-        ],
-        parallel: true,
-        tag,
-      },
-    };
-  });

package/src/server/api/routers/welcomePacks/procedures/get.ts

@@ -1,36 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetInputSchema, WelcomePackSchema } from "../schemas";
-import { getWelcomePackByAddress } from "@/lib/queries/welcome-packs";
-import { welcomePackKey } from "@helium/welcome-pack-sdk";
-import { PublicKey } from "@solana/web3.js";
-
-/**
- * Get a welcome pack by wallet address and pack ID.
- */
-export const get = publicProcedure
-  .route({
-    method: "GET",
-    path: "/welcome-packs/wallet/{walletAddress}/{packId}",
-  })
-  .input(GetInputSchema)
-  .output(WelcomePackSchema)
-  .errors({
-    NOT_FOUND: { message: "Welcome pack not found" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { walletAddress, packId } = input;
-
-    // Derive the welcome pack address from wallet and packId
-    const welcomePackAddress = welcomePackKey(
-      new PublicKey(walletAddress),
-      Number(packId),
-    )[0].toBase58();
-
-    const pack = await getWelcomePackByAddress(welcomePackAddress);
-
-    if (!pack) {
-      throw errors.NOT_FOUND({ message: "Welcome pack not found" });
-    }
-
-    return pack;
-  });

package/src/server/api/routers/welcomePacks/procedures/getByAddress.ts

@@ -1,26 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { GetByAddressInputSchema, WelcomePackSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { getWelcomePackByAddress } from "@/lib/queries/welcome-packs";
-
-/**
- * Get a welcome pack by its address.
- */
-export const getByAddress = publicProcedure
-  .route({ method: "GET", path: "/welcome-packs/{packAddress}" })
-  .input(GetByAddressInputSchema)
-  .output(WelcomePackSchema)
-  .errors({
-    NOT_FOUND: { message: "Welcome pack not found" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { packAddress } = input;
-
-    const pack = await getWelcomePackByAddress(packAddress);
-
-    if (!pack) {
-      throw errors.NOT_FOUND({ message: "Welcome pack not found" });
-    }
-
-    return pack;
-  });

package/src/server/api/routers/welcomePacks/procedures/invite.ts

@@ -1,44 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { InviteInputSchema, InviteOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { createSolanaConnection } from "@/lib/solana";
-import { init as initWelcomePack } from "@helium/welcome-pack-sdk";
-import { PublicKey } from "@solana/web3.js";
-
-/**
- * Generate an invite message to be signed for a welcome pack.
- */
-export const invite = publicProcedure
-  .route({
-    method: "POST",
-    path: "/welcome-packs/{packAddress}/invite/{walletAddress}",
-  })
-  .input(InviteInputSchema)
-  .output(InviteOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { packAddress, walletAddress, expirationDays } = input;
-
-    if (!packAddress || !walletAddress) {
-      throw errors.BAD_REQUEST({
-        message: "Pack address and wallet address are required",
-      });
-    }
-
-    // Load uniqueId from on-chain welcome pack account
-    const { provider } = createSolanaConnection(walletAddress);
-    const program = await initWelcomePack(provider);
-    const welcomePack = await program.account.welcomePackV0.fetch(
-      new PublicKey(packAddress),
-    );
-    const uniqueId = welcomePack.uniqueId.toString();
-    const expirationTs =
-      Math.floor(Date.now() / 1000) + expirationDays * 24 * 60 * 60;
-
-    // Keep the canonical message format aligned with client expectations
-    const message = `Approve invite ${uniqueId} expiring ${expirationTs}`;
-
-    return { message, expirationTs };
-  });

package/src/server/api/routers/welcomePacks/procedures/list.ts

@@ -1,27 +0,0 @@
-import { publicProcedure } from "../../../procedures";
-import { ListInputSchema, ListOutputSchema } from "../schemas";
-import { ORPCError } from "@orpc/server";
-import { getWelcomePacksByOwner } from "@/lib/queries/welcome-packs";
-
-/**
- * List all welcome packs for a wallet.
- */
-export const list = publicProcedure
-  .route({ method: "GET", path: "/welcome-packs/wallet/{walletAddress}" })
-  .input(ListInputSchema)
-  .output(ListOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Wallet address is required" },
-  })
-  .handler(async ({ input }) => {
-    const { walletAddress } = input;
-
-    if (!walletAddress) {
-      throw new ORPCError("BAD_REQUEST", {
-        message: "Wallet address is required",
-      });
-    }
-
-    const packs = await getWelcomePacksByOwner(walletAddress);
-    return packs;
-  });

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

@@ -1,27 +0,0 @@
-import { list } from "./procedures/list";
-import { create } from "./procedures/create";
-import { get } from "./procedures/get";
-import { deletePack } from "./procedures/deletePack";
-import { getByAddress } from "./procedures/getByAddress";
-import { claim } from "./procedures/claim";
-import { invite } from "./procedures/invite";
-
-/**
- * Welcome Packs router - handles welcome pack operations.
- */
-export const welcomePacksRouter = {
-  /** List all welcome packs for a wallet */
-  list,
-  /** Create a new welcome pack */
-  create,
-  /** Get a welcome pack by wallet and pack ID */
-  get,
-  /** Delete a welcome pack */
-  delete: deletePack,
-  /** Get a welcome pack by its address */
-  getByAddress,
-  /** Claim a welcome pack */
-  claim,
-  /** Generate an invite message for a welcome pack */
-  invite,
-};