Net

Net: Onchain Messaging Protocol

Overview

The Net dapp consists of a series of Net apps powered by Net protocol.

Net protocol is an onchain messaging protocol designed to simplify the process of writing and reading messages stored on the blockchain. It is a free, public good that can be deployed on any blockchain. Net enables both onchain apps (smart contracts) and off-chain dapps to send and read messages, making it a versatile tool for developers building decentralized applications.

This is solely the documentation for the onchain Net protocol (not for the Net dapp itself), which powers the Net dapp and any other apps built on top of it.

Key Features

  • Fully onchain: All data is stored on the blockchain, leveraging the cost efficiency of Layer 2 and Layer 3 blockchains. This enables fully onchain dapps that read all of their core data from the blockchain rather than external databases.
  • Decentralized and Censorship-Resistant: Net is fully decentralized at the protocol level, ensuring that anyone can use it and build apps on top of it without permission or cost.
  • Global Message Storage: Messages are stored on the blockchain and can be read by anyone.
  • Flexible Message Retrieval: Messages can be queried globally, by app, by app user, or by app user and topic.
  • Open and Permissionless: Anyone can build apps on top of Net.
  • Cross-Chain Compatibility: Net can exist on any blockchain.

Net is deployed at the following address on Ethereum, Base, Ink, Ham, Degen, Unichain, and Hyperliquid:

0x00000000b24d62781db359b07880a105cd0b64e6

You can view the contract on Etherscan here: Net on Etherscan.

How Net Works

Send Message Functions

Net provides two primary functions for sending messages: sendMessageViaApp and sendMessage. Both functions allow users and apps to store messages onchain, with optional topics for indexing and filtering.

1. sendMessageViaApp

  • Used by onchain apps to send messages.
  • Allows apps to specify the sender, message content, topic, and data.
  • Messages are indexed by:
    • App
    • App-user
    • App-topic
    • App-user-topic
  • Emits a MessageSentViaApp event.
function sendMessageViaApp(
    address sender,
    string calldata text,
    string calldata topic,
    bytes calldata data
) external;

2. sendMessage

  • Used by users to send messages directly (without an app).
  • Allows users to specify the message content, topic, and data.
  • Messages are indexed by:
    • Global messages (no app)
    • User-topic
  • Emits a MessageSent event.
function sendMessage(
    string calldata text,
    string calldata topic,
    bytes calldata data
) external;

Emitting Events for Indexers

When a message is sent, Net emits an event (MessageSentViaApp or MessageSent) to notify indexers and other off-chain services. Indexers can listen to these events and use the messagesLength value (emitted as part of the event) as the index to query in Net to retrieve the corresponding message.

For example:

  • After emitting MessageSentViaApp, the message can be retrieved using messagesLength - 1 as the index.
  • This allows indexers to efficiently track and process messages without needing to scan all Net messages.
event MessageSentViaApp(
    address indexed app,
    address indexed sender,
    string indexed topic,
    uint256 messagesLength
);

event MessageSent(
    address indexed sender,
    string indexed topic,
    uint256 messagesLength
);

Reading Messages

Messages can be read in several ways:

  1. Globally: Retrieve all messages sent through Net.
  2. By App: Retrieve all messages sent by a specific app.
  3. By App Topic: Retrieve all messages sent by a specific app, filtered by a specific topic.
  4. By App User: Retrieve all messages sent by a specific user within an app.
  5. By App User and Topic: Retrieve messages sent by a specific user within an app, filtered by a specific topic.

Smart Contract Details

Core Contract: Net.sol

The Net.sol contract is the core of the protocol. It handles message storage, indexing, and retrieval.

Key Functions

  1. sendMessageViaApp:

    • Allows apps to send messages with a specified sender, text, topic, and data.
    • Messages are indexed by app, app-user, app-topic, and app-user-topic.
    • Emits a MessageSentViaApp event.

  2. sendMessage:

    • Allows users to send messages directly (without an app).
    • Messages are indexed globally and by user-topic.
    • Emits a MessageSent event.

  3. Message Retrieval Functions:

    • Messages can be retrieved by app, app-user, app-topic, or app-user-topic.
    • Example: getMessageForApp, getMessageForAppUser, getMessageForAppTopic, etc.

  4. Bulk Retrieval Functions:

    • Retrieve multiple messages in a range for efficient querying.
    • Example: getMessagesInRangeForApp, getMessagesInRangeForAppUser, etc.

  5. Message Count Functions:

    • Get the total number of messages for a specific query type.
    • Example: getTotalMessagesForAppCount, getTotalMessagesForAppUserCount, etc.

Onchain Net Apps

1. Net Storage

Net Storage is an onchain Net app that allows users to store and modify values associated with keys. All changes are recorded as Net messages, ensuring that the complete version history is stored fully onchain.

2. Net Bazaar

Net Bazaar is an onchain Net app for sharing Seaport orders. Orders are sent as Net messages and indexed by topic, making it easy to find orders for specific token contracts. All order data is stored fully onchain through Net.

3. Net Seaport Zone

Net Seaport Zone is an onchain Net app for validating and storing Seaport sales. Sales are sent as Net messages and indexed by topic. All sale data is stored fully onchain through Net.

4. Inscribed Drops

Inscribed Drops is an onchain Net app for creating NFT mints by inscribing token URIs and mint configurations in Net messages. It supports configurable mint prices, supply limits, and wallet limits. All NFT metadata and mint configurations are stored fully onchain through Net.

5. Memecoin-NFTs

Memecoin-NFTs is an onchain Net app for creating memecoin-NFTs, where the NFT mint is open for 24 hours and minting the NFT also gives you the memecoin. The premise is that the NFT gives you a long-term collectible and allows you to collect art paired with a memecoin. This is built on top of Inscribed Drops, Net Storage, and a fork of Clanker. Creators of memecoin-NFTs can claim a percentage of the memecoin trading fees.

Examples

Query Net for message sent by Net Bazaar 
import { readContract } from "viem/actions";
import {
  createPublicClient,
  defineChain,
  http,
  decodeAbiParameters,
} from "viem";

export type OnchainMessage = {
  data: `0x${string}`;
  text: string;
  sender: string;
  app: string;
  timestamp: BigInt;
  topic: string;
};

// Define the Hyperliquid EVM chain
export const HYPER_LIQUID_EVM = defineChain({
  id: 999,
  name: "HyperEVM",
  nativeCurrency: { name: "Hype", symbol: "HYPE", decimals: 18 },
  rpcUrls: {
    default: {
      http: ["https://rpc.hyperliquid.xyz/evm"],
    },
    public: {
      http: ["https://rpc.hyperliquid.xyz/evm"],
    },
  },
  iconUrls: [""],
  blockExplorers: {
    default: {
      name: "Hyperliquid",
      url: "https://hyperliquid.cloud.blockscout.com/",
    },
  },
  testnet: false,
});

const NET_CONTRACT: { address: `0x${string}`; abi: any } = {
  address: "0x00000000b24d62781db359b07880a105cd0b64e6",
  abi: [
    {
      type: "function",
      name: "getMessage",
      inputs: [{ name: "idx", type: "uint256", internalType: "uint256" }],
      outputs: [
        {
          name: "",
          type: "tuple",
          internalType: "struct INet.Message",
          components: [
            { name: "app", type: "address", internalType: "address" },
            { name: "sender", type: "address", internalType: "address" },
            { name: "timestamp", type: "uint256", internalType: "uint256" },
            { name: "data", type: "bytes", internalType: "bytes" },
            { name: "text", type: "string", internalType: "string" },
            { name: "topic", type: "string", internalType: "string" },
          ],
        },
      ],
      stateMutability: "view",
    },
  ],
};

// Define the ABI for decoding the Seaport order
const SEAPORT_ORDER_ABI = [
  {
    type: "tuple",
    name: "Submission",
    components: [
      {
        type: "tuple",
        name: "parameters",
        components: [
          { type: "address", name: "offerer" },
          { type: "address", name: "zone" },
          {
            type: "tuple[]",
            name: "offer",
            components: [
              { type: "uint8", name: "itemType" },
              { type: "address", name: "token" },
              { type: "uint256", name: "identifierOrCriteria" },
              { type: "uint256", name: "startAmount" },
              { type: "uint256", name: "endAmount" },
            ],
          },
          {
            type: "tuple[]",
            name: "consideration",
            components: [
              { type: "uint8", name: "itemType" },
              { type: "address", name: "token" },
              { type: "uint256", name: "identifierOrCriteria" },
              { type: "uint256", name: "startAmount" },
              { type: "uint256", name: "endAmount" },
              { type: "address", name: "recipient" },
            ],
          },
          { type: "uint8", name: "orderType" },
          { type: "uint256", name: "startTime" },
          { type: "uint256", name: "endTime" },
          { type: "bytes32", name: "zoneHash" },
          { type: "uint256", name: "salt" },
          { type: "bytes32", name: "conduitKey" },
          { type: "uint256", name: "totalOriginalConsiderationItems" },
        ],
      },
      { type: "uint256", name: "counter" },
      { type: "bytes", name: "signature" },
    ],
  },
];

// Create a public client for the Hyperliquid chain
const publicClient = createPublicClient({
  chain: HYPER_LIQUID_EVM,
  transport: http(),
});

// Function to decode the Seaport order from message data
function getSeaportOrderFromListingMessageData(messageData: `0x${string}`) {
  const [decodedOrder]: any[] = decodeAbiParameters(
    SEAPORT_ORDER_ABI,
    messageData
  );
  return decodedOrder;
}

// Main function to fetch and decode the message
async function fetchAndDecodeMessage(messageIndex: number) {
  try {
    // Fetch the message from the contract
    const messageResult = (await readContract(publicClient, {
      abi: NET_CONTRACT.abi,
      address: NET_CONTRACT.address,
      functionName: "getMessage",
      args: [messageIndex],
    })) as OnchainMessage | undefined;

    if (!messageResult) {
      console.error("Message not found for index:", messageIndex);
      return;
    }

    if (!messageResult.data) {
      console.error("Message data not found for index:", messageIndex);
      return;
    }

    // Decode the message data
    const decodedOrder = getSeaportOrderFromListingMessageData(
      messageResult.data
    );

    // Log the decoded Seaport order
    console.log("Decoded Seaport Order:", decodedOrder);
  } catch (error) {
    console.error("Error fetching or decoding message:", error);
  }
}

// Run the example
fetchAndDecodeMessage(38768);

Note

This documentation will be improved and expanded over time. Nothing said here or anywhere on the Net dapp is financial advice