Preface

This book documents the entire TXCL ecosystem: a public EVM-compatible blockchain, a 2-way cross-chain bridge to BNB Smart Chain, a native automated market-maker DEX, and a self-custody web wallet — all built and deployed by the TradeXcele team.

It is structured as five parts:

• Part I — Foundations: What TXCL is and why it exists.
• Part II — User Guide: How regular users interact with everything.
• Part III — Builder Guide: How developers integrate, deploy contracts, and build dApps.
• Part IV — Operations: Running, monitoring, securing the production stack.
• Part V — Build History: The 6-phase rollout that produced the current system.

How to read this book: Skip to whichever chapter matches your role. Users can read Parts I & II. Devs add Part III. Ops/admins add Part IV. The reference at the back has every link, address, and command in one place.

What Is TXCL?

Overview

TXCL Chain is a public EVM-compatible blockchain operated by TradeXcele. It runs Ethereum-compatible smart contracts, has a native gas coin (TXCL), and is freely accessible to any wallet that supports custom EVM chains (MetaMask, Trust Wallet, Rabby, Coinbase Wallet, OKX Wallet).

It exists alongside — and is bridged to — the existing TXC token on BNB Smart Chain.

The Three Tokens

TXCL involves three distinct assets, each with a clear purpose. Understanding the difference is critical.

Why It Exists

• Brand & identity — "Powered by TXCL Chain" is a much stronger story than "BEP-20 token on BSC."
• Fast, cheap transactions — 5s blocks, near-zero gas costs. Great for high-frequency utility (airdrops, claims).
• Sovereign decisions — TradeXcele controls block production and chain rules.
• Cross-chain liquidity — wTXC on TXCL stays 1:1 backed by TXC locked on BSC, so the bridge keeps the asset price unified.

Honest caveat: TXCL Chain is currently a single-validator PoA chain. This means it is not censorship-resistant the way decentralized L1s are. The decentralization roadmap in the public chain page acknowledges this and lays out phased validator expansion.

Architecture

System Diagram

┌────────────────────────────────────────────────────────────────────┐
│  Single VPS · 72.61.118.50 · Ubuntu 24.04                          │
│                                                                    │
│   ┌──────────┐     ┌─────────────┐      ┌──────────────────┐      │
│   │  geth    │     │  nginx +    │      │  PHP-FPM 8.2     │      │
│   │ Clique   │◄───►│  Lua method │◄────►│  Web UIs +       │      │
│   │ ChainId  │     │  allowlist  │      │  Block indexer + │      │
│   │  47294   │     │  TLS 443    │      │  Bridge APIs     │      │
│   └──────────┘     └─────────────┘      └──────────────────┘      │
│        ▲                  ▲                       │                │
│        │                  │                       ▼                │
│   ┌────┴──────────────────┴────┐         ┌──────────────┐          │
│   │  Bridge Relayer (Node.js)  │◄───────►│  MariaDB +   │          │
│   │  watches BSC + TXCL        │         │  file state  │          │
│   │  signs vouchers            │         └──────────────┘          │
│   └────────────────────────────┘                                   │
│                  ▲                                                 │
└──────────────────┼─────────────────────────────────────────────────┘
                   │ HTTPS
       ┌───────────┴────────────┐
       │  BSC Mainnet           │
       │  TXC token             │
       │  TXCBridge.sol         │
       └────────────────────────┘

Components

Data Flows

BSC → TXCL Bridge

1. User → TXCBridge.depositToTXCL(amount)     [BSC tx, signed by user]
2. Event DepositToTXCL emitted
3. Relayer picks up event after 3 BSC confirmations
4. Relayer → TXCLBridge.mintFromBSC(user, amount, bscTxHash)  [TXCL tx]
5. wTXC.mint(user, amount) called by bridge
6. User holds wTXC on TXCL

TXCL → BSC Bridge

1. User → TXCLBridge.bridgeBackToBSC(amount)  [TXCL tx, signed by user]
2. wTXC burned, BridgeBackToBSC event emitted
3. Relayer picks up event after 2 TXCL confirmations
4. Relayer signs voucher: keccak256(user, amount, txclTxHash, bridgeAddr, chainId)
5. User reads voucher from /bridge/api/voucher.php
6. User → TXCBridge.withdrawFromTXCL(user, amt, hash, sig)  [BSC tx, signed by user]
7. Bridge verifies relayer sig, transfers TXC to user

Getting Started

Add TXCL Chain to Your Wallet

The easiest path: visit tradexcele.cloud/add/ and click "Add TXCL Chain to Wallet". Your wallet will prompt to add the network.

Manual setup if needed:

Network Name:    TXCL Chain
RPC URL:         https://tradexcele.cloud/rpc/
Chain ID:        47294
Currency Symbol: TXCL
Block Explorer:  https://tradexcele.cloud/chain

After switching networks, your wallet shows a 0 TXCL balance. That's normal — you need gas before you can do anything.

Get TXCL Gas

Two ways:

1. Faucet — Visit tradexcele.cloud/chain/faucet/, paste your address, claim free TXCL (rate-limited).
2. Airdrop — If you're a TradeXcele user, claim ~155 TXCL from the airdrop portal at tradexcele.cloud/airdrop/.

Buy TXC on PancakeSwap

TXC is a BEP-20 token on BSC. Buy with BNB on PancakeSwap:

https://pancakeswap.finance/swap?outputCurrency=0x6F029555A065Ac3334aA6aDb9957efe0bA460E8F

Then use the bridge (Chapter 4) to move it to TXCL Chain as wTXC.

Using the Bridge

The bridge is a 2-way conversion between BSC TXC and TXCL Chain wTXC.

BSC → TXCL (Lock & Mint)

1. Visit tradexcele.cloud/bridge/
2. Connect MetaMask (must hold TXC on BSC)
3. Direction tab: BSC → TXCL
4. Enter amount (min 1 TXC, fee 0.1 TXC)
5. Click Bridge → MetaMask prompts Approve (one-time per wallet)
6. Then prompts the actual Lock transaction
7. Wait ~30 seconds — relayer auto-mints wTXC on TXCL

TXCL → BSC (Burn & Claim)

1. Visit tradexcele.cloud/bridge/
2. Direction tab: TXCL → BSC
3. Connect MetaMask, switch to TXCL Chain
4. Enter amount of wTXC to bridge back
5. Approve wTXC spending (one-time), then sign the burn tx
6. Wait ~16 seconds for the relayer's voucher to appear
7. Click Claim on BSC — MetaMask switches to BSC, you sign the withdrawal
8. TXC arrives in your BSC wallet

Always leave a small amount of native gas in each wallet. You need TXCL gas to burn wTXC, and BNB gas to claim on BSC.

Using the DEX (Swap)

The TXCLSwap AMM at tradexcele.cloud/swap/ trades TXCL native ↔ wTXC directly on TXCL Chain (no bridge needed).

Swap workflow

1. Visit /swap/
2. Connect wallet (auto-switches to TXCL Chain)
3. Enter "You Pay" amount
4. The "You Receive" updates automatically based on pool reserves
5. Click Swap → MetaMask signs once (or twice if approving wTXC)

Add liquidity (LP)

Liquidity providers earn 0.30% of every trade. To add LP, send addLiquidity(maxToken) to TXCLSwap with msg.value = nativeAmount.

Using the Wallet

The TXCL Wallet at tradexcele.cloud/wallet/ is a self-custody web wallet (PWA-installable). Keys never leave your browser.

Create wallet

1. Visit /wallet/
2. Click Create New Wallet
3. Set strong password (min 6 chars; longer is better)
4. Save the 12-word seed phrase OFFLINE on paper
5. Click "I've Saved It" — wallet opens

Key features

• Multi-account — Tap account pill → "+ Add" creates HD-derived sub-account
• Custom token import — Tokens section → "+ Add" → paste contract address
• Network switching — Tap network pill (TXCL ↔ BSC)
• Send/Receive — Native + ERC-20 transfers, with QR codes
• PWA install — Add to home screen for app-like experience

Security

Network Reference

TXCL Chain

BNB Smart Chain (for cross-chain)

Smart Contracts

wTXC (Wrapped TXC)

Standard ERC-20 with onlyBridge mint/burn. Lives on TXCL Chain.

TXCBridge (BSC side)

function depositToTXCL(uint256 amount) external;
function withdrawFromTXCL(
    address user,
    uint256 amount,
    bytes32 txclTxHash,
    bytes signature
) external;

TXCLBridge (TXCL side)

function mintFromBSC(address user, uint256 amount, bytes32 bscTxHash) external; // onlyRelayer
function bridgeBackToBSC(uint256 amount) external; // user-callable

TXCLSwap (AMM)

function addLiquidity(uint256 maxToken) external payable returns (uint256 lpMinted);
function removeLiquidity(uint256 lpAmount) external returns (uint256 nativeOut, uint256 tokenOut);
function swapNativeToToken(uint256 minTokenOut) external payable returns (uint256);
function swapTokenToNative(uint256 tokenIn, uint256 minNativeOut) external returns (uint256);
function quoteNativeToToken(uint256 nativeIn) external view returns (uint256);
function quoteTokenToNative(uint256 tokenIn) external view returns (uint256);

Build Your Own dApp

Connect to TXCL via ethers.js

import { ethers } from "ethers";

const TXCL = {
  chainId: 47294,
  rpc: "https://tradexcele.cloud/rpc/",
};

// Read-only
const provider = new ethers.JsonRpcProvider(TXCL.rpc);
const block = await provider.getBlockNumber();

// User signing (browser, with MetaMask)
const browserProvider = new ethers.BrowserProvider(window.ethereum);
const signer = await browserProvider.getSigner();

Add network programmatically

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [{
    chainId: '0xb8be',
    chainName: 'TXCL Chain',
    nativeCurrency: { name: 'TXCL', symbol: 'TXCL', decimals: 18 },
    rpcUrls: ['https://tradexcele.cloud/rpc/'],
    blockExplorerUrls: ['https://tradexcele.cloud/chain']
  }]
});

Deploy your own contract

// Compile with solc 0.8.20, evmVersion: 'paris'
// Deploy via Remix → Injected Provider → connect to TXCL Chain
// Or via Hardhat:

module.exports = {
  solidity: { version: "0.8.20", settings: { evmVersion: "paris" } },
  networks: {
    txcl: {
      url: "https://tradexcele.cloud/rpc/",
      accounts: [process.env.PRIVATE_KEY],
      chainId: 47294,
    }
  }
};

Important: TXCL Chain runs Geth without the PUSH0 opcode (Shanghai). Always compile with evmVersion: "paris" to avoid "invalid opcode: PUSH0" errors.

APIs & RPC

Public JSON-RPC

POST https://tradexcele.cloud/rpc/
Content-Type: application/json

{ "jsonrpc": "2.0", "method": "eth_chainId", "params": [], "id": 1 }
→ { "jsonrpc": "2.0", "id": 1, "result": "0xb8be" }

Allowed methods: eth_*, net_*, web3_* (excluding eth_sign*, eth_accounts, eth_sendTransaction).

Rate limit: 20 req/sec per IP at nginx, 30 req/sec at PHP layer.

Bridge APIs

Explorer APIs

Server Layout

/var/lib/geth/data/                       chain database
/var/lib/geth/treasury_keystore/          70M TXCL wallet
/var/lib/geth/airdrop_keystore/           30M TXCL wallet
/var/lib/geth/relayer_keystore/           bridge relayer wallet
/etc/geth/genesis.json                    chain config
/etc/geth/keystore.pwd                    validator passphrase
/etc/geth/relayer_priv.txt                relayer privkey (mode 600)

/home/tradexcelses/bridge/contracts/      Solidity source
/home/tradexcelses/bridge/relayer/        Node.js relayer
/home/tradexcelses/bridge/relayer/state/  state files (last_block, vouchers)
/home/tradexcelses/bridge/relayer/.env    relayer config (mode 600)
/home/tradexcelses/bridge/deployment-*    deployment manifests

/home/tradexcelses/tradexcele.cloud/      web root
  ├── add/         add to MetaMask
  ├── airdrop/     airdrop claim
  ├── bridge/      bridge UI + API
  ├── chain/       block explorer
  ├── deploy/      one-click BSC deploy (used)
  ├── relayer-update/  relayer migration tool (used)
  ├── rpc/         hardened JSON-RPC proxy
  ├── swap/        DEX UI
  ├── wallet/      self-custody wallet (PWA)
  └── index.php

/etc/systemd/system/geth.service          chain auto-start
/etc/systemd/system/txcl-bridge-relayer.service  relayer auto-start
/var/log/txcl-bridge-relayer.log          relayer log

Running Services

Common ops commands

# Check chain
systemctl status geth
journalctl -fu geth

# Restart relayer (after .env changes)
systemctl restart txcl-bridge-relayer
tail -f /var/log/txcl-bridge-relayer.log

# Check relayer state
ls /home/tradexcelses/bridge/relayer/state/vouchers/
cat /home/tradexcelses/bridge/relayer/state/deposits.log
cat /home/tradexcelses/bridge/relayer/state/withdrawals.log

Security

Defense layers

Threat model

• VPS compromise: Attacker can read relayer key → forge bridge messages → max damage limited by TXC pool size + locked LP
• Relayer key theft: Bridge owner can call setRelayer(newAddr) to invalidate stolen key
• Validator key theft: Catastrophic — attacker can rewrite chain state. Mitigation: keystore mode 600, key never copied off VPS
• RPC DoS: Rate-limited at nginx + PHP. Cloudflare-fronting recommended for stage 2

Monitoring & Backups

Daily health checks

# Block height advancing?
curl -sX POST https://tradexcele.cloud/rpc/ -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Relayer alive?
systemctl is-active txcl-bridge-relayer

# Disk space?
df -h /var/lib/geth/data

# Relayer balance?
curl -sX POST https://bsc.publicnode.com/ -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0xd6251a24AC7D2519AFE6276F77cD09afFe1BD958","latest"],"id":1}'

Backup strategy

• Validator key: Backup /var/lib/geth/data/keystore/ + passphrase OFFLINE on encrypted hardware
• Treasury / airdrop / relayer keystores: Same — offline encrypted backup
• Chain data: Daily snapshots of /var/lib/geth/data/ to /var/backups/geth/
• Web files: Existing TradeXcele backup process covers /home/tradexcelses/
• Database: mysqldump nightly

Build History

This section documents how the system was actually deployed, in order. Useful for reproducing or extending.

The 6 Phases

Phase 0 — Chain Bootstrap (Day 1)

• Install Geth 1.14.x
• Generate genesis with chainId 47294, allocations
• Generate signer + treasury + airdrop + faucet wallets
• geth init genesis.json
• systemd unit, start node

Phase 1 — TXCL Contracts (Day 2)

• Solc 0.8.20 with evmVersion: paris
• Deploy wTXC, then TXCLBridge with constructor (wTXC, relayer)
• Wire wTXC.setBridge(TXCLBridge)
• Deploy TXCLSwap with constructor (wTXC)

Phase 2 — BSC Contract (Day 2)

• Deploy TXCBridge on BSC via Remix or one-click /deploy/
• Constructor: (TXC_TOKEN, RELAYER)
• Verify on BSCScan

Phase 3 — Relayer Migration (Day 2)

• Generate fresh VPS-only relayer wallet (key never leaves server)
• Update TXCLBridge.relayer (free, on TXCL)
• Update TXCBridge.relayer (BSC tx, ~$0.10 gas)
• Fund new relayer with 0.04 BNB + 5 TXCL

Phase 4 — Service Startup

• Configure .env with addresses + relayer key
• Install systemd unit
• Start service, verify "relayer check OK" in logs

Phase 5 — End-to-End Test

• User: bridge 5 TXC BSC → TXCL
• Wait 30s, verify 4.9 wTXC minted
• User: bridge wTXC back, claim TXC on BSC
• Confirm balance reconciliation

Phase 6 — User Tooling

• Self-custody wallet (PWA)
• Add-to-MetaMask landing page
• Documentation book (this page)

All Links

Public-facing

External

All Addresses

System wallets

Smart contracts

CLI Commands

SSH & service ops

ssh -i ~/.ssh/txcl_vps root@72.61.118.50

systemctl status geth
systemctl status txcl-bridge-relayer
journalctl -fu geth
tail -f /var/log/txcl-bridge-relayer.log

systemctl restart txcl-bridge-relayer
systemctl restart geth

Quick chain queries

# Block height
curl -sX POST https://tradexcele.cloud/rpc/ -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Address balance
curl -sX POST https://tradexcele.cloud/rpc/ -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0xADDR","latest"],"id":1}'

# wTXC total supply
curl -sX POST https://tradexcele.cloud/rpc/ -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_call",
       "params":[{"to":"0x485eaB9D8996A1efAD36e621D86834bb8Ab99CEF",
                  "data":"0x18160ddd"},"latest"],"id":1}'

UFW / firewall

ufw status numbered
ufw limit 22/tcp        # rate-limit ssh
ufw allow 443/tcp       # allow https

Glossary

Troubleshooting

"execution reverted (unknown custom error)" when bridging

Check your wallet's TXC balance. You can't bridge tokens you don't hold. Also check that you've approved the bridge contract to spend (one-time per wallet).

Bridge UI shows "No pool" / can't swap

The TXCLSwap pool needs to be seeded with initial liquidity by the team. Until then, swap is not functional.

"invalid opcode: PUSH0" on contract deploy

You compiled with default Shanghai EVM target. Recompile with evmVersion: "paris" for TXCL Chain.

Relayer service not running

systemctl status txcl-bridge-relayer
journalctl -u txcl-bridge-relayer -n 50

# common issues:
# - wrong RPC URL → check .env BSC_RPC
# - relayer wallet out of gas → check BNB and TXCL balances
# - private key mismatch → re-verify TXC_BRIDGE.relayer() == wallet address

Wallet shows 0 balance after refresh

Probably switched to wrong network. Tap the network pill (top right of wallet) and select TXCL.

I forgot my wallet password

The password is needed to decrypt your local seed. If forgotten, you must reset the wallet (which wipes encrypted seed) and re-import using your 12-word seed phrase. That's why the seed phrase backup is critical.

Bridge fee seems high

0.1 TXC fee is per-bridge. For frequent bridging consider batching. Fee is configurable by bridge owner.

How do I see my pending vouchers?

Go to /bridge/, switch direction to TXCL → BSC, connect wallet. Pending vouchers appear in green cards labelled "Vouchers Ready to Claim on BSC".