Use the Network

Connect a Wallet

Estimated read time: 7 minutes

JSON-RPC compatibility

Asentum exposes a JSON-RPC interface compatible with the Ethereum tooling ecosystem. Wallets, libraries, and explorers built for Ethereum work against Asentum with thin shims. The supported subset includes:

eth_blockNumber
eth_getBalance
eth_call
eth_sendRawTransaction
eth_getTransactionReceipt
eth_chainId
eth_getLogs
… and most other read-only and mutation methods you'd expect.

Important caveat: Asentum is JSON-RPC compatible, not bytecode-compatible. Solidity contracts compiled to EVM bytecode do not run on Asentum. Smart contracts on Asentum are written in plain JavaScript — see Smart Contracts.

MetaMask & browser wallets

Add the Asentum network to MetaMask (or any EVM-compatible wallet) by pointing it at the Asentum RPC URL. Once Phase 2 opens, the canonical "Add to MetaMask" button will be at connect.asentum.io.

Manual configuration:

Network name: Asentum (testnet)
RPC URL:      https://rpc-testnet.asentum.io
Chain ID:     <published in Phase 2>
Currency:     ASE
Explorer:     https://explorer.asentum.io

MetaMask, Rainbow, Trust Wallet, Frame, Rabby, and other EVM-compatible browser wallets all work the same way. The wallet UX (signing prompts, balance display, transaction history) is identical to any other EVM chain.

ethers.js

ethers.js v6 works with Asentum out of the box. Point the provider at the Asentum RPC URL:

import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider('https://rpc-testnet.asentum.io');
const blockNumber = await provider.getBlockNumber();
const balance = await provider.getBalance('0x...');

viem

viem works the same way:

import { createPublicClient, http } from 'viem';

const client = createPublicClient({
  transport: http('https://rpc-testnet.asentum.io'),
});

const blockNumber = await client.getBlockNumber();

Asentum will publish a viem chain config and an ethers.js network spec once Phase 2 chain IDs are locked.

Asentum SDK

For projects that need access to Asentum-specific features (the JS contract model, async message-passing, transaction bundles, delegation), use the official @asentum/sdk:

import { Chain, Wallet, Contract } from '@asentum/sdk';

const chain = new Chain({ rpc: 'https://rpc-testnet.asentum.io' });
const wallet = await Wallet.fromKeystore('./my-key.json');
const contract = await chain.contract('0x...');

// Async message-passing call
const result = await contract.transfer('0xabc...', 100n);

The SDK is a thin wrapper that handles ML-DSA-65 signing transparently — you don't have to think about post-quantum cryptography in application code. The wallet handles it.

Differences from Ethereum

The wire format and call interface look enough like Ethereum that existing tools work, but there are real differences under the hood:

Signatures are ML-DSA-65 (Dilithium3), not ECDSA. Each signature is ~3.3 KB instead of 65 bytes. Each public key is ~1.9 KB instead of 33 bytes.
Address derivation is BLAKE3(pubkey)[0:20], not Keccak256.
Smart contracts are JavaScript, not EVM bytecode. ABI is generated from the JS contract module, not from a Solidity compiler.
Finality is BFT. Tendermint-style 2/3 commit means no chain reorgs. A confirmed transaction is final.
Transaction bundles are first-class. A single transaction can carry an atomic sequence of contract calls — no need for an intermediary "bundler" service.