Build Next-Gen Green Web3 on Verdis

1. Connect to the Verdis Network Endpoint
   Establish a secure JSON-RPC or WebSocket connection to the Verdis node cluster using JavaScript/TypeScript (`@polkadot/api`), Rust (`subxt`), or HTTP curl.
   JavaScript / TS Rust curl

   Copy

   const { ApiPromise, WsProvider } = require('@polkadot/api');
   
   async function connectVerdis() {
     // Connect to official Verdis WebSocket RPC endpoint
     const provider = new WsProvider('wss://rpc.verdischain.com');
     const api = await ApiPromise.create({ provider });
   
     // Fetch chain metadata and system specs
     const [chain, nodeName, nodeVersion] = await Promise.all([
       api.rpc.system.chain(),
       api.rpc.system.name(),
       api.rpc.system.version()
     ]);
   
     console.log(`Connected to ${chain} running ${nodeName} v${nodeVersion}`);
     return api;
   }
   
   connectVerdis().catch(console.error);

   use subxt::{OnlineClient, PolkadotConfig};
   
   #[tokio::main]
   async fn main() -> Result<(), Box<dyn std::error::Error>> {
       // Initialize Subxt client targeting Verdis RPC endpoint
       let api = OnlineClient::<PolkadotConfig>::from_url("wss://rpc.verdischain.com").await?;
       
       let latest_block = api.blocks().at_latest().await?;
       println!("Verdis Head Block Number: #{}", latest_block.number());
       println!("Verdis Block Hash: {:?}", latest_block.hash());
       Ok(())
   }

   # Query Verdis System Health via HTTP JSON-RPC
   curl -X POST https://rpc.verdischain.com \
     -H "Content-Type: application/json" \
     -d '{"jsonrpc":"2.0","id":1,"method":"system_health","params":[]}'
   
   # Output Response:
   # {"jsonrpc":"2.0","result":{"isSyncing":false,"peers":9,"shouldHavePeers":true},"id":1}

2. Generate Account & Keyring (SS58 Format 909)
   Verdis accounts use `sr25519` schnorrkel signature scheme with custom SS58 prefix `909`. Always derive accounts safely using standard BIP-39 mnemonics.
   JavaScript / Account Keyring Derivation Copy

   const { Keyring } = require('@polkadot/api');
   const { mnemonicGenerate, cryptoWaitReady } = require('@polkadot/util-crypto');
   
   async function createVerdisAccount() {
     await cryptoWaitReady();
   
     // Initialize Keyring with Verdis SS58 prefix 909
     const keyring = new Keyring({ type: 'sr25519', ss58Format: 909 });
   
     // Generate new 12-word seed phrase
     const mnemonic = mnemonicGenerate();
     const pair = keyring.addFromUri(mnemonic, { name: 'Verdis Dev Pair' });
   
     console.log(`Generated Mnemonic: "${mnemonic}"`);
     console.log(`Verdis SS58 Address: ${pair.address}`);
     return { pair, mnemonic };
   }

3. Request Testnet VRDX from Faucet
   Fund your freshly derived address with testnet VRDX tokens to execute extrinsics and deploy smart contracts.
   cURL / Faucet Request Endpoint Copy

   # Request 100 testnet VRDX tokens to your SS58 address
   curl -X POST https://rpc.verdischain.com/faucet \
     -H "Content-Type: application/json" \
     -d '{"address": "YOUR_VERDIS_SS58_ADDRESS", "amount": 100}'

4. Submit a VRDX Transfer Extrinsic
   Construct, sign, and submit a balance transfer on Verdis using `balances.transferKeepAlive`.
   JavaScript / Sign and Send Transfer Copy

   async function sendVRDX(api, senderPair, recipientAddress, amountVRDX) {
     // Convert VRDX to Planck units (1 VRDX = 1,000,000,000 Planck)
     const decimals = api.registry.chainDecimals[0] || 9;
     const amountPlanck = BigInt(amountVRDX) * (10n ** BigInt(decimals));
   
     // Create balance transfer keep-alive call
     const tx = api.tx.balances.transferKeepAlive(recipientAddress, amountPlanck);
   
     // Sign and watch extrinsic submission
     const unsub = await tx.signAndSend(senderPair, ({ status, events, dispatchError }) => {
       console.log(`Transaction Status: ${status.type}`);
   
       if (status.isInBlock) {
         console.log(`Included in Block: ${status.asInBlock.toHex()}`);
       } else if (status.isFinalized) {
         console.log(`Finalized in Block: ${status.asFinalized.toHex()}`);
         unsub();
       }
   
       if (dispatchError) {
         if (dispatchError.isModule) {
           const decoded = api.registry.findMetaError(dispatchError.asModule);
           console.error(`Module Error: ${decoded.section}.${decoded.name}`);
         } else {
           console.error(`Dispatch Error: ${dispatchError.toString()}`);
         }
       }
     });
   }

Verdis WebSocket API relies on JSON-RPC 2.0 pub/sub messaging. Clients subscribe to specific notification topics and receive real-time updates as state mutates.

const WebSocket = require('ws');

const ws = new WebSocket('wss://rpc.verdischain.com');

ws.on('open', () => {
  console.log('WebSocket connection established to Verdis RPC');

  // Subscribe to new best block headers
  const subscribeHeader = {
    jsonrpc: '2.0',
    id: 1,
    method: 'chain_subscribeNewHeads',
    params: []
  };

  ws.send(JSON.stringify(subscribeHeader));
});

ws.on('message', (data) => {
  const payload = JSON.parse(data);

  if (payload.method === 'chain_newHead') {
    const header = payload.params.result;
    const blockNum = parseInt(header.number, 16);
    console.log(`🌿 New Verdis Block #${blockNum} | State Root: ${header.stateRoot}`);
  }
});

import asyncio
import json
import websockets

async fn subscribe_verdis_events():
    url = "wss://rpc.verdischain.com"
    async with websockets.connect(url) as ws:
        req = {
            "jsonrpc": "2.0",
            "id": 1,
            "method": "chain_subscribeNewHeads",
            "params": []
        }
        await ws.send(json.dumps(req))
        print("Subscribed to chain_subscribeNewHeads")

        while True:
            msg = await ws.recv()
            event = json.loads(msg)
            if "params" in event:
                block_hex = event["params"]["result"]["number"]
                print(f"🌿 Verdis New Block: #{int(block_hex, 16)}")

asyncio.run(subscribe_verdis_events())