| title | ArgusVM (AVM) |
|---|---|
| description | Register-based virtual machine for Paxeer Network - EVM-compatible but not EVM-dependent |
| icon | microchip |
ArgusVM (AVM) is Paxeer Network's native register-based virtual machine designed for high-performance smart contract execution. Built from the ground up for blockchain applications, ArgusVM provides 256-bit native arithmetic, deterministic gas metering, and superior performance compared to stack-based architectures.
**Revolutionary Architecture:** ArgusVM represents Paxeer's path to becoming the **first EVM L2 to transition into EVM-compatibility without EVM-dependency**. We maintain full compatibility while building a fully self-sustainable ecosystem. Faster execution than stack-based VMs (no push/pop overhead) First-class support for cryptographic operations Compatible with EVM but not dependent on itPaxeer Network is pioneering a new approach: EVM-compatible but EVM-independent. While we maintain full compatibility with existing Ethereum tooling and contracts, we're building our own execution environment that doesn't rely on EVM infrastructure.
ArgusVM enables Paxeer to operate independently:- Native execution environment
- Custom gas model optimized for our architecture
- Register-based design for better performance
- Full control over VM evolution
- Can execute EVM bytecode (via translation layer)
- Supports existing Ethereum tooling
- Seamless migration path for developers
- Bridge compatibility maintained
- **10,000+ TPS** per core (vs ~15 TPS for EVM)
- **<1ms latency** for simple calls
- **No stack manipulation** overhead
- **Better register allocation** for compilers
ArgusVM uses 32 general-purpose 256-bit registers plus special-purpose registers:
// General-purpose registers (256-bit)
r0-r31 : 32 general-purpose registers
// Special-purpose registers (64-bit)
pc : Program counter
sp : Stack pointer (for call frames)
fp : Frame pointer (for local variables)
gas : Remaining gas
status : Status flags64-bit status register with condition flags:
bit 0: ZERO - Last operation result was zero
bit 1: CARRY - Arithmetic carry occurred
bit 2: OVERFLOW - Arithmetic overflow occurred
bit 3: HALT - Execution halted
bit 4: REVERT - Transaction should revert
bit 5-63: Reserved
ArgusVM uses a segmented memory model optimized for smart contracts:
``` ┌─────────────────────────┐ 0x00000000 │ Code Segment │ (Read-only, contract bytecode) │ (Max 24KB) │ ├─────────────────────────┤ 0x00006000 │ Data Segment │ (Read/Write, initialized data) │ (Max 8KB) │ ├─────────────────────────┤ 0x00008000 │ Stack │ (Read/Write, grows downward) │ (Max 64KB) │ ├─────────────────────────┤ 0x00018000 │ Heap │ (Read/Write, dynamic allocation) │ (Max 128KB) │ └─────────────────────────┘ 0x00038000 ```- Key-value store:
bytes32 → bytes32 - Accessed via:
SLOADandSSTOREopcodes - Gas costs:
SLOAD: 200 gas (cold), 100 gas (warm)SSTORE: 5000 gas (cold), 200 gas (warm)
Fixed-width 64-bit instructions:
┌────────┬────────┬────────┬────────┬────────────────┐
│ opcode │ dst │ src1 │ src2 │ immediate │
│ 8-bit │ 8-bit │ 8-bit │ 8-bit │ 32-bit │
└────────┴────────┴────────┴────────┴────────────────┘
| Operation | Gas Cost |
|---|---|
| Arithmetic | 3 gas |
| Bitwise | 3 gas |
| Comparison | 3 gas |
| Memory load | 3 gas |
| Memory store | 3 gas |
| Storage load (cold) | 200 gas |
| Storage load (warm) | 100 gas |
| Storage store (cold) | 5000 gas |
| Storage store (warm) | 200 gas |
| Jump | 8 gas |
| Call | 100 gas + target gas |
| Create | 32000 gas |
| Log | 375 gas + 375 per topic + 8 per byte |
memory_cost = (memory_size_word ** 2) / 512 + (3 * memory_size_word)
- Max depth: 1024 calls
- Each frame stores:
- Return address (pc)
- Saved registers (r0-r31)
- Local variables
- Gas limit for this call
ArgusVM provides a syscall interface for cryptographic operations:
| ID | Name | Input | Output |
|---|---|---|---|
| 0 | ecrecover | hash, v, r, s | address |
| 1 | sha256 | data, len | hash |
| 2 | keccak256 | data, len | hash |
| 3 | blake2b | data, len | hash |
| 4 | verify_ed25519 | msg, sig, pubkey | bool |
| 5 | verify_secp256k1 | msg, sig, pubkey | bool |
| 6 | bls_verify | msg, sig, pubkey | bool |
| 7 | bls_aggregate | sigs[], len | aggregated_sig |
| 8 | modexp | base, exp, mod | result |
| 9 | bn256_add | x1, y1, x2, y2 | x3, y3 |
| 10 | bn256_mul | x, y, scalar | x2, y2 |
| 11 | bn256_pairing | points[], len | bool |
Standard precompiles for common cryptographic operations:
| Address | Name | Purpose |
|---|---|---|
| 0x01 | ECRecover | ECDSA signature recovery |
| 0x02 | SHA256 | SHA-256 hash |
| 0x03 | RIPEMD160 | RIPEMD-160 hash |
| 0x04 | Identity | Data copy |
| 0x05 | ModExp | Modular exponentiation |
| 0x06 | BN256Add | BN256 elliptic curve addition |
| 0x07 | BN256Mul | BN256 elliptic curve multiplication |
| 0x08 | BN256Pairing | BN256 pairing check |
| 0x09 | Blake2F | Blake2b F compression |
| 0x0A | BLS12Verify | BLS12-381 signature verification |
| 0x0B | BLS12Aggregate | BLS12-381 signature aggregation |
┌──────────────────────┐
│Magic Number (4 bytes)│ 0x41564D00 ("AVM\0")
├──────────────────────┤
│ Version (2 bytes) │ 0x0001
├──────────────────────┤
│ Code Size (4 bytes) │ Length of code section
├──────────────────────┤
│ Data Size (4 bytes) │ Length of data section
├──────────────────────┤
│ Code Section │ Executable instructions
│ (variable length) │
├──────────────────────┤
│ Data Section │ Initialized constants
│ (variable length) │
├──────────────────────┤
│ Metadata Section │ ABI, source map, etc.
│ (variable length) │
└──────────────────────┘
// Example: ADD r1, r2, r3
// Encoding: 0x01 0x01 0x02 0x03 0x00000000
┌────────┬────────┬────────┬────────┬────────────────┐
│ opcode │ dst │ src1 │ src2 │ immediate │
│ 0x01 │ 0x01 │ 0x02 │ 0x03 │ 0x00000000 │
└────────┴────────┴────────┴────────┴────────────────┘- ❌ System time (use
block.timestamp) - ❌ Random numbers (use
block.hash + nonce) - ❌ Floating point (use fixed-point arithmetic)
- ❌ Hash map iteration order (use sorted keys)
- ❌ External I/O (only syscalls allowed)
- ✅ All arithmetic is 256-bit integer (no floats)
- ✅ Division by zero returns 0 (no exceptions)
- ✅ Out-of-bounds memory access reverts
- ✅ All randomness from blockchain state
- ✅ Fixed gas costs per operation
| Metric | Value |
|---|---|
| Throughput | 10,000+ simple transactions/sec per core |
| Latency | <1ms per simple contract call |
| Memory | <100MB per VM instance |
| Startup | <10ms to initialize VM |
- JIT compilation for hot paths (future)
- Register allocation optimization
- Instruction fusion (combine common patterns)
- Lazy memory allocation
| Feature | ArgusVM | EVM | WASM |
|---|---|---|---|
| Architecture | Register | Stack | Stack |
| Word Size | 256-bit | 256-bit | 32/64-bit |
| Gas Metering | Yes | Yes | External |
| Deterministic | Yes | Yes | Depends |
| Precompiles | Yes | Yes | No |
| JIT Support | Future | No | Yes |
| EVM Compatible | Yes | N/A | No |
| EVM Dependent | No | Yes | No |
While ArgusVM is independent, we maintain full EVM compatibility through a translation layer:
EVM bytecode can be translated to AVM bytecode:- Stack operations → Register operations
- EVM opcodes → AVM opcodes
- Gas costs normalized
- Behavior preserved
- Hardhat, Foundry, Remix support
- MetaMask and other wallets
- Block explorers
- Bridge protocols
1. Deploy existing Solidity contracts (via translation)
2. Gradually migrate to OpenLang
3. Optimize for ArgusVM architecture
4. Leverage native performance benefits
ArgusVM is designed to work with OpenLang, Paxeer's Rust-inspired smart contract language:
// OpenLang example
contract MyToken {
state balance: Map<address, u256>;
pub fn transfer(to: address, amount: u256) -> bool {
require(balance[msg.sender] >= amount, "insufficient balance");
balance[msg.sender] -= amount;
balance[to] += amount;
return true;
}
}- Rust-inspired syntax
- Type safety
- Built-in overflow protection
- Optimized register allocation
ArgusVM represents Paxeer Network's commitment to building a fully self-sustainable ecosystem while maintaining EVM compatibility. By combining register-based architecture, 256-bit native arithmetic, and deterministic execution, ArgusVM provides the foundation for Paxeer to become the first EVM L2 to transition into EVM-compatibility without EVM-dependency.
**Join the Revolution:** Build on ArgusVM and be part of the future of blockchain execution environments. Start with [OpenLang](/openlang) and [OPAX-28](/opax-28) today!