Abubakar — back to top

Exchanges & L1 forks — Islamabad

Muhammad Abubakar

Blockchain Engineer, Blockchain Backend Lead, Bitcoin Core Developer, Smart Contract Developer, Backend Engineer

I build the systems that let a business take payments in crypto and know, for certain, that the money arrived. It’s hard because every blockchain works differently — and none of them ever tells you “done”.

Bitcoin Core forks · EVM · TRON — Node.js, TypeScript, Solidity, C++

About

Behind the interface

I build the infrastructure behind the interface

Most of what I build is invisible when it works: the code that takes a crypto payment, checks it really landed, moves money out of a wallet safely and tells the rest of the product what happened — on blockchains I often run myself.

In engineering termsBackend systems for blockchain products — payment rails, wallet services, node infrastructure and chain integrations — plus the APIs and WebhookA message one system sends another the moment something happens — here, “this payment just settled”. that connect them to everything else. Correct first, then fast.

Focus areas

  1. Blockchain

    Connecting a product to the blockchains its customers actually use, so it can see money arrive and send it out.

    Technical detail

    Integrations across Bitcoin, Ethereum, BSC, Base, Polygon and TRON: reading blocks, tracking transactions through ConfirmationsHow many blocks have been added on top of the one holding a transaction. The more there are, the less likely it is to be undone., settling payments.

  2. Backend systems

    The servers and APIs an app talks to, built so a glitch never charges or pays anyone twice.

    Technical detail

    Node.js and TypeScript services, REST APIs, and WebhookA message one system sends another the moment something happens — here, “this payment just settled”. that are signed, retried and IdempotentDoing something twice has the same effect as doing it once. If a payment notice arrives twice, the customer is still credited once..

  3. Smart contracts

    Programs that live on the blockchain and enforce the rules of a deal without a middleman.

    Technical detail

    Solidity on EVMEthereum Virtual Machine — the engine shared by Ethereum and compatible networks like BSC, Base and Polygon. One integration can serve all of them. networks, and the backend code that reads, writes and reconciles contract state.

  4. Web3 infrastructure

    Running the blockchain itself — including new networks forked from Bitcoin — not just renting access to someone else’s.

    Technical detail

    Bitcoin Core v22 and post-v29 forks in production: chainparams and genesis design, Seed nodeA well-known node that new nodes contact first to discover the rest of the network. and DNS seeders, cross-platform builds, systemd-managed full nodes, a live chain split diagnosed and resolved.

  5. System architecture

    Designing for the day something goes wrong — on a blockchain it will — so nothing is lost and nothing counts twice.

    Technical detail

    Explicit state machines, events that can arrive twice, and failure handled as a normal code path.

How I work

  1. Assume everything arrives twice

    Networks retry. A payment notice can show up twice; it should only ever count once.

    Webhooks retry, RPC calls time out, blocks ReorgThe blockchain briefly disagrees with itself and replaces its most recent blocks. A payment that looked confirmed can vanish, so you wait a few blocks before trusting it.. IdempotentDoing something twice has the same effect as doing it once. If a payment notice arrives twice, the customer is still credited once. is designed in.

  2. State you can point at

    At any moment you can ask where a payment is, and why — and get a straight answer.

    Every payment, transaction and job has an explicit state and a recorded reason for it.

  3. Failure is a code path

    Things will go wrong. What happens next is decided in advance, not improvised.

    Timeouts, stuck NonceA running counter on every transaction an account sends. They must go out in order, so one stuck number blocks everything queued behind it. and dropped transactions are designed like features.

  4. Boring where it counts

    The payment system should be the least exciting part of your product.

    Interesting problems, unremarkable infrastructure. The rail should be the quiet part.

Selected work

06 case studies

Systems that run under the product

Live products and the systems under them. Each one says what it is in plain words first; the problem, what I built and the result follow.

01 / 06Crypto investment platform

SILPRE

Delivered at MicroSlush

Backend Blockchain Developer · Feb 2026 – present

A crypto investment platform: people deposit crypto, earn returns on a fixed-term plan and withdraw. I built the blockchain and backend layer that moves the money.

Visit user.silpre.net(opens in new tab)Full case study

active investment pool, reached within three months of launch
$600,000+
active investment pool, reached within three months of launch
paid out in investor returns
$340,000+
paid out in investor returns
processed in user withdrawals
$40,000+
processed in user withdrawals
The problem
Every deposit, return and withdrawal is real money on three blockchains, in five assets, often at the same moment. Two payouts racing each other, or a rounding slip between assets, is someone’s balance going wrong.
The result
Live in production, with settlement running automatically: returns and withdrawals paid on-chain.

Interface

Web platform

Mobile app

What I built
  • Multi-asset deposit and withdrawal services for USDS, USDT, USDC, BNB and ETH across BSC, Ethereum and TRON, with live CoinGecko price feeds for conversion.
  • Withdrawal and swap services on Firebase Cloud Functions with ethers.js and TronWeb.
  • ROI plan engines — 100-day, 12-month and group — with accrual, cancellation and payout scheduling.
  • Firestore transactions keep balance updates atomic under concurrent payouts.
  • A centralised admin-wallet pattern with per-asset decimal precision (6 for USDT/USDC, 18 for native tokens) to prevent rounding loss.
  • Admin APIs for users, roles, KYC verification, deposits, withdrawals and investment requests.
  • Node.js
  • TypeScript
  • Express.js
  • Firebase Cloud Functions
  • Firestore
  • ethers.js
  • TronWeb
  • BEP20 / ERC20 / TRC20
Fig. 01 — SILPRE — money in across the top, investors and admins below (simplified)Architecture
Fig. 01 — SILPRE — money in across the top, investors and admins below (simplified)Deposits in → Deposit service; Deposit service → Balances; Balances → ROI engine; ROI engine → Admin wallet; Admin wallet returns to Payouts out; Investor → Platform API; Platform API → Balances; Price feed → Balances; Admin APIs → ROI engineDEPOSITS INBSC · ETH · TRONDEPOSIT SERVICEethers.js · TronWebBALANCESFirestore txnsROI ENGINEaccrual · payoutsADMIN WALLETper-asset decimalsINVESTORweb appPLATFORM APIExpress · FunctionsPRICE FEEDCoinGeckoADMIN APISKYC · requestsPAYOUTS OUTBSC · ETH · TRON

02 / 06Centralized crypto exchange

SWAP21

Delivered at OVEX Technologies

Blockchain Backend Lead · Jul 2025 – present

A crypto exchange that runs on its own Bitcoin-based blockchain — its own nodes, block explorer and custodial wallets. I lead the team that builds and runs that layer.

Visit swap21.com(opens in new tab)Full case study

The problem
An exchange on its own chain has no provider to fall back on. Every deposit has to be noticed, every withdrawal signed, and every node kept in agreement — by the team, around the clock.
The result
A live exchange on a chain the team operates itself — including bringing it back from a consensus split.

Interface

Exchange

What I built
  • The blockchain layer end to end: wallet generation, deposit detection, transaction flow and withdrawal signing against the fork’s nodes.
  • The network’s block explorer, and a customised Bitcoin Core Qt wallet for transaction tracking and wallet management.
  • Full nodes across several Ubuntu servers, converted to systemd units with peer-maintenance scripts and timers for unattended recovery.
  • Deposit-monitoring workers, and PostgreSQL connection exhaustion eliminated under sustained load.
  • Mining and consensus parameters tuned for faster confirmations.
  • Bitcoin Core (C++)
  • Python
  • Django
  • Celery
  • PostgreSQL
  • Redis
  • Ubuntu
  • systemd
  • Nginx
Fig. 02 — SWAP21 — withdrawals across the top, deposits return below (simplified)Architecture
Fig. 02 — SWAP21 — withdrawals across the top, deposits return below (simplified)Trader → Exchange API; Exchange API → PostgreSQL; PostgreSQL → Signer; Signer → Fork nodes; Fork nodes → Node network; Node network returns to Deposit workers; Deposit workers returns to PostgreSQL; Exchange API → Deposit walletsTRADERexchangeEXCHANGE APIDjango · CeleryPOSTGRESQLbalancesSIGNERcustodial withdrawalsFORK NODESBitcoin Core forkDEPOSIT WALLETSaddress generationDEPOSIT WORKERSdetect · confirmNODE NETWORKsystemd · timers

03 / 06Production incident

The live chain split

Delivered at OVEX Technologies

Blockchain Backend Lead · Jul 2025 – present

The exchange’s blockchain split in two: part of the network followed one history, part followed another. Until it was resolved, nobody could say which deposits were real or which balances to trust. I diagnosed the split and brought every exchange node back onto one chain.

The result
Consensus restored across the exchange nodes.This is what separates someone who has run a chain in production from someone who has read about one.
Fig. 03 — One history becomes two, then one again — illustrative, not a trace of the incidentConcept
What a chain split looks likeThree blocks of shared history, then the chain forks into two competing histories, A and B. After the split is resolved, every node follows history A, which keeps growing, and history B is dropped.SHARED HISTORYHISTORY AONE CHAIN AGAINHISTORY B · DROPPED

04 / 06Custom blockchain networks

Bitcoin & EVM L1 forks

New blockchains built from Bitcoin’s and Ethereum’s code — designed from the first block, built for every major operating system, and run as real networks.

The problem
A fork is more than a renamed binary. It needs its own rules from block zero, nodes that can find each other, isolation from the network it was copied from, and builds that come out the same every time.
The result
Networks that start from a designed first block, find their peers, stay isolated from Bitcoin mainnet, and build the same way on every platform.
What I built
  • BTC1: a Bitcoin Core v22–derived network powering live custodial exchange backends.
  • Genesis block, premine window and emission schedule on a post-v29 Bitcoin Core (CMake) base, keeping a 21M supply cap on Bitcoin’s halving curve.
  • chainparams and consensus configuration, with full isolation from Bitcoin mainnet through custom magic bytes, P2P ports and removal of upstream DNS seeds.
  • A DNS seeder on AWS EC2 with Route 53, and peer discovery hardened with chainparams-level Seed nodeA well-known node that new nodes contact first to discover the rest of the network. literals after an upstream seed outage.
  • Reproducible Docker builds, plus cross-platform node and Qt wallet builds for Linux/WSL2, Windows (MinGW via depends) and macOS (Homebrew Qt 5.15).
  • An EVM L1 (chainId 5356) on Geth v1.10.26 proof-of-work, with Uniswap V3 contracts deployed for on-chain liquidity.
  • Bitcoin Core (C++)
  • CMake
  • MinGW
  • Qt
  • Docker
  • AWS EC2
  • Route 53
  • Geth
  • Uniswap V3
Fig. 04 — A block propagating across peers, build pipeline below

05 / 06Wallet services

EVM wallet infrastructure

Wallets a product controls from code — create addresses, send funds, track every transfer — across four networks, without ever exposing the keys.

The problem
Products need to create addresses, move funds and know what happened on several EVM chains, without leaking keys or losing track of NonceA running counter on every transaction an account sends. They must go out in order, so one stuck number blocks everything queued behind it. when transactions stall.
The result
One wallet interface across Ethereum, BSC, Base and Polygon, so adding a network is configuration rather than a new code path.
What I built
  • A wallet API accepts intents; a builder prices GasThe fee paid to an EVM network to process a transaction. It rises and falls with demand. and assigns nonces per chain.
  • Per-address nonce queues, so concurrent sends never collide.
  • Keys derive from HD walletOne master secret that can derive any number of addresses, so every customer gets their own deposit address without storing a separate key for each., and signing happens in an isolated signer, apart from request handling.
  • Ethers.js providers per network with fallback RPC endpoints; a broadcaster submits and a tracker follows receipts to FinalityThe point after which a transaction can no longer realistically be reversed..
  • ethers.js
  • Node.js
  • TypeScript
  • Ethereum
  • BSC
  • Base
  • Polygon
Fig. 05 — Per-chain nonce queues through an isolated signer

06 / 06Property tokenization

Web3 real estate marketplace

Delivered at OVEX Technologies

Blockchain Backend Lead · Jul 2025 – present

A property marketplace where who-owns-what is recorded on a blockchain anyone can check, while browsing stays as fast as any ordinary website.

The problem
Listings and ownership records usually live in separate systems, so buyers can’t check the state of what they’re buying. Putting everything on-chain makes search and media slow and expensive.
The result
Listings whose sale state can be checked on-chain, with browsing that feels like any other web app.
What I built
  • Real-estate tokenization contracts in Solidity with Hardhat: listing and transfer state live on-chain, with property purchases signed through MetaMask.
  • Contracts emit an event for every state change; an indexer replays those events into Firestore, so search and media stay fast and the off-chain view can always be rebuilt from the chain.
  • Solidity
  • Hardhat
  • ethers.js
  • MetaMask
  • Next.js
  • React
  • Firestore
Fig. 06 — Contract events replayed into the off-chain index

Research

06 articles · Medium

Notes from the protocol layer

What I learn running Bitcoin forks and exchange backends, written up so the next engineer doesn’t lose a week to the same problem.

  1. Governance

    DAO (Decentralized Autonomous Authority)(opens on Medium in a new tab)

    How an organisation can be run by code and token votes instead of a central authority — and where that breaks down.

    Smart contracts · Token voting · Security risks · Voting costs

  2. Bitcoin forks

    Cross-Compiling Bitcoin Core for Windows: Solving Common Build Errors for Bitcoin v22(opens on Medium in a new tab)

    How to build a Windows wallet for a Bitcoin v22 fork from Linux, and fix the three errors that stop the build.

    Qt wallet · Filesystem API · UPnP · secp256k1

    Evidence forBitcoin & EVM L1 forks

  3. Bitcoin forks

    Solving the “Minimum Chain Work” Sync Issue in Bitcoin Forks(opens on Medium in a new tab)

    Why nodes on a new Bitcoin fork refuse to download blocks from each other — and the one setting that fixes it.

    nMinimumChainWork · chainparams · Peer sync

    Evidence forBitcoin & EVM L1 forks

  4. Scaling

    Bitcoin Lightning Network(opens on Medium in a new tab)

    How Lightning makes Bitcoin payments fast and cheap by settling most of them away from the main chain.

    Payment channels · Multi-hop routing · HTLCs · Liquidity

  5. Ethereum

    Ethereum Transaction LifeCycle(opens on Medium in a new tab)

    What happens between signing an Ethereum transaction and it becoming final — and how its fee is actually worked out.

    Validators · Finality · Gas · EIP-1559

    Evidence forSILPREEVM wallet infrastructure

  6. Bitcoin

    Bitcoin Transaction Life Cycle(opens on Medium in a new tab)

    Everything between pressing Send and a Bitcoin payment being settled — including what to do when one gets stuck.

    Fees · Confirmations · RBF · CPFP

    Evidence forSWAP21

All writing on Medium(opens in new tab)

Experience

Jul 2024 – Present

Each role closer to the chain

From product software, to the backend of a live investment platform, to leading the blockchain team behind an exchange.

  1. Present1 yr 4 mo

    OVEX Technologies

    Blockchain Backend Lead

    Islamabad · On-site · Promoted from Blockchain Developer

    Lead the blockchain team for OVEX’s exchange products, built on in-house Bitcoin and EVM L1 forks — from node architecture to the wallets that hold customer funds.

    Technical detail
    • Own node architecture, wallet design and release standards for custodial and non-custodial exchange products.
    • Set technical direction for deposit detection, withdrawal signing and UTXOBitcoin doesn’t keep account balances. It tracks unspent pieces of earlier payments, like individual coins in a wallet, and every payment spends some of them. management across multi-server node deployments.
    • Review exchange backend services and C++ Bitcoin Core node changes before they reach production.
    • Mentor developers on Bitcoin protocol internals, chainparams and consensus configuration, EVM contract patterns and custodial key handling.

    Case studiesSWAP21The live chain splitBitcoin & EVM L1 forksWeb3 real estate marketplace

    Team lead · Exchange infrastructure · Bitcoin Core forks

    • Bitcoin Core (C++)
    • Python
    • Django
    • Celery
    • PostgreSQL
    • Redis
    • Solidity
    • Hardhat
  2. Present9 moConcurrent contract

    MicroSlush

    Backend Blockchain Developer

    Remote · Netherlands

    Built the blockchain and backend layer of SILPRE, a crypto investment platform — deposits, settlement and withdrawals across BSC, Ethereum and TRON.

    Technical detail
    • Owned the multi-chain withdrawal and swap services, the investment and settlement backend, and the admin platform APIs.
    • Built for concurrent payouts and multi-asset precision: atomic balance updates and per-asset decimals.

    Case studiesSILPRE

    Settlement · Multi-chain withdrawals & swaps · Admin APIs

    • Node.js
    • TypeScript
    • Express.js
    • Firebase Cloud Functions
    • Firestore
    • ethers.js
    • TronWeb
  3. 2 mo

    Forhopps Inc

    Software Developer

    Remote

    Built a SaaS platform on the MERN stack, including a customised rich-text editor.

    Feature delivery · Full-stack

    • MongoDB
    • Express
    • React
    • Node.js
    • TipTap

Skills

4 groups · 30 tools · 54 links

The stack is a graph

The tools I work with, from the screen a customer sees down to the blockchain itself.

Every tool here earns its place by connecting to another. Select one to trace what it works with.

L3 · Frontend

L2–L1 · Backend

L1 · Infrastructure

L0 · Blockchain

Contact

Islamabad · UTC+5

Let’s build the part that has to work

Tell me what you’re building. A sentence or two is enough to start — or skip the writing and book a call.

Send a message

Message sent — thank you. I’ll reply by email.

Your message could not be sent. Please email abubakarrashraf20@gmail.com directly.

What’s this about?

What you’re building, and where you’d like help. A few sentences is plenty.

Goes straight to my inbox.