How to Publish Real-Time Data Streams on DPSN: A Guide for Developers

In today's digital landscape, real-time data delivery is essential for AI systems and applications. DPSN provides developers with a decentralized infrastructure to create and publish secure data streams with blockchain-verified ownership. This guide shows you how to turn topics into valuable real-time data streams on the DPSN network.

Understanding DPSN Data Streams

Data streams in DPSN function as:

• Ownership-based channels: Each stream is owned by the wallet that purchases the underlying topic

• Real-time data pipelines: Publishers push continuous data to create streams that subscribers receive in real-time

• Permissioned resources: Only the topic owner can publish to the stream, while anyone can subscribe to it

• Authenticated channels: The blockchain provides the authentication and ownership layer

Think of data streams as secure broadcast channels where data integrity and publisher authenticity are guaranteed by blockchain verification.

Topics: The Foundation of Data Streams

Before creating a data stream, you need to understand topics:

• Topics are the foundational data unit you mint on DPSN infrastructure

• Topics establish your ownership of a specific data distribution channel

• Each topic is secured by blockchain-verified ownership

• You can create sub-topics under a single topic if you wish to publish different types of data

A topic becomes a stream when you consistently push data to it. By minting a topic and then publishing real-time data to it continuously, you transform it into a valuable data stream that others can subscribe to, creating direct monetization potential for your data.

How Topic Ownership Works (The Foundation of Streams)

When you mint a topic to create a stream:

1. Your wallet initiates a blockchain transaction to the DPSN smart contract on the Base Sepolia network

2. This transaction:

• Requires at least 0.002 Base Sepolia ETH

• Associates the topic name with your wallet's address in the contract

• Generates a unique topicHash that becomes owned by your wallet

3. Authentication works through:

• Your wallet's private key signing messages when publishing data to the topic

• The DPSN nodes verifying that only the registered owner can publish to that topic

By continuously publishing to your owned topic, you create a data stream that subscribers can reliably access.

Quick Guide: Creating and Publishing Data Streams

1. Install the DPSN Client SDK using npm or yarn:

npm install dpsn-client

# or

yarn add dpsn-client

2. Import and Initialize the Client

import { DpsnClient } from 'dpsn-client';

To initialize and authenticate with DPSN services, you’ll need an EVM wallet private key:

Use an EVM wallet: Create or use an existing Ethereum-based wallet, preferably on testnet for security.

Add your RPC details:

• DPSN URL: betanet.dpsn.org

• DPSN Smart Contract Address: 0xC4c4CFCB2EDDC26660850A4f422841645941E352 (on Base Sepolia testnet)

• BASE RPC URL: URL from any Base testnet RPC provider

• Minimum balance needed: 0.002 Base Sepolia ETH to mint a topic. You can mint the faucet tokens from here.

Get your private key: Export it from your wallet’s security settings. Configure the client:

const dpsnClient = new DpsnClient(
    "betanet.dpsn.org",  // DPSN network endpoint
    "<YOUR_EVM_WALLET_PRIVATE_KEY>",  // Your EVM wallet private key
    {
        network: 'testnet',
        wallet_chain_type: 'ethereum'
    }
);

3. Configure Blockchain Settings

// Set blockchain configuration
dpsnClient.setBlockchainConfig(
    "YOUR_TESTNET_BASE_RPC_URL",           // Your Base testnet RPC URL
    "0xC4c4CFCB2EDDC26660850A4f422841645941E352"   // DPSN contract address
);

4. Check Topic Minting Price

// Get the current price for minting a topic
const price = await dpsnClient.getTopicPrice();
console.log("Topic minting price:", price.toString());

5. Mint a Topic (The Foundation of Your Stream)

try {
    // Mint a new topic 
    const { receipt, topicHash } = await dpsnClient.purchaseTopic("YOUR_TOPIC_NAME");
    console.log("Successfully minted topic:", topicHash);
    console.log("Transaction receipt:", receipt);
} catch (error) {
    console.error("Failed to mint topic:", error);
}

6. Fetch Your Owned Topics

// Fetch all topics you own
const ownedTopics = await dpsnClient.fetchOwnedTopics();
console.log("Your topics:", ownedTopics);

7. Transform Your Topic into a Stream by Publishing Real-Time Data

try {
    // Publish data to your topic
    // A message can be JSON, string, or binary data e.g.
    const message = {
        timestamp: Date.now(),
        data: "Your message content",
        metadata: {
            source: "your-app",
            version: "1.0"
        }
    };


    await dpsnClient.publish(topicHash, message);
    console.log("Successfully published message to topic:", topicHash);
} catch (error) {
    console.error("Failed to publish message:", error);
}

Best Practices for Data Stream Publishers

To maximize the effectiveness of your real-time data streams:

• Consistent Publishing: Transform your topic into a valuable stream by publishing data consistently

• Stream Quality: Ensure your stream provides timely, accurate data that subscribers can rely on

• Error Handling: Implement proper error handling for both blockchain transactions and data publishing

• Gas Management: Monitor gas prices and set appropriate gas limits for topic minting transactions

• Data Validation: Validate data before publishing to ensure it meets your stream's requirements

• Transaction Monitoring: Track transaction status and implement retry mechanisms for failed transactions

Need Custom Solutions?

For custom data stream requirements, lower latency options, or specialized topic configurations, please reach out to us on telegram - https://t.me/dpsn_dev. We offer customized solutions for enterprise clients and high-frequency applications, including tailored data publishing infrastructure for time-sensitive systems.