@helium/blockchain-api 0.1.2 → 0.1.3

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

@@ -1,119 +0,0 @@
-import { z } from "zod";
-
-// ============================================================================
-// Input Schemas
-// ============================================================================
-
-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 SubmitInputSchema = z.object({
-  transactions: z.array(TransactionItemSchema),
-  parallel: z.boolean(),
-  tag: z.string().optional(),
-});
-
-export const GetInputSchema = z.object({
-  id: z.string(),
-  commitment: z.enum(["confirmed", "finalized"]),
-});
-
-export const ResubmitInputSchema = z.object({
-  id: z.string(),
-});
-
-export const GetByPayerInputSchema = z.object({
-  payer: z.string().min(32),
-  page: z.coerce.number().int().min(1).default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(20),
-  status: z.string().optional().default("pending"),
-});
-
-export const GetByPayerAndTagInputSchema = z.object({
-  payer: z.string().min(32),
-  tag: z.string(),
-  page: z.coerce.number().int().min(1).default(1),
-  limit: z.coerce.number().int().min(1).max(100).default(20),
-  status: z.string().optional().default("pending"),
-});
-
-// ============================================================================
-// Output Schemas
-// ============================================================================
-
-export const SubmitOutputSchema = z.object({
-  batchId: z.string(),
-  message: z.string().optional(),
-});
-
-export const TransactionStatusSchema = z.object({
-  signature: z.string(),
-  status: z.string(),
-  transaction: z.unknown().optional(),
-});
-
-export const BatchStatusOutputSchema = z.object({
-  batchId: z.string(),
-  status: z.string(),
-  submissionType: z.string(),
-  parallel: z.boolean(),
-  transactions: z.array(TransactionStatusSchema),
-  jitoBundleId: z.string().optional(),
-  jitoBundleStatus: z.unknown().optional(),
-});
-
-export const ResubmitOutputSchema = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  error: z.string().optional(),
-  newSignatures: z.array(z.string()).optional(),
-});
-
-export const PayerBatchSummarySchema = z.object({
-  batchId: z.string(),
-  tag: z.string().optional(),
-  status: z.string(),
-  submissionType: z.string(),
-  parallel: z.boolean(),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  transactions: z.array(
-    z.object({
-      metadata: TransactionMetadataSchema.optional(),
-    }),
-  ),
-});
-
-export const PayerBatchesOutputSchema = z.object({
-  payer: z.string(),
-  batches: z.array(PayerBatchSummarySchema),
-  pagination: z.object({
-    page: z.number(),
-    limit: z.number(),
-    total: z.number(),
-    totalPages: z.number(),
-  }),
-});
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-export type SubmitInput = z.infer<typeof SubmitInputSchema>;
-export type GetInput = z.infer<typeof GetInputSchema>;
-export type ResubmitInput = z.infer<typeof ResubmitInputSchema>;
-export type GetByPayerInput = z.infer<typeof GetByPayerInputSchema>;
-export type GetByPayerAndTagInput = z.infer<typeof GetByPayerAndTagInputSchema>;
-export type SubmitOutput = z.infer<typeof SubmitOutputSchema>;
-export type BatchStatusOutput = z.infer<typeof BatchStatusOutputSchema>;
-export type ResubmitOutput = z.infer<typeof ResubmitOutputSchema>;
-export type PayerBatchesOutput = z.infer<typeof PayerBatchesOutputSchema>;

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

@@ -1,75 +0,0 @@
-import { z } from "zod";
-import { publicProcedure } from "../../procedures";
-import { BridgeUser } from "@/lib/models/bridge-user";
-import { ORPCError } from "@orpc/server";
-
-// ============================================================================
-// Schemas
-// ============================================================================
-
-const BridgeWebhookInputSchema = z.object({
-  type: z.string(),
-  kyc_link_id: z.string().optional(),
-  kyc_status: z.string().optional(),
-  tos_status: z.string().optional(),
-  customer_id: z.string().optional(),
-});
-
-const BridgeWebhookOutputSchema = z.object({
-  success: z.boolean(),
-  error: z.string().optional(),
-});
-
-// ============================================================================
-// Procedures
-// ============================================================================
-
-/**
- * Bridge webhook handler for KYC/ToS status updates.
- */
-const bridge = publicProcedure
-  .route({ method: "POST", path: "/webhooks/bridge" })
-  .input(BridgeWebhookInputSchema)
-  .output(BridgeWebhookOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Bridge user not found" },
-    INVALID_PAYLOAD: { message: "Invalid webhook payload" },
-  })
-  .handler(async ({ input, errors }) => {
-    const data = input;
-
-    // Handle KYC link status updates
-    if (data.type === "kyc_link.status_updated") {
-      const bridgeUser = await BridgeUser.findOne({
-        where: { kycLinkId: data.kyc_link_id },
-      });
-
-      if (!bridgeUser) {
-        console.error(
-          "Bridge user not found for KYC link ID:",
-          data.kyc_link_id,
-        );
-        throw errors.NOT_FOUND({ message: "Bridge user not found" });
-      }
-
-      // Update statuses
-      await bridgeUser.update({
-        kycStatus: data.kyc_status,
-        tosStatus: data.tos_status,
-        bridgeCustomerId: data.customer_id,
-      });
-
-      return { success: true };
-    }
-
-    // Handle other webhook types here
-    return { success: true };
-  });
-
-// ============================================================================
-// Router Export
-// ============================================================================
-
-export const webhooksRouter = {
-  bridge,
-};

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