feat: add burn button and auto reload (#623)

coodos · web-flow · commit 5cec93d333a5 · 2025-12-15T21:54:47.000+05:30
* feat: add burn button and auto reload

* feat: add leger tx hashes

* feat: make burn work properly

* fix: build

* chore: migration

* chore: fix icon

* feat: better TX ui

* chore: switch account UX

* feat: better table ux

* feat: account creation better display
diff --git a/platforms/eCurrency-api/src/controllers/LedgerController.ts b/platforms/eCurrency-api/src/controllers/LedgerController.ts
@@ -2,14 +2,17 @@ import { Request, Response } from "express";
 import { LedgerService } from "../services/LedgerService";
 import { AccountType } from "../database/entities/Ledger";
 import { GroupService } from "../services/GroupService";
+import { CurrencyService } from "../services/CurrencyService";
 
 export class LedgerController {
     private ledgerService: LedgerService;
     private groupService: GroupService;
+    private currencyService: CurrencyService;
 
     constructor() {
         this.ledgerService = new LedgerService();
         this.groupService = new GroupService();
+        this.currencyService = new CurrencyService();
     }
 
     getBalance = async (req: Request, res: Response) => {
@@ -206,6 +209,8 @@ export class LedgerController {
                     description: entry.description,
                     balance: entry.balance,
                     createdAt: entry.createdAt,
+                    hash: entry.hash,
+                    prevHash: entry.prevHash,
                     sender: sender ? {
                         name: (sender as any).name || (sender as any).handle,
                         ename: (sender as any).ename,
@@ -272,6 +277,8 @@ export class LedgerController {
                 description: transaction.description,
                 balance: transaction.balance,
                 createdAt: transaction.createdAt,
+                hash: transaction.hash,
+                prevHash: transaction.prevHash,
                 sender: sender ? {
                     id: sender.id,
                     name: (sender as any).name || (sender as any).handle,
@@ -289,6 +296,61 @@ export class LedgerController {
         }
     };
 
+    burn = async (req: Request, res: Response) => {
+        try {
+            if (!req.user) {
+                return res.status(401).json({ error: "Authentication required" });
+            }
+
+            const { currencyId, amount, description } = req.body;
+
+            if (!currencyId || amount === undefined || amount === null) {
+                return res.status(400).json({ error: "currencyId and amount are required" });
+            }
+
+            const parsedAmount = Number(amount);
+            if (Number.isNaN(parsedAmount) || parsedAmount <= 0) {
+                return res.status(400).json({ error: "Amount must be a positive number" });
+            }
+
+            const currency = await this.currencyService.getCurrencyById(currencyId);
+            if (!currency) {
+                return res.status(404).json({ error: "Currency not found" });
+            }
+
+            // Only group admins of the currency's group can burn (treasury)
+            const isAdmin = await this.groupService.isGroupAdmin(currency.groupId, req.user.id);
+            if (!isAdmin) {
+                return res.status(403).json({ error: "Only group admins can burn from treasury" });
+            }
+
+            const burnEntry = await this.ledgerService.burn(
+                currencyId,
+                currency.groupId,
+                parsedAmount,
+                description
+            );
+
+            res.status(200).json({
+                message: "Burn successful",
+                transaction: {
+                    id: burnEntry.id,
+                    amount: burnEntry.amount,
+                    balance: burnEntry.balance,
+                    createdAt: burnEntry.createdAt,
+                    hash: burnEntry.hash,
+                    prevHash: burnEntry.prevHash,
+                },
+            });
+        } catch (error: any) {
+            console.error("Error burning currency:", error);
+            if (error.message.includes("Insufficient balance") || error.message.includes("not found")) {
+                return res.status(400).json({ error: error.message });
+            }
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
     initializeAccount = async (req: Request, res: Response) => {
         try {
             if (!req.user) {
diff --git a/platforms/eCurrency-api/src/database/entities/Ledger.ts b/platforms/eCurrency-api/src/database/entities/Ledger.ts
@@ -76,6 +76,12 @@ export class Ledger {
     @Column("decimal", { precision: 18, scale: 2 })
     balance!: number; // Running balance after this entry
 
+    @Column({ type: "text", nullable: true })
+    hash!: string | null;
+
+    @Column({ type: "text", nullable: true })
+    prevHash!: string | null;
+
     @CreateDateColumn()
     createdAt!: Date;
 }
diff --git a/platforms/eCurrency-api/src/database/migrations/1765809758435-migration.ts b/platforms/eCurrency-api/src/database/migrations/1765809758435-migration.ts
@@ -0,0 +1,16 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class Migration1765809758435 implements MigrationInterface {
+    name = 'Migration1765809758435'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "ledger" ADD "hash" text`);
+        await queryRunner.query(`ALTER TABLE "ledger" ADD "prevHash" text`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "ledger" DROP COLUMN "prevHash"`);
+        await queryRunner.query(`ALTER TABLE "ledger" DROP COLUMN "hash"`);
+    }
+
+}
diff --git a/platforms/eCurrency-api/src/index.ts b/platforms/eCurrency-api/src/index.ts
@@ -118,6 +118,7 @@ app.patch("/api/currencies/:id/max-negative", authGuard, currencyController.upda
 app.get("/api/ledger/balance", authGuard, ledgerController.getBalance);
 app.get("/api/ledger/balance/:currencyId", authGuard, ledgerController.getBalanceByCurrencyId);
 app.post("/api/ledger/transfer", authGuard, ledgerController.transfer);
+app.post("/api/ledger/burn", authGuard, ledgerController.burn);
 app.get("/api/ledger/history", authGuard, ledgerController.getHistory);
 app.get("/api/ledger/history/:currencyId", authGuard, ledgerController.getHistory);
 app.get("/api/ledger/transaction/:id", authGuard, ledgerController.getTransactionById);
diff --git a/platforms/eCurrency-api/src/services/LedgerService.ts b/platforms/eCurrency-api/src/services/LedgerService.ts
@@ -5,6 +5,7 @@ import { Currency } from "../database/entities/Currency";
 import { User } from "../database/entities/User";
 import { Group } from "../database/entities/Group";
 import { TransactionNotificationService } from "./TransactionNotificationService";
+import crypto from "crypto";
 
 export class LedgerService {
     ledgerRepository: Repository<Ledger>;
@@ -15,6 +16,18 @@ export class LedgerService {
         this.currencyRepository = AppDataSource.getRepository(Currency);
     }
 
+    private computeHash(payload: any): string {
+        return crypto.createHash("sha256").update(JSON.stringify(payload)).digest("hex");
+    }
+
+    private async getPrevHash(currencyId: string): Promise<string | null> {
+        const prev = await this.ledgerRepository.findOne({
+            where: { currencyId },
+            order: { createdAt: "DESC", id: "DESC" },
+        });
+        return prev?.hash ?? null;
+    }
+
     async getAccountBalance(currencyId: string, accountId: string, accountType: AccountType): Promise<number> {
         const latestEntry = await this.ledgerRepository.findOne({
             where: {
@@ -67,10 +80,34 @@ export class LedgerService {
             balance: newBalance,
         };
         
-        const entry = this.ledgerRepository.create(entryData);
+        // capture previous hash before inserting current entry
+        const prevHash = await this.getPrevHash(currencyId);
 
+        const entry = this.ledgerRepository.create(entryData);
         const saved = await this.ledgerRepository.save(entry);
-        return Array.isArray(saved) ? saved[0] : saved;
+
+        const hashPayload = {
+            id: saved.id,
+            currencyId: saved.currencyId,
+            accountId: saved.accountId,
+            accountType: saved.accountType,
+            amount: saved.amount,
+            type: saved.type,
+            description: saved.description,
+            senderAccountId: saved.senderAccountId,
+            senderAccountType: saved.senderAccountType,
+            receiverAccountId: saved.receiverAccountId,
+            receiverAccountType: saved.receiverAccountType,
+            balance: saved.balance,
+            createdAt: saved.createdAt,
+            prevHash,
+        };
+
+        saved.prevHash = prevHash;
+        saved.hash = this.computeHash(hashPayload);
+
+        const finalized = await this.ledgerRepository.save(saved);
+        return Array.isArray(finalized) ? finalized[0] : finalized;
     }
 
     async transfer(
@@ -160,6 +197,54 @@ export class LedgerService {
         return { debit, credit };
     }
 
+    async burn(
+        currencyId: string,
+        groupId: string,
+        amount: number,
+        description?: string
+    ): Promise<Ledger> {
+        const currency = await this.currencyRepository.findOne({ where: { id: currencyId } });
+        if (!currency) {
+            throw new Error("Currency not found");
+        }
+
+        // Ensure treasury account exists
+        await this.initializeAccount(currencyId, groupId, AccountType.GROUP);
+
+        const currentBalance = await this.getAccountBalance(currencyId, groupId, AccountType.GROUP);
+
+        // Enforce bounds
+        if (!currency.allowNegative && currentBalance < amount) {
+            throw new Error("Insufficient balance. Negative balances are not allowed.");
+        }
+
+        if (currency.allowNegative && currency.maxNegativeBalance !== null && currency.maxNegativeBalance !== undefined) {
+            const newBalance = currentBalance - amount;
+            if (newBalance < Number(currency.maxNegativeBalance)) {
+                throw new Error(`Insufficient balance. This currency allows negative balances down to ${currency.maxNegativeBalance}.`);
+            }
+        }
+
+        const burnDescription = description || `Burned ${amount} ${currency.name}`;
+
+        // Single debit entry against treasury
+        const debit = await this.addLedgerEntry(
+            currencyId,
+            groupId,
+            AccountType.GROUP,
+            amount,
+            LedgerType.DEBIT,
+            burnDescription,
+            groupId,
+            AccountType.GROUP,
+            undefined,
+            undefined,
+            currentBalance
+        );
+
+        return debit;
+    }
+
     async getTransactionHistory(
         currencyId?: string,
         accountId?: string,
diff --git a/platforms/eCurrency/client/src/components/currency/add-currency-account-modal.tsx b/platforms/eCurrency/client/src/components/currency/add-currency-account-modal.tsx
@@ -72,7 +72,13 @@ export default function AddCurrencyAccountModal({ open, onOpenChange, accountCon
       return response.data;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: balancesQueryKey });
+      // Refresh balances and history for the active context right after adding
+      queryClient.invalidateQueries({
+        predicate: (q) => {
+          const key = q.queryKey?.[0];
+          return key === "balances" || key === "history" || key === "accountDetails";
+        },
+      });
       setCurrencyId("");
       setSearchQuery("");
       setIsOpen(false);
diff --git a/platforms/eCurrency/client/src/components/currency/transaction-card.tsx b/platforms/eCurrency/client/src/components/currency/transaction-card.tsx
@@ -1,4 +1,4 @@
-import { ArrowLeft, ArrowRight, Sparkles } from "lucide-react";
+import { ArrowLeft, ArrowRight, Sparkles, Flame } from "lucide-react";
 import { formatEName } from "../../lib/utils";
 
 interface TransactionCardProps {
@@ -9,10 +9,43 @@ interface TransactionCardProps {
 
 export default function TransactionCard({ transaction, currencyName, onClick }: TransactionCardProps) {
   // For credits: show "Received from X", for debits: show "Sent to X"
-  // For minted: show "Minted"
+  // For minted: show "Minted", for burned: show "Burned"
+  // For account initialization: show "Account Created"
   let mainText = "";
-  if (transaction.description?.includes("Minted")) {
+  const desc = transaction.description?.toLowerCase() || "";
+  const balance = Number(transaction.balance) || 0;
+  const amount = Math.abs(Number(transaction.amount)) || 0;
+  
+  // Check description for mint/burn keywords
+  const hasMintInDesc = desc.includes("minted") || desc.includes("mint");
+  const hasBurnInDesc = desc.includes("burned") || desc.includes("burn");
+  const hasInitInDesc = desc.includes("initialized") || desc.includes("account created");
+  
+  // Account initialization: balance is 0, amount is 0 (or very close), no sender
+  const isAccountInit = balance === 0 && amount < 0.01 && 
+    (!transaction.sender || (!transaction.sender.name && !transaction.sender.ename)) &&
+    (hasInitInDesc || transaction.description === "Account initialized");
+  
+  // Fallback: credit with no sender and group account type is likely a mint (but not if balance is 0)
+  const isLikelyMint = transaction.type === "credit" && 
+    (!transaction.sender || (!transaction.sender.name && !transaction.sender.ename)) &&
+    transaction.accountType === "group" &&
+    balance > 0; // Only consider it a mint if balance is positive
+  
+  // Debit with no receiver and group account type is likely a burn
+  const isLikelyBurn = transaction.type === "debit" &&
+    (!transaction.receiver || (!transaction.receiver.name && !transaction.receiver.ename)) &&
+    transaction.accountType === "group";
+  
+  const isMinted = hasMintInDesc || isLikelyMint;
+  const isBurned = hasBurnInDesc || isLikelyBurn;
+  
+  if (isAccountInit) {
+    mainText = "Account Created";
+  } else if (isMinted) {
     mainText = "Minted";
+  } else if (isBurned) {
+    mainText = "Burned";
   } else if (transaction.type === "credit") {
     const senderName = transaction.sender?.name || formatEName(transaction.sender?.ename) || "Unknown";
     mainText = `Received from ${senderName}`;
@@ -21,8 +54,6 @@ export default function TransactionCard({ transaction, currencyName, onClick }:
     mainText = `Sent to ${receiverName}`;
   }
 
-  const isMinted = transaction.description?.includes("Minted");
-
   return (
     <div
       className="p-4 hover:bg-gray-50 transition-colors cursor-pointer"
@@ -34,13 +65,17 @@ export default function TransactionCard({ transaction, currencyName, onClick }:
             className={`w-10 h-10 rounded-full flex items-center justify-center ${
               isMinted
                 ? "bg-purple-100"
-                : transaction.type === "credit"
-                  ? "bg-green-100"
-                  : "bg-blue-100"
+                : isBurned
+                  ? "bg-red-100"
+                  : transaction.type === "credit"
+                    ? "bg-green-100"
+                    : "bg-blue-100"
             }`}
           >
             {isMinted ? (
               <Sparkles className="h-5 w-5 text-purple-600" />
+            ) : isBurned ? (
+              <Flame className="h-5 w-5 text-red-600" />
             ) : transaction.type === "credit" ? (
               <ArrowLeft className="h-5 w-5 text-green-600" />
             ) : (
diff --git a/platforms/eCurrency/client/src/components/currency/transaction-detail-modal.tsx b/platforms/eCurrency/client/src/components/currency/transaction-detail-modal.tsx
diff --git a/platforms/eCurrency/client/src/pages/currency-detail.tsx b/platforms/eCurrency/client/src/pages/currency-detail.tsx
