@helium/blockchain-api 0.1.1 → 0.1.3

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

@@ -1,709 +0,0 @@
-import { z } from "zod";
-import { ORPCError } from "@orpc/server";
-import { v4 as uuidv4 } from "uuid";
-import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import {
-  createAssociatedTokenAccountIdempotentInstruction,
-  createTransferCheckedInstruction,
-  getAssociatedTokenAddressSync,
-} from "@solana/spl-token";
-import {
-  populateMissingDraftInfo,
-  toVersionedTx,
-  HNT_MINT,
-  withPriorityFees,
-} from "@helium/spl-utils";
-import { Op } from "sequelize";
-
-import { protectedProcedure, publicProcedure } from "../../procedures";
-import {
-  InitKycInputSchema,
-  CreateBankAccountInputSchema,
-  GetBankAccountInputSchema,
-  DeleteBankAccountInputSchema,
-  GetSendQuoteInputSchema,
-  SendFundsInputSchema,
-  GetTransferInputSchema,
-  UpdateTransferInputSchema,
-  KycStatusOutputSchema,
-  FeesOutputSchema,
-  BankAccountListOutputSchema,
-  BankAccountSchema,
-  DeleteBankAccountOutputSchema,
-  QuoteOutputSchema,
-  SendFundsOutputSchema,
-  UpdateTransferOutputSchema,
-} from "./schemas";
-import { env } from "@/lib/env";
-import { privy } from "@/lib/privy";
-import { BridgeUser } from "@/lib/models/bridge-user";
-import { BankAccount } from "@/lib/models/bank-account";
-import { BridgeTransfer } from "@/lib/models/bridge-transfer";
-import { TOKEN_MINTS } from "@/lib/constants/tokens";
-import {
-  generateTransactionTag,
-  TRANSACTION_TYPES,
-} from "@/lib/utils/transaction-tags";
-
-// Helper functions
-const usdToUsdc = (usdAmount: string) => {
-  if (!usdAmount || isNaN(parseFloat(usdAmount))) return null;
-  return (parseFloat(usdAmount) * Math.pow(10, 6)).toString();
-};
-
-const usdcToUsd = (usdcAmount: string) => {
-  return parseFloat(usdcAmount) / Math.pow(10, 6);
-};
-
-const usdCeil = (amount: number) => {
-  return Math.ceil(amount * Math.pow(10, 2)) / Math.pow(10, 2);
-};
-
-// ============================================================================
-// Procedures
-// ============================================================================
-
-const getKycStatus = protectedProcedure
-  .route({ method: "GET", path: "/fiat/kyc" })
-  .output(KycStatusOutputSchema)
-  .errors({
-    EMAIL_NOT_LINKED: { message: "Email not linked" },
-  })
-  .handler(async ({ context, errors }) => {
-    const privyUser = context.session.user;
-
-    if (!privyUser.email) {
-      throw errors.EMAIL_NOT_LINKED({ message: "Email not linked" });
-    }
-
-    const bridgeUser = await BridgeUser.findOne({
-      where: { privyUserId: privyUser.id },
-    });
-
-    if (bridgeUser) {
-      return {
-        kycStatus: bridgeUser.kycStatus,
-        tosStatus: bridgeUser.tosStatus,
-        tosLink: bridgeUser.tosLink,
-        kycLink: bridgeUser.kycLink,
-        kycLinkId: bridgeUser.kycLinkId,
-        accountType: bridgeUser.accountType,
-      };
-    }
-
-    return {
-      kycStatus: "not_started",
-      tosStatus: "pending",
-      tosLink: null,
-      kycLink: null,
-      kycLinkId: null,
-    };
-  });
-
-const initKyc = protectedProcedure
-  .route({ method: "POST", path: "/fiat/kyc" })
-  .input(InitKycInputSchema)
-  .output(KycStatusOutputSchema)
-  .errors({
-    EMAIL_NOT_LINKED: { message: "Email not linked" },
-    BRIDGE_ERROR: { message: "Failed to create Bridge KYC link" },
-  })
-  .handler(async ({ input, context, errors }) => {
-    const { type } = input;
-    const privyUser = context.session.user;
-
-    if (!privyUser.email) {
-      throw errors.EMAIL_NOT_LINKED({ message: "Email not linked" });
-    }
-
-    let bridgeUser = await BridgeUser.findOne({
-      where: { privyUserId: privyUser.id },
-    });
-
-    if (bridgeUser && !bridgeUser.accountType && type) {
-      bridgeUser.accountType = type;
-      await bridgeUser.save();
-    }
-
-    if (
-      bridgeUser?.kycStatus === "approved" &&
-      bridgeUser?.tosStatus === "approved"
-    ) {
-      return {
-        kycStatus: bridgeUser.kycStatus,
-        tosStatus: bridgeUser.tosStatus,
-        tosLink: bridgeUser.tosLink,
-        kycLink: bridgeUser.kycLink,
-        kycLinkId: bridgeUser.kycLinkId,
-        accountType: bridgeUser.accountType,
-      };
-    }
-
-    let rejectionReasons: string[] = [];
-
-    if (!bridgeUser) {
-      const response = await fetch(`${env.BRIDGE_API_URL}/kyc_links`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Api-Key": env.BRIDGE_API_KEY,
-          "Idempotency-Key": uuidv4(),
-        },
-        body: JSON.stringify({
-          email: privyUser.email.address,
-          type: type || "individual",
-          redirect_uri: `${
-            process.env.NEXT_PUBLIC_APP_URL
-          }/withdraw?step=5&type=${type || "individual"}`,
-        }),
-      });
-
-      let data = await response.json();
-      const existsAlready = data.existing_kyc_link;
-      if (existsAlready) {
-        data = data.existing_kyc_link;
-      }
-
-      if (!response.ok && !existsAlready) {
-        console.error("Failed to create Bridge KYC link", data);
-        throw errors.BRIDGE_ERROR({
-          message: "Failed to create Bridge KYC link",
-        });
-      }
-
-      const [newBridgeUser] = await BridgeUser.findOrCreate({
-        where: { privyUserId: privyUser.id },
-        defaults: {
-          privyUserId: privyUser.id,
-          kycLinkId: data.id,
-          kycStatus: data.kyc_status,
-          tosStatus: data.tos_status,
-          tosLink: data.tos_link,
-          kycLink: data.kyc_link,
-          bridgeCustomerId: data.customer_id,
-          accountType: type || "individual",
-        },
-      });
-
-      bridgeUser = newBridgeUser;
-    } else {
-      const response = await fetch(
-        `${env.BRIDGE_API_URL}/kyc_links/${bridgeUser.kycLinkId}`,
-        {
-          method: "GET",
-          headers: {
-            "Content-Type": "application/json",
-            "Api-Key": env.BRIDGE_API_KEY,
-          },
-        },
-      );
-
-      if (!response.ok) {
-        throw errors.BRIDGE_ERROR({ message: "Failed to get Bridge KYC link" });
-      }
-
-      const data = await response.json();
-      if (process.env.BRIDGE_API_URL?.includes("sandbox")) {
-        bridgeUser.tosStatus = "approved";
-      } else {
-        bridgeUser.tosStatus = data.tos_status;
-      }
-      bridgeUser.kycStatus = data.kyc_status;
-      bridgeUser.tosLink = data.tos_link;
-      bridgeUser.kycLink = data.kyc_link;
-      await bridgeUser.save();
-      rejectionReasons = (data.rejection_reasons || []).map(
-        (r: { reason: string }) => r.reason,
-      );
-    }
-
-    return {
-      kycStatus: bridgeUser.kycStatus,
-      tosStatus: bridgeUser.tosStatus,
-      tosLink: bridgeUser.tosLink,
-      kycLink: bridgeUser.kycLink,
-      kycLinkId: bridgeUser.kycLinkId,
-      accountType: bridgeUser.accountType,
-      rejectionReasons,
-    };
-  });
-
-const getFees = publicProcedure
-  .route({ method: "GET", path: "/fiat/fees" })
-  .output(FeesOutputSchema)
-  .handler(async () => {
-    const developerFee = process.env.BRIDGE_DEVELOPER_FEE || "0.50";
-    const developerFeePercentage =
-      process.env.BRIDGE_DEVELOPER_FEE_PERCENTAGE || "0.5";
-
-    return {
-      developer_fee: developerFee,
-      developer_fee_percent: parseFloat(developerFeePercentage),
-    };
-  });
-
-const listBankAccounts = protectedProcedure
-  .route({ method: "GET", path: "/fiat/bank-accounts" })
-  .output(BankAccountListOutputSchema)
-  .errors({
-    NO_CUSTOMER: { message: "Bridge customer ID not found" },
-  })
-  .handler(async ({ context, errors }) => {
-    const privyUser = context.session.user;
-
-    const bridgeUser = await BridgeUser.findOne({
-      where: { privyUserId: privyUser.id },
-    });
-
-    if (!bridgeUser?.bridgeCustomerId) {
-      throw errors.NO_CUSTOMER({ message: "Bridge customer ID not found" });
-    }
-
-    const bankAccounts = await BankAccount.findAll({
-      where: { bridgeUserId: bridgeUser.id },
-    });
-
-    return bankAccounts.map((account) => account.toJSON());
-  });
-
-const createBankAccount = protectedProcedure
-  .route({ method: "POST", path: "/fiat/bank-accounts" })
-  .input(CreateBankAccountInputSchema)
-  .output(BankAccountSchema)
-  .errors({
-    NO_CUSTOMER: { message: "Bridge customer ID not found" },
-    BRIDGE_ERROR: { message: "Failed to add bank account" },
-  })
-  .handler(async ({ input, context, errors }) => {
-    const privyUser = context.session.user;
-
-    const bridgeUser = await BridgeUser.findOne({
-      where: { privyUserId: privyUser.id },
-    });
-
-    if (!bridgeUser?.bridgeCustomerId || !bridgeUser.id) {
-      throw errors.NO_CUSTOMER({ message: "Bridge customer ID not found" });
-    }
-
-    const {
-      currency,
-      account_type,
-      bank_name,
-      account_name,
-      first_name,
-      last_name,
-      account_owner_name,
-      business_name,
-      account,
-      address,
-    } = input;
-
-    const bankAccountResponse = await fetch(
-      `${env.BRIDGE_API_URL}/customers/${bridgeUser.bridgeCustomerId}/external_accounts`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Api-Key": env.BRIDGE_API_KEY,
-          "Idempotency-Key": uuidv4(),
-        },
-        body: JSON.stringify({
-          currency,
-          account_type,
-          bank_name,
-          account_name,
-          first_name,
-          last_name,
-          account_owner_type: bridgeUser.accountType,
-          account_owner_name,
-          ...(business_name && { business_name }),
-          account: {
-            routing_number: account.routing_number,
-            account_number: account.account_number,
-            checking_or_savings: account.checking_or_savings,
-          },
-          address: {
-            street_line_1: address.street_line_1,
-            country: address.country,
-            state: address.state,
-            city: address.city,
-            postal_code: address.postal_code,
-          },
-        }),
-      },
-    );
-
-    if (!bankAccountResponse.ok) {
-      const errorData = await bankAccountResponse.json();
-      console.error("Failed to add bank account", errorData);
-      throw errors.BRIDGE_ERROR({
-        message: errorData.message || "Failed to add bank account",
-      });
-    }
-
-    const bankAccountData = await bankAccountResponse.json();
-
-    const bankAccount = await BankAccount.create({
-      bridgeUserId: bridgeUser.id,
-      bridgeExternalAccountId: bankAccountData.id,
-      accountName: account_name,
-      bankName: bank_name,
-      lastFourDigits: account.account_number.slice(-4),
-      routingNumber: account.routing_number,
-      accountType: account.checking_or_savings,
-    });
-
-    return bankAccount.toJSON();
-  });
-
-const deleteBankAccount = protectedProcedure
-  .route({ method: "DELETE", path: "/fiat/bank-accounts/{id}" })
-  .input(DeleteBankAccountInputSchema)
-  .output(DeleteBankAccountOutputSchema)
-  .errors({
-    NO_CUSTOMER: { message: "Bridge customer ID not found" },
-    BRIDGE_ERROR: { message: "Failed to delete bank account" },
-  })
-  .handler(async ({ input, context, errors }) => {
-    const { id } = input;
-    const privyUser = context.session.user;
-
-    const bridgeUser = await BridgeUser.findOne({
-      where: { privyUserId: privyUser.id },
-    });
-
-    if (!bridgeUser?.bridgeCustomerId) {
-      throw errors.NO_CUSTOMER({ message: "Bridge customer ID not found" });
-    }
-
-    const bankAccount = await BankAccount.findOne({
-      where: { bridgeExternalAccountId: id },
-    });
-
-    const response = await fetch(
-      `${env.BRIDGE_API_URL}/customers/${bridgeUser.bridgeCustomerId}/external_accounts/${id}`,
-      {
-        method: "DELETE",
-        headers: {
-          "Content-Type": "application/json",
-          "Api-Key": env.BRIDGE_API_KEY,
-        },
-      },
-    );
-
-    if (!response.ok) {
-      const errorData = await response.json();
-      console.error("Failed to delete bank account", errorData);
-      throw errors.BRIDGE_ERROR({
-        message: errorData.message || "Failed to delete bank account",
-      });
-    }
-
-    await bankAccount?.destroy();
-
-    return { success: true };
-  });
-
-const getSendQuote = publicProcedure
-  .route({ method: "GET", path: "/fiat/bank-accounts/{id}/send" })
-  .input(GetSendQuoteInputSchema)
-  .output(QuoteOutputSchema)
-  .errors({
-    BAD_REQUEST: { message: "Invalid request" },
-    JUPITER_ERROR: { message: "Failed to get quote from Jupiter" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { usdAmount } = input;
-
-    const usdcAmount = usdToUsdc(usdAmount);
-    if (!usdcAmount) {
-      throw errors.BAD_REQUEST({ message: "Invalid USD amount" });
-    }
-
-    const quoteResponse = await fetch(
-      `https://lite-api.jup.ag/swap/v1/quote?inputMint=${HNT_MINT.toBase58()}&outputMint=${
-        TOKEN_MINTS.USDC
-      }&swapMode=ExactOut&amount=${usdcAmount}&slippageBps=50`,
-    );
-
-    if (!quoteResponse.ok) {
-      throw errors.JUPITER_ERROR({
-        message: "Failed to get quote from Jupiter",
-      });
-    }
-
-    return await quoteResponse.json();
-  });
-
-const sendFunds = publicProcedure
-  .route({ method: "POST", path: "/fiat/bank-accounts/{id}/send" })
-  .input(SendFundsInputSchema)
-  .output(SendFundsOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Bank account not found" },
-    BRIDGE_ERROR: { message: "Failed to create Bridge transfer" },
-    JUPITER_ERROR: { message: "Failed to get swap instructions" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { id, userAddress, quoteResponse } = input;
-
-    const bankAccount = await BankAccount.findByPk(id, {
-      include: [
-        {
-          as: "bridgeUser",
-          model: BridgeUser,
-          attributes: ["bridgeCustomerId"],
-        },
-      ],
-    });
-
-    if (!bankAccount) {
-      throw errors.NOT_FOUND({ message: "Bank account not found" });
-    }
-
-    // Cancel any existing transfers
-    const existingTransfers = await BridgeTransfer.findAll({
-      where: {
-        bridgeUserId: bankAccount.bridgeUserId,
-        solanaSignature: { [Op.is]: null } as unknown as string,
-        state: { [Op.notIn]: ["cancelled", "failed"] },
-      },
-    });
-
-    for (const transfer of existingTransfers) {
-      try {
-        await fetch(
-          `https://api.bridge.xyz/v0/transfers/${transfer.bridgeTransferId}`,
-          {
-            method: "DELETE",
-            headers: {
-              "Api-Key": process.env.BRIDGE_API_KEY!,
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({}),
-          },
-        );
-        await transfer.destroy();
-      } catch (e) {
-        console.error("Error cancelling transfer:", e);
-      }
-    }
-
-    // Create transfer with Bridge
-    const fee = (
-      parseFloat(process.env.BRIDGE_DEVELOPER_FEE || "0.50") +
-      usdCeil(
-        (parseFloat(process.env.BRIDGE_DEVELOPER_FEE_PERCENTAGE || "0.5") /
-          100) *
-          usdcToUsd(quoteResponse.outAmount),
-      )
-    ).toString();
-
-    const bridgeTransferResponse = await fetch(
-      "https://api.bridge.xyz/v0/transfers",
-      {
-        method: "POST",
-        headers: {
-          "Api-Key": process.env.BRIDGE_API_KEY!,
-          "Content-Type": "application/json",
-          "Idempotency-Key": uuidv4(),
-        },
-        body: JSON.stringify({
-          on_behalf_of: bankAccount.bridgeUser!.bridgeCustomerId,
-          amount: usdcToUsd(quoteResponse.outAmount).toString(),
-          developer_fee: fee,
-          source: {
-            payment_rail: "solana",
-            currency: "usdc",
-            from_address: userAddress,
-          },
-          destination: {
-            payment_rail: "ach",
-            currency: "usd",
-            external_account_id: bankAccount.bridgeExternalAccountId,
-          },
-        }),
-      },
-    );
-
-    if (!bridgeTransferResponse.ok) {
-      const error = await bridgeTransferResponse.json();
-      throw errors.BRIDGE_ERROR({
-        message: error.message || "Failed to create Bridge transfer",
-      });
-    }
-
-    const bridgeTransfer = await bridgeTransferResponse.json();
-    const destination = bridgeTransfer.source_deposit_instructions.to_address;
-
-    const ata = getAssociatedTokenAddressSync(
-      new PublicKey(TOKEN_MINTS.USDC),
-      new PublicKey(destination),
-      true,
-    );
-
-    await BridgeTransfer.create({
-      bridgeTransferId: bridgeTransfer.id,
-      bridgeUserId: bankAccount.bridgeUserId,
-      bankAccountId: bankAccount.id!,
-      amount: quoteResponse.outAmount,
-      state: bridgeTransfer.state,
-    });
-
-    // Get swap instructions from Jupiter
-    const myUsdcAta = getAssociatedTokenAddressSync(
-      new PublicKey(TOKEN_MINTS.USDC),
-      new PublicKey(userAddress),
-      true,
-    );
-
-    const instructionsResponse = await fetch(
-      "https://lite-api.jup.ag/swap/v1/swap-instructions",
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          quoteResponse,
-          userPublicKey: userAddress,
-          destinationTokenAccount: myUsdcAta.toBase58(),
-          dynamicComputeUnitLimit: true,
-          prioritizationFeeLamports: {
-            priorityLevelWithMaxLamports: {
-              maxLamports: 1000000,
-              priorityLevel: "medium",
-            },
-          },
-        }),
-      },
-    );
-
-    const instructions = await instructionsResponse.json();
-    if (instructions.error) {
-      throw errors.JUPITER_ERROR({
-        message: "Failed to get swap instructions: " + instructions.error,
-      });
-    }
-
-    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 = [
-      createAssociatedTokenAccountIdempotentInstruction(
-        new PublicKey(userAddress),
-        myUsdcAta,
-        new PublicKey(userAddress),
-        new PublicKey(TOKEN_MINTS.USDC),
-      ),
-      deserializeInstruction(instructions.swapInstruction),
-      createAssociatedTokenAccountIdempotentInstruction(
-        new PublicKey(userAddress),
-        ata,
-        new PublicKey(destination),
-        new PublicKey(TOKEN_MINTS.USDC),
-      ),
-      createTransferCheckedInstruction(
-        myUsdcAta,
-        new PublicKey(TOKEN_MINTS.USDC),
-        ata,
-        new PublicKey(userAddress),
-        BigInt(quoteResponse.outAmount),
-        6,
-      ),
-    ];
-
-    const draft = {
-      instructions: jupIxs,
-      feePayer: new PublicKey(userAddress),
-      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 }),
-      }),
-    );
-
-    const tag = generateTransactionTag({
-      type: TRANSACTION_TYPES.BANK_SEND,
-      bankAccountId: id,
-      userAddress,
-      amount: quoteResponse.outAmount,
-    });
-
-    return {
-      bridgeTransfer,
-      transactionData: {
-        transactions: [
-          {
-            serializedTransaction: Buffer.from(tx.serialize()).toString(
-              "base64",
-            ),
-            metadata: {
-              type: "bank_send",
-              description: `Withdraw $${(
-                parseFloat(quoteResponse.outAmount) / 1e6
-              ).toFixed(2)} worth of HNT to Bank Account`,
-            },
-          },
-        ],
-        parallel: false,
-        tag,
-      },
-    };
-  });
-
-const updateTransfer = publicProcedure
-  .route({ method: "PATCH", path: "/fiat/transfers/{id}" })
-  .input(UpdateTransferInputSchema)
-  .output(UpdateTransferOutputSchema)
-  .errors({
-    NOT_FOUND: { message: "Transfer not found" },
-  })
-  .handler(async ({ input, errors }) => {
-    const { id, solanaSignature } = input;
-
-    const transfer = await BridgeTransfer.findOne({
-      where: { bridgeTransferId: id },
-    });
-
-    if (!transfer) {
-      throw errors.NOT_FOUND({ message: "Transfer not found" });
-    }
-
-    await transfer.update({ solanaSignature });
-
-    return { success: true };
-  });
-
-// ============================================================================
-// Router Export
-// ============================================================================
-
-export const fiatRouter = {
-  getKycStatus,
-  initKyc,
-  getFees,
-  listBankAccounts,
-  createBankAccount,
-  deleteBankAccount,
-  getSendQuote,
-  sendFunds,
-  updateTransfer,
-};