Integration and Bridge Documentation
Connect SmartChain to your applications, exchanges, and other blockchains.
SmartChain is built for interoperability. This Integration and Bridge Documentation explains how to connect your products to SmartChain, how to use its RPC and SDKs, and how to move value securely between SmartChain and other networks.
On this page:
Environments · APIs · Transactions · Contracts & Events · Bridge · Testing · Monitoring · Compliance
SmartChain
RVA Network
Ethereum
Other Chains
Who this documentation is for
If your product needs to talk to SmartChain or move assets across chains, this page is your reference.
dApp & protocol developers
Developers building directly on SmartChain, creating DeFi protocols and decentralized applications.
Exchanges & custodians
Centralised and decentralised exchanges listing SmartChain tokens and managing custody solutions.
Wallets & UX teams
Wallet teams and custodians integrating SmartChain assets and transactions into user interfaces.
Data & analytics providers
Providers indexing SmartChain blocks, events, and balances for analytics and reporting.
Environments and prerequisites
Before integrating, choose the right environment and confirm the basics.
Networks and endpoints
Testnet
Safe environment for development and QA, mirroring mainnet features with test assets.
Base RPC URL: https://testnet-rpc.rva.ltd
WebSocket: wss://testnet-rpc.rva.ltd/ws
Chain ID: rva-smartchain-testnet-1
Faucet: https://faucet.rva.ltd/testnet
Mainnet
Production network with real value and strict reliability expectations.
Base RPC URL: https://rpc.rva.ltd
WebSocket: wss://rpc.rva.ltd/ws
Chain ID: rva-smartchain-1
Prerequisites
- •Familiarity with public key cryptography and basic blockchain concepts
- •Ability to manage API credentials and secure signing keys
- •Access to your organisation's logging and monitoring stack
Core integration model
SmartChain exposes a simple, predictable integration surface. Integrators can choose their preferred stack, using the same underlying protocols.
RPC and API access
Standard JSON-RPC methods for accounts, balances, blocks, and transactions. Read-only calls for querying state, logs, and smart contract data. Write operations for broadcasting signed transactions. Optional high-level REST endpoints for common workflows.
SDKs and tools
While you can call the RPC directly, SDKs (such as JavaScript/TypeScript or Python libraries) simplify building and signing transactions, encoding smart contract calls, subscribing to events and logs, and handling retries and back-off automatically.
Example JSON-RPC call
{
"jsonrpc": "2.0",
"method": "eth_getBalance",
"params": ["0x...", "latest"],
"id": 1
}Building and broadcasting transactions
This section walks through the full flow from intent to finality from an integration perspective.
Construct
Define the operation (transfer, contract call, staking, or bridge interaction). Set recipient, amount, gas limit, and optional metadata.
Sign
Sign the transaction with the user's or service's private key. Use hardware wallets, secure enclaves, or dedicated signing services where possible.
Broadcast
Submit the signed transaction to a SmartChain RPC endpoint. Receive a transaction hash for tracking.
Track and confirm
Poll or subscribe to transaction status. Treat a transaction as confirmed once it reaches the documented finality depth.
Handle failures
Timeouts, rejections, or out-of-gas events are covered with clear error codes and remediation hints.
Construct
Define the operation (transfer, contract call, staking, or bridge interaction). Set recipient, amount, gas limit, and optional metadata.
Sign
Sign the transaction with the user's or service's private key. Use hardware wallets, secure enclaves, or dedicated signing services where possible.
Broadcast
Submit the signed transaction to a SmartChain RPC endpoint. Receive a transaction hash for tracking.
Track and confirm
Poll or subscribe to transaction status. Treat a transaction as confirmed once it reaches the documented finality depth.
Handle failures
Timeouts, rejections, or out-of-gas events are covered with clear error codes and remediation hints.
Smart contracts and events
For developers building dApps and protocols on SmartChain.
Deployment and verification
How to deploy contracts and verify their source. Standard ABI usage and encoding of function calls.
Event subscriptions
Subscribing to smart contract events via WebSocket or log filters. Designing events for analytics, indexing, and user notifications.
Recommended patterns
Patterns are provided for deposit contracts, upgradeable contracts, and off-chain indexing.
Example event structure
// Event emitted by contract
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
// Subscribe to events
const filter = {
address: contractAddress,
topics: [ethers.utils.id("Transfer(address,address,uint256)")]
};
provider.on(filter, (log) => {
// Handle event
});Events enable real-time indexing and analytics for your dApp or protocol.
Bridge architecture and design
SmartChain's bridge layer enables secure value transfer and message passing between chains.
Bridge flow diagram
SmartChain
Bridge contract
Relayer & Validators
External Chain
Bridge contract
High-level design
- •Lock-and-mint / burn-and-release flows for wrapped assets
- •Cross-chain messaging for instructions, not just tokens
- •Finality-aware relayers that only act once transactions are confirmed on the source chain
- •On-chain contracts on both SmartChain and external networks, managing asset custody and accounting
Security model
- •Multi-signature or validator-based attestation of cross-chain events
- •Rate limits, daily thresholds, and emergency pausing options
- •Monitoring hooks for anomalous volumes or patterns
The documentation explains how the bridge validates proofs, how messages are sequenced, and how failures are handled.
Integrating the bridge into your product
Different products use the bridge in different ways. Each pattern includes recommended user messaging for pending, successful, and failed bridge operations.
Exchange & custodian flows
Mapping deposit addresses and memos to internal accounts. Monitoring bridge events to confirm deposits and releases. Reconciling balances between SmartChain and external networks.
dApp & protocol flows
Using bridge contracts to move tokens into SmartChain-native liquidity pools. Triggering cross-chain operations from smart contracts or backend services. Designing UX flows that reflect confirmation and finality clearly for users.
Wallet UX flows
Exposing bridge functionality as a first-class flow in the wallet UI. Guiding users through source chain selection, target asset, fees, and estimated time to completion.
User-friendly flow tips
- ✓Show pending state while transaction is in progress
- ✓Display confirmation once finality is reached
- ✓Provide clear error messages for failed operations
- ✓Estimate and display completion time
Events, webhooks, and real-time updates
Timely information is critical for a good integration.
Subscription mechanisms
Subscription mechanisms for new blocks, pending transactions, and contract events. Suggestions for implementing your own webhook layer on top of SmartChain streams.
Reliability strategies
Strategies for deduplication, idempotency, and re-delivery in case of outages. This enables real-time balance updates, deposit notifications, and alerting in your own systems.
Event pipeline
SmartChain
Event source
Event Stream
WebSocket / RPC
Your Webhook/API
Integration endpoint
Testing, monitoring, and compliance
Testing & migration
- •Using testnet to validate transaction flows, bridge operations, and smart contract logic
- •Sample test cases for deposits, withdrawals, failed transactions, and unusual states
Migration checklist
- ✓ Endpoints configured
- ✓ Keys secured
- ✓ Fee settings verified
- ✓ Monitoring enabled
- ✓ Runbooks documented
Monitoring & resilience
- •Common RPC and bridge error codes with recommended responses
- •Retry strategies and back-off policies for safe re-submission
- •Monitoring metrics for call latency, error rates, bridge volumes, and confirmation times
- •Alerting suggestions for stuck transactions, delayed bridge messages, or provider outages
Well-behaved integrations are resilient to transient network or infrastructure issues.
Compliance & audit
For regulated institutions and security-sensitive teams:
- •Guidance on logging and retaining transaction and bridge data
- •Reconciliation between on-chain balances, wrapped assets, and internal ledgers
- •High-level overview of audit trails for key operations, configuration changes, and bridge events
Quick reference and support
This section provides a navigation hub to key topics on this page.
Quick reference
Support
If you need more detail, refer to the relevant sections above and align the guidance with your own security and reliability policies.
Integrations and bridges are long-lived systems. Use this documentation as your baseline, then extend it with your own internal standards for security, observability, and compliance.