Radius Development Skill

What this Skill is for

Use this Skill when the user asks for:

Radius dApp UI work (React / Next.js with wagmi)
Wallet connection + transaction signing on Radius
Smart contract deployment to Radius (Foundry / Solidity)
Micropayment patterns (pay-per-visit content, API metering, streaming payments)
x402 protocol integration (per-request API billing, facilitator patterns)
TypeScript integration with viem (clients, transactions, contract interaction, events)
EVM compatibility questions specific to Radius
Stablecoin-native fee model and Turnstile mechanism
Radius network configuration, RPC endpoints, contract addresses
Production gotchas (wallet compatibility, nonce management, decimal handling)

Default stack decisions (opinionated)

TypeScript: viem (directly, no wrapper SDK)

Use
```
defineChain
```
from viem to create the Radius chain definition with
```
fees.estimateFeesPerGas()
```
.
Use
```
createPublicClient
```
for reads,
```
createWalletClient
```
for writes.
Use viem's native
```
watchContractEvent
```
,
```
getLogs
```
, and
```
watchBlockNumber
```
for event monitoring.
Do NOT use
```
@radiustechsystems/sdk
```
— it is deprecated. Use plain viem for everything.

UI: wagmi + @tanstack/react-query for React apps

Define the Radius chain via
```
defineChain
```
and pass it to wagmi's
```
createConfig
```
.
Use
```
injected()
```
connector for MetaMask and EIP-1193 wallets.

Standard wagmi hooks:

useAccount

useConnect

useSendTransaction

useWaitForTransactionReceipt

Smart contracts: Foundry

```
forge create
```
for direct deployment,
```
forge script
```
for scripted deploys.
```
cast call
```
for reads,
```
cast send
```
for writes.
OpenZeppelin for standard patterns (ERC-20, ERC-721, access control).
Solidity 0.8.x, Osaka hardfork support via Revm 33.1.0.

Chain: Radius Testnet (default) + Radius Network (mainnet)

Setting	Testnet	Mainnet
Chain ID	`72344`	`723`
RPC	`https://rpc.testnet.radiustech.xyz`	`https://rpc.radiustech.xyz`
Native currency	RUSD (18 decimals)	RUSD (18 decimals)
SBC token (ERC-20)	—	`0x33ad9e4bd16b69b5bfded37d8b5d9ff9aba014fb` (6 decimals)
Explorer	`https://testnet.radiustech.xyz`	`https://network.radiustech.xyz`
Faucet	`https://testnet.radiustech.xyz/testnet/faucet`	Not available
Transaction cost API	`https://testnet.radiustech.xyz/api/v1/network/transaction-cost`	`https://network.radiustech.xyz/api/v1/network/transaction-cost`

Fees: Stablecoin-native via Turnstile

Users pay gas in stablecoins (USD). No separate gas token needed.
Fixed cost: ~0.0001 USD per standard ERC-20 transfer.
Fixed gas price:
```
9.85998816e-10
```
RUSD per gas (~986M wei, ~1 gwei).
```
eth_gasPrice
```
returns the fixed gas price (NOT zero).
```
eth_maxPriorityFeePerGas
```
returns
```
0x0
```
(no priority fee bidding).
Failed transactions do NOT charge gas.
If a sender has SBC but not enough RUSD, Turnstile converts SBC → RUSD inline.

Canonical chain definitions

Always define the chain with

fees.estimateFeesPerGas()

— never rely on viem defaults:

typescript

import { defineChain } from 'viem';

export const radiusTestnet = defineChain({
  id: 72344,
  name: 'Radius Testnet',
  nativeCurrency: { decimals: 18, name: 'RUSD', symbol: 'RUSD' },
  rpcUrls: { default: { http: ['https://rpc.testnet.radiustech.xyz'] } },
  blockExplorers: {
    default: { name: 'Radius Explorer', url: 'https://testnet.radiustech.xyz' },
  },
  fees: {
    async estimateFeesPerGas() {
      const res = await fetch(
        'https://testnet.radiustech.xyz/api/v1/network/transaction-cost'
      );
      const { gas_price_wei } = await res.json();
      return { gasPrice: BigInt(gas_price_wei) };
    },
  },
});

export const radiusMainnet = defineChain({
  id: 723,
  name: 'Radius Network',
  nativeCurrency: { decimals: 18, name: 'RUSD', symbol: 'RUSD' },
  rpcUrls: { default: { http: ['https://rpc.radiustech.xyz'] } },
  blockExplorers: {
    default: { name: 'Radius Explorer', url: 'https://network.radiustech.xyz' },
  },
  fees: {
    async estimateFeesPerGas() {
      const res = await fetch(
        'https://network.radiustech.xyz/api/v1/network/transaction-cost'
      );
      const { gas_price_wei } = await res.json();
      return { gasPrice: BigInt(gas_price_wei) };
    },
  },
});

Critical Radius differences from Ethereum

Always keep these in mind when writing code for Radius:

Feature	Ethereum	Radius
Fee model	Market-based ETH gas bids	Fixed ~0.0001 USD via Turnstile
Settlement	~12 minutes (12+ confirmations)	Sub-second (~500ms finality)
Failed txs	Charge gas even if reverted	Charge only on success
Required token	Must hold ETH for gas	Stablecoins only (USD)
Reorgs	Possible	Impossible
`eth_gasPrice`	Market rate	Fixed gas price (~986M wei)
`eth_maxPriorityFeePerGas`	Suggested priority fee	Always `0x0`
`eth_getBalance`	Native ETH balance	Native + convertible USD balance
`eth_blockNumber`	Monotonic block height	Current timestamp in milliseconds
Block hash	Hash of block header	Equals block number (timestamp-based)
`transactionIndex`	Position in block	Can be `0` for multiple txs in same ms
SBC decimals	—	6 decimals (NOT 18)

Solidity patterns to watch:

solidity

// DON'T — native balance behaves differently on Radius
require(address(this).balance > 0);

// DO — use ERC-20 balance instead
require(IERC20(feeToken).balanceOf(address(this)) > 0);

SBC decimal handling — always use 6:

typescript

import { parseUnits, formatUnits } from 'viem';

// CORRECT
const amount = parseUnits('1.0', 6);   // 1_000_000n
const display = formatUnits(balance, 6); // "1.0"

// WRONG — this is the most common mistake
const wrong = parseUnits('1.0', 18);  // 1_000_000_000_000_000_000n (1e12x too large!)

Standard ERC-20 interactions, storage operations, and events work unchanged.

Operating procedure (how to execute tasks)

1. Classify the task layer

UI/wallet layer — React components, wallet connection, transaction UX
TypeScript/scripts layer — Backend scripts, server-side verification, event monitoring
Smart contract layer — Solidity contracts, deployment, testing
Micropayment layer — Pay-per-visit, API metering, streaming payments
x402 layer — HTTP-native micropayments, facilitator integration

2. Pick the right building blocks

UI: wagmi + Radius chain via
```
defineChain
```
+ React hooks

Scripts/backends: plain viem (

createPublicClient

createWalletClient

defineChain

)

Smart contracts: Foundry (
```
forge
```
/
```
cast
```
) + OpenZeppelin
Micropayments: viem + server-side verification + wallet integration
x402: Middleware pattern with Radius facilitator for settlement

3. Implement with Radius-specific correctness

Always be explicit about:

Defining the Radius chain with
```
defineChain
```
including
```
fees.estimateFeesPerGas()
```
Using
```
createPublicClient
```
for reads and
```
createWalletClient
```
for writes (plain viem)
Stablecoin fee model (no ETH needed, no gas price bidding)
Sub-second finality (no need to wait for multiple confirmations)
SBC uses 6 decimals (use
```
parseUnits(amount, 6)
```
, NOT
```
parseEther
```
)
RUSD (native token) uses 18 decimals (use
```
parseEther
```
for native transfers)
Environment variables for private keys (never hardcode)
Gas price comes from transaction cost API, not from defaults

4. Watch for production gotchas

Before shipping, review gotchas.md for:

Wallet compatibility (MetaMask is the only wallet that reliably adds Radius)
Nonce collision handling under concurrent load
Block number is a timestamp (use BigInt, never parseInt)
Transaction receipts can be null even for confirmed transactions
EIP-2612 permit domain must match exactly:
```
{ name: "SBC", version: "1" }
```

5. Test

Smart contracts:
```
forge test
```
locally, then deploy to Radius Testnet
TypeScript scripts: Run against testnet RPC with funded test accounts

Get testnet tokens from

https://testnet.radiustech.xyz/testnet/faucet

Verify deployments:

cast code <address> --rpc-url https://rpc.testnet.radiustech.xyz

6. Deliverables expectations

When you implement changes, provide:

Exact files changed + diffs (or patch-style output)
Commands to install dependencies, build, and test
A short "risk notes" section for anything touching signing, fees, payments, or token transfers

Progressive disclosure (read when needed)

TypeScript reference (viem): typescript-viem.md
Event watching + historical queries (viem): events-viem.md
Smart contract deployment (Foundry): smart-contracts.md
Wallet integration (wagmi / viem / MetaMask): wallet-integration.md
Micropayment patterns: micropayments.md
x402 protocol integration: x402-integration.md
EVM differences + Turnstile + architecture: evm-differences.md
Network config + contract addresses + RPC reference: network-config.md
Production gotchas: gotchas.md
Security checklist: security.md
Curated reference links: resources.md

radius-dev

NPX Install

Tags

SKILL.md Content