@btc-vision/btc-runtime 1.11.0-rc.9 → 1.11.0

package/docs/core-concepts/blockchain-environment.md

@@ -1,6 +1,6 @@
 # Blockchain Environment
 
-The `Blockchain` object is the primary interface for interacting with the OPNet runtime. It provides access to block information, transaction context, storage operations, cryptographic functions, and cross-contract calls.
+The `Blockchain` object is the primary interface for interacting with the OP_NET runtime. It provides access to block information, transaction context, storage operations, cryptographic functions, and cross-contract calls.
 
 ## Overview
 
@@ -55,15 +55,15 @@ flowchart LR
 
 ### Solidity Comparison
 
-| Solidity | OPNet | Notes |
+| Solidity | OP_NET | Notes |
 |----------|-------|-------|
 | `block.number` | `Blockchain.block.number` | Current block height |
-| `block.timestamp` | `Blockchain.block.medianTimestamp` | OPNet uses Median Time Past |
+| `block.timestamp` | `Blockchain.block.medianTimestamp` | OP_NET uses Median Time Past |
 | `blockhash(n)` | `Blockchain.getBlockHash(n)` | Historical block hash |
 
 ### Median Time Past
 
-OPNet uses **Median Time Past (MTP)** instead of raw block timestamps. MTP is the median of the last 11 block timestamps, providing more reliable time measurements that are resistant to miner manipulation.
+OP_NET uses **Median Time Past (MTP)** instead of raw block timestamps. MTP is the median of the last 11 block timestamps, providing more reliable time measurements that are resistant to miner manipulation.
 
 ```typescript
 // Get current timestamp (median time past)
@@ -140,7 +140,7 @@ This distinction is critical for security:
 
 ### Solidity Comparison
 
-| Solidity | OPNet | Notes |
+| Solidity | OP_NET | Notes |
 |----------|-------|-------|
 | `msg.sender` | `Blockchain.tx.sender` | Immediate caller |
 | `tx.origin` | `Blockchain.tx.origin` | Original signer (ExtendedAddress) |
@@ -157,7 +157,7 @@ config:
 sequenceDiagram
     participant User as User/EOA
     participant TX as Transaction Broadcast
-    participant VM as OPNet VM
+    participant VM as OP_NET VM
     participant ContractA as Target Contract
     participant ContractB as External Contract
     participant Storage as Storage
@@ -166,7 +166,7 @@ sequenceDiagram
     User->>TX: Sign transaction
     TX->>VM: Broadcast transaction
 
-    Note over User,Storage: OPNet Runtime Initialization
+    Note over User,Storage: OP_NET Runtime Initialization
     VM->>VM: Initialize Blockchain Context
     VM->>VM: Set tx.origin = User Address
     VM->>VM: Set tx.sender = User Address
@@ -401,7 +401,7 @@ sequenceDiagram
 // Solidity
 (bool success, bytes memory data) = target.call(calldata);
 
-// OPNet
+// OP_NET
 const result = Blockchain.call(target, calldata, true);
 // result.success: boolean
 // result.data: BytesReader
@@ -438,7 +438,7 @@ const doubleHash: Uint8Array = Blockchain.hash256(data);
 
 ### Signature Verification
 
-OPNet supports Schnorr, ECDSA (secp256k1), and quantum-resistant ML-DSA signatures:
+OP_NET supports Schnorr, ECDSA (secp256k1), and quantum-resistant ML-DSA signatures:
 
 ```typescript
 import { SignaturesMethods } from '@btc-vision/btc-runtime/runtime';
@@ -525,7 +525,7 @@ ML-DSA Security Levels:
 
 ### Keccak-256 Hashing
 
-OPNet includes an Ethereum-compatible Keccak-256 implementation (original Keccak, not NIST SHA-3):
+OP_NET includes an Ethereum-compatible Keccak-256 implementation (original Keccak, not NIST SHA-3):
 
 ```typescript
 import { keccak256, keccak256Concat, functionSelector, ethAddressFromPubKey } from '@btc-vision/btc-runtime/runtime';

package/docs/core-concepts/decorators.md

@@ -1,10 +1,10 @@
 # Decorators
 
-Decorators are essential for OPNet smart contracts. They define the ABI (Application Binary Interface) that allows external callers to interact with your contract methods.
+Decorators are essential for OP_NET smart contracts. They define the ABI (Application Binary Interface) that allows external callers to interact with your contract methods.
 
 ## Overview
 
-OPNet uses three main decorators:
+OP_NET uses three main decorators:
 
 | Decorator | Purpose |
 |-----------|---------|
@@ -51,9 +51,9 @@ flowchart LR
 
 ## Solidity Comparison
 
-OPNet decorators serve the same purpose as Solidity's function signatures but are more explicit:
+OP_NET decorators serve the same purpose as Solidity's function signatures but are more explicit:
 
-| Solidity | OPNet |
+| Solidity | OP_NET |
 |----------|-------|
 | `function name() public view returns (string)` | `@method() @returns({ name: 'name', type: ABIDataTypes.STRING })` |
 | `function balanceOf(address owner) public view returns (uint256)` | `@method({ name: 'owner', type: ABIDataTypes.ADDRESS }) @returns({ name: 'balance', type: ABIDataTypes.UINT256 })` |
@@ -79,7 +79,7 @@ The `ABIDataTypes` enum defines all supported parameter and return types:
 
 | Type | Description | Size |
 |------|-------------|------|
-| `ABIDataTypes.ADDRESS` | OPNet address | 32 bytes |
+| `ABIDataTypes.ADDRESS` | OP_NET address | 32 bytes |
 | `ABIDataTypes.BYTES` | Variable-length bytes | Variable |
 | `ABIDataTypes.BYTES32` | Fixed 32-byte value | 32 bytes |
 

package/docs/core-concepts/events.md

@@ -1,6 +1,6 @@
 # Events
 
-Events in OPNet allow contracts to emit signals that can be observed by off-chain systems. They're essential for tracking state changes, building user interfaces, and indexing blockchain data.
+Events in OP_NET allow contracts to emit signals that can be observed by off-chain systems. They're essential for tracking state changes, building user interfaces, and indexing blockchain data.
 
 ## Overview
 
@@ -81,7 +81,7 @@ classDiagram
 
 ### Using Predefined Events
 
-OPNet provides common events out of the box:
+OP_NET provides common events out of the box:
 
 ```typescript
 import {
@@ -162,7 +162,7 @@ event Stake(address indexed staker, uint256 amount, uint64 duration);
 ```
 
 ```typescript
-// OPNet
+// OP_NET
 @final
 export class StakeEvent extends NetEvent {
     public constructor(staker: Address, amount: u256, duration: u64) {
@@ -469,7 +469,7 @@ event Transfer(address indexed from, address indexed to, uint256 value);
 ```
 
 ```typescript
-// OPNet - uses predefined TransferredEvent with operator field
+// OP_NET - uses predefined TransferredEvent with operator field
 // Event type: 'Transferred'
 import { TransferredEvent } from '@btc-vision/btc-runtime/runtime';
 
@@ -494,7 +494,7 @@ emit Transfer(from, to, amount);
 ```
 
 ```typescript
-// OPNet - using predefined TransferredEvent (includes operator)
+// OP_NET - using predefined TransferredEvent (includes operator)
 this.emitEvent(new TransferredEvent(Blockchain.tx.sender, from, to, amount));
 
 // Or using custom TransferEvent (without operator)
@@ -507,7 +507,7 @@ this.emitEvent(new TransferEvent(from, to, amount));
 // Solidity: indexed parameters for filtering
 event Transfer(address indexed from, address indexed to, uint256 value);
 
-// OPNet: All parameters can be filtered by off-chain indexers
+// OP_NET: All parameters can be filtered by off-chain indexers
 // (no explicit "indexed" keyword needed)
 ```
 

package/docs/core-concepts/pointers.md

@@ -1,6 +1,6 @@
 # Pointers
 
-Pointers are the foundation of OPNet's storage system. Understanding how they work is essential for building efficient and secure smart contracts.
+Pointers are the foundation of OP_NET's storage system. Understanding how they work is essential for building efficient and secure smart contracts.
 
 ## What Are Pointers?
 
@@ -52,7 +52,7 @@ flowchart LR
 
 ## Why Pointers?
 
-OPNet's pointer system provides:
+OP_NET's pointer system provides:
 
 | Benefit | Description |
 |---------|-------------|
@@ -63,7 +63,7 @@ OPNet's pointer system provides:
 
 ## Solidity Comparison
 
-In Solidity, storage slots are assigned implicitly by the compiler. In OPNet, you explicitly allocate pointers at runtime:
+In Solidity, storage slots are assigned implicitly by the compiler. In OP_NET, you explicitly allocate pointers at runtime:
 
 ```solidity
 // Solidity - Implicit slot assignment
@@ -75,7 +75,7 @@ contract Token {
 ```
 
 ```typescript
-// OPNet - Explicit pointer allocation
+// OP_NET - Explicit pointer allocation
 export class Token extends OP_NET {
     private totalSupplyPointer: u16 = Blockchain.nextPointer;  // ~0 (allocated at runtime)
     private namePointer: u16 = Blockchain.nextPointer;          // ~1 (allocated at runtime)
@@ -85,7 +85,7 @@ export class Token extends OP_NET {
 
 ### Storage Key Hashing Comparison
 
-| Solidity | OPNet |
+| Solidity | OP_NET |
 |----------|-------|
 | Automatic slot assignment | Explicit pointer allocation |
 | Slot 0, 1, 2, ... | `Blockchain.nextPointer` |

package/docs/core-concepts/security.md

@@ -1,10 +1,10 @@
 # Security
 
-Security is paramount in smart contract development. This guide covers OPNet's security mechanisms and best practices for writing secure contracts.
+Security is paramount in smart contract development. This guide covers OP_NET's security mechanisms and best practices for writing secure contracts.
 
 ## Security Mechanisms
 
-OPNet provides several built-in security features:
+OP_NET provides several built-in security features:
 
 | Feature | Description |
 |---------|-------------|
@@ -48,7 +48,7 @@ const remainder = SafeMath.mod(a, b); // Reverts on division by zero
 
 ### Solidity Comparison
 
-In Solidity 0.8+, arithmetic operations revert on overflow/underflow by default. OPNet achieves the same behavior through SafeMath:
+In Solidity 0.8+, arithmetic operations revert on overflow/underflow by default. OP_NET achieves the same behavior through SafeMath:
 
 ```solidity
 // Solidity 0.8+ - automatic overflow protection
@@ -56,7 +56,7 @@ uint256 result = a + b;  // Reverts on overflow
 ```
 
 ```typescript
-// OPNet - explicit SafeMath usage
+// OP_NET - explicit SafeMath usage
 const result = SafeMath.add(a, b);  // Reverts on overflow
 ```
 
@@ -138,7 +138,7 @@ modifier onlyOwner() {
 ```
 
 ```typescript
-// OPNet
+// OP_NET
 protected onlyOwner(): void {
     if (!Blockchain.tx.sender.equals(this.owner.value)) {
         throw new Revert('Not owner');

package/docs/core-concepts/storage-system.md

@@ -1,10 +1,10 @@
 # Storage System
 
-OPNet uses a pointer-based storage system that provides deterministic, secure, and efficient data persistence on Bitcoin L1. This guide explains how storage works and how to use it effectively.
+OP_NET uses a pointer-based storage system that provides deterministic, secure, and efficient data persistence on Bitcoin L1. This guide explains how storage works and how to use it effectively.
 
 ## Overview
 
-Unlike Solidity where storage is implicitly managed, OPNet requires explicit pointer allocation for all persistent data. This design provides:
+Unlike Solidity where storage is implicitly managed, OP_NET requires explicit pointer allocation for all persistent data. This design provides:
 
 - **Deterministic storage locations** via SHA256 hashing
 - **Collision-free addressing** through unique pointer combinations
@@ -88,13 +88,13 @@ flowchart LR
     P4 --> N1["owner+spender hash -> allowance"]
 ```
 
-## Solidity vs OPNet Storage Model
+## Solidity vs OP_NET Storage Model
 
-In Solidity, storage slots are assigned implicitly by the compiler. In OPNet, you explicitly allocate pointers at runtime.
+In Solidity, storage slots are assigned implicitly by the compiler. In OP_NET, you explicitly allocate pointers at runtime.
 
 ### Quick Reference Table
 
-| Feature | Solidity | OPNet |
+| Feature | Solidity | OP_NET |
 |---------|----------|-------|
 | Storage slot assignment | Implicit (compiler) | Explicit (`Blockchain.nextPointer`) |
 | Hash function | keccak256 | SHA256 |
@@ -110,7 +110,7 @@ In Solidity, storage slots are assigned implicitly by the compiler. In OPNet, yo
 
 ### Type Mapping Reference
 
-| Solidity Type | OPNet Equivalent | Notes |
+| Solidity Type | OP_NET Equivalent | Notes |
 |---------------|------------------|-------|
 | `uint256` | `StoredU256` | 32 bytes |
 | `uint64` (packed) | `StoredU64` | Stores up to 4 u64 values in one slot |
@@ -136,7 +136,7 @@ contract Token {
 ```
 
 ```typescript
-// OPNet - Explicit pointer allocation
+// OP_NET - Explicit pointer allocation
 export class Token extends OP_NET {
     private readonly totalSupplyPointer: u16 = Blockchain.nextPointer;  // ~0 (allocated at runtime)
     private readonly namePointer: u16 = Blockchain.nextPointer;          // ~1 (allocated at runtime)
@@ -168,7 +168,7 @@ flowchart LR
         S_CONTRACT -->|"CAN hold ETH"| S_CUSTODY["Contract Custody<br/>address(this).balance"]
     end
 
-    subgraph OPNetFlow["OPNet (Bitcoin L1)"]
+    subgraph OPNetFlow["OP_NET (Bitcoin L1)"]
         O_USER[("👤 User")] -->|"Signs Bitcoin TX"| O_TX["Bitcoin Transaction"]
         O_TX -->|"WASM executes"| O_CONTRACT["Smart Contract"]
 
@@ -188,10 +188,10 @@ flowchart LR
     end
 
     subgraph KeyDiff["Critical Differences"]
-        DIFF1["Custody: Solidity holds funds,<br/>OPNet verifies outputs"]
-        DIFF2["Storage: Solidity implicit slots,<br/>OPNet explicit pointers"]
-        DIFF3["Hash: Solidity keccak256,<br/>OPNet SHA256"]
-        DIFF4["Execution: Solidity EVM,<br/>OPNet WASM"]
+        DIFF1["Custody: Solidity holds funds,<br/>OP_NET verifies outputs"]
+        DIFF2["Storage: Solidity implicit slots,<br/>OP_NET explicit pointers"]
+        DIFF3["Hash: Solidity keccak256,<br/>OP_NET SHA256"]
+        DIFF4["Execution: Solidity EVM,<br/>OP_NET WASM"]
     end
 ```
 
@@ -226,15 +226,15 @@ config:
 sequenceDiagram
     participant User
     participant Bitcoin as Bitcoin L1
-    participant OPNet as OPNet Node
+    participant OP_NET as OP_NET Node
     participant WASM as WASM Runtime
     participant Contract
     participant Blockchain as Blockchain API
     participant Storage as Storage System
 
     User->>Bitcoin: Broadcast Transaction
-    Bitcoin->>OPNet: New Block with TX
-    OPNet->>WASM: Execute Contract
+    Bitcoin->>OP_NET: New Block with TX
+    OP_NET->>WASM: Execute Contract
     WASM->>Contract: Instantiate
     Contract->>Blockchain: nextPointer
     Blockchain-->>Contract: 0 (totalSupply)
@@ -247,13 +247,13 @@ sequenceDiagram
     Contract->>Storage: Read/Write with pointers
     Storage-->>Contract: Data
     Contract-->>WASM: Execution Result
-    WASM-->>OPNet: State Changes
-    OPNet->>OPNet: Update State Root
+    WASM-->>OP_NET: State Changes
+    OP_NET->>OP_NET: Update State Root
 ```
 
 ## System Architecture
 
-The following diagram shows how storage fits into the overall OPNet architecture:
+The following diagram shows how storage fits into the overall OP_NET architecture:
 
 ```mermaid
 ---
@@ -271,8 +271,8 @@ flowchart TD
         UTXO["UTXOs"]
     end
 
-    subgraph OPNetConsensus["OPNet Consensus Layer"]
-        INDEXER["OPNet Nodes"]
+    subgraph OPNetConsensus["OP_NET Consensus Layer"]
+        INDEXER["OP_NET Nodes"]
         WASM["WASM Runtime"]
         EPOCH["Epoch Mining<br/>SHA1 PoW"]
         CHECKPOINT["State Checksum<br/>Root Hash"]
@@ -317,7 +317,7 @@ flowchart TD
 
 ## Storage Types
 
-OPNet provides typed storage classes for common data types:
+OP_NET provides typed storage classes for common data types:
 
 ### Primitive Storage
 
@@ -405,7 +405,7 @@ public constructor() {
 
 ### Common Patterns Comparison
 
-| Pattern | Solidity | OPNet |
+| Pattern | Solidity | OP_NET |
 |---------|----------|-------|
 | Increment counter | `counter++;` | `counter.value = SafeMath.add(counter.value, u256.One);` |
 | Read balance | `balances[addr]` | `balanceOf.get(addr)` |
@@ -524,7 +524,7 @@ protected setAllowance(owner: Address, spender: Address, amount: u256): void {
 // struct User { address addr; uint256 balance; bool active; }
 // mapping(uint256 => User) public users;
 
-// OPNet: Use multiple pointers or encode into u256
+// OP_NET: Use multiple pointers or encode into u256
 private readonly userAddressPointer: u16 = Blockchain.nextPointer;
 private readonly userBalancePointer: u16 = Blockchain.nextPointer;
 private readonly userActivePointer: u16 = Blockchain.nextPointer;
@@ -588,7 +588,7 @@ contract SimpleToken {
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 import { u256 } from '@btc-vision/as-bignum/assembly';
 import {

package/docs/examples/basic-token.md

@@ -376,7 +376,7 @@ function mint(address to, uint256 amount) external onlyOwner {
     emit Minted(to, amount);
 }
 
-// OPNet
+// OP_NET
 @method(
     { name: 'to', type: ABIDataTypes.ADDRESS },
     { name: 'amount', type: ABIDataTypes.UINT256 },
@@ -508,7 +508,7 @@ modifier onlyOwner() {
 
 function mint(address to, uint256 amount) external onlyOwner { }
 
-// OPNet uses inline checks
+// OP_NET uses inline checks
 public mint(calldata: Calldata): BytesWriter {
     this.onlyDeployer(Blockchain.tx.sender);  // Throws if not deployer
     // ...
@@ -627,11 +627,11 @@ contract BasicToken is ERC20, Ownable {
 }
 ```
 
-## Solidity vs OPNet Comparison
+## Solidity vs OP_NET Comparison
 
 ### Key Differences Table
 
-| Aspect | Solidity (ERC20) | OPNet (OP20) |
+| Aspect | Solidity (ERC20) | OP_NET (OP20) |
 |--------|------------------|--------------|
 | **Inheritance** | `contract MyToken is ERC20, Ownable` | `class MyToken extends OP20` |
 | **Constructor** | `constructor() ERC20("Name", "SYM")` | `onDeployment()` + `this.instantiate(new OP20InitParameters(...))` |
@@ -658,7 +658,7 @@ function mint(address to, uint256 amount) external onlyOwner {
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 // Method with decorators
 @method(
@@ -682,7 +682,7 @@ public mint(calldata: Calldata): BytesWriter {
 }
 ```
 
-### Advantages of OPNet Approach
+### Advantages of OP_NET Approach
 
 | Feature | Benefit |
 |---------|---------|
@@ -703,7 +703,7 @@ constructor(string memory name, string memory symbol) ERC20(name, symbol) {
 }
 ```
 
-**OPNet (onDeployment called during contract deployment):**
+**OP_NET (onDeployment called during contract deployment):**
 ```typescript
 public override onDeployment(calldata: Calldata): void {
     const name = calldata.readString();
@@ -721,7 +721,7 @@ event Minted(address indexed to, uint256 amount);
 emit Minted(to, amount);
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 // Event class definition
 class MintEvent extends NetEvent {

package/docs/examples/nft-with-reservations.md

@@ -287,7 +287,7 @@ function whitelistMint(uint256 quantity, bytes32[] calldata proof) external {
     _mintInternal(msg.sender, quantity);
 }
 
-// OPNet - Using on-chain mapping (simpler approach)
+// OP_NET - Using on-chain mapping (simpler approach)
 @method({ name: 'quantity', type: ABIDataTypes.UINT256 })
 @returns({ name: 'success', type: ABIDataTypes.BOOL })
 @emit('Minted')
@@ -908,7 +908,7 @@ public getSaleInfo(_calldata: Calldata): BytesWriter { }
 
 ## Solidity Comparison
 
-| Aspect | Solidity (ERC721) | OPNet (OP721) |
+| Aspect | Solidity (ERC721) | OP_NET (OP721) |
 |--------|-------------------|---------------|
 | Inheritance | `contract NFT is ERC721, Ownable` | `class NFT extends OP721` |
 | Constructor | `constructor() ERC721("Name", "SYM")` | `onDeployment()` + `this.instantiate(...)` |
@@ -936,7 +936,7 @@ function whitelistMint(uint256 quantity, bytes32[] calldata proof) external paya
 }
 ```
 
-**OPNet (On-chain mapping):**
+**OP_NET (On-chain mapping):**
 ```typescript
 private _whitelist: AddressMemoryMap;
 
@@ -985,7 +985,7 @@ function reveal(string calldata _baseURI) external onlyOwner {
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 private _baseURI: StoredString;
 private _hiddenURI: StoredString;
@@ -1032,7 +1032,7 @@ function setSalePhase(SalePhase phase) external onlyOwner {
 require(salePhase == SalePhase.WHITELIST, "Whitelist sale not active");
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 const PHASE_INACTIVE: u8 = 0;
 const PHASE_WHITELIST: u8 = 1;
@@ -1061,7 +1061,7 @@ if (this._salePhase.value != PHASE_WHITELIST) {
 }
 ```
 
-### Advantages of OPNet Approach
+### Advantages of OP_NET Approach
 
 | Feature | Benefit |
 |---------|---------|
@@ -1088,7 +1088,7 @@ function _mintInternal(address to, uint256 quantity) internal {
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 private _mintInternal(to: Address, quantity: u256): void {
     const currentSupply = this.totalSupply();
@@ -1137,7 +1137,7 @@ function cancelReservation() external {
 }
 ```
 
-**OPNet (Bitcoin UTXO model):**
+**OP_NET (Bitcoin UTXO model):**
 ```typescript
 // Payment handled at Bitcoin transaction level
 // Refund logic would involve different mechanisms
@@ -1180,7 +1180,7 @@ function getSaleInfo() external view returns (
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 @method()
 @returns(

package/docs/examples/oracle-integration.md

@@ -112,7 +112,7 @@ function latestRoundData() external view returns (
     uint80 answeredInRound
 );
 
-// OPNet - Custom multi-oracle aggregation
+// OP_NET - Custom multi-oracle aggregation
 @method({ name: 'asset', type: ABIDataTypes.ADDRESS })
 @returns(
     { name: 'price', type: ABIDataTypes.UINT256 },
@@ -977,11 +977,11 @@ contract MultiOracle is Ownable {
 }
 ```
 
-## Solidity vs OPNet Comparison
+## Solidity vs OP_NET Comparison
 
 ### Key Differences Table
 
-| Aspect | Solidity (Chainlink-style) | OPNet |
+| Aspect | Solidity (Chainlink-style) | OP_NET |
 |--------|---------------------------|-------|
 | **Oracle Interface** | `AggregatorV3Interface` with rounds | Custom multi-oracle aggregation |
 | **Price Storage** | `mapping(address => PriceData)` | `AddressMemoryMap` |
@@ -992,7 +992,7 @@ contract MultiOracle is Ownable {
 | **Staleness Check** | `block.timestamp - data.timestamp` | `now - timestamp > maxStaleness` |
 | **Return Format** | Multiple return values | `BytesWriter` serialization |
 
-### Chainlink vs OPNet Oracle Pattern
+### Chainlink vs OP_NET Oracle Pattern
 
 **Chainlink (Solidity) - Consumer Pattern:**
 ```solidity
@@ -1021,7 +1021,7 @@ contract PriceConsumer {
 }
 ```
 
-**OPNet - Self-Contained Oracle:**
+**OP_NET - Self-Contained Oracle:**
 ```typescript
 @method({ name: 'asset', type: ABIDataTypes.ADDRESS })
 @returns(
@@ -1068,7 +1068,7 @@ function _calculateMedian(uint256[] memory arr, uint256 len) internal pure retur
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 private calculateMedian(prices: u256[]): u256 {
     const len = prices.length;
@@ -1104,7 +1104,7 @@ bytes32 key = keccak256(abi.encodePacked(oracle, asset));
 oracleSubmissions[key] = PriceData(price, timestamp);
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 // Uses sha256 for storage key
 private oracleAssetKey(oracle: Address, asset: Address): u256 {
@@ -1122,7 +1122,7 @@ private setOraclePrice(key: u256, price: u256): void {
 }
 ```
 
-### Advantages of OPNet Approach
+### Advantages of OP_NET Approach
 
 | Feature | Benefit |
 |---------|---------|
@@ -1146,7 +1146,7 @@ function _withinDeviation(uint256 oldPrice, uint256 newPrice) internal view retu
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 private withinDeviation(oldPrice: u256, newPrice: u256): bool {
     const maxDev = this._maxDeviation.value;
@@ -1173,7 +1173,7 @@ function submitPrice(address asset, uint256 price) external {
 }
 ```
 
-**OPNet:**
+**OP_NET:**
 ```typescript
 private oracles: StoredAddressArray;
 
@@ -1200,10 +1200,10 @@ public submitPrice(calldata: Calldata): BytesWriter {
 | Use Case | Recommended Approach |
 |----------|---------------------|
 | **Need Chainlink feeds** | Solidity with AggregatorV3Interface |
-| **Custom oracle network** | OPNet multi-oracle aggregation |
-| **Bitcoin-native DeFi** | OPNet with Bitcoin timestamp |
+| **Custom oracle network** | OP_NET multi-oracle aggregation |
+| **Bitcoin-native DeFi** | OP_NET with Bitcoin timestamp |
 | **Existing EVM infrastructure** | Solidity |
-| **New protocol on Bitcoin** | OPNet |
+| **New protocol on Bitcoin** | OP_NET |
 
 ---