Kalyani Government Engineering College

Affiliated to

Maulana Abul Kalam Azad University of Technology

Department of Computer Application

Kalyani- 741235, Nadia, West Bengal

Project report on,

Swappy: A Unified Decentralized Platform for Token Swapping, Wallet Management & RAG Chat
Assistance

Submitted by,

Monajir Asraf – 10271023014

Ashesh Karmakar - 10271023007

Souptik Nag - 10271023033

Under the supervision of,

Dr. Indrajit Bhattacharya

Assistant Professor

Department of Computer Applications, KGEC

 Certificate of Approval

This is to certify that Project Report on “Swappy: A Unified Decentralized Platform for Token
Swapping, Wallet Management & RAG Chat Assistance” is a record of major project work under the
curriculum of Maulana Abul Kalam Azad University of Technology(MAKAUT) for the MCA 2nd year
4th semester Examination, 2025 for the subject “ Major Project and Viva-voce(MCAN-482)’’ carried
out by Monajir Asraf -10271023014, Ashesh Karmakar -10271023007 and Souptik Nag –
10271023033, students of Kalyani Govt. Engineering College under the guidance of Dr. Indrajit
Bhattacharya as a requirement for the partial fulfilment of the Degree of Master of Computer
Application.

Supervisor
Head Department of Computer Application
Department of Computer Application Kalyani Government Engineering College
Kalyani Government Engineering College

Examiner

Departmental seal
 Acknowledgement

We would like to express our sincere gratitude to everyone who supported and guided us
throughout the journey of our project.

First and foremost, we are deeply thankful to our respected Principal, Dr. Sourabh Kumar
Das, Principal, Kalyani Government Engineering College, for providing us with the
opportunity to undertake this project and for fostering an environment that encourages
innovation and learning.

We extend our heartfelt thanks to our Project Coordinator, Dr. Indrajit Bhattarcharya, for
their invaluable guidance, constructive feedback, and constant encouragement
throughout the project. Their expertise and insights were instrumental in shaping our
work.

We would also like to convey our gratitude to the esteemed faculty members of the
Department of Computer Applications. Their profound knowledge, continuous support,
and dedication to teaching have been a great source of inspiration and motivation for us.

Lastly, we thank our peers and everyone who directly or indirectly contributed to the
successful completion of this project.

Thank you all for your unwavering support and encouragement.

Monajir Asraf Ashesh Karmakar Souptik Nag

Roll: 10271023014 Roll: 10271023007 Roll: 10271023033
ABSTRACT
This project presents the development of a decentralized token exchange platform
built on the Ethereum blockchain, integrating key elements of decentralized finance (DeFi),
decentralized exchange (DEX), user-controlled wallets, and AI-based chat support for
users. The core of the system is an Automated Market Maker (AMM), which enables token
swapping without relying on traditional order book mechanisms. The platform supports
ERC-20 tokens, including custom ones. The platform also supports liquidity provisioning,
allowing users to contribute token pairs to the pool. Users can connect to the platform using
MetaMask or a custom decentralized wallet developed as part of the project, where they
can generate and manage their account directly through the web interface. This gives users
complete control over their private keys and transactions, enhancing both flexibility and
security. To improve accessibility and learning, an AI chatbot is also included, using a
Retrieval-Augmented Generation (RAG) model. This chatbot allows users to ask questions
related to blockchain, tokens, smart contracts and decentralized finance in real time making
the platform not only functional but also educational. It improves the user experience by
helping users understand how things work without leaving the platform.

The project covers smart contract development, wallet creation, token management,
and AI integration. It combines all major parts of a Web3 application and creates a full
working system for decentralized trading.
MOTIVATION
The goal of this project is to simplify and enhance the decentralized finance
experience. It aims to build a DEX that is small in scale but rich in functionality, offering
core DeFi features in a compact, educational, and developer-friendly way.
We are motivated by three main ideas:
1. User Control: Allow users to manage their assets without depending on third-party
custodians or external wallets.
2. Ease of Use: Provide a simpler interface with only essential options, reducing friction
for first-time users.
3. Learning Support: Use an integrated AI chatbot to guide users through blockchain
concepts and the platform itself.

By focusing on these points, the project becomes not only a tool but also a teaching
platform for understanding how decentralized trading and smart contracts work
INTRODUCTION
Decentralized finance (DeFi) is a growing field in blockchain technology that lets
users trade, invest, and manage digital assets without depending on banks or other
centralized institutions. Platforms like Uniswap, PancakeSwap, and SushiSwap have
shown how effective decentralized exchanges (DEXs) can be, allowing users to swap
tokens through smart contracts instead of using traditional order books. These platforms
use a model called Automated Market Maker (AMM), where users provide token pairs to
a shared pool. A pricing formula, usually based on the constant product model (x * y = k),
keeps the pool balanced. In return, users receive LP (liquidity provider) tokens, which
represent their share in the pool and can earn them rewards from trading fees.

This project is based on similar concepts but designed with a simpler and more
focused structure. It supports just three ERC-20 tokens, which include custom tokens and
optionally stablecoins like USDC or DAI. Users can swap these tokens directly through the
smart contract, add liquidity to the pool, and withdraw it whenever needed. The AMM
contract manages all logic on-chain, without any need for a central server. Unlike many
projects that rely only on third-party wallets like MetaMask, this system includes a custom-
built decentralized wallet. This wallet allows users to generate an account, store their
private key, and interact with the platform without needing browser extensions. However,
for flexibility, the system still supports integration with well-known wallets like MetaMask.
Another key part of this project is the addition of a Retrieval-Augmented Generation (RAG)
chatbot. This chatbot is trained to answer user questions about blockchain, token standards,
swapping, liquidity pools, and general DeFi concepts. It helps new users understand how
to use the platform and learn more about the underlying technology without leaving the
interface.

This project offers a simpler, fully self-contained system that combines these ideas
into one working application. It provides a full stack experience from smart contract logic
to user interface, wallet control, and an AI assistant. By keeping the system compact and
easy to understand, it becomes a practical tool for learning, testing, and demonstrating the
principles of decentralized applications. It also allows room for future expansion, such as
multi-token pools, analytics dashboards, or mobile wallet support.
NOVELTY
This project stands out by bringing together multiple decentralized technologies
into one unified platform. While DEXs, wallets, and AI chatbots exist independently, few
systems offer all three working seamlessly together in a simple, single application.
Key novel aspects include:
• A custom-built decentralized wallet fully integrated into the platform, offering an
alternative to MetaMask
• A lightweight AMM swap system that is fully on-chain and easy to understand,
designed for learning and testing
• A Retrieval-Augmented Generation (RAG) based chatbot that acts as a live assistant,
answering blockchain-related questions
• Support for both custom tokens and popular ERC-20 tokens like USDC or DAI in the
same swap system
• A full local development stack with smart contract deployment, testing, and frontend
integration

This makes the system both functional and instructional, providing value to users
and developers alike.
CONTRIBUTION
The major contributions of this project are:
1. A fully functional decentralized exchange (DEX) with support for token swaps and
liquidity pooling, built using Solidity and deployed on a local Ethereum blockchain.
2. Custom ERC-20 tokens (e.g., AGN, FLR, MGN) created and managed within the
platform to simulate a real token economy.
3. An Automated Market Maker (AMM) contract that uses the constant product
formula to handle pricing and swaps without any central control.
4. A custom decentralized wallet system that lets users create, import, and manage
Ethereum addresses directly in the browser without relying on third-party extensions.
5. Wallet integration support for common tools like MetaMask and WalletConnect,
offering flexibility to users.
6. An integrated RAG-based chatbot that improves user experience by explaining
terms, guiding actions, and answering common questions about blockchain and DeFi.
7. A clean, React-based frontend that provides a smooth user experience for swapping
tokens, adding liquidity, and interacting with the system.
8. Unit tests and scripts built with Hardhat to simulate real interactions, verify contract
logic, and ensure platform reliability.

Together, these contributions form a complete Web3 application that showcases

blockchain development skills, frontend integration, AI integration, and decentralized
design thinking.
LITERATURE SURVEY

Sl No. Paper Name Author’s name Techniques used Research Findings

1 The Ecology of Annetta Ho, Blockchain data AMMs facilitate
Automated Cosmin Cazan analysis, Case decentralized crypto
Market Makers and Andrew studies of trading but pose investor,
Schrumm Uniswap, Curve, governance, and systemic
Sushiswap, risks.
Balancer,

2 Optimal Zhengge Zhou Blockchain, Optimal Liquidity

Automated AMM algorithm Provision, No trade gap
Market Makers
3 A Myersonian Jason Milionis, Decentralized Presents a mathematical
Framework for Ciamac C. Exchange, AMM framework for optimal
Optimal Liquidity Moallemi, Tim liquidity provision in
Provision in Roughgarden AMMs.
Automated
Market Makers
4 Decentralized Khetesh Blockchain, Provides a comprehensive
Wallet Choudhary, Afiya AWS, Android overview of decentralized
Application using Dhanse, Mandavi Studio, Flutter, applications, exploring
Blockchain Dubey, Yash React-Native security, privacy and roles
of smart contract in
Kushwaha, Prof.
Dapps.
Anand Ingle
METHODOLOGY
Introduction to Web 3.0

Web 3.0 is the next stage of the internet. It is designed to be more open, secure, and
controlled by users instead of big companies. In Web 1.0, websites were simple and mostly
read-only. Web 2.0 added social media, apps, and user-generated content. However, most of
the data and control in Web 2.0 is held by a few large platforms like Google, Facebook, or
Amazon.
Web 3.0 changes that. It uses blockchain technology to give users more control over their own
data, identity, and digital assets. Instead of depending on a central server, Web 3.0 apps (often
called dApps) run on decentralized networks like Ethereum. This means no single person or
company owns or controls the whole system.
A big part of Web 3.0 is the use of smart contracts programs stored on a blockchain that
automatically carry out tasks. This allows for safe, peer-to-peer transactions without the need
for middlemen.
Web 3.0 also connects with technologies like cryptocurrencies, NFTs, and decentralized
finance (DeFi). It opens the door to a more private, secure, and user-friendly internet where
people can own and trade digital items freely.

Blockchain

Blockchain is a type of digital record-keeping system that stores information across

many computers. Instead of saving data in one central place, it spreads it out over a network.
Every change made is grouped into a block, and these blocks are linked together in a chain.
Once a block is added, it cannot be changed, which makes the data secure and trustworthy.
Blockchain is mostly known for powering cryptocurrencies like Bitcoin and Ethereum, but it
can be used for many other things like smart contracts, voting systems, and supply chain
tracking.

Decentralized Finance

Decentralized Finance, or DeFi, is a new way to handle money using blockchain

technology. It removes the need for banks or other middlemen. In DeFi, people can borrow,
lend, trade, or earn interest on digital assets by using smart contracts. These are programs that
run automatically on blockchains like Ethereum. Since DeFi is open to anyone with a crypto
wallet and internet access, it makes financial services more accessible and transparent.

Decentralized Exchange

A Decentralized Exchange (DEX) is a platform that lets users trade cryptocurrencies

directly with each other. It works without a central company or authority controlling the
process. Instead of using traditional order books, many DEXs use Automated Market Makers
(AMMs) that rely on smart contracts and liquidity pools to set prices and handle trades. DEXs
give users full control over their funds, and all transactions happen on the blockchain, making
them secure and transparent.
Overall Architecture

This project is built as a full-stack decentralized application (dApp), combining smart

contracts, blockchain interaction, frontend UI, wallet management, and AI-powered support.
The architecture is modular, meaning each component handles a specific function and interacts
with others in a clear and secure way.

The system follows a Web3-based architecture, where the frontend communicates directly with
smart contracts on the blockchain, and the user’s wallet signs and sends all transactions. An AI
chatbot system runs alongside to provide helpful support.

• Components of the architecture:

o Smart Contracts written in Solidity language.
o Frontend designed with React and Ethers.js.
o Wallets e.g. MetaMask, Swappy wallet.
o RAG AI chatbot.
o Local hardhat blockchain and Sepolia Ethereum Testnet.
• High level system architecture:
• Description of Swappy Platform:
o Smart Contracts:
Smart contracts are the core of the system. They are deployed on an Ethereum-
compatible blockchain (Hardhat local network and Sepolia test net). The main
contracts include:
Token
Exchange
Liquidity Pool

These smart contracts are written in Solidity language. All contract logic is
transparent and immutable once deployed. At the very first the the Token smart
contract creates a custom ERC-20 token on the Ethereum blockchain. When deployed,
it mints an initial supply to the deployer's address. It also includes a mint() function
that allows to mint more tokens.

Then the Exchange contract manages a decentralized token exchange platform. It

stores a list of supported tokens and allows creation of liquidity pools between any
tokens. Allows users to add liquidity to a pool and enables users to swap one token for
another using those pools.

The Liquidity Pool contract manages a token pair pool used for swapping and
liquidity provisioning. It holds two ERC-20 tokens (token0 and token1) and maintains
their reserves. Users can add liquidity by depositing both tokens, and in return, they
receive pool shares (LP tokens) through an internal _mint function. They can also
remove liquidity, which burns their LP tokens and sends back a proportional share of
the reserves. The swap function allows users to trade one token for another based on
the constant product AMM formula, applying a 0.3% fee. The contract updates reserve
after every liquidity or swap operation and includes utility functions for square root
and minimum value calculations used during LP token minting.

o Blockchain Network:

This project follows a real-world development and deployment pipeline using the
Ethereum blockchain. Initially, all contracts were developed and tested on a local
blockchain using Hardhat. After verifying functionality and performance locally, the
contracts were then deployed to the Sepolia test network using Alchemy as the node
provider.

• Local Blockchain Development with Hardhat:

To ensure safe and efficient testing, the initial smart contract
development and debugging were done using the Hardhat local blockchain
network. Hardhat is a powerful Ethereum development framework that allows
developers to simulate an Ethereum-like environment on their local machine.

In this process the contract deployment is very fast. This provides 20

funded test accounts on Ethereum Local blockchain. Also, no gas fee or waiting
time is there in this deployment process.
 • Deployment to Sepolia Test Network via Alchemy:

After successful local testing, the contracts were deployed to the Sepolia
Ethereum testnet, a live public test network. This helps simulate real-world
conditions like - Network latency, Real wallet use, Gas fees, Contract
immutability. For test network I used Sepolia as it is lightweight, fast, and
recommended by Ethereum for testing. It's supported by most wallets and tools
like Alchemy and Infura. The use of Alchemy and Sepolia also prepares the
system for future mainnet deployment with minimal changes.

• Token Creation:

The project includes the creation of a custom cryptocurrency token that follows
the ERC-20 standard, which is the most commonly used token format on the Ethereum
blockchain. These tokens serve as the foundation for all activities in the decentralized
exchange (DEX) platform, including swapping, liquidity provisioning, and balance
tracking.

When the token contract is deployed, it requires three inputs: a name, a symbol,
and an initial supply. The name and symbol are used for identification purposes across
wallets and exchanges. The initial supply defines the total number of tokens minted at
the time of deployment and is directly assigned to the deployer's address. This process
ensures that the creator or owner of the project receives all tokens at the start and can
then distribute or use them within the system.

The token supports all standard ERC-20 functions, such as transferring tokens
between users, approving other addresses to spend tokens on behalf of the holder, and
checking balances and total supply. These functionalities are inherited from
OpenZeppelin’s ERC-20 implementation, which ensures safety, reliability, and
compatibility with other Ethereum applications.

Additionally, the token includes a public minting function, which allows any
user to mint new tokens and assign them to a specific address. While this feature can
be helpful during development and testing—for example, to simulate a faucet or to
ensure all test accounts have sufficient balances—it would typically be restricted or
removed in a production environment to prevent unlimited token inflation. In this
project, the minting function has not been access-restricted, meaning anyone interacting
with the contract can generate new tokens.

The token behaves just like any standard cryptocurrency: users can hold it in
wallets, approve it for use in contracts (like the AMM), and use it for swaps or liquidity
provisioning. It works seamlessly with the other parts of the platform, including the
Automated Market Maker and Liquidity Pool contracts, and is easily recognized by
MetaMask and other Ethereum-compatible wallets.

This custom token implementation is essential for simulating a real-world token

economy within the platform. It allows users to engage in token-based transactions
 while giving the developers full control over its creation, distribution, and integration
into the DEX ecosystem.

• Automated Market Maker (AMM):

In this project, an Automated Market Maker (AMM) is used as the core

mechanism that enables decentralized token swaps and liquidity management. The
AMM replaces the traditional order book model used in centralized exchanges by
relying on mathematical formulas and token reserves held in smart contracts. It allows
users to exchange tokens, provide liquidity, and earn rewards — all without a
middleman or centralized control.

The AMM in this system is implemented as a dedicated smart contract

(LiquidityPool). It operates by keeping reserves of two ERC-20 tokens and uses a
pricing formula to determine the exchange rate at any given moment. This model
ensures that tokens can be traded automatically and fairly, based on supply and demand.

The formula used to manage pricing is the constant product formula:

x*y=k

Where:

▪ x is the reserve of Token A,

▪ y is the reserve of Token B, and
▪ k is a constant value that remains unchanged during each swap (except
when liquidity is added or removed).

This formula ensures that as more of one token is bought, its price increases in
relation to the other token, thus maintaining balance and reducing the chance of
draining the pool.

o Token Swap:
Token swapping is the primary function of the AMM in this platform. When
a user wants to trade one token for another, they interact directly with the liquidity
pool through the smart contract. The contract calculates how much of the output
token the user should receive based on the current reserves, using the constant
product formula with a small transaction fee (usually 0.3%).
o Liquidity provision
Liquidity provision allows users to contribute tokens to the AMM in order to
enable trading. This creates a liquidity pool to enable swapping those tokens.
• Smart Contract Deployment:
The deployment of smart contracts is a key step in making the decentralized
exchange (DEX) platform functional and accessible. This process involves compiling,
configuring, and deploying the core contracts, e.g. the ERC-20 tokens, the Automated
Market Maker (AMM), and the liquidity pool logic in a blockchain network where
users can interact with them via wallet interfaces. The entire deployment workflow is
built using Hardhat, that simplifies contract compilation, testing, and deployment.
Hardhat allows for both local simulation and live testnet deployment, making it ideal
for development and real-world testing.
The deployment process is as follows-

o Contract Compilation:
The smart contracts are written in Solidity language. Before deployment
they are compiled using Hardhat. This step ensures the contracts are translated into
bytecode and ABI (Application Binary Interface), which are required for blockchain
execution and frontend interaction.

o Local Deployment with Hardhat Network:

To verify functionality in a safe and fast environment, the contracts are first
deployed to a local blockchain using Hardhat's built-in node. This deploys 3 ERC-
20 tokens (AGN, FLR, MGN), the Exchange contract for pool management and
liquidityPool contracts for token pairs.
The local setup also provides 20 pre-funded test accounts, making it easy to
simulate multiple users adding liquidity and swapping tokens.
o Testnet Deployment to Sepolia via Alchemy:
Once tested locally, the contracts are deployed to the Sepolia testnet, a
public Ethereum testing network. This helps simulate real-world performance,
including transaction finality, wallet integration, and network latency. In this project
for Sepolia testnet, a free Alchemy account is created and an API key is generated.
Using the RPC URL and the private key of the deployer the deployment is executed.

Post-deployment, the smart contracts can be interacted with using MetaMask or

the custom wallet built into the frontend. Users can swap tokens, add liquidity, and
verify contract state changes in real time. Optionally, the contracts can be verified on
Sepolia Etherscan using the Hardhat Etherscan plugin, which enables public viewing
of source code and easier auditing.

• Testing:
Testing is a critical part of this project to ensure that all smart contracts behave
correctly and securely under different scenarios. It verifies the functionality of token
transfers, liquidity operations, token swaps, and edge cases such as insufficient liquidity
or invalid input. This project uses the Hardhat testing framework with Chai assertion
library which are widely used tools in the Ethereum development ecosystem.
The testing process for this project covers five key functional areas to ensure
correctness and robustness across all smart contract interactions. First, token
functionality is validated by testing token minting, transfers, balance updates, and
approval mechanisms required for contract-based token spending. Next, the liquidity
pool behavior is examined by adding token pairs with the correct ratio, accurately
minting LP tokens, updating internal reserves, and verifying proper return of tokens
during liquidity removal. The swap logic is rigorously tested to ensure that output
amounts are calculated correctly using the constant product formula, that swaps execute
properly without exceeding reserves, and that incorrect input tokens are safely rejected.
In addition, the integrity of the AMM contract is verified by preventing duplicate pool
creation, ensuring token order consistency (e.g., tokenA/tokenB vs tokenB/tokenA),
and validating all input token addresses. Finally, the testing includes edge case
handling, such as zero-value liquidity additions, token swaps with insufficient approval,
liquidity removal without LP tokens, and pool creation attempts using identical tokens.
Together, these tests confirm that the system operates securely and reliably under a wide
range of normal and abnormal conditions.

After running the test, the result is as follows:

npx hardhat test

Exchange
✔ Should create a pool
✔ Should swap tokens

LiquidityPool
✔ Should add liquidity
✔ Should swap token0 for token1

Lock
Deployment
✔ Should set the right unlockTime
✔ Should set the right owner
✔ Should receive and store the funds to lock
✔ Should fail if the unlockTime is not in the future
Withdrawals
Validations
✔ Should revert with the right error if called too soon
✔ Should revert with the right error if called from another account
✔ Shouldn't fail if the unlockTime has arrived and the owner calls it
Events
✔ Should emit an event on withdrawals
Transfers
✔ Should transfer the funds to the owner

Token
✔ Should have correct name and symbol
✔ Should assign initial supply to owner
✔ Should allow minting

16 passing (1s)
 All core functionalities were tested successfully, with expected behaviors as
Token minting, transferring, and approvals, pool creation and liquidity provision,
swapping logic with proper reserve management, rejection of invalid or unauthorized
actions. These tests confirm that the platform is functionally stable, user-interaction
safe, and performs accurate token accounting.

• Advantages over current technology:

1. Custom and Extendable AMM

Uses a custom-built AMM contract that is lightweight, transparent, and easy to

audit. Can be easily extended or modified (e.g., for research, academic experimentation,
or new tokenomics).

2. Lower or Zero Gas Fees (Future-Ready)

On Ethereum testnet now, but can be easily deployed on low-fee chains like-
BNB Smart Chain (PoSA) for faster finality and negligible gas fees, Polygon,
Avalanche, or Optimism for Layer 2 scalability and <1 sec confirmations. Offers
cheaper transactions than Uniswap on Ethereum mainnet.

3. Faster Transactions (Testnet or L2 Support)

Platform is optimized to run on testnets and Layer 2s where transactions are
faster and can be migrated to Arbitrum, Optimism, or BNB Chain, enabling near-instant
swaps.

4. Cross-Chain Ready

Designed to be chain-agnostic and can be quickly adapted to PoS and PoSA

blockchains and compatible with future deployments on BNB Chain, Polygon,
Avalanche, and others.
• Swappy Wallet (Browser Extension-Based Web3 Wallet)

One of the most innovative and user-centric features of our project is the Swappy
Wallet, a browser extension-based Web3 wallet that brings decentralized asset management
directly to the user’s fingertips. Built entirely from scratch for this project, Swappy Wallet
functions similarly to well-known tools like MetaMask, but with a more focused and
minimal approach tailored specifically to our platform’s architecture. Unlike wallets that
require additional integration steps or third-party dependencies, Swappy Wallet operates as
a standalone extension, allowing users to manage their blockchain accounts independently.
Whether users want to swap tokens, transfer assets, manage NFTs, or simply check balances
they can do it all within this lightweight and secure extension. What truly sets Swappy
Wallet apart is its tight integration with our decentralized exchange (DEX) while still
remaining a fully independent tool. Users are not forced to rely on external wallets; instead,
they can create and manage their own wallet using a 12-word seed phrase, switch between
networks, and interact with smart contracts, all from within the browser, without leaving
the page.
This provides a streamlined, user-controlled, and developer-friendly experience,
making Swappy Wallet both a utility tool and an educational resource for anyone exploring
blockchain technology.

o Key Functionalities and Features

Swappy Wallet is designed to be lightweight, secure, and easy to use — whether
you’re a developer, a crypto enthusiast, or a complete beginner. Below is a breakdown
of its core features and how each contributes to the overall user experience:

1. Create a Wallet Using a 12-Word Recovery Phrase

One of the most important features of Swappy Wallet is the ability to create a
brand-new Ethereum-compatible wallet directly from the extension. When a user
selects “Create Wallet,” the extension generates a 12-word mnemonic phrase (also
known as a seed phrase), following the BIP-39 standard used by most major crypto
wallets.
This phrase is the only way to back up and restore the wallet. It is shown to the
user in a secure and private manner and never leaves the browser. All wallet
information, including private keys, is generated and stored locally on the user’s device
— never on a server — which ensures complete user control and true decentralization.
This aligns with the core principles of Web3 and trustless systems.

2. Restore Wallet Using Seed Phrase

If a user has previously created a wallet, they can choose the “Sign In With Seed
Phrase” option to recover their wallet on any browser or device. All they need to do is
input the same 12-word phrase.
This recovery system removes the need for traditional login systems like
usernames or passwords. There is no account creation, no email verification, and no
cloud storage — the phrase itself is the identity. As long as the phrase is safely stored,
users will always be able to regain access to their funds and tokens, making it highly
portable and secure.
3. Support for Multiple Blockchain Networks
Swappy Wallet is designed to work seamlessly across various Ethereum-
compatible networks. Users can select the desired network from a simple dropdown
menu, and the wallet will switch configurations instantly.

Currently, the supported networks include:

▪ Ethereum Mainnet – The primary blockchain for real transactions.
▪ Sepolia Testnet – A widely used Ethereum testnet with faucet support; ideal for
testing smart contracts.
▪ Polygon Mainnet – A popular Layer 2 network known for low gas fees and fast
transactions.
▪ Mumbai Testnet – The test network for Polygon, perfect for experimenting with
NFTs and token interactions.

This multi-network support is crucial for developers and testers, as it enables

seamless transitions between test environments and live chains. In the future, more
networks can be added with minimal configuration.

4. Token and NFT Management

Swappy Wallet is not just limited to handling native tokens like ETH and
MATIC. It comes with full support for both ERC-20 tokens and NFTs (ERC-721 &
ERC-1155).
Users can:
▪ Manually add any ERC-20 token by providing its contract address.
▪ View real-time token balances, which are fetched from the blockchain and
displayed in an organized way.
▪ Browse their owned NFTs, including viewing images, metadata, and properties.

All of this is powered by Moralis API, which helps pull reliable token and NFT
data, including token names, symbols, and icons. This provides a cleaner and more user-
friendly display than raw contract data alone.

5. Send, Receive, and Swap Tokens

Swappy Wallet gives users complete control over their assets, allowing them to:
▪ Send tokens to other wallet addresses securely by entering the recipient address
and amount.
▪ Receive tokens by simply copying and sharing their public wallet address.
▪ Swap tokens instantly through the integrated DEX, without needing to connect to
an external wallet like MetaMask.
Swapping is powered by our Automated Market Maker (AMM) smart contracts,
which are deployed on networks like Sepolia and Polygon. The wallet signs transactions
locally using the private key stored in the browser, ensuring all operations remain
private and under user control.

6. Lightweight, Clean, and Beginner-Friendly Interface

One of the biggest goals while designing Swappy Wallet was simplicity. We
wanted users — especially those new to crypto — to feel comfortable using the wallet
from the start.
 The UI includes:
▪ A friendly welcome screen with a message like “Hey there ”
▪ Two prominent buttons for “Create Wallet” and “Sign In With Seed Phrase”
▪ A network switcher dropdown in the top-right corner for easy network selection.

o Frontend Technology Stack

The frontend of our platform, including the Swappy Wallet browser extension, has
been built with a modern and modular technology stack designed for responsiveness,
scalability, and developer efficiency. Each technology was chosen with the goal of
offering a smooth user experience while maintaining high performance and ease of
maintenance.

1. React.js
React is the core framework used for building the user interface. Its component-
based architecture allows us to break the app into reusable pieces such as wallet
creation, dashboard, token list, and swap UI. It provides fast rendering with virtual
DOM and smooth updates to the UI based on changes in state or blockchain data.
React’s developer tools and community support made it the ideal choice for building a
complex Web3 interface.

2. Tailwind CSS
We used Tailwind CSS, a utility-first CSS framework, to design a clean and
responsive UI without writing bulky custom stylesheets. Tailwind allowed us to build
modern, mobile-friendly components directly in JSX using pre-defined utility classes.
The design system is consistent across the wallet and DEX interface, giving a
professional look and feel with minimal effort.

3. JavaScript (ES6+)
The entire frontend logic is written in modern JavaScript, using ES6+ features
such as arrow functions, async/await, destructuring, and modules. JavaScript drives all
wallet logic including seed phrase generation, key derivation, network switching, and
transaction signing.

4. ethers.js
ethers.js is the primary library used for interacting with the Ethereum blockchain
from the frontend.
▪ It allows the Swappy Wallet to:
▪ Create wallets using mnemonic phrases (BIP-39).
▪ Sign and send transactions directly from the browser.
▪ Fetch balances, contract states, and token metadata.

We preferred ethers.js over Web3.js due to its smaller size, better documentation,
and improved TypeScript support.

5. Browser Extension APIs (WebExtension / Manifest V3)

Swappy Wallet is packaged as a browser extension using the WebExtension API
standard. It runs as a Chrome extension, compatible with Chromium-based browsers like
Brave and Edge. The React app is compiled and injected into the extension structure
(Manifest V3 format), allowing persistent access through the browser.
6. Context API and Local Storage
React’s built-in Context API is used for state management across the wallet (e.g.,
saving user address, network, balances). We also utilize localStorage to persist wallet data
such as:
▪ Encrypted private key
▪ Network selection
▪ Recently added tokens
▪ This ensures that user sessions are maintained even after refreshing or reopening the
browser.

7. Axios + Moralis API

Axios is used to make HTTP requests to the Moralis Web3 API, which helps us
retrieve token balances, NFT metadata, and transaction histories in real-time. The API
responses are processed and presented in a user-friendly format in the wallet interface.

o Backend Integration with Moralis

To enhance functionality and performance across our DEX platform and Swappy
Wallet extension, we integrated the Moralis Web3 API into our backend. Moralis serves
as a bridge between the blockchain and our application, providing fast, reliable, and
structured access to blockchain data — including token balances, transaction history, NFT
metadata, and more.

Why We Chose Moralis

Directly interacting with blockchain nodes for every request can be slow, complex,
and expensive. Moralis offers a much faster and developer-friendly alternative by giving
us structured APIs that return blockchain data in clean formats.

Here’s what we gained by using Moralis:

1. Faster API responses compared to using direct RPC or JSON-RPC calls.
2. Support for multiple blockchains like Ethereum, Sepolia, Polygon, and
Mumbai Testnet.
3. Simple endpoints for accessing NFTs, tokens, transactions, and wallet
balances.
4. Cleaner data, so we spend less time processing or formatting it in the backend.

How the Backend Works

Our backend is built using Node.js and Express.js. It acts as a middle layer
between our frontend (React-based interface and Swappy Wallet extension) and the
Moralis service. Here’s how we’ve set it up:

1. Secure API Key Storage

We keep the Moralis API key inside a .env file to make sure it’s never
exposed on the client side.

2. Backend Routes (APIs We Created)

We created simple Express.js routes that call the Moralis APIs behind the
scenes:

o /wallet/balance/:address – Returns the native token (ETH or MATIC) balance for the
user.
o /tokens/:address/:chain – Lists all ERC-20 tokens held by the wallet on a chosen
network.
o /nfts/:address/:chain – Fetches NFTs owned by the wallet address.
o /transactions/:address – Retrieves the latest activity or transaction history.

These routes take care of formatting, error handling, and API calls, so the
frontend only has to make simple HTTP requests to our server.

3. Supported Networks
We’ve connected the backend to the same networks supported by Swappy
Wallet:
Ethereum Mainnet and Sepolia Testnet
Polygon Mainnet and Mumbai Testnet
So no matter what chain the user is working on, they’ll see accurate data
pulled in real time.

4. Security and Optimization

We take care to protect sensitive data and improve performance by:

Keeping API keys server-side — the frontend never sees them

Caching repeated requests, so we don’t overload the Moralis API with identical calls.
Handling errors gracefully, so if something goes wrong (like invalid wallet address
or network down), the user gets a helpful message instead of a crash.

o Why Swappy Wallet?

When starting this project, we knew that simply building a decentralized exchange
wasn’t enough. We needed to rethink how users interact with it. Most platforms rely
heavily on third-party wallets like MetaMask, which, although powerful, come with their
own set of challenges. Users are often required to install separate browser extensions,
manually configure networks, approve every transaction through a pop-up, and sometimes
struggle with understanding what’s actually happening under the hood. For newcomers to
Web3, this can be overwhelming. Even for experienced users, the disconnection between
the exchange and the wallet often breaks the flow.

That’s where the idea for Swappy Wallet came in, not as a replacement for
MetaMask, but as an integrated, user-friendly companion that’s purpose-built for our DEX
ecosystem. Swappy Wallet is a browser extension that removes the need for external setup
or third-party connections. Users can create their own Ethereum-compatible wallets right
inside the extension, get a 12-word recovery phrase, and start managing their assets within
seconds. There’s no signup, no central server, and no dependency on external platforms.
Everything is self-contained, secure, and entirely under the user’s control.

But more than that, Swappy Wallet gives us something incredibly valuable:
freedom. Freedom to design the user experience exactly how we want it. We’re not
constrained by the limitations of someone else’s UI or feature roadmap. If we want to
support additional testnets like Sepolia or Mumbai, we can. If we want to allow custom
token additions or show NFTs directly in the wallet, we can do that too, and we did. This
freedom allowed us to create something that feels natural and intuitive, especially for
users who are just starting their journey into blockchain and decentralized finance.
 We also see Swappy Wallet as an educational tool. It introduces users to concepts
like private key ownership, mnemonic phrases, and network switching in a way that’s
simple and approachable. Rather than requiring users to figure things out on their own
through multiple apps, we provide a cohesive, all-in-one experience. Everything from
wallet creation to token swapping happens in one place no jumping between tabs, no
external confirmations, no confusion.

Ultimately, Swappy Wallet reflects the heart of this project: accessibility,

decentralization, and control. It’s not just a wallet it’s the doorway to our platform, built
with care to remove complexity and put power back in the hands of the user. That’s why
Swappy Wallet exists to simplify the Web3 experience without compromising on the
values that make it special.

• Wallet Integration
Wallet integration plays a crucial role in connecting users to the decentralized
application. In our project, we made sure to design the wallet integration in a way that is
smooth, intuitive, and flexible, catering to both new users and experienced developers.
Below is a detailed explanation of how wallet integration has been implemented in our
DEX platform.

▪ Seamless Connection to Swappy Wallet

Swappy Wallet, our custom browser extension, is fully integrated into the
platform to work right out of the box. As soon as the extension is installed and activated,
our application automatically detects the wallet’s presence. The connection process is
frictionless — there’s no need for manual imports or connection buttons. Once
connected, the DEX interface instantly reads the wallet address, displays the active
blockchain network, and fetches the balance of native tokens (like ETH or MATIC)
along with custom tokens. This tight coupling between the DEX and Swappy Wallet
creates a smooth user experience where interactions feel native, not bolted on.

▪ Support for External Wallets (MetaMask & WalletConnect)

Even though we built our own wallet, we also respect user choice. Some users
might already be comfortable using wallets like MetaMask or might prefer mobile-
based wallets that connect through WalletConnect. That’s why we made our DEX
flexible — it allows users to connect using either of these popular tools.

When a user chooses to connect through MetaMask, the platform triggers the
MetaMask extension to request access to the wallet. Similarly, for WalletConnect, a QR
code is generated so users can scan and connect from mobile wallets like Trust Wallet
or Rainbow. This level of support ensures that our DEX is open and inclusive, not
limited to just our internal tools.
 ▪ Automatic Network Detection and Switching

Blockchain applications often work on multiple networks, but switching

between them can be confusing for users. To make this easier, we added automatic
network detection to the platform. As soon as a wallet is connected, the DEX reads the
current network and displays it in the UI.

If the user is on an unsupported network, a helpful alert is shown explaining the

issue and guiding them to switch to a supported one. For Swappy Wallet users, changing
networks is extremely simple. We built a network selector dropdown inside the wallet
interface itself, allowing one-click switching between Ethereum Mainnet, Sepolia,
Polygon, and Mumbai.

▪ Secure Transaction Signing

Every interaction with the smart contracts, whether it’s swapping tokens,
providing liquidity, or minting, requires the user’s approval through their wallet. With
Swappy Wallet, all of this happens inside the browser. When a transaction is initiated,
the wallet signs it locally using the user’s private key stored securely in the browser’s
local environment.

For users connecting via MetaMask or WalletConnect, a standard transaction

approval popup appears where they can review and sign the transaction. In all cases,
the transactions are non-custodial, meaning the user’s private keys are never exposed
or stored on any server, the user remains in full control.

▪ Focus on Simplicity and Accessibility

Above all, our wallet integration was designed with simplicity in mind. We’ve
seen many users struggle with complex Web3 setups, so we made sure to present clear
options like:

✓ “Create a Wallet” : for first-time users who don’t have an existing wallet.
✓ “Sign In With Seed Phrase” : for users recovering their wallet.
✓ “Connect Wallet” : for those who prefer MetaMask or WalletConnect.

The flow is linear and beginner-friendly. We’ve kept jargon to a minimum, used
simple UI prompts, and designed the experience to guide users step-by-step. This makes
the DEX approachable even for those who are new to blockchain.
Swappy Wallet - Working Architecture:

• RAG Chatbot:
o Detailed Workflow of the RAG Chatbot

The RAG chatbot in this project is designed to help users understand

blockchain-related topics like token standards, liquidity pools, and decentralized
trading. It uses a combination of document retrieval and language generation.
Below is the complete step-by-step process of how it works, from document storage
to user interaction.

1. Document Preparation and Embedding

The first step is to collect the source documents. These include guides,
explanations, FAQs, and concept notes about blockchain, smart contracts, ERC-20
tokens, and decentralized finance. These documents are cleaned and split into
smaller parts or chunks.
 Each chunk is converted into a vector (numerical representation) using a
pre-trained embedding model. In this case, a Hugging Face model like all-MiniLM-
L6-v2 is used. This model captures the semantic meaning of each text chunk.

2. Storing Embeddings in Pinecone

Once the embeddings are created, they are stored in Pinecone. Pinecone is a
vector database that allows fast similarity search across high-dimensional vectors. Each
text chunk is stored in Pinecone along with metadata (like the original document name
or topic). These vectors are indexed using a similarity metric such as cosine similarity,
which helps in finding the most relevant pieces of information later.

3. User Query Handling

When a user types a question through the chatbot interface (for example, asking
“How does token swapping work?”), the following happens:

The user input is sent to the backend Flask application through an API request.

The Flask app receives the query and first passes it through the same embedding model
that was used to prepare the document chunks.

This turns the user question into a query vector.

4. Similarity Search with Pinecone

The query vector is then sent to the Pinecone vector database. Pinecone
compares this vector with all stored vectors and returns the top matching chunks. These
chunks are likely to contain information relevant to the user’s question. Usually, 3–5
top chunks are retrieved and sent back to the Flask app.

5. Creating the Prompt for the Language Model

Once the relevant chunks are received, the Flask app arranges the retrieved text
into a structured prompt. This prompt includes a system message that sets the assistant’s
behavior (e.g., "You are a helpful assistant for blockchain questions") and a user
message that contains the retrieved content and the actual user question.

This approach is known as Retrieval-Augmented Generation (RAG). It

combines external knowledge (retrieved from Pinecone) with the reasoning abilities of
a language model.

6. Passing the Prompt to the Language Model

The structured prompt is then sent to a large language model (LLM) through the
OpenAI API. In this case, a model like gpt-3.5-turbo or gpt-4 is used. The API is
accessed via the internet, and during development, ngrok is used to tunnel the Flask app
so that it can be accessed from the public internet. Ngrok exposes a public URL that
forwards requests to your local server, which is useful when testing the frontend with a
backend that runs locally.

7. Receiving and Returning the Response

The OpenAI API processes the input and returns a response generated based on
the context (retrieved documents) and the user’s question. The Flask backend receives
this response and sends it back to the chatbot interface on the frontend. The frontend
displays the answer to the user in a chat-like format.

8. Frontend Integration

The frontend is built using React. It has a simple UI for inputting user queries
and displaying the chatbot’s responses. Each message is sent to the Flask backend,
which is connected to the RAG pipeline, and the results are shown to the user without
needing to refresh or reload the page.

o Summary of Tech Stack Involved

Embedding Model: Hugging Face (all-MiniLM-L6-v2)

Vector Store: Pinecone
LLM: OpenAI API (gpt-3.5-turbo or gpt-4)
Backend: Flask (Python)
Frontend: React
API Exposure during Development: Ngrok
Pipeline Type: Retrieval-Augmented Generation (RAG)

This chatbot improves the user experience on your DEX platform by answering
blockchain questions directly within the interface. It doesn’t rely only on pre-trained
answers but actively pulls from the latest available information in your document store.
Each part of the workflow is modular, so it can be improved independently in the future.
Implementation
To showcase the working of the decentralized exchange platform, several key screens from the
live running project have been captured. These screenshots serve as visual proof of
functionality, illustrating how users interact with the platform, from connecting a wallet to
performing swaps and adding liquidity.

Swappy (swapping platform):

Home Page – SWAPPY DEX : In this page the user needs to connect to the wallet first and the
chatbot icon is also there in the right corner.

Wallet Connected : After connecting to the wallet the home page looks like this, if liquidity
pool is already there.
Add Liquidity Page: This interface allows the user to provide a pair of tokens to the liquidity
pool. Once submitted, tokens are transferred to the pool contract.
Add Liquidity Page while adding tokens into liquidity pool. In this page Metamask pop up is
there for signing the transaction.

Pool Creation Confirmation: This shows the on-screen status confirming that a liquidity pool
has been successfully created between two tokens.

Token Balances before swap: This screen displays balances before token swap.
Token Balances after swap: This screen displays updated balances after a succesful token swap.
Swappy Wallet:

Wallet Welcome Screen: This screen is Seed Phrase Generation: This screen
the entry point to the custom wallet shows the process of creating a new
named Swappy Wallet. wallet by generating a 12-word seed.
..phrase. The user is instructed to
securely save this phrase, as it is the
only way to recover their wallet in the
future.

Recover Wallet Using Seed Phrase:

This screen allows users to restore
access to a previously created wallet
using a valid 12-word seed phrase. Token Transfer Page: This enables the
user to send tokens from their wallet to
another wallet address.
 Token Import Screen: In this module Token transfer to users: Here we can
users can import tokens. send tokens to someone by their wallet
address.
RAG Chatbot:
Advantages

1. Fully Decentralized Architecture

This project enables token swaps and liquidity provision without any central
authority or intermediary which is more secure than the centralized platforms.

2. Custom Automated Market Maker (AMM)

Uses own constant product formula of Automated Market Maker to manage token
prices and ensure continuous trading without order books.

3. Multi-Wallet Support

Supports MetaMask, WalletConnect etc. and an integrated custom decentralized

wallet, offering flexible user options.

4. Onboarding Through AI Chatbot

The Retrieval-Augmented Generation (RAG) chatbot helps new users understand

blockchain terms, token mechanics, and platform usage. This reduces the learning curve
and keeps the experience within one interface.

5. Educational and Developer-Friendly

The system is designed in a way that developers and learners can understand and
test DeFi concepts without needing to interact with large, complex systems. It is well suited
for learning how smart contracts, wallets, and AI assistance work together.

6. Modern Full Stack Web3 Stack

Built with Solidity, React, Hardhat, and Ethers.js for clean development,
modularity, and seamless smart contract integration.

7. Flexibility and Modularity

Each part of the platform like the smart contract, wallet, UI, and chatbot, can be
changed or updated separately. This makes future upgrades easier to implement.
Limitations

1. Limited Token Support

Currently, the platform supports only a few custom tokens and optionally one or two
stablecoins. It does not yet support large pools of tokens or token discovery.

2. No Live Chain Deployment

The platform works well in a local or testing environment but is not yet deployed on
public Ethereum or testnets, which limits real-world usage or public access.

3. Basic RAG Chatbot Capabilities

While helpful, the chatbot is limited to answering based on the documents it was given.
It cannot handle advanced reasoning or remember past queries across a session.

4. Single Token Pool per Pair

There is no support for dynamic pricing models or multiple liquidity pools per token
pair, which reduces flexibility and real-world accuracy.

5. No Real-time Data or Analytics

The system does not provide live market data, transaction analytics, or real-time price
feeds. Users must rely on external sources for deeper insight.

6. Limited Testing on Scale

The system has been tested with a few users and mock interactions, but not under stress
or real user loads, which may affect reliability when scaled.
Future Work

1. Deploy to Public Testnets or Mainnet

Moving the platform to a testnet like Goerli or Sepolia will help test it in real blockchain
environments and make it accessible to more users.

2. Expand Token and Pool Support

Add support for more ERC-20 tokens, multi-token pools, and dynamic pool creation to make
the exchange more useful and realistic.

3. Improve Chatbot Capabilities

Enhance the chatbot with session memory and better handling of follow-up questions. Allow it
to learn from user interactions or frequently asked queries.

4. Add Investment and Trend Tools

Introduce a module where users can view token trends or get simple guidance based on
historical data. This would help users make better decisions.

5. Include Analytics Dashboard

Add a dashboard that shows key metrics like liquidity, volume, pool balance, and swap history.
This will provide better insights into platform usage.

6. Mobile and Lightweight Web Support

Develop a mobile-friendly version or a progressive web app so that users can access the
platform on different devices.

7. Security Audits and Testing

Perform more rigorous contract audits and testing with tools like Slither or MythX before
scaling or going live.
Conclusion

This project successfully brings together the essential parts of a decentralized application into
one unified platform. It combines a token swap system, a custom-built decentralized wallet,
and an AI-powered chatbot that helps users understand blockchain concepts without needing
to leave the platform. Each component is connected in a way that offers a complete experience,
from interacting with smart contracts to managing tokens and receiving real-time help through
the chatbot. This makes the project not just a technical showcase but also a practical learning
environment for users and developers who want to understand how decentralized finance works
in action.

The decentralized exchange (DEX) built here allows token swapping and liquidity
provision using an Automated Market Maker model. It supports ERC-20 tokens and provides
a hands-on example of how token pricing and liquidity management can happen fully on-chain.
This part of the project reflects real-world platforms like Uniswap but in a scaled-down form
that makes it easier to study and extend. The custom wallet system is another strong feature, as
it lets users create and manage Ethereum accounts without relying only on tools like MetaMask.
This allows the platform to remain fully self-contained and provides a deeper understanding of
how wallet integration works behind the scenes. One of the key contributions of this project is
the Retrieval-Augmented Generation (RAG) chatbot. It plays an important role in guiding users
and explaining blockchain-related topics in simple language. Instead of forcing users to search
for answers outside the application, the chatbot provides assistance within the same interface.
This improves the onboarding process and makes the platform more accessible to people who
may be new to blockchain or DeFi. Together, these features make the project a well-rounded
system that serves multiple purposes. It is useful for trading and testing, but also serves as a
practical tool for learning.

Overall, the project proves that even a small-scale system, when well designed, can
deliver the core experience of decentralized finance and serve as a complete demonstration of
Web3 development. With some improvements in scale, user support, and chatbot capabilities,
it can grow into a reliable platform that not only functions well but also teaches and guides
users in the evolving space of blockchain technology.
References

• Articles and Journals:

1. Annetta Ho, et al. (2024). “The Ecology of Automated Market Makers.”
2. Zhengge Zhou. (2024). “Optimal Automated Market Makers”.
3. Jason Milionis, et al. (2023). "A Myersonian Framework for Optimal Liquidity
Provision in Automated Market Makers."
4. Khetesh Choudhary, et al. (2024). " Decentralized Wallet Application using
Blockchain."
5. V. Buterin, (2014) “A Next-Generation Smart Contract and Decentralized
Application Platform,” Ethereum Whitepaper.
6. Y. Zhang, R. Xie, J. Qian, and S. Wang, “Automated Market Making for
Decentralized Exchanges: A Survey,” IEEE Access, vol. 9, pp. 144998–145012,
2021.

• Online Resources:
1. OpenZeppelin, ERC-20 Token Standard Documentation, 2023,
https://docs.openzeppelin.com/contracts/4.x/erc20
2. Uniswap Labs, Uniswap v2 Core Documentation, 2023. , https://docs.uniswap.org/
3. Moralis, Moralis Web3 API Docs, 2024, https://docs.moralis.io/
4. MetaMask, MetaMask Developer Documentation, ConsenSys, 2023,
https://docs.metamask.io/
5. Polygon Labs, Polygon PoS Architecture and Developer Docs, 2023,
https://wiki.polygon.technology/
6. OpenAI, Retrieval-Augmented Generation (RAG) in AI Applications, 2024,
https://platform.openai.com/docs
7. Hardhat by Nomic Foundation, Ethereum Development Environment, 2023,
https://hardhat.org/