Quick Start
5-minute tutorial to run an Orbinum node and perform your first transaction.
This guide assumes you've completed the Installation. If not, do it first.
1. Start Development Node
Start a local node with temporary data, exposing the RPC port:
docker run --rm -p 9944:9944 ghcr.io/orbinum/node:testnet-latest \
--dev --tmp --rpc-cors all --rpc-external --rpc-methods Unsafe
You'll see blocks being produced:
🏁 Block #1 (0x1234...)
🏁 Block #2 (0x5678...)
🏁 Block #3 (0x9abc...)
Keep this terminal open. The node must be running for the following steps.
The --rpc-cors all flag allows browser apps to connect to your local node.
Local development only.
2. Connect the App
Open the Orbinum app and point it at your local node:
- Go to app.orbinum.network
- Open the network selector and choose Development
- Confirm it connects to your local node at
ws://127.0.0.1:9944
Verification: the explorer should show blocks being produced in real time.
The --dev mode includes pre-funded accounts:
- Alice (validator)
- Bob
- Charlie
All have an initial balance of 1,000,000 ORB.
3. First Transfer (SDK)
The @orbinum/sdk TypeScript SDK is
the recommended way to talk to the chain from code. Transfer 100 ORB from Alice
to Bob against your local node.
Install the SDK and a keyring to load the dev accounts:
npm install @orbinum/sdk @polkadot/keyring
import { OrbinumClient, getPolkadotSigner, formatORB } from '@orbinum/sdk';
import { Keyring } from '@polkadot/keyring';
// 1. Connect to your local dev node
const client = await OrbinumClient.connect({ substrateWs: 'ws://127.0.0.1:9944' });
// 2. Load the //Alice dev account and build a signer
const keyring = new Keyring({ type: 'sr25519' });
const alice = keyring.addFromUri('//Alice');
const bob = keyring.addFromUri('//Bob').address;
const signer = getPolkadotSigner(alice);
// 3. Transfer 100 ORB (18 decimals). transferKeepAlive keeps the sender alive.
const amount = 100n * 10n ** 18n;
const tx = client.substrate.unsafe.tx.Balances.transferKeepAlive({
dest: bob,
value: amount,
});
const result = await tx.signAndSubmit(signer);
console.log(`Sent ${formatORB(amount)} — included in block #${result.blockNumber}`);
console.log(`ok=${result.ok} txHash=${result.txHash}`);
// 4. Clean up
client.destroy();
Result: result.ok === true and Bob's balance increases by 100 ORB. You can
confirm it in the explorer (Step 2) — the transfer appears in the latest block.
This is a public balance transfer (amounts and addresses are visible). For
private transfers through the shielded pool, the SDK exposes
client.shieldedPool.privateTransfer(...) — see
Privacy Architecture.
4. EVM Transaction (Optional)
Orbinum includes Ethereum compatibility via Frontier.
Connect MetaMask
Local development network (when running your own --dev node):
| Field | Value |
|---|---|
| Network Name | Orbinum Dev |
| RPC URL | http://127.0.0.1:9944 |
| Chain ID | 1281 |
| Currency Symbol | ORB |
Official Testnet (to connect to the live testnet instead):
| Field | Value |
|---|---|
| Network Name | Orbinum Testnet |
| RPC URL | https://rpc-1.testnet.orbinum.io |
| Chain ID | 2700 |
| Currency Symbol | ORB |
| Explorer | https://explorer.testnet.orbinum.network |
Test Transaction
Import a development account in MetaMask:
Private Key: 0x5fb92d6e98884f76de468fa3f6278f8807c48bebc13595d45af5bdc4da702133
This is Alith's private key (EVM development account). Never use development keys in production.
Send a transaction to another address from MetaMask. You should see the transaction processed instantly.
5. Explore the Chain
In the explorer
At app.orbinum.network (connected to your Development node) you can browse recent blocks and their extrinsics, inspect emitted events, and check account balances after your transfers.
Query state from the SDK
Read an account balance directly with the same client:
const account = await client.substrate.unsafe.query.System.Account.getValue(bob);
console.log(`Bob free balance: ${formatORB(account.data.free)}`);
The client.substrate.unsafe.query.* namespace exposes every storage item in the
runtime (Balances, ShieldedPool, etc.).
Next Steps
Learn About Privacy Features
Now that you have a node running, explore privacy capabilities:
- Shield Tokens: Deposit ORB into the shielded pool for private transactions
- Private Transfers: Send assets without revealing amounts or addresses
- Unshield: Withdraw tokens from the private pool to the public world
Documentation:
Development Guides
- Running a Node - Development and testnet node setup with Docker
Build on Orbinum
- SDK Integration - Integrate privacy into your dApp (Q2 2026)
- EVM Contracts - Deploy smart contracts with Solidity/Hardhat
- Substrate Pallets - Extend the runtime with custom pallets
Troubleshooting
| Issue | Solution |
|---|---|
| Node won't start | Check the container logs; make sure port 9944 isn't already in use |
| Explorer / SDK can't connect | Run the node with --rpc-cors all --rpc-external and publish the port (-p 9944:9944) |
| MetaMask won't connect | Verify Chain ID (1281 for local dev, 2700 for testnet) and RPC URL |
Transaction fails (ok: false) | Check the sender has enough balance; inspect result.error |
Need help? Check the complete documentation or open an issue on GitHub.