Reference no: EM133976699

Lab: Blockchain-Based Ecosystems: Memecoins & Stablecoins Development, Attack Simulation, and Auditing

1. Overview
This lab guides students through designing, implementing, deploying, testing, and auditing a simple memecoin (ERC-20) and a minimal ecosystem around it (liquidity pool, simple governance, and a front-end). The lab emphasizes on hands-on smart contract development, off-chain assets, tampering/attack simulation, and understanding security tradeoffs. Enjoy trusted, budget-friendly assignment help from today onward!
Students will:
Build a token
Deploy it to a local testnet
Create a Uniswap-style liquidity pair
Implement simple governance
Simulate common memecoin attacks like rug-pull, unauthorized minting, honeypot
Detect attacks and propose mitigations.
2. Lab Environment Setup
You will be running our code locally using Visual Studio Code to edit our code and using the terminal to run commands. I will reference the code using a file name as label or function name in cases where we have more than a function inside a file. Below are the tools we would be using
Node.js v16+ and npm
Hardhat local node (an Ethereum local chain)
Ethers.js
MetaMask (for manual UI testing) or a local script wallet
Python 3.8+ for off-chain helper scripts
3. Tasks (Lab Steps)
Part 1: Mime Coin
Task 0 - Environment & Setup

Task 1 - Create a basic ERC-20 memecoin
Implement Memecoin.sol (ERC-20) with these features:
name, symbol, decimals.
initialSupply minted to deployer.
mint function restricted to onlyOwner.
burn function available to any holder.
setMaxWallet(uint256) (optional anti-whale).
Deploy and record the token address and owner address.

Task 2 - Add simple tokenomics and on-chain rules
Add configurable transaction fee (tax) on transfers that routes to a treasury address.
Implement enableTrading() gating so token is non-transferable until the owner opens trading (useful for launch control).
Add excludeFromFees(address) and isExcludedFromFees(address) logic.

Task 3 - Provide liquidity & interact with an Automated Market Maker (AMM) integration
Using a Uniswap v2 fork or the provided simplified AMM, create a token-ETH pair and add liquidity programmatically from your deployer account
Show the token price after adding liquidity.

Task 4 - Attack simulations & tamper exercises
This mirrors the vulnerability and tamper simulations from Project 1 but adapted to tokens.
Unauthorized Minting / Owner Key Leak simulation
Create a second (attacker) signer and simulate that signer calling mint() (if onlyOwner is removed or the owner key is compromised). Demonstrate supply inflation and its effect on price.
Rug-pull simulation
Owner adds liquidity and then withdraws all liquidity from the pool (or transfers treasury tokens and removes liquidity). Show how token price collapses and holders are stuck with worthless tokens.
Honeypot / Transfer Revert
Introduce a buggy transfer logic that allows buys but prevents sells (simulate a honeypot). Demonstrate a transaction that fails on sell.
Front-end social engineering simulation
Show how a malicious UI could trick users to approve unlimited allowance or sign a permit that transfers tokens. Demonstrate by interacting with a script that calls approve(spender, type(uint256).max) and then transferFrom.
For each simulation:
Run tests showing the exploit succeeds (or fails if protections exist).
Recompute on-chain states (supply, balances, reserves) and show the exact mismatch (before/after)

Task 5 - Detection and mitigation of attack
Write unit tests that assert invariants such as total supply cap, owner balance limits, and that enableTrading gating prevents transfers pre-launch.
Implement fixes: reintroduce onlyOwner on mint, add timelock for owner actions, add a renounceOwnership() demonstration and explain consequences.

Part 2: Stable Coin: Students will build a simplified Collateralized Stablecoin
Task 0 - The Stablecoin Creation
Create the assets and the pricing mechanism.
StableCoin.sol: A standard ERC-20 (symbol: USDM) where mint and burn are restricted to the Vault contract.
MockOracle.sol: A simple contract that stores a variable ethPriceUSD.
Task 1 - The Vault (Minting & Redeeming)
Allow users to deposit ETH and borrow USDM against it.
Deposit/Mint:
User sends ETH.
Contract calculates USD value using MockOracle.
Checks if (ETH Value / Mint Amount) >= 1.5
Mints USDM to user.
Repay/Withdraw:
User approves and sends USDM back to Vault.
Vault burns USDM.
Vault returns equivalent ETH to user.
Calculate the Health Factor if the position is at risk of attack using ETH collateral amount * ETH Price / USDM Minted

Task 2 - Attack Simulation: The Death Spiral
Simulate what happens when the collateral asset crashes like the DeFi exploits.
Set Oracle price of ETH to $3000.
User A deposits 1 ETH ($3000 value) and mints 2000 USDM. (Ratio: 1.5).
The attacker (or market conditions) calls MockOracle.setPrice(1500).
User A's collateral is now worth $1500, but they owe 2000 USDM. The system is under-collateralized.
User A decides never to repay the loan because keeping the 2000 USDM is more profitable than getting back $1500 of ETH. The protocol is now insolvent.

Task 3 - Detection & Mitigation of the Death Spial Attack

How the code of how you would detect this attack and mitigate the attack from happening