feat: update clientPayment status

constants/index.ts

@@ -92,7 +92,7 @@ export const RESPONSE_MESSAGES = {
   INVALID_OUTPUT_SCRIPT_LENGTH_500: (l: number) => { return { statusCode: 500, message: `Invalid outputScript length ${l}` } },
   FAILED_TO_PARSE_TX_OP_RETURN_500: { statusCode: 500, message: 'Failed to parse OP_RETURN data in Tx.' },
   PAYBUTTON_ID_NOT_PROVIDED_400: { statusCode: 400, message: 'Paybutton id not provided' },
-  METHOD_NOT_ALLOWED: { statusCode: 500, message: 'Method not allowed.' },
+  METHOD_NOT_ALLOWED_405: { statusCode: 405, message: 'Method not allowed.' },
   USER_HAS_NO_ORGANIZATION_400: { statusCode: 400, message: 'User does not belong to an organization.' },
   USER_ALREADY_HAS_ORGANIZATION_400: { statusCode: 400, message: 'User already belongs to an organization.' },
   USER_HAS_ALREADY_USED_INVITE_400: { statusCode: 400, message: 'You have already used this invite.' },

pages/api/paybutton/download/transactions/[paybuttonId].ts

@@ -14,7 +14,7 @@ import { fetchUserProfileFromId } from 'services/userService'
 export default async (req: any, res: any): Promise<void> => {
   try {
     if (req.method !== 'GET') {
-      throw new Error(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED.message)
+      throw new Error(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405.message)
     }
     if ((req.query.paybuttonId === undefined)) {
       throw new Error(RESPONSE_MESSAGES.PAYBUTTON_ID_NOT_PROVIDED_400.message)
@@ -59,9 +59,9 @@ export default async (req: any, res: any): Promise<void> => {
         res.status(RESPONSE_MESSAGES.PAYBUTTON_ID_NOT_PROVIDED_400.statusCode)
           .json(RESPONSE_MESSAGES.PAYBUTTON_ID_NOT_PROVIDED_400)
         break
-      case RESPONSE_MESSAGES.METHOD_NOT_ALLOWED.message:
-        res.status(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED.statusCode)
-          .json(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED)
+      case RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405.message:
+        res.status(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405.statusCode)
+          .json(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405)
         break
       case RESPONSE_MESSAGES.MISSING_PRICE_FOR_TRANSACTION_400.message:
         res.status(RESPONSE_MESSAGES.MISSING_PRICE_FOR_TRANSACTION_400.statusCode)

pages/api/paybutton/transactions/[id].ts

@@ -43,6 +43,6 @@ export default async (req: any, res: any): Promise<void> => {
       }
     }
   } else {
-    res.status(405).json(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED)
+    res.status(405).json(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405)
   }
 }

pages/api/payments/download/index.ts

@@ -13,7 +13,7 @@ import { fetchAllPaymentsByUserId } from 'services/transactionService'
 export default async (req: any, res: any): Promise<void> => {
   try {
     if (req.method !== 'GET') {
-      throw new Error(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED.message)
+      throw new Error(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405.message)
     }
 
     await setSession(req, res)
@@ -57,9 +57,9 @@ export default async (req: any, res: any): Promise<void> => {
     await downloadTxsFile(res, quoteSlug, timezone, transactions, userId)
   } catch (error: any) {
     switch (error.message) {
-      case RESPONSE_MESSAGES.METHOD_NOT_ALLOWED.message:
-        res.status(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED.statusCode)
-          .json(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED)
+      case RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405.message:
+        res.status(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405.statusCode)
+          .json(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405)
         break
       case RESPONSE_MESSAGES.MISSING_PRICE_FOR_TRANSACTION_400.message:
         res.status(RESPONSE_MESSAGES.MISSING_PRICE_FOR_TRANSACTION_400.statusCode)

pages/api/payments/paymentId/index.ts

@@ -0,0 +1,40 @@
+import { Decimal } from '@prisma/client/runtime/library'
+import { generatePaymentId } from 'services/transactionService'
+import { parseAddress, parseCreatePaymentIdPOSTRequest } from 'utils/validators'
+import { RESPONSE_MESSAGES } from 'constants/index'
+import { runMiddleware } from 'utils/index'
+
+import Cors from 'cors'
+
+const cors = Cors({
+  methods: ['POST']
+})
+
+export default async (req: any, res: any): Promise<void> => {
+  await runMiddleware(req, res, cors)
+  if (req.method === 'POST') {
+    try {
+      const values = parseCreatePaymentIdPOSTRequest(req.body)
+      const address = parseAddress(values.address)
+      const amount = values.amount as Decimal | undefined
+
+      const paymentId = await generatePaymentId(address, amount)
+
+      res.status(200).json({ paymentId })
+    } catch (error: any) {
+      switch (error.message) {
+        case RESPONSE_MESSAGES.ADDRESS_NOT_PROVIDED_400.message:
+          res.status(RESPONSE_MESSAGES.ADDRESS_NOT_PROVIDED_400.statusCode).json(RESPONSE_MESSAGES.ADDRESS_NOT_PROVIDED_400)
+          break
+        case RESPONSE_MESSAGES.INVALID_ADDRESS_400.message:
+          res.status(RESPONSE_MESSAGES.INVALID_ADDRESS_400.statusCode).json(RESPONSE_MESSAGES.INVALID_ADDRESS_400)
+          break
+        default:
+          res.status(500).json({ statusCode: 500, message: error.message })
+      }
+    }
+  } else {
+    res.status(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405.statusCode)
+      .json(RESPONSE_MESSAGES.METHOD_NOT_ALLOWED_405)
+  }
+}

prisma-local/migrations/20250912183436_client_payment/migration.sql

@@ -0,0 +1,14 @@
+-- CreateTable
+CREATE TABLE `ClientPayment` (
+    `paymentId` VARCHAR(191) NOT NULL,
+    `status` ENUM('PENDING', 'ADDED_TO_MEMPOOL', 'CONFIRMED') NOT NULL,
+    `addressString` VARCHAR(191) NOT NULL,
+    `amount` DECIMAL(65, 30) NULL,
+    `createdAt` DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+    `updatedAt` DATETIME(3) NOT NULL,
+
+    PRIMARY KEY (`paymentId`)
+) DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- AddForeignKey
+ALTER TABLE `ClientPayment` ADD CONSTRAINT `ClientPayment_addressString_fkey` FOREIGN KEY (`addressString`) REFERENCES `Address`(`address`) ON DELETE RESTRICT ON UPDATE CASCADE;

prisma-local/schema.prisma

@@ -22,6 +22,7 @@ model Address {
   syncing      Boolean                @default(false)
   paybuttons   AddressesOnButtons[]
   transactions Transaction[]
+  clientPayments                     ClientPayment[]
 
   @@index([networkId], map: "Address_networkId_fkey")
 }
@@ -271,3 +272,19 @@ model Invoice {
   @@unique([invoiceNumber, userId], map: "Invoice_invoiceNumber_userId_unique_constraint")
   @@unique([transactionId, userId], map: "Invoice_transactionId_userId_unique_constraint")
 }
+
+enum ClientPaymentStatus {
+ PENDING
+ ADDED_TO_MEMPOOL
+ CONFIRMED
+}
+
+model ClientPayment {
+  paymentId            String                 @id
+  status               ClientPaymentStatus               
+  addressString        String
+  amount               Decimal?              
+  address              Address   @relation(fields: [addressString], references: [address])
+  createdAt            DateTime               @default(now())
+  updatedAt            DateTime               @updatedAt
+}

services/chronikService.ts

@@ -11,9 +11,11 @@ import {
   upsertTransaction,
   getSimplifiedTransactions,
   getSimplifiedTrasaction,
-  connectAllTransactionsToPrices
+  connectAllTransactionsToPrices,
+  updateClientPaymentStatus,
+  getClientPayment
 } from './transactionService'
-import { Address, Prisma } from '@prisma/client'
+import { Address, Prisma, ClientPaymentStatus } from '@prisma/client'
 import xecaddr from 'xecaddrjs'
 import { getAddressPrefix, satoshisToUnit } from 'utils/index'
 import { fetchAddressesArray, fetchAllAddressesForNetworkId, getEarliestUnconfirmedTxTimestampForAddress, getLatestConfirmedTxTimestampForAddress, setSyncing, setSyncingBatch, updateLastSynced, updateManyLastSynced } from './addressService'
@@ -28,6 +30,7 @@ import { appendTxsToFile } from 'prisma-local/seeds/transactions'
 import { PHASE_PRODUCTION_BUILD } from 'next/dist/shared/lib/constants'
 import { syncPastDaysNewerPrices } from './priceService'
 import { AddressType } from 'ecashaddrjs/dist/types'
+import { DecimalJsLike } from '@prisma/client/runtime/library'
 
 const decoder = new TextDecoder()
 
@@ -551,10 +554,38 @@ export class ChronikBlockchainClient {
     }
   }
 
+  private async handleUpdateClientPaymentStatus (
+    txAmount: string | number | Prisma.Decimal | DecimalJsLike,
+    opReturn: string | undefined, status: ClientPaymentStatus,
+    txAddress: string): Promise<void> {
+    const parsedOpReturn = parseOpReturnData(opReturn ?? '')
+    const paymentId = parsedOpReturn.paymentId
+    if (paymentId === undefined || paymentId === '') {
+      return
+    }
+    const clientPayment = await getClientPayment(paymentId)
+    if (clientPayment === null || clientPayment.status === 'CONFIRMED') {
+      return
+    }
+    if (clientPayment.amount !== null) {
+      if (Number(clientPayment.amount) === Number(txAmount) &&
+        (clientPayment.addressString === txAddress)) {
+        await updateClientPaymentStatus(paymentId, status)
+      }
+    } else {
+      if (clientPayment.addressString === txAddress) {
+        await updateClientPaymentStatus(paymentId, status)
+      }
+    }
+  }
+
   private async processWsMessage (msg: WsMsgClient): Promise<void> {
     // delete unconfirmed transaction from our database
     // if they were cancelled and not confirmed
     if (msg.type === 'Tx') {
+      const transaction = await this.chronik.tx(msg.txid)
+      const addressesWithTransactions = await this.getAddressesForTransaction(transaction)
+
       if (msg.msgType === 'TX_REMOVED_FROM_MEMPOOL') {
         console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] ${msg.txid}`)
         const transactionsToDelete = await fetchUnconfirmedTransactions(msg.txid)
@@ -569,6 +600,10 @@ export class ChronikBlockchainClient {
       } else if (msg.msgType === 'TX_CONFIRMED') {
         console.log(`${this.CHRONIK_MSG_PREFIX}: [${msg.msgType}] ${msg.txid}`)
         this.confirmedTxsHashesFromLastBlock = [...this.confirmedTxsHashesFromLastBlock, msg.txid]
+        for (const addressWithTransaction of addressesWithTransactions) {
+          const { amount, opReturn } = addressWithTransaction.transaction
+          await this.handleUpdateClientPaymentStatus(amount, opReturn, 'CONFIRMED' as ClientPaymentStatus, addressWithTransaction.address.address)
+        }
       } else if (msg.msgType === 'TX_ADDED_TO_MEMPOOL') {
         if (this.isAlreadyBeingProcessed(msg.txid, false)) {
           return
@@ -588,6 +623,8 @@ export class ChronikBlockchainClient {
             if (created) { // only execute trigger for newly added txs
               await executeAddressTriggers(broadcastTxData, tx.address.networkId)
             }
+            const { amount, opReturn } = addressWithTransaction.transaction
+            await this.handleUpdateClientPaymentStatus(amount, opReturn, 'ADDED_TO_MEMPOOL' as ClientPaymentStatus, addressWithTransaction.address.address)
           }
         }
         this.mempoolTxsBeingProcessed -= 1

services/transactionService.ts

@@ -1,6 +1,6 @@
 import prisma from 'prisma-local/clientInstance'
-import { Prisma, Transaction } from '@prisma/client'
-import { RESPONSE_MESSAGES, USD_QUOTE_ID, CAD_QUOTE_ID, N_OF_QUOTES, UPSERT_TRANSACTION_PRICES_ON_DB_TIMEOUT, SupportedQuotesType, NETWORK_IDS, PRICES_CONNECTION_BATCH_SIZE, PRICES_CONNECTION_TIMEOUT } from 'constants/index'
+import { Prisma, Transaction, ClientPaymentStatus } from '@prisma/client'
+import { RESPONSE_MESSAGES, USD_QUOTE_ID, CAD_QUOTE_ID, N_OF_QUOTES, UPSERT_TRANSACTION_PRICES_ON_DB_TIMEOUT, SupportedQuotesType, NETWORK_IDS, NETWORK_IDS_FROM_SLUGS, PRICES_CONNECTION_BATCH_SIZE, PRICES_CONNECTION_TIMEOUT } from 'constants/index'
 import { fetchAddressBySubstring, fetchAddressById, fetchAddressesByPaybuttonId, addressExists } from 'services/addressService'
 import { AllPrices, QuoteValues, fetchPricesForNetworkAndTimestamp, flattenTimestamp } from 'services/priceService'
 import _ from 'lodash'
@@ -9,6 +9,8 @@ import { SimplifiedTransaction } from 'ws-service/types'
 import { OpReturnData, parseAddress } from 'utils/validators'
 import { generatePaymentFromTxWithInvoices } from 'redis/paymentCache'
 import { ButtonDisplayData, Payment } from 'redis/types'
+import { v4 as uuidv4 } from 'uuid'
+import { multiBlockchainClient } from 'services/chronikService'
 
 export function getTransactionValue (transaction: TransactionWithPrices | TransactionsWithPaybuttonsAndPrices | SimplifiedTransaction): QuoteValues {
   const ret: QuoteValues = {
@@ -974,3 +976,53 @@ export const fetchDistinctPaymentYearsByUser = async (userId: string): Promise<n
 
   return years.map(y => y.year)
 }
+
+export const generatePaymentId = async (address: string, amount?: Prisma.Decimal): Promise<string> => {
+  const rawUUID = uuidv4()
+  const cleanUUID = rawUUID.replace(/-/g, '')
+  const status = 'PENDING' as ClientPaymentStatus
+  address = parseAddress(address)
+  const prefix = address.split(':')[0].toLowerCase()
+  const networkId = NETWORK_IDS_FROM_SLUGS[prefix]
+  const isAddressRegistered = await addressExists(address)
+
+  const clientPayment = await prisma.clientPayment.create({
+    data: {
+      address: {
+        connectOrCreate: {
+          where: { address },
+          create: {
+            address,
+            networkId
+          }
+        }
+      },
+      paymentId: cleanUUID,
+      status,
+      amount
+    },
+    include: {
+      address: true
+    }
+  })
+
+  if (!isAddressRegistered) {
+    void multiBlockchainClient.syncAndSubscribeAddresses([clientPayment.address])
+  }
+
+  return clientPayment.paymentId
+}
+
+export const updateClientPaymentStatus = async (paymentId: string, status: ClientPaymentStatus): Promise<void> => {
+  await prisma.clientPayment.update({
+    where: { paymentId },
+    data: { status }
+  })
+}
+
+export const getClientPayment = async (paymentId: string): Promise<Prisma.ClientPaymentGetPayload<{ include: { address: true } }> | null> => {
+  return await prisma.clientPayment.findUnique({
+    where: { paymentId },
+    include: { address: true }
+  })
+}