RadioÐoge

What is RadioDoge?

RadioDoge is a decentralized communication and data transmission network that enables Dogecoin transactions over radio waves, bypassing the need for traditional internet access. It uses long-distance RF protocols such as LoRa and VaraHF to provide reliable and resilient secure data transmission to reach the Dogecoin blockchain.

RadioDoge empowers the unbanked and those in remote areas to access blockchain-based financial services, engage in transactions with neighbors and the world at large, and maintain self-control and self-governance over their finances.

Firmware Versions

RadioDoge has two firmware versions available:

• Firmware V1: Original firmware with basic LoRa mesh networking capabilities
• Firmware V3: Advanced firmware with web interface, wallet management, and enhanced features

Choose the version that best fits your needs. V3 is recommended for most users as it includes a built-in web interface and more features.

Accessing the Built-in Web Interface

The RadioDoge Heltec firmware includes a built-in web interface that provides comprehensive documentation and controls. Here's how to access and use it:

Step 1: Connect to the Device

After uploading the firmware and powering on your device:

1. The device will create a WiFi access point (AP mode)
2. Look for a WiFi network named something like RadioDoge-XXXX or ESP32-XXXX
3. Connect to this network from your computer or mobile device
4. The default password is typically radiodoge or may be displayed on the OLED screen

Step 2: Access the Web Interface

Once connected to the device's WiFi network:

1. Open a web browser on your connected device
2. Navigate to: http://192.168.4.1 (default IP address)
3. You should see the RadioDoge web interface homepage

Web Interface Features

The built-in web interface provides the following sections:

1. Home/Dashboard

• Device Status: Shows current node address, connection status, and system information
• Network Info: Displays connected hub information, signal strength, and network topology
• Quick Actions: Fast access to common operations like sending transactions or checking balance

2. Configuration Menu

Access device settings and preferences:

• Node Configuration:
  • Set your unique node address (e.g., 10.2.58)
  • Configure hub address (e.g., 10.0.1 for main hub)
  • Set LoRa frequency (915MHz for US, 868MHz for EU)
  • Adjust transmit power (typically 14-20 dBm)
• WiFi Settings:
  • Configure WiFi access point name (SSID)
  • Set WiFi password
  • Optionally connect to existing WiFi network
• Display Settings:
  • OLED screen brightness
  • Display timeout settings
  • Information display preferences

3. Wallet Management

Manage your Dogecoin addresses and keys:

• Address Book:
  • Add new addresses manually or via QR code
  • Label addresses with friendly names
  • Edit or delete saved addresses
  • Import/export address book
• Wallet Setup:
  • Generate new wallet addresses (using LibDogecoin)
  • Import existing private keys (encrypted storage)
  • View public addresses (private keys never displayed)
  • Backup wallet data
• Security:
  • Set encryption PIN for balance privacy
  • Configure key storage encryption
  • Manage access permissions

4. Transaction Operations

Send and receive Dogecoin transactions:

• Send Transaction:
  • Select source address from address book or enter manually
  • Enter destination address (or select from address book)
  • Specify amount in DOGE
  • Review transaction details
  • Confirm and send
  • View transaction ID (TXID) after confirmation
• Receive Transactions:
  • Generate receiving address
  • Display QR code for easy sharing
  • Monitor incoming transactions
• Transaction History:
  • View sent transactions with TXIDs
  • View received transactions
  • Check transaction status and confirmations
  • Export transaction log

5. Network Operations

Manage network connections and hub communication:

• Hub Discovery:
  • Scan for available hubs in range
  • View hub addresses and signal strength
  • Select which hub to connect to
  • View hub information (address, type, status)
• Connection Status:
  • Current hub connection
  • Signal quality indicators
  • Network topology view
  • Connection statistics
• Message Relay:
  • Send encrypted messages to other nodes
  • View received messages
  • Message history

6. Balance & Account Management

• Check Balance:
  • Query balance for any address
  • View balance for registered addresses
  • Update balance information from hub
• Register with Hub:
  • Register address for balance monitoring (optional)
  • Set encryption PIN for privacy
  • Unregister when moving to different hub

7. System Information

• Device Info:
  • Firmware version
  • Hardware model
  • Uptime and system status
  • Memory usage
• Network Statistics:
  • Messages sent/received
  • Transactions processed
  • Network errors and retries
  • Connection quality metrics
• Logs:
  • System logs
  • Transaction logs
  • Network activity logs
  • Error logs for troubleshooting

Using the OLED Display

In addition to the web interface, the Heltec board features an OLED display that shows:

• Boot Screen: Device initialization and status
• Hub Information: Connected hub address and signal strength
• Node Address: Your device's network address
• Status Indicators: Connection status, power level, errors
• Menu Navigation: When using physical buttons (if available)

Menu Navigation (Physical Controls)

If your Heltec board has physical buttons, you can navigate the firmware menu:

• Button 1 (Left): Navigate up/previous menu item
• Button 2 (Right): Navigate down/next menu item
• Button 3 (Center/Select): Select/confirm action

Typical Workflow

Here's a typical workflow for using RadioDoge:

1. Initial Setup:
   • Power on device
   • Connect to device WiFi network
   • Access web interface at http://192.168.4.1
   • Configure node address and hub address
   • Set LoRa frequency for your region
2. Wallet Setup:
   • Generate or import wallet addresses
   • Add addresses to address book
   • Set encryption PIN for privacy
3. Connect to Hub:
   • Device automatically scans for hubs
   • Select hub from discovered list (if multiple available)
   • Wait for connection confirmation
4. Send Transaction:
   • Navigate to "Send Transaction" in web interface
   • Select source address
   • Enter destination address and amount
   • Review and confirm
   • Wait for TXID confirmation
5. Verify Transaction:
   • Copy TXID from confirmation
   • Check on blockchain explorer (e.g., chain.so)
   • Verify transaction details match

Advanced Features

Multi-Hop Routing

If your node cannot directly reach a hub, the firmware can automatically route through other nodes:

• Network topology is discovered automatically
• Messages are encrypted at each hop
• Routing information is displayed in the web interface

Offline Transaction Queue

If the hub is temporarily unavailable:

• Transactions are queued locally on the device
• Queue status is shown in the web interface
• Transactions are automatically sent when connection is restored

Low Power Mode

For battery-powered deployments:

• Enable sleep mode in configuration
• Device wakes on hub beacon or user interaction
• Battery level monitoring (if supported by hardware)

Troubleshooting via Web Interface

The web interface includes troubleshooting tools:

• Connection Test: Test LoRa radio functionality
• Hub Ping: Check connectivity to hub
• System Diagnostics: View detailed system information
• Reset Options: Factory reset, network reset, etc.
• Firmware Update: OTA (Over-The-Air) firmware updates (if supported)

REST API Overview

Firmware V3 provides a comprehensive REST API for programmatic control of all device functions. All API endpoints return JSON responses and support both GET and POST methods where applicable.

wifi_tethering RECOMMENDED: Broadcast API Commands

The broadcast feature is the recommended way to send Dogecoin transactions. It creates a blockchain-like mesh network that automatically finds gateways and forwards transactions.

Broadcast Dogecoin Transaction (Blockchain-Like)

Endpoint: POST /api/broadcast

Description: Broadcast a Dogecoin transaction to the entire RadioDoge network. No internet required! Automatically finds gateway and forwards to Dogecoin network.

curl -X POST "http://192.168.4.1/api/broadcast" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "type=transaction&priority=normal&message=0100000001..."

async function broadcastTransaction(signedTx) {
  const response = await fetch('http://192.168.4.1/api/broadcast', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: `type=transaction&priority=normal&message=${signedTx}`
  });
  
  const result = await response.json();
  console.log('Transaction broadcasted:', result);
  return result;
}

Parameters:

• type: transaction (required)
• priority: normal, high, or urgent (optional, default: normal)
• message: Signed Dogecoin transaction hex string (required)

Broadcast General Message

Endpoint: POST /api/broadcast

curl -X POST "http://192.168.4.1/api/broadcast" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "type=announcement&priority=normal&message=Network update"

Parameters:

• type: announcement, emergency, network, or transaction (required)
• priority: normal, high, or urgent (optional)
• message: Message content (required)

send Communication API Endpoints

Send Direct Message

Endpoint: POST /api/message

Description: Send a text message to a specific RadioDoge device via LoRa.

curl -X POST "http://192.168.4.1/api/message" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "address=10.1.2&type=text&text=Hello from RadioDoge!"

Parameters:

• address: Target address (e.g., "10.1.2") (required)
• type: Message type - text, data, or command (required)
• text: Message content (required)

Send Direct Transaction (LoRa)

Endpoint: POST /api/transaction

Description: Send a Dogecoin transaction to a specific device via LoRa. If the receiving device has an internet gateway configured, it will automatically forward to the Dogecoin network.

curl -X POST "http://192.168.4.1/api/transaction" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "address=10.1.2&type=signed&data=0100000001..."

Parameters:

• address: Target address (e.g., "10.1.2") (required)
• type: Transaction type - signed, raw, or utxo (required)
• data: Transaction data as hex string (required)

Response Format (with Gateway):

{
  "success": true,
  "action": "transaction",
  "target": "10.1.2",
  "type": "signed",
  "message": "Transaction sent to 10.1.2",
  "internet_forwarded": true,
  "internet_response": "{\"success\":true,\"transaction_id\":\"abc123...\"}"
}

{
  "success": true,
  "action": "transaction",
  "target": "10.1.2",
  "type": "signed",
  "message": "Transaction sent to 10.1.2",
  "internet_forwarded": true,
  "internet_response": "{\"success\":false,\"error\":\"transaction already in block chain\"}"
}

Send Transaction to Internet Gateway

Endpoint: POST /api/transaction/send

Description: Send transaction directly to your configured internet gateway (Dogecoin Core, DogeBox, etc.) for immediate broadcast to the Dogecoin network.

curl -X POST "http://192.168.4.1/api/transaction/send" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "transaction=0100000001..."

Parameters:

• transaction: Signed transaction hex string (required)

Response:

{
  "success": true,
  "action": "transaction_send",
  "message": "Transaction sent to stored gateway",
  "gateway_type": "core",
  "server_response": "{\"success\":true,\"transaction_id\":\"abc123...\"}"
}

Send Ping

Endpoint: GET /api/ping or POST /api/ping

Description: Test connectivity between RadioDoge devices.

curl -X GET "http://192.168.4.1/api/ping?region=10&community=1&node=2"

# Or with POST
curl -X POST "http://192.168.4.1/api/ping" \
  -d "region=10&community=1&node=2"

Parameters:

• region: Target region (0-255) (required)
• community: Target community (0-255) (required)
• node: Target node (0-255) (required)
• broadcast: Set to "1" for broadcast ping (optional)

info Device Status & Configuration API

Get Device Status

Endpoint: GET /api/status

Description: Get current device status and configuration information.

curl -X GET "http://192.168.4.1/api/status"

Get/Set LoRa Address

Endpoints: GET /api/address or POST /api/address

Description: Get or set the LoRa network address (Region.Community.Node).

curl -X POST "http://192.168.4.1/api/address" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "region=10&community=1&node=5"

POST Parameters:

• region: Region number (0-255) (required)
• community: Community number (0-255) (required)
• node: Node number (0-255) (required)

Get WiFi Status

Endpoint: GET /api/wifi

Description: Get WiFi connection status and configuration.

curl -X GET "http://192.168.4.1/api/wifi"

Connect to Internet WiFi

Endpoint: POST /api/wifi/connect

Description: Connect to an internet WiFi network.

curl -X POST "http://192.168.4.1/api/wifi/connect" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "ssid=MyWiFi&password=MyPassword"

Parameters:

• ssid: WiFi network name (required)
• password: WiFi password (required)

Disconnect from Internet WiFi

Endpoint: POST /api/wifi/disconnect

curl -X POST "http://192.168.4.1/api/wifi/disconnect"

Clear Stored WiFi Credentials

Endpoint: POST /api/wifi/clear

curl -X POST "http://192.168.4.1/api/wifi/clear"

security Password Management API

Change Access Point Password

Endpoint: POST /api/password/change

Description: Change the WiFi access point password. Password must be 8-32 characters and contain both letters and numbers.

curl -X POST "http://192.168.4.1/api/password/change" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "password=NewSecurePassword123"

Parameters:

• password: New password (8-32 chars, must contain letters + numbers) (required)

Reset Password to Default

Endpoint: POST /api/password/reset

curl -X POST "http://192.168.4.1/api/password/reset"

Get Password Status

Endpoint: GET /api/password/status

curl -X GET "http://192.168.4.1/api/password/status"

router Gateway Management API

Get Gateway Status

Endpoint: GET /api/gateway/status

Description: Get current internet gateway configuration and status.

curl -X GET "http://192.168.4.1/api/gateway/status"

Save Gateway Configuration

Endpoint: POST /api/gateway/save

Description: Save internet gateway credentials. Gateway credentials persist across reboots.

curl -X POST "http://192.168.4.1/api/gateway/save" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "type=core&ip=192.168.1.100&port=22555&username=myuser&password=mypass"

curl -X POST "http://192.168.4.1/api/gateway/save" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "type=custom&ip=192.168.1.100&port=8080&endpoint=/api/push/tx"

Parameters:

• type: Gateway type - core, dogebox, wallet, or custom (required)
• ip: Gateway IP address (required)
• port: Gateway port (required)
• username: RPC username (for Core gateway) (optional)
• password: RPC password (for Core gateway) (optional)
• endpoint: Custom endpoint path (for custom gateway) (optional)

Get Gateway Configuration

Endpoint: GET /api/gateway/config

curl -X GET "http://192.168.4.1/api/gateway/config"

Set Gateway Configuration

Endpoint: POST /api/gateway/config

curl -X POST "http://192.168.4.1/api/gateway/config" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "type=core&ip=192.168.1.100&port=22555&username=user&password=pass"

Test Gateway Connection

Endpoint: POST /api/gateway/test

curl -X POST "http://192.168.4.1/api/gateway/test" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "url=http://192.168.1.100:22555"

Clear Gateway Configuration

Endpoint: POST /api/gateway/clear

curl -X POST "http://192.168.4.1/api/gateway/clear"

Get Gateway Debug Info

Endpoint: GET /api/gateway/debug

curl -X GET "http://192.168.4.1/api/gateway/debug"

Load Gateway Configuration

Endpoint: GET /api/gateway/load

curl -X GET "http://192.168.4.1/api/gateway/load"

code JSON-RPC API

Send JSON-RPC Request

Endpoint: POST /api/jsonrpc

Description: Send a JSON-RPC request directly to Dogecoin Core nodes using standard JSON-RPC protocol.

curl -X POST "http://192.168.4.1/api/jsonrpc" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "transaction=0100000001...&url=http://192.168.1.100:22555&rpcuser=myuser&rpcpass=mypass"

Parameters:

• transaction: Signed transaction hex string (required)
• url: Dogecoin Core RPC URL (required)
• rpcuser: RPC username (required)
• rpcpass: RPC password (required)

Response (Success):

{
  "success": true,
  "action": "jsonrpc_send",
  "message": "JSON-RPC call sent to Dogecoin Core",
  "gateway": "http://192.168.1.100:22555",
  "parsed_response": "{\"success\":true,\"transaction_id\":\"abc123...\"}"
}

Response (Error):

{
  "success": true,
  "action": "jsonrpc_send",
  "message": "JSON-RPC call sent to Dogecoin Core",
  "gateway": "http://192.168.1.100:22555",
  "parsed_response": "{\"success\":false,\"error\":\"transaction already in block chain\"}"
}

Send RPC Request

Endpoint: POST /api/rpc

Description: Send a generic RPC request to the configured gateway.

curl -X POST "http://192.168.4.1/api/rpc" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "rpc_body={\"jsonrpc\":\"1.0\",\"id\":\"1\",\"method\":\"getinfo\",\"params\":[]}"

Parameters:

• rpc_body: JSON-RPC request body (required)

monitoring Monitoring & Logging API

Get Real-Time Logs

Endpoint: GET /api/logs

Description: Get system logs in JSON format. Logs include LoRa activity, WiFi events, API calls, and transaction processing.

curl -X GET "http://192.168.4.1/api/logs"

Get Logs as Plain Text

Endpoint: GET /api/logs/text

curl -X GET "http://192.168.4.1/api/logs/text"

Send Logs via LoRa

Endpoint: POST /api/logs/send

Description: Send current system logs to another RadioDoge device via LoRa for remote monitoring.

curl -X POST "http://192.168.4.1/api/logs/send" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "address=10.1.2&type=logs&logs=log_content"

Parameters:

• address: Target address (e.g., "10.1.2") (required)
• type: Message type - logs (required)
• logs: Log content to send (required)

Get Queue Status

Endpoint: GET /api/queue/status

Description: View request queue status and pending requests. The queue system processes requests sequentially and waits for confirmations.

curl -X GET "http://192.168.4.1/api/queue/status"

Get Multipart Status

Endpoint: GET /api/multipart/status

Description: View active multipart transmission sessions. Large transactions (>255 bytes) are automatically split into multiple packets.

curl -X GET "http://192.168.4.1/api/multipart/status"

router Internet Bridge API

Enable Internet Bridge

Endpoint: POST /api/bridge/enable

Description: Enable internet bridge to share your internet connection with devices connected to the RadioDoge WiFi network.

curl -X POST "http://192.168.4.1/api/bridge/enable"

Disable Internet Bridge

Endpoint: POST /api/bridge/disable

curl -X POST "http://192.168.4.1/api/bridge/disable"

Get Bridge Status

Endpoint: GET /api/bridge/status

curl -X GET "http://192.168.4.1/api/bridge/status"

Response Example:

{
  "success": true,
  "timestamp": 1234567890,
  "bridge": {
    "enabled": true,
    "internet_connected": true,
    "ap_gateway": "192.168.4.1",
    "ap_subnet": "255.255.255.0",
    "internet_ip": "192.168.1.100",
    "internet_ssid": "YourWiFi"
  }
}

HTTP Proxy

Endpoint: GET /proxy?url=WEBSITE

Description: Access websites through the RadioDoge device's internet connection via HTTP proxy.

curl "http://192.168.4.1/proxy?url=google.com"
curl "http://192.168.4.1/proxy?url=https://github.com"
curl "http://192.168.4.1/proxy?url=example.com"

account_balance_wallet Wallet API

Generate Wallet

Endpoint: GET /api/wallet/generate

Description: Generate a new Dogecoin wallet using libdogecoin. Requires libdogecoin.js to be loaded.

curl -X GET "http://192.168.4.1/api/wallet/generate"

settings Configuration API

Clear LoRa Configuration

Endpoint: POST /api/lora/clear

curl -X POST "http://192.168.4.1/api/lora/clear"

Complete API Reference

All available API endpoints:

JavaScript Examples

Broadcast Transaction (Recommended)

async function broadcastDogecoinTransaction(signedTx) {
  const response = await fetch('http://192.168.4.1/api/broadcast', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: `type=transaction&priority=normal&message=${signedTx}`
  });
  
  const result = await response.json();
  console.log('Transaction broadcasted to entire RadioDoge network!', result);
  
  // The transaction will automatically:
  // 1. Spread through the mesh network
  // 2. Find a device with internet connectivity
  // 3. Forward to the Dogecoin blockchain
  // 4. Send the response back to you
  return result;
}

Send Direct Transaction

async function sendDogecoinTransaction(signedTx, targetAddress) {
  const response = await fetch('http://192.168.4.1/api/transaction', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: `address=${targetAddress}&type=signed&data=${signedTx}`
  });
  
  const result = await response.json();
  
  if (result.internet_forwarded) {
    const internetResult = JSON.parse(result.internet_response);
    if (internetResult.success) {
      console.log('Transaction ID:', internetResult.transaction_id);
    } else {
      console.error('Error:', internetResult.error);
    }
  }
  
  return result;
}

Send Transaction to Gateway

async function sendTransactionToGateway(signedTx) {
  const response = await fetch('http://192.168.4.1/api/transaction/send', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: `transaction=${signedTx}`
  });
  
  const result = await response.json();
  console.log('Gateway Response:', result);
  return result;
}

Get Device Status

async function getDeviceStatus() {
  const response = await fetch('http://192.168.4.1/api/status');
  const status = await response.json();
  console.log('Device Status:', status);
  return status;
}

Change Password

async function changePassword(newPassword) {
  const response = await fetch('http://192.168.4.1/api/password/change', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: `password=${encodeURIComponent(newPassword)}`
  });
  
  const result = await response.json();
  console.log('Password changed:', result);
  return result;
}

Internet Bridge Examples

// Enable internet bridge
async function enableBridge() {
  const response = await fetch('http://192.168.4.1/api/bridge/enable', {
    method: 'POST'
  });
  const result = await response.json();
  console.log('Bridge Status:', result);
  return result;
}

// Get bridge status
async function getBridgeStatus() {
  const response = await fetch('http://192.168.4.1/api/bridge/status');
  const status = await response.json();
  console.log('Bridge Status:', status);
  return status;
}

// Access website via proxy
async function accessWebsite(url) {
  const proxyUrl = `http://192.168.4.1/proxy?url=${encodeURIComponent(url)}`;
  window.open(proxyUrl, '_blank');
}

Real-World Use Cases

Example 1: Remote Village Payment

Scenario: Send 100 DOGE from village A to village B (no internet in village A)

Steps:

1. Create signed transaction in village A (with internet)
2. Send via RadioDoge to village B device (address 10.1.2)
3. Village B device has internet gateway configured
4. Transaction automatically broadcasts to Dogecoin network
5. Both devices receive transaction ID confirmation

curl -X POST "http://192.168.4.1/api/transaction" \
  -d "address=10.1.2&type=signed&data=0100000001..."

Example 2: Emergency Internet Broadcast

Scenario: You have internet but want to use RadioDoge's gateway for reliability

Steps:

1. Configure Dogecoin Core gateway (192.168.1.100:22555)
2. Save RPC credentials (username/password)
3. Send transaction directly to gateway
4. Get immediate transaction ID or error message

curl -X POST "http://192.168.4.1/api/transaction/send" \
  -d "transaction=0100000001..."

Important Notes

Basic Operations

For detailed usage instructions, refer to the Firmware Usage Guide above, which covers the built-in web interface. The firmware provides comprehensive documentation and controls through its web interface.

Quick Start

1. Connect to device WiFi network
2. Open web browser to http://192.168.4.1
3. Follow the on-screen instructions in the web interface
4. Configure your node settings
5. Set up your wallet
6. Connect to a hub and start transacting!

RadioDoge is a fully working prototype leveraging LoRA, VaraHF radio and the Starlink network. We are looking for partners or even regular shibes in remote areas who would be interested in establishing regional hubs, and working with local communities to demonstrate and develop the technology for their needs.

We are looking to collaborate with NGOs, Governments or anyone who sees the potential for equipping farmers, teachers, tradespeople in remote or under facilitated areas with financial tools to engage with the top of the supply chains and not be exploited by greedy middlemen.

Please contact Michi Lumin via the forum: forum.dogecoin.org if you want to get involved.