Senior Software Engineer

Smart Contracts

• Refactor the existing betting contract — dynamic odds, cleaner pool logic, and handling UFC match volume without issues
• Build the yield farming contracts: time-based distribution, clean accounting, low gas per claim
• Upgradeable PSPN and UFC token contracts with proper mint/burn controls and access management
• Internal swap contract with slippage limits and price estimates users can actually trust
• Admin tooling for match creation, result posting, and full round lifecycle management
• Multi-sig setup for anything high-risk — rate changes, emergency pauses, upgrades
• Batch processing for bets and yield claims when we're handling volume
• Event architecture so the frontend gets real-time updates without hammering RPC endpoints
• Role-based access control across the entire contract suite
• Gas optimization on everything — swaps, bets, claims. Users notice when it's expensive.
• Refund logic for cancelled rounds and invalid match outcomes
• Circuit breakers for network congestion and gas spike scenarios

Architecture & Integration

• Modular contract design — UFC, PSPN, Swap, and Bet contracts need to interact cleanly
• Proxy patterns for upgradeability (UUPS or Transparent — you choose what fits best)
• Custom ERC-20 extensions for yield mechanics and transfer restrictions
• Error handling that degrades gracefully instead of silently failing
• Logging and monitoring for production contracts on PulseChain mainnet
• Off-chain integration for match data storage and indexing
• Data structures that don't become bottlenecks with thousands of active bets
• Architecture that supports multiple concurrent betting rounds without state collisions

Frontend & Web3

• Connect the React frontend to contracts via ethers.js v6
• Wallet support: MetaMask, Coinbase, Trust Wallet, WalletConnect
• Real-time balance and transaction state — users shouldn't need to refresh
• Transaction feedback that's actually useful when something goes wrong
• Network switching to PulseChain from within the app
• Redux Toolkit for blockchain state management across the app
• Optimistic UI where it makes sense
• Queue management for multiple pending transactions
• Gas estimates and cost previews before users confirm
• Event listeners tied to live betting round state

Security

• Security reviews before any deployment — reentrancy, overflow, access control
• Automated scans (Slither, Mythril) as part of the standard process
• RBAC for admin and operator functions
• Multi-sig on anything that moves money or changes critical parameters
• Minimum bet amounts, maximum pool caps, and basic investor protections
• Emergency pause on betting rounds and farming
• Audit trail for all privileged operations
• Time-locked admin actions on anything sensitive
• Withdrawal limits and cooldown periods where the risk warrants it

Performance & Observability

• Gas profiling and optimization across all contract operations
• Storage layout decisions that actually matter at scale — mappings over arrays where it counts
• Batch operations to cut per-user transaction costs
• Dashboard tooling for round progress, yield accrual, and contract health
• Alerts on critical events and unexpected failures
• Analytics for platform usage and user behaviour

On-chain experience

• 7+ years writing Solidity and deploying to mainnet — not just testnets
• Solid understanding of EVM internals: storage layout, gas mechanics, transaction flow
• Solidity 0.8.x, current patterns, current pitfalls
• You know what reentrancy looks like in the wild and how to stop it
• PulseChain experience is a plus; any EVM-compatible chain is a fine starting point

Contract work

• Shipped betting or prediction market contracts — at least one in production
• Built yield farming or staking systems that ran with real money
• ERC-20 extensions beyond the standard — custom logic, hooks, restrictions
• Swap mechanics, AMM basics, slippage handling
• Proxy patterns: UUPS or Transparent. You've used one in production, not just read about it.
• Time-based reward distribution
• Pool-based payout math and odds calculation

Frontend

• React with TypeScript — not just familiar, actually fast with it
• Redux Toolkit for async blockchain state
• ethers.js v6. The new API, not just the old patterns.
• Wallet connection flows — Web3Onboard or something equivalent
• You understand why blockchain operations are async and handle edge cases properly
• At least one production dApp frontend shipped

Tooling

• Hardhat or Foundry — whichever you're faster with
• Test coverage that goes past happy paths: Mocha, Chai, or Jest
• Git, PRs, code reviews — done properly, not just going through the motions
• Deployed and verified contracts on block explorers
• TypeScript across both contracts and frontend

Good to have

• Comfortable integrating Web3 libraries into production apps
• Familiar with oracle setups — Chainlink or similar
• Know how off-chain indexing works: subgraphs, custom indexers
• Can read on-chain data and reason about what a contract is actually doing