chore: move eCurrency

platforms/eCurrency-api/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "ecurrency-api",
+    "version": "1.0.0",
+    "description": "eCurrency Platform API",
+    "main": "src/index.ts",
+    "scripts": {
+        "start": "ts-node --project tsconfig.json src/index.ts",
+        "dev": "nodemon --exec \"npx ts-node\" src/index.ts",
+        "build": "tsc",
+        "typeorm": "typeorm-ts-node-commonjs",
+        "migration:generate": "typeorm-ts-node-commonjs migration:generate -d src/database/data-source.ts",
+        "migration:run": "typeorm-ts-node-commonjs migration:run -d src/database/data-source.ts",
+        "migration:revert": "typeorm-ts-node-commonjs migration:revert -d src/database/data-source.ts"
+    },
+    "dependencies": {
+        "axios": "^1.6.7",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.5",
+        "express": "^4.18.2",
+        "jsonwebtoken": "^9.0.2",
+        "pg": "^8.11.3",
+        "reflect-metadata": "^0.2.1",
+        "typeorm": "^0.3.24",
+        "uuid": "^9.0.1",
+        "web3-adapter": "link:../../infrastructure/web3-adapter"
+    },
+    "devDependencies": {
+        "@types/cors": "^2.8.17",
+        "@types/express": "^4.17.21",
+        "@types/jsonwebtoken": "^9.0.5",
+        "@types/node": "^20.11.24",
+        "@types/pg": "^8.11.2",
+        "@types/uuid": "^9.0.8",
+        "@typescript-eslint/eslint-plugin": "^7.0.1",
+        "@typescript-eslint/parser": "^7.0.1",
+        "eslint": "^8.56.0",
+        "nodemon": "^3.0.3",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.3.3"
+    }
+}
+

platforms/eCurrency-api/src/controllers/AuthController.ts

@@ -0,0 +1,106 @@
+import { Request, Response } from "express";
+import { v4 as uuidv4 } from "uuid";
+import { UserService } from "../services/UserService";
+import { EventEmitter } from "events";
+import { signToken } from "../utils/jwt";
+
+export class AuthController {
+    private userService: UserService;
+    private eventEmitter: EventEmitter;
+
+    constructor() {
+        this.userService = new UserService();
+        this.eventEmitter = new EventEmitter();
+    }
+
+    sseStream = async (req: Request, res: Response) => {
+        const { id } = req.params;
+
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+        });
+
+        const handler = (data: any) => {
+            res.write(`data: ${JSON.stringify(data)}\n\n`);
+        };
+
+        this.eventEmitter.on(id, handler);
+
+        req.on("close", () => {
+            this.eventEmitter.off(id, handler);
+            res.end();
+        });
+
+        req.on("error", (error) => {
+            console.error("SSE Error:", error);
+            this.eventEmitter.off(id, handler);
+            res.end();
+        });
+    };
+
+    getOffer = async (req: Request, res: Response) => {
+        const baseUrl = process.env.VITE_ECURRENCY_BASE_URL || "http://localhost:9888";
+        const url = new URL(
+            "/api/auth",
+            baseUrl,
+        ).toString();
+        const sessionId = uuidv4();
+        const offer = `w3ds://auth?redirect=${url}&session=${sessionId}&platform=ecurrency`;
+        res.json({ offer, sessionId });
+    };
+
+    login = async (req: Request, res: Response) => {
+        try {
+            const { ename, session, w3id, signature } = req.body;
+
+            if (!ename) {
+                return res.status(400).json({ error: "ename is required" });
+            }
+
+            if (!session) {
+                return res.status(400).json({ error: "session is required" });
+            }
+
+            // Only find existing users - don't create new ones during auth
+            const user = await this.userService.findUser(ename);
+
+            if (!user) {
+                // User doesn't exist - they need to be created via webhook first
+                return res.status(404).json({ 
+                    error: "User not found", 
+                    message: "User must be created via eVault webhook before authentication" 
+                });
+            }
+
+            const token = signToken({ userId: user.id });
+
+            const data = {
+                user: {
+                    id: user.id,
+                    ename: user.ename,
+                    name: user.name,
+                    handle: user.handle,
+                    description: user.description,
+                    avatarUrl: user.avatarUrl,
+                    bannerUrl: user.bannerUrl,
+                    isVerified: user.isVerified,
+                    isPrivate: user.isPrivate,
+                    email: user.email,
+                    emailVerified: user.emailVerified,
+                    createdAt: user.createdAt,
+                    updatedAt: user.updatedAt,
+                },
+                token,
+            };
+            this.eventEmitter.emit(session, data);
+            res.status(200).send();
+        } catch (error) {
+            console.error("Error during login:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+}
+

platforms/eCurrency-api/src/controllers/CurrencyController.ts

@@ -0,0 +1,148 @@
+import { Request, Response } from "express";
+import { CurrencyService } from "../services/CurrencyService";
+import { AccountType } from "../database/entities/Ledger";
+
+export class CurrencyController {
+    private currencyService: CurrencyService;
+
+    constructor() {
+        this.currencyService = new CurrencyService();
+    }
+
+    createCurrency = async (req: Request, res: Response) => {
+        try {
+            if (!req.user) {
+                return res.status(401).json({ error: "Authentication required" });
+            }
+
+            const { name, description, groupId, allowNegative } = req.body;
+
+            if (!name || !groupId) {
+                return res.status(400).json({ error: "Name and groupId are required" });
+            }
+
+            const currency = await this.currencyService.createCurrency(
+                name,
+                groupId,
+                req.user.id,
+                allowNegative || false,
+                description
+            );
+
+            res.status(201).json({
+                id: currency.id,
+                name: currency.name,
+                description: currency.description,
+                ename: currency.ename,
+                groupId: currency.groupId,
+                allowNegative: currency.allowNegative,
+                createdBy: currency.createdBy,
+                createdAt: currency.createdAt,
+                updatedAt: currency.updatedAt,
+            });
+        } catch (error: any) {
+            console.error("Error creating currency:", error);
+            if (error.message.includes("Only group admins")) {
+                return res.status(403).json({ error: error.message });
+            }
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    getAllCurrencies = async (req: Request, res: Response) => {
+        try {
+            const currencies = await this.currencyService.getAllCurrencies();
+            res.json(currencies.map(currency => ({
+                id: currency.id,
+                name: currency.name,
+                ename: currency.ename,
+                groupId: currency.groupId,
+                allowNegative: currency.allowNegative,
+                createdBy: currency.createdBy,
+                createdAt: currency.createdAt,
+                updatedAt: currency.updatedAt,
+            })));
+        } catch (error) {
+            console.error("Error getting currencies:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    getCurrencyById = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const currency = await this.currencyService.getCurrencyById(id);
+
+            if (!currency) {
+                return res.status(404).json({ error: "Currency not found" });
+            }
+
+            res.json({
+                id: currency.id,
+                name: currency.name,
+                description: currency.description,
+                ename: currency.ename,
+                groupId: currency.groupId,
+                allowNegative: currency.allowNegative,
+                createdBy: currency.createdBy,
+                createdAt: currency.createdAt,
+                updatedAt: currency.updatedAt,
+            });
+        } catch (error) {
+            console.error("Error getting currency:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    getCurrenciesByGroup = async (req: Request, res: Response) => {
+        try {
+            const { groupId } = req.params;
+            const currencies = await this.currencyService.getCurrenciesByGroup(groupId);
+            res.json(currencies.map(currency => ({
+                id: currency.id,
+                name: currency.name,
+                description: currency.description,
+                ename: currency.ename,
+                groupId: currency.groupId,
+                allowNegative: currency.allowNegative,
+                createdBy: currency.createdBy,
+                createdAt: currency.createdAt,
+                updatedAt: currency.updatedAt,
+            })));
+        } catch (error) {
+            console.error("Error getting currencies by group:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    mintCurrency = async (req: Request, res: Response) => {
+        try {
+            if (!req.user) {
+                return res.status(401).json({ error: "Authentication required" });
+            }
+
+            const { id } = req.params;
+            const { amount, description } = req.body;
+
+            if (!amount) {
+                return res.status(400).json({ error: "amount is required" });
+            }
+
+            await this.currencyService.mintCurrency(
+                id,
+                amount,
+                description,
+                req.user.id
+            );
+
+            res.status(200).json({ message: "Currency minted successfully" });
+        } catch (error: any) {
+            console.error("Error minting currency:", error);
+            if (error.message.includes("Only group admins") || error.message.includes("not found") || error.message.includes("must be positive")) {
+                return res.status(400).json({ error: error.message });
+            }
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+}
+

platforms/eCurrency-api/src/controllers/GroupController.ts

@@ -0,0 +1,75 @@
+import { Request, Response } from "express";
+import { GroupService } from "../services/GroupService";
+
+export class GroupController {
+    private groupService: GroupService;
+
+    constructor() {
+        this.groupService = new GroupService();
+    }
+
+    search = async (req: Request, res: Response) => {
+        try {
+            const { q, limit } = req.query;
+
+            if (!q || typeof q !== "string") {
+                return res.status(400).json({ error: "Query parameter 'q' is required" });
+            }
+
+            let limitNum = 10;
+            if (typeof limit === "string") {
+                const parsed = parseInt(limit, 10);
+                if (!Number.isNaN(parsed) && parsed > 0 && parsed <= 100) {
+                    limitNum = parsed;
+                }
+            }
+
+            const groups = await this.groupService.searchGroups(q, limitNum);
+
+            res.json(groups.map(group => ({
+                id: group.id,
+                name: group.name,
+                ename: group.ename,
+                description: group.description,
+                charter: group.charter,
+                createdAt: group.createdAt,
+                updatedAt: group.updatedAt,
+            })));
+        } catch (error) {
+            console.error("Error searching groups:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+
+    getUserGroups = async (req: Request, res: Response) => {
+        try {
+            if (!req.user) {
+                return res.status(401).json({ error: "Authentication required" });
+            }
+
+            const groups = await this.groupService.getUserGroups(req.user.id);
+
+            // Check which groups the user is admin of
+            const groupsWithAdminStatus = await Promise.all(
+                groups.map(async (group) => {
+                    const isAdmin = await this.groupService.isGroupAdmin(group.id, req.user!.id);
+                    return {
+                        id: group.id,
+                        name: group.name,
+                        ename: group.ename,
+                        description: group.description,
+                        isAdmin,
+                        createdAt: group.createdAt,
+                        updatedAt: group.updatedAt,
+                    };
+                })
+            );
+
+            res.json(groupsWithAdminStatus);
+        } catch (error) {
+            console.error("Error getting user groups:", error);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    };
+}
+