swapanrishi/de-centrilized_market_place

1. Overall shape

BlockMart is a hybrid dApp marketplace: user-facing commerce flows are split between an off-chain web/app layer for metadata and UX, and an on-chain settlement layer for escrow and asset transfer. The main architectural boundary is between fast relational data handling and trustless blockchain execution.

2. Frontend subsystem

The frontend/ package is a React + TypeScript single-page app built with Vite and styled with Tailwind CSS. It is the primary user interface for browsing, listing, and trading assets, and it likely uses Ethers.js / wallet connectors to connect the browser to a crypto wallet for blockchain actions.

3. Backend subsystem

The backend/ package is a Node.js backend (compiled to backend/dist/index.js) that acts as the off-chain service boundary. From the repo layout and README, this layer is responsible for serving marketplace metadata, coordinating application state, and persisting data in the relational database through Prisma.

4. Database / persistence layer

The persistent off-chain store is PostgreSQL, accessed via Prisma ORM. The repo contains Prisma schemas and migrations under both backend/prisma/ and a root-level prisma/, which suggests either:

- a shared schema reused across parts of the repo, or

- an earlier/alternate schema location from the project’s evolution.

For architecture diagrams, treat the database as the off-chain source of truth for product listings, user metadata, reviews, and other non-transactional content.

5. Blockchain subsystem

The blockchain/ package is a separate Hardhat-based Solidity workspace. It contains contracts, tests, deployment/ignition modules, and utility scripts. This is the on-chain execution boundary where escrow, payment settlement, and trust-sensitive logic live.

6. On-chain/off-chain split

The key data-flow distinction is:

- Off-chain: product images, descriptions, user profiles, reviews, search-friendly marketplace metadata

- On-chain: payment transfer, escrow release, and asset settlement

The README explicitly positions the design as a gas-efficient hybrid model, with blockchain used only where trustlessness matters.

7. Transaction lifecycle

A typical marketplace flow is:

1. User browses listings in the frontend.

2. Listing metadata comes from the backend/database.

3. User connects a wallet and initiates a blockchain transaction.

4. Smart contract holds funds in escrow.

5. The buyer confirms receipt.

6. The contract releases funds / finalizes settlement.

This is the core cross-boundary flow the diagram should emphasize.

8. Smart contract tooling

The blockchain package includes:

- hardhat.config.ts for local/testnet chain setup

- test/BlockMartEscrow.test.ts for contract-level verification

- ignition/modules/ for deployment orchestration

- scripts/send-op-tx.ts for manual transaction execution

These files indicate the on-chain side is treated as a standalone deployable system with its own CI/test boundary.

9. Authentication / legacy entry points

The repo also includes php/login.php, php/register.php, login-pg.html, and RegisterSign.html. These look like an alternate or legacy auth path separate from the React frontend and Node backend. If you draw the architecture, place these as a parallel web entry path rather than part of the main React/Node flow unless the code confirms otherwise.

10. Containerization and runtime environment

The backend has Docker files, indicating it can be packaged independently with its runtime dependencies. The README also calls out Docker for local backend/database environment. That makes the deployment boundary likely:

- frontend served separately,

- backend in a container,

- PostgreSQL as a local or managed service,

- blockchain contracts deployed to Sepolia for testnet usage.

11. External dependencies / services

The main external service is the Ethereum Sepolia testnet, which is the on-chain runtime target. Wallets such as MetaMask or WalletConnect are also part of the runtime boundary, because they authorize and sign user transactions from the browser.

12. Repo-level organization

The repository is effectively a multi-package monorepo:

- frontend/ for UI

- backend/ for API and database access

- blockchain/ for contracts and deployment

- php/ plus standalone HTML files for alternate auth pages

- root-level Prisma assets and package files, suggesting shared or historical infrastructure

This separation is important for the diagram because it shows three primary runtime domains: browser, server/database, and blockchain.

13. What to emphasize in the diagram

The most important architecture boundaries are:

- Browser ↔ Backend for marketplace metadata and app state

- Browser ↔ Wallet ↔ Blockchain for signing and escrow transactions

- Backend ↔ PostgreSQL/Prisma for persistent off-chain data

- Contracts ↔ Sepolia for settlement execution

If you only highlight one thing, highlight the hybrid split between off-chain commerce data and on-chain settlement logic.