supporting system

HypeMint Multi-Chain Launchpad

Cross-Chain Memecoin Platform - Backend Math Audit, 14 EVM + Solana, Solidity/Rust Anti-Whale Contracts

I was brought in for frontend work, but the launch math behind the product was not behaving correctly. I traced pump.fun's virtual-reserve model through public API data, helped shape a bonding-curve formula for Solana and 14 EVM networks, and used GitHub Copilot to draft Solidity and Rust vesting contracts that were then checked at their boundaries. Creators can launch a memecoin without paying an upfront gas fee.

scale: Runs across Solana and 14 EVM networks, with backend state and live chain events kept separate by token. Each purchase carries its own one-hour vesting timer.
latency: Updates the pricing curve as transactions arrive, so the frontend chart can reflect the current state without calculating the curve in the browser.
reliability: Graduation is tied to 793.1M of a 1B token supply rather than a USD target, so a move in the native coin price does not change the rule. Pricing, slippage, and fees use BigInt rather than floating-point values.
automation: BullMQ workers consume chain events, apply the 1% platform fee, and update token supply state. Contract addresses live in Postgres, so adding a network begins with data configuration instead of a frontend rewrite.

HypeMint - Home page — The launchpad home, including the bonding-curve view.

Context

Problem had shape before code did.

HypeMint lets someone launch a memecoin without paying the initial launch fee. Purchases move the price through constant-product math on the backend. Once the curve has sold through its available tokens, buying stops. The system takes its 1% fee, combines the reserved supply with the collected funds for liquidity on an exchange such as Uniswap, then sends the LP tokens and mint controls to an unrecoverable address.

Audited backend tokenomics and used public pump.fun API data to correct the virtual-reserve model.
Helped correct initial pricing by anchoring the pool with 30 virtual native coins and 1.073 billion virtual memecoins.
Designed a cross-chain bonding-curve formula for Solana and 14 EVM networks, including Polygon, Arbitrum, and Base.
Wrote Solidity and Rust code with GitHub Copilot for an anti-whale vesting feature. Buyers receive 25% of tokens immediately and the remaining 75% vests linearly over one hour.

Chains: Solana and 14 EVM networks, with shared bonding-curve math and contract addresses stored in Postgres.
Graduation: A supply rule at 793.1M of 1B tokens, so graduation does not depend on USD or native-coin price swings.
Math: BigInt for pricing, slippage, and fees, avoiding floating-point rounding errors.
Contracts: Solidity for EVM and Rust for Solana, drafted with Copilot and manually checked.
Fee Model: BullMQ workers apply the 1% platform fee. The roughly $2 creation fee goes to the first buyer, leaving the creator with no launch cost.
Rug-Proof: LP tokens and mint controls move to an unrecoverable address at graduation.
Frontend: The active network selects wagmi for EVM or @solana/web3.js for Solana, while pricing stays on the backend.
Vesting: Each purchase releases 25% immediately and vests the remaining 75% linearly over one hour.

Build

Structure had to survive job.

The backend splits the 1B supply into 793.1M for the active curve and 206.9M held back for the liquidity pool created at graduation.
The platform covers the roughly $2 network-creation charge at launch and recovers it from the first buyer, leaving the creator with no upfront launch fee.
At graduation, LP tokens and mint controls are sent to an unrecoverable address so the original team cannot take back control of the liquidity or minting.
The frontend switches between wagmi for EVM transactions and @solana/web3.js for Solana based on the active network.
BullMQ workers receive raw chain events, apply the 1% platform fee, and update token supply state as events are processed.
Deployment addresses are stored in Postgres. Supporting another chain means adding its address record rather than hardcoding a new frontend path.

I was assigned frontend work, but the backend math was preventing the product from behaving as intended. The curve started at zero liquidity, and the $69,000 graduation target shifted with daily price changes. I studied public API behavior to understand the virtual reserves, then helped shape a formula that could work on Solana and 14 EVM networks. The frontend now reads the corrected endpoints instead of carrying that math itself.

Working stack

Next.js / React / Bun / ElysiaJS / PostgreSQL / Drizzle ORM / Redis / BullMQ / wagmi / @solana/web3.js / Solidity / Rust

Evidence

Browser becomes part of argument.

01 / 06The token-creation flow, built so the creator has no upfront gas cost.

Decisions

Small cuts make system trustworthy.

I replaced the fixed $69,000 market-cap target with a supply-based graduation rule. A token now graduates when the 793.1M threshold is reached, regardless of changes in the native coin price.
Pricing, slippage, and fee calculations use BigInt so the backend does not introduce floating-point rounding into token amounts.
I worked with a senior developer on the Next.js interface. It reads the corrected math from backend endpoints instead of trying to reproduce that logic on the client.
GitHub Copilot helped draft the Solidity and Rust anti-snipe and vesting contracts. Buyers receive 25% immediately, with the remaining 75% released linearly over one hour. I manually checked the generated code at its boundaries.

Pressure

What resisted, broke, stayed expensive.

Constraints in motion

The original pricing logic started with zero funds, so it read as zero liquidity and the curve could not move.
A fixed $69,000 graduation target kept changing its practical meaning as Solana and Ethereum moved in price.
The first backend design put the full 1B supply into the curve, leaving nothing to pair with collected funds when liquidity moved to a DEX.
The frontend depended on the virtual-reserve model, so I had to understand it through public token APIs before the interface could be trusted.
The Solana AMM approach had to be carried over into fee and ownership handling for 14 EVM networks.
AI-assisted Solidity and Rust drafts still needed deliberate boundary testing before they could be used.

Failure modes

Putting the full 1B supply in the opening curve left no tokens for the DEX liquidity pair at graduation.
The $69,000 USD trigger was unstable because its meaning shifted with the price of Solana or Ethereum.
The AI-assisted smart-contract drafts needed manual boundary tests and were not a substitute for an independent Solidity or Rust security review.

Trade

GitHub Copilot made the Solidity and Rust drafts faster to produce, but it also created extra manual testing work.
The first buyer covers the initial block-space fee. That keeps launch free for the creator but gives the first purchase an added cost.
A 793.1M supply threshold does not move with USD markets, but it makes exact backend supply accounting essential.

Result

What held. What carries forward.

behavior

Helped repair the bonding curve by studying pump.fun's public API

I used public pump.fun responses to identify the virtual-reserve inputs: 30 virtual native coins and 1.073B virtual memecoins. Those findings helped the backend team correct the implementation.

architecture

One bonding-curve model for Solana and 14 EVM networks

The formula carries Solana AMM behavior over to Polygon, Arbitrum, Base, and 11 other EVM networks. Postgres address mapping keeps the chain-specific contract data in one place.

metric

A graduation rule based on token supply, not market price

The $69,000 trigger was replaced with a 793.1M supply threshold. Graduation now follows token mechanics rather than the price of the chain's native coin.

engineering

Anti-whale vesting in Solidity and Rust

The EVM Solidity and Solana Rust contracts were drafted with GitHub Copilot. Buyers receive 25% immediately and 75% over one hour, with manual boundary checks on the generated code.

If rebuilt

Move live bonding-curve updates from polling to WebSockets.
Support launch templates with more than one token instead of one token per launch.
Add on-chain governance for changes to the graduation threshold.
Commission a formal security audit for the Solidity and Rust contracts drafted with AI assistance.

結論
The interface could not be correct while the tokenomics behind it were unclear. Researching the public APIs exposed the broken assumptions, led to a cross-chain formula, and gave the frontend stable endpoints to read from. It reinforced a practical lesson: frontend ownership sometimes means checking the system behind the screen, not only the screen itself.

Make it hold together

Complex frontend system need steady hand?

Architecture, interface, production constraints. Together.

Start a conversation Download résumé