docs: improve code examples and documentation

sscovil · sscovil · commit 626077b03f2e · 2025-03-05T17:26:48.000-05:00
diff --git a/README.md b/README.md
@@ -5,19 +5,18 @@ smart contract platform that enables near-instant settlement and can process mil
 
 ## Overview
 
-Radius provides scalable, low-latency smart contract execution with sub-second finality. These SDKs make it easy to
-build applications that leverage Radius' high throughput and near-instant settlement capabilities.
+Next-generation payments require processing power that is orders of magnitude more efficient than what is currently
+available. Built by the team that brought USDC to market, Radius is the result of many years rethinking smart contract
+scalability from first principles.
 
-## Key Features
+Unlike blockchains that sequentially process a limited batch of transactions at a time, our distributed execution layer
+handles multiple transactions simultaneously. Our platform has demonstrated that it can process over 2.8 million
+transactions per second with near zero latency and cost, far exceeding any other system that exists today.
 
-- 2.8M+ transactions per second
-- 100+ gigagas/sec throughput
-- ~500 ms latency
-- Transaction cost < $0.000001
-- Full EVM compatibility & multi-VM support
-- Horizontal scaling
-- Parallel execution & state updates
-- No global transaction ordering
+Radius is fully EVM-compatible and provides SDKs in [multiple programming languages](#available-sdks) with a clean,
+consistent interface, enabling developers to easily add instant payments to their apps with just a few lines of code.
+
+No block times. No bidding wars. Just instant settlement.
 
 ## Available SDKs
 
@@ -26,6 +25,40 @@ build applications that leverage Radius' high throughput and near-instant settle
 - [Rust SDK](rust/README.md) (coming soon)
 - [TypeScript SDK](typescript/README.md)
 
+## Use Cases
+
+Radius is capable of handling millions of micro-payments per second at a cost that makes doing so economically viable.
+This is particularly well-suited for AI agent use cases, and equally so for any application that requires massive scale,
+instant settlement, and cryptographic guarantees.
+
+### AI Payments
+- AI agents buying products and services in real-time
+- Pay-per-API-call data access at fractions of a cent
+- Pay-per-compute, storage, bandwidth request
+- High-frequency trading settlement
+
+### Traditional Payments
+- High-frequency trading and settlement
+- Pay-per-use services and subscriptions
+- Real-time revenue sharing and splits
+
+### Beyond Payments
+- Decentralized social networks and content systems
+- Gaming and virtual world state management
+- IoT sensor networks and data marketplaces
+- Identity and attestation systems
+
+## Available Today
+
+The Radius invite-only testnet launched in January 2025 with major stablecoin issuers and AI labs already onboard.
+Radius supports both simple payments and other EVM-compatible smart contracts, so developers can experience the
+efficiency of its parallel execution design.
+
+The next trillion transactions won't come from humans typing on keyboards. They'll come from AI agents making
+split-second decisions. We're building the infrastructure necessary to make that future possible.
+
+Ready to build the future? Start [here](https://docs.radiustech.xyz/radius-testnet-access).
+
 ## Contributing
 
 We welcome contributions to all Radius SDKs! Please see:
@@ -37,9 +70,9 @@ We welcome contributions to all Radius SDKs! Please see:
 ## Support
 
 - [Website](https://radiustech.xyz/)
-- [Documentation](https://docs.radiustech.xyz/)
+- [Testnet Access](https://docs.radiustech.xyz/radius-testnet-access)
 - [GitHub Issues](https://github.com/radiustechsystems/sdk/issues)
 
 ## License
 
-This SDK is released under the [MIT License](LICENSE).
+All Radius SDKs are released under the [MIT License](LICENSE).
diff --git a/go/README.md b/go/README.md
@@ -1,79 +1,87 @@
 # Radius Go SDK
 
-A Go client library for interacting with the [Radius platform](https://radiustech.xyz/), providing a simple and
-idiomatic way to interact with Radius services.
+The official Go client library for interacting with the [Radius platform](https://radiustech.xyz/), providing a simple
+and idiomatic way to interact with Radius services.
 
 ## Features
 
 - Account management and transaction signing
 - Smart contract deployment and interaction
 - Optional request logging and interceptors
-- EVM compatibility with high performance
-- Comprehensive error handling
+- EVM compatibility with high performance & low latency
 
 ## Requirements
 
-- Go 1.23.3 or higher
+- Go 1.13 or higher
+- Radius JSON-RPC endpoint: https://docs.radiustech.xyz/radius-testnet-access
+- Ethereum private key: https://ethereum.org/en/developers/docs/accounts/#account-creation
 
 ## Installation
 
 ```bash
 go get github.com/radiustechsystems/sdk/go
-go mod tidy
 ```
 
 ## Quickstart Examples
 
 ### Connect to Radius and Create an Account
 
-```go
-// Connect to Radius
-client, err := radius.NewClient("https://your-radius-endpoint")
-if err != nil {
-    log.Fatal(err)
-}
+Be sure to use your own `RADIUS_ENDPOINT` and `PRIVATE_KEY` values, as mentioned in the [Requirements](#requirements).
 
-// Create an account using a private key
-account := radius.NewAccount(
-    radius.WithPrivateKeyHex("your-private-key", client),
+```go
+const (
+	RADIUS_ENDPOINT = "https://rpc.testnet.tryradi.us/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
+	PRIVATE_KEY = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036415f";
 )
+
+client, err := radius.NewClient(RADIUS_ENDPOINT)
+account := radius.NewAccount(radius.WithPrivateKeyHex(PRIVATE_KEY, client))
 ```
 
 ### Transfer Value Between Accounts
 
+Here, we send 100 tokens to another account. Be sure to replace the recipient's address with one of your own.
+
 ```go
 // Send 100 tokens to another account
-recipient, err := radius.AddressFromHex("0x...")
+recipient, err := radius.AddressFromHex("0x5e97870f263700f46aa00d967821199b9bc5a120") // Recipient's address
 amount := big.NewInt(100)
 receipt, err := account.Send(context.Background(), client, recipient, amount)
 if err != nil {
-    log.Fatal(err)
+	log.Fatal(err)
 }
 
 log.Printf("Transaction hash: %s", receipt.TxHash.Hex())
 ```
 
 ### Deploy a Smart Contract
 
+Here, we deploy the [SimpleStorage.sol](https://github.com/radiustechsystems/sdk/tree/main/contracts/solidity)
+example contract included in this SDK, with the application binary interface (ABI) and bytecode that were generated
+using the Solidity compiler [solcjs](https://docs.soliditylang.org/en/latest/installing-solidity.html#npm-node-js).
+
 ```go
-// Parse ABI and bytecode
+// Parse ABI and bytecode of the SimpleStorage contract
 abi := radius.ABIFromJSON(`[{"inputs":[],"name":"get","outputs":[{"type":"uint256"}],"type":"function"},{"inputs":[{"type":"uint256"}],"name":"set","type":"function"}]`)
-bytecode := radius.BytecodeFromHex("608060405234801561001057600080fd5b50610150806100...")
+bytecode := radius.BytecodeFromHex("6080604052348015600e575f5ffd5b5060a580601a5f395ff3fe6080604052348015600e575f5ffd5b50600436106030575f3560e01c806360fe47b11460345780636d4ce63c146045575b5f5ffd5b6043603f3660046059565b5f55565b005b5f5460405190815260200160405180910390f35b5f602082840312156068575f5ffd5b503591905056fea26469706673582212207655d86666fa8aa75666db8416e0f5db680914358a57e84aa369d9250218247f64736f6c634300081c0033")
 
 // Deploy the contract
 contract, err := client.DeployContract(
-    context.Background(),
-    account.Signer(),
-    bytecode,
-    abi,
+	context.Background(),
+	account.Signer(),
+	bytecode,
+	abi,
 )
 ```
 
 ### Interact with a Smart Contract
 
+Assuming the contract was previously deployed (which is typically the case), we can interact with it using the contract
+address and ABI. Be sure to replace the contract address with that of your own deployed contract.
+
 ```go
-// Reference an existing contract
-address, err := radius.AddressFromHex("0x...")
+// Reference a previously deployed contract
+address, err := radius.AddressFromHex("0x5e97870f263700f46aa00d967821199b9bc5a120") // Contract address
 abi := radius.ABIFromJSON(`[{"inputs":[],"name":"get","outputs":[{"type":"uint256"}],"type":"function"},{"inputs":[{"type":"uint256"}],"name":"set","type":"function"}]`)
 contract := radius.NewContract(address, abi)
 
@@ -92,7 +100,7 @@ log.Printf("Stored value: %v", result[0])
 
 ```go
 type MyCustomSigner struct{
-    // ...
+	// ...
 }
 func (s *MyCustomSigner) Address() radius.Address { /* ... */ }
 func (s *MyCustomSigner) ChainID() *big.Int { /* ... */ }
@@ -108,25 +116,25 @@ customSignerAccount := radius.NewAccount(radius.WithSigner(customSigner))
 
 ```go
 client, err := radius.NewClient("https://your-radius-endpoint",
-    radius.WithLogger(func(format string, args ...any) {
-        log.Printf(format, args...)
-    }),
-    radius.WithInterceptor(func(reqBody string, resp *http.Response) (*http.Response, error) {
-        // Examine request body, modify response, etc.
-        return resp, nil
-    }),
+	radius.WithLogger(func(format string, args ...any) {
+		log.Printf(format, args...)
+	}),
+	radius.WithInterceptor(func(reqBody string, resp *http.Response) (*http.Response, error) {
+		// Examine request body, modify response, etc.
+		return resp, nil
+	}),
 )
 ```
 
 ### Custom HTTP Client
 
 ```go
 httpClient := &http.Client{
-    Timeout: time.Second * 30,
+	Timeout: time.Second * 30,
 }
 
 client, err := radius.NewClient("https://your-radius-endpoint",
-    radius.WithHttpClient(httpClient),
+	radius.WithHttpClient(httpClient),
 )
 ```
 
@@ -144,4 +152,4 @@ For repository-wide guidelines, see the [General Contributing Guide](../CONTRIBU
 
 ## License
 
-This project is licensed under the [MIT License](../LICENSE).
+All Radius SDKs are released under the [MIT License](../LICENSE).
diff --git a/typescript/README.md b/typescript/README.md
@@ -1,19 +1,20 @@
 # Radius TypeScript SDK
 
-A TypeScript client library for interacting with [Radius](https://radiustech.xyz/), providing a simple and type-safe
-way to interact with the Radius platform.
+The official TypeScript client library for interacting with the [Radius platform](https://radiustech.xyz/), providing
+a simple and idiomatic way to interact with Radius services.
 
 ## Features
 
 - Account management and transaction signing
 - Smart contract deployment and interaction
 - Optional request logging and interceptors
-- EVM compatibility with high performance
-- Type-safe contract interactions
+- EVM compatibility with high performance & low latency
 
 ## Requirements
 
-- Node.js >= 20.12.2
+- Node.js >= 20.12
+- Radius JSON-RPC endpoint: https://docs.radiustech.xyz/radius-testnet-access
+- Ethereum private key: https://ethereum.org/en/developers/docs/accounts/#account-creation
 
 ## Installation
 
@@ -32,58 +33,74 @@ yarn add @radiustechsystems/sdk
 
 ### Connect to Radius and Create an Account
 
+Be sure to use your own `RADIUS_ENDPOINT` and `PRIVATE_KEY` values, as mentioned in the [Requirements](#requirements).
+
 ```typescript
-import { NewClient, NewAccount, withPrivateKey } from '@radiustechsystems/sdk';
+import { Account, Client, NewClient, NewAccount, withPrivateKey } from '@radiustechsystems/sdk';
+
+const RADIUS_ENDPOINT = "https://rpc.testnet.tryradi.us/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
+const PRIVATE_KEY = "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036415f";
+
+const client: Client = await NewClient(RADIUS_ENDPOINT);
+const account: Account = await NewAccount(withPrivateKey(PRIVATE_KEY, client));
+```
 
-// Connect to Radius
-const client = await NewClient('https://your-radius-endpoint');
+Alternatively, using plain JavaScript and CommonJS `require` syntax:
 
-// Create an account using a private key
-const account = await NewAccount(withPrivateKey('your-private-key', client));
+```javascript
+const { Account, Client, NewClient, NewAccount, withPrivateKey } = require('@radiustechsystems/sdk');
 ```
 
 ### Transfer Value Between Accounts
 
+Here, we send 100 tokens to another account. Be sure to replace the recipient's address with one of your own.
+
 ```typescript
-import { AddressFromHex } from '@radiustechsystems/sdk';
+import { Address, AddressFromHex, Receipt } from '@radiustechsystems/sdk';
 
-// Send 100 tokens to another account
-const recipient = AddressFromHex('0x...');
-const amount = BigInt(100);
-const receipt = await account.send(client, recipient, amount);
+const recipient: Address = AddressFromHex('0x5e97870f263700f46aa00d967821199b9bc5a120'); // Recipient's address
+const amount: bigint = BigInt(100);
+const receipt: Receipt = await account.send(client, recipient, amount);
 
 console.log('Transaction hash:', receipt.txHash.hex());
 ```
 
 ### Deploy a Smart Contract
 
+Here, we deploy the [SimpleStorage.sol](https://github.com/radiustechsystems/sdk/tree/main/contracts/solidity)
+example contract included in this SDK, with the application binary interface (ABI) and bytecode that were generated
+using the Solidity compiler [solcjs](https://docs.soliditylang.org/en/latest/installing-solidity.html#npm-node-js).
+
 ```typescript
-import { ABIFromJSON, BytecodeFromHex } from '@radiustechsystems/sdk';
+import { ABI, ABIFromJSON, BytecodeFromHex } from '@radiustechsystems/sdk';
 
-// Parse ABI and bytecode
-const abi = ABIFromJSON(`[{"inputs":[],"name":"get","outputs":[{"type":"uint256"}],"type":"function"},{"inputs":[{"type":"uint256"}],"name":"set","type":"function"}]`);
-const bytecode = BytecodeFromHex('608060405234801561001057600080fd5b50610150806100...');
+// Parse ABI and bytecode of the SimpleStorage contract
+const abi: ABI = ABIFromJSON(`[{"inputs":[],"name":"get","outputs":[{"type":"uint256"}],"type":"function"},{"inputs":[{"type":"uint256"}],"name":"set","type":"function"}]`);
+const bytecode: Uint8Array = BytecodeFromHex('6080604052348015600e575f5ffd5b5060a580601a5f395ff3fe6080604052348015600e575f5ffd5b50600436106030575f3560e01c806360fe47b11460345780636d4ce63c146045575b5f5ffd5b6043603f3660046059565b5f55565b005b5f5460405190815260200160405180910390f35b5f602082840312156068575f5ffd5b503591905056fea26469706673582212207655d86666fa8aa75666db8416e0f5db680914358a57e84aa369d9250218247f64736f6c634300081c0033');
 
 // Deploy the contract
 const contract = await client.deployContract(account.signer, bytecode, abi);
 ```
 
 ### Interact with a Smart Contract
 
+Assuming the contract was previously deployed (which is typically the case), we can interact with it using the contract
+address and ABI. Be sure to replace the contract address with that of your own deployed contract.
+
 ```typescript
-import { NewContract, AddressFromHex, ABIFromJSON } from '@radiustechsystems/sdk';
+import { ABI, Address, AddressFromHex, ABIFromJSON, Contract, NewContract, Receipt } from '@radiustechsystems/sdk';
 
-// Reference an existing contract
-const address = AddressFromHex('0x...');
-const abi = ABIFromJSON(`[{"inputs":[],"name":"get","outputs":[{"type":"uint256"}],"type":"function"},{"inputs":[{"type":"uint256"}],"name":"set","type":"function"}]`);
-const contract = NewContract(address, abi);
+// Reference a previously deployed contract
+const address: Address = AddressFromHex('0x5e97870f263700f46aa00d967821199b9bc5a120'); // Contract address
+const abi: ABI = ABIFromJSON(`[{"inputs":[],"name":"get","outputs":[{"type":"uint256"}],"type":"function"},{"inputs":[{"type":"uint256"}],"name":"set","type":"function"}]`);
+const contract: Contract = NewContract(address, abi);
 
 // Write to the contract
-const value = BigInt(42);
-const receipt = await contract.execute(client, account.signer, 'set', value);
+const value: bigint = BigInt(42);
+const receipt: Receipt = await contract.execute(client, account.signer, 'set', value);
 
 // Read from the contract
-const result = await contract.call(client, 'get');
+const result: unknown[] = await contract.call(client, 'get');
 console.log('Stored value:', result[0]);
 ```
 
@@ -148,4 +165,4 @@ SDK. For repository-wide guidelines, see the [General Contributing Guide](../CON
 
 ## License
 
-This project is licensed under the [MIT License](../LICENSE).
+All Radius SDKs are released under the [MIT License](../LICENSE).
