Solving Multi-Cryptocurrency Payment Challenges
When a business decides to accept cryptocurrencies, they often imagine a simple "Pay with BTC" button. Reality is more complex: the system must handle Bitcoin's UTXO model, EVM's account-based model with ERC-20 tokens, and Solana's SPL standard — all without losing funds. An architectural mistake can lead to lost transactions or compliance issues. Based on over 50 projects, we have developed a universal scheme covering 90% of needs. We solve the problem of multi-cryptocurrency payments by supporting Bitcoin payments, Ethereum payments, USDT TRC20 (and ERC-20), Solana USDC, and other tokens. Our custom crypto payment gateway gives full control over fees, confirmation times, and security. In a recent case, we integrated 7 networks in 10 business days with end-to-end real-time payment visibility. We use Foundry for smart contract compilation and viem for EVM network monitoring. Each integration includes confirmation settings: Bitcoin minimum 3, EVM 12 blocks, Solana finalized slot. This reduced erroneous credits to zero. Our architecture prioritizes crypto payment security through private key encryption and automatic sweeps. The typical custom integration investment is recouped within 3–6 months for businesses processing over $50,000 monthly; an average project costs between $10,000 and $30,000 depending on network count.
How Much Does a Custom Integration Cost?
Architectural Options by Transaction Volume
The choice boils down to three options. Custom integration pays back 1.5–2 times faster than a ready-made provider with monthly volumes above $50,000 — commission savings can be significant. For example, at $100,000/month, saving 0.5% means $500/month.
| Criteria | Ready Provider | Custom Integration | Hybrid Approach |
|---|---|---|---|
| Time to launch | 1–2 days | 2–4 weeks | 1–2 weeks |
| Transaction fee | 0.5–1% | 0% (only network gas) | 0% for EVM, ~0.5% for BTC |
| UX control | Limited | Full | High |
| Vendor lock-in | Yes | No | Partial |
| Payback at volume >$50k/month | Not payback | 3–6 months | 6–12 months |
With monthly volumes above $50,000, custom integration pays back in 3–6 months, saving from $1,500 in commissions compared to ready providers.
Generating Addresses for All Networks from One Seed (HD Wallet BIP44)
As per BIP-44 (BIP44), the hierarchy is: m / purpose' / coin_type' / account' / change / address_index. For each new payment, a new address is generated by incrementing address_index. One master seed — addresses for all networks. Hierarchical deterministic derivation ensures that each address is derived from the same seed using elliptic curve cryptography, maintaining security and portability.
from hdwallet import HDWallet
def derive_address(master_seed: str, coin_type: int, index: int) -> str:
wallet = HDWallet()
wallet.from_mnemonic(master_seed)
# BTC: coin_type=0, ETH: coin_type=60, SOL: coin_type=501
wallet.from_path(f"m/44'/{coin_type}'/0'/0/{index}")
return wallet.p2pkh_address() # for BTC
# wallet.address() for ETH
Address generation example
For Bitcoin use coin_type=0, for Ethereum coin_type=60, for Solana coin_type=501. Store address_index in the database and monotonically increase it. Never reuse addresses.
Important: address_index must monotonically increase and be stored in DB. Never reuse addresses — that violates privacy and complicates reconciliation.
Integration by Network
EVM Networks (Ethereum, Polygon, BSC, Arbitrum, Base)
One codebase abstracts multiple RPC endpoints leveraging chain-specific providers and transport layers. Monitor Transfer events of ERC-20 + native ETH/MATIC transfers using an asynchronous event-driven architecture.
import { createPublicClient, http, parseAbi } from 'viem';
import { mainnet, polygon, arbitrum } from 'viem/chains';
const chains = [
{ chain: mainnet, rpc: process.env.ETH_RPC, tokens: ETH_TOKENS },
{ chain: polygon, rpc: process.env.POLY_RPC, tokens: POLY_TOKENS },
{ chain: arbitrum, rpc: process.env.ARB_RPC, tokens: ARB_TOKENS },
];
// Unified handler for all EVM networks
async function watchEVMPayment(client, tokenAddress, recipientAddress, orderId) {
return client.watchContractEvent({
address: tokenAddress,
abi: ERC20_ABI,
eventName: 'Transfer',
args: { to: recipientAddress },
onLogs: (logs) => handlePayment(logs, orderId),
});
}
Bitcoin: Recommended Fulcrum Node
For Bitcoin payments, we recommend Fulcrum. Bitcoin UTXO model — no "balance", only unspent outputs. An address is considered paid when UTXOs with the required amount arrive. Integration options: Electrum Protocol (ElectrumX/Fulcrum) — blockchain.scripthash.subscribe for address change subscription; BlockCypher/Mempool.space API — without own infrastructure; Bitcoin Core + ZMQ — full node with ZeroMQ notifications. For production we recommend Fulcrum (fast SPV-compatible node) + own Bitcoin Core in pruned mode. Bitcoin confirmations: 1 confirmation (~10 minutes) for small amounts, 3+ as standard, 6 for large payments.
TRON (USDT TRC20)
TRON is a special case due to USDT TRC20 popularity in CIS and Asia. API via TronGrid (HTTP) or own node. Addresses in Base58Check format (start with T).
import tronpy
client = tronpy.Tron(network='mainnet')
def check_trc20_payment(address: str, contract: str, min_amount: int) -> list:
txns = client.get_token_trc20_transfers(
contract_address=contract,
to_address=address,
min_timestamp=int((time.time() - 3600) * 1000)
)
return [tx for tx in txns if tx['value'] >= min_amount]
Solana: USDC and SPL Tokens
According to Solana documentation (Solana Token Documentation), each token has its own Associated Token Account (ATA) for each wallet. The receiving address for USDC is not the wallet itself, but its ATA for USDC.
import { getAssociatedTokenAddress } from '@solana/spl-token';
const usdcMint = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
const paymentATA = await getAssociatedTokenAddress(usdcMint, paymentKeypair.publicKey);
Solana finality: using commitment level finalized — ~32 slots (~13 seconds).
How Do We Ensure Payment Finality?
Regardless of network, payments progress through states: pending_payment -> mempool_detected -> confirmed (N conf) -> settled. Our PostgreSQL schema tracks these states.
CREATE TABLE payment_orders (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
order_id VARCHAR(100) UNIQUE NOT NULL,
currency VARCHAR(20) NOT NULL,
network VARCHAR(20) NOT NULL,
payment_address VARCHAR(200) NOT NULL,
expected_amount NUMERIC(30, 8) NOT NULL,
received_amount NUMERIC(30, 8) DEFAULT 0,
tx_hash VARCHAR(200),
confirmations INTEGER DEFAULT 0,
required_confirmations INTEGER NOT NULL,
status VARCHAR(30) DEFAULT 'pending',
expires_at TIMESTAMPTZ NOT NULL,
created_at TIMESTAMPTZ DEFAULT NOW(),
INDEX idx_payment_address (payment_address),
INDEX idx_status_expires (status, expires_at)
);
Recommended confirmation counts:
| Network | Recommended Confirmations | Block Time |
|---|---|---|
| Bitcoin | 3-6 | ~10 minutes |
| Ethereum | 12 | ~12 seconds |
| Solana (finalized) | 1 | ~13 seconds |
| Tron | 19 | ~3 seconds |
Rates and Tolerance: Protecting Against Volatility
The user sees "Pay 0.001523 BTC" — the rate is fixed for 15–30 minutes. During that time, the rate may fluctuate by 1–2%. We need tolerance: 0.1% for stablecoins, 1% for BTC, 1.5% for ETH. For a $10,000 transaction, a 1% tolerance covers $100. Rates with minimal delay: CoinGecko API (free, 60s cache) or Binance WebSocket (real-time, for high-frequency).
Security: What We Guarantee
- Private keys never on the web server. HD wallet seed in HSM or at least in encrypted storage (AWS KMS, HashiCorp Vault).
- Sweep transactions — automatic transfer of received funds to cold wallet on schedule or threshold. For example, sweep when balance exceeds $50,000.
- Double-spend protection — for BTC and ETH, do not confirm payment based on first unconfirmed. Set required_confirmations appropriately for the amount.
- Address validation — address passes checksum validation (EIP-55 for ETH, Base58Check for BTC) before saving. Address error = loss of funds.
With a transaction value of $100, Ethereum network fee is ~$2, but with a custom gateway you control gas and can reduce it to $0.50. For 1000 transactions per month, savings amount to $1,500. Our multi-signature and threshold signature schemes can further enhance security for enterprise deployments.
Deliverables
- Architecture documentation and transaction flow diagrams.
- Source code for each network integration (EVM, Bitcoin, Tron, Solana).
- Infrastructure scripts for deploying RPC nodes or configuring providers.
- Operational and recovery instructions.
- Training for your team on using the system.
- First month of support after launch.
All deliverables are provided as source code with documentation.
Implementation Process
- Analysis (1–2 days): determine required currencies, volumes, geography (TRON popular in CIS/Asia), confirmation requirements.
- Infrastructure (2–4 days): configure RPC providers or own nodes, integrate HD wallet, design DB schema.
- Monitoring (3–4 days): develop workers for each network, confirmation logic, webhook notifications.
- Testing (1–2 days): testnet for EVM and Solana, Bitcoin testnet, edge cases (underpayment, overpayment, expired order, reorg).
Total 1–2 weeks depending on the number of networks. Contact us for an accurate timeline estimate for your project.
Our multi-network payment solution covers all major blockchains with a unified API.