feat: add burn button and auto reload

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (

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) {

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

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"`);
+ }
+
+}

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

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,

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

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" />
  ) : (