Vyniq Chain Technical Documentation

Complete developer guide for building on Vyniq Chain — a mobile-first Layer 2 appchain anchored to BNB Chain. This document covers architecture, RPC API reference, wallet integration, consensus mechanics, tokenomics, and SDK usage.

Quick Start Guide

This section gets you from zero to a working connection to the Vyniq Chain testnet in under five minutes. Before beginning, ensure you have Node.js 18+ and a tool like curl or WebSocket client available.

Prerequisites

• Node.js v18.0.0 or later
• npm or yarn package manager
• Basic familiarity with JSON-RPC and REST APIs
• A code editor (VS Code recommended)

Connecting to the Testnet

The Vyniq Chain testnet is publicly accessible. Use the following endpoint to connect:

curl -X POST https://testnet-rpc.vyniq.xyz \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "vyniq_getBlockchainInfo",
    "params": [],
    "id": 1
  }'

Expected response:

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "chain": "vyniq-testnet-1",
    "blockHeight": 1337,
    "validator": "0xa1b2c3...",
    "protocolVersion": 1,
    "peers": 4
  }
}

Architecture

Vyniq Chain is built as a modular Layer 2 appchain. Each layer in the stack is independently deployable and communicates through well-defined protocols.

Layer Stack

┌─────────────────────────────────────────┐
│         Frontend (React / RN)           │  L4
│   Web App · Mobile Wallet · Explorer    │
├─────────────────────────────────────────┤
│          Mobile Wallet (React Native)   │  L3
│   Ed25519 Keypair · Send/Receive/Stake  │
├─────────────────────────────────────────┤
│             API Server (TypeScript)       │  L2
│   REST · JSON-RPC · WebSocket · Faucet  │
├─────────────────────────────────────────┤
│           Blockchain Core (TypeScript)    │  L1
│   PoA Consensus · Mempool · Block Prod.  │
├─────────────────────────────────────────┤
│            P2P Network (libp2p)          │  Net
│   Gossipsub · Noise Encryption · Discovery│
├─────────────────────────────────────────┤
│        BNB Chain Bridge (Planned)       │  Future
│   Settlement · Asset Bridging           │
└─────────────────────────────────────────┘

Core Components

The blockchain core is written in TypeScript and consists of the following modules:

• Consensus Engine: Proof of Authority with trusted validator set and Ed25519 block signing
• Transaction Pool (Mempool): Priority-ordered pending transaction queue with fee-based sorting
• Block Producer: Assembles candidate blocks from mempool transactions and broadcasts via gossip
• State Database: LevelDB-backed key-value store for account balances, nonces, and chain state
• P2P Layer: libp2p-based peer discovery, Noise protocol encryption, and Gossipsub message propagation

RPC API Reference

Vyniq Chain exposes a JSON-RPC 2.0 API over HTTP and WebSocket. All requests use standard JSON-RPC formatting with content type application/json.

Endpoints

Standard Methods

vyniq_getBlockchainInfo

Returns current blockchain status including block height, active validator, and connected peers.

curl -X POST https://testnet-rpc.vyniq.xyz/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"vyniq_getBlockchainInfo","params":[],"id":1}'

vyniq_getBalance

Returns the VYN token balance for a given address.

vyniq_sendTransaction

Submits a signed transaction to the network for inclusion in a block.

// Build and send a transaction
const tx = {
  from: "0xabc123...",
  to: "0xdef456...",
  amount: "1000000000000000000", // 1 VYN in wei
  nonce: 5,
  signature: "0x..."
};

const response = await fetch("https://testnet-rpc.vyniq.xyz/rpc", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0",
    method: "vyniq_sendTransaction",
    params: [tx],
    id: 2
  })
});

const data = await response.json();
console.log("Transaction hash:", data.result);

vyniq_getBlock

Returns block data by block number or hash.

curl -X POST https://testnet-rpc.vyniq.xyz/rpc \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"vyniq_getBlock","params":["latest"],"id":1}'

vyniq_getTransaction

Retrieves transaction details by transaction hash.

vyniq_getNonce

Returns the current nonce for a given address. Required for constructing valid transactions.

WebSocket Subscriptions

Connect to the WebSocket endpoint at wss://testnet-ws.vyniq.xyz for real-time events.

const ws = new WebSocket("wss://testnet-ws.vyniq.xyz");

ws.onopen = () => {
  // Subscribe to new blocks
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    method: "vyniq_subscribe",
    params: ["newBlocks"],
    id: 1
  }));
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log("New block:", data.params.result);
};

Wallet Integration

Vyniq Chain uses Ed25519 key pairs for all cryptographic operations. Keys can be generated and managed through the mobile wallet application or programmatically via the SDK.

Generating a Key Pair

import { generateKeyPair } from "vyniq-crypto";

// Generate a new Ed25519 key pair
const { publicKey, privateKey } = generateKeyPair();

console.log("Address:", publicKey); // 0x-prefixed hex string
console.log("Private Key:", privateKey); // Keep this secret!

Signing a Transaction

import { signTransaction } from "vyniq-crypto";

const tx = {
  from: "0xabc123...",
  to: "0xdef456...",
  amount: "5000000000000000000", // 5 VYN
  nonce: 7
};

const signedTx = signTransaction(tx, privateKey);
// signedTx now contains the signature field

Mobile Wallet (React Native)

The Vyniq mobile wallet is built with React Native and supports the following features:

• Ed25519 key generation with secure local storage
• Send and receive VYN tokens via QR code or manual address entry
• Transaction history with status tracking
• Staking interface for delegation
• Testnet faucet integration

Testing The mobile wallet is currently in active testing. A public release will follow testnet stabilization.

Consensus

Vyniq Chain uses a modern Proof of Authority (PoA) consensus model. Trusted validators secure the network by validating transactions and producing blocks — no computational competition required.

This provides:

• Fast finality — Blocks are finalized instantly upon validator signature
• Low latency — Sub-second block propagation across the network
• Extremely low energy usage — No computational puzzles or energy-intensive computation required
• Stable network performance — Predictable block times and throughput
• Enterprise-grade reliability — Designed for consistent, always-on operation

Consensus Parameters

Architecture Overview

                    ┌──────────────┐
                    │    Users     │
                    │ (Transactions)│
                    └──────┬───────┘
                           │
                           ▼
                    ┌──────────────┐
                    │  Validators  │
                    │ (PoA Signers) │
                    └──────┬───────┘
                           │
                           ▼
              ┌────────────────────────┐
              │   Proof of Authority   │
              │      Consensus         │
              └────────────┬───────────┘
                           │
                           ▼
                    ┌──────────────┐
                    │    Block     │
                    │  Production  │
                    └──────┬───────┘
                           │
              ┌────────────┼────────────┐
              │            │            │
              ▼            ▼            ▼
       ┌───────────┐ ┌──────────┐
       │Validator  │ │   Burn   │
       │  (50%)    │ │  (50%)   │
       └───────────┘ └──────────┘
              │
              ▼
       ┌──────────────┐
       │  Blockchain  │
       │   Storage    │
       └──────────────┘

Validator Rewards

Each transaction pays a fixed network fee of 0.005 VYN. The gas fee is distributed automatically:

Burn Mechanism

Vyniq includes an automatic burn mechanism. 50% of every gas fee is permanently sent to the burn address. This gradually reduces circulating supply while keeping the total maximum supply fixed at 10,000,000,000 VYN.

Staking

Staking rewards come from the Validator Incentives allocation (10% of total supply). Stakers delegate to validators and earn a share of network revenue. This keeps validator incentives and staking incentives independent.

Gas Fee

Gas fees remain fixed to provide predictable costs for users.

Validator Requirements

• Operate secure VPS servers with high uptime
• Approved by the Vyniq Governance process
• Comply with protocol consensus rules
• Future roadmap includes decentralized validator onboarding

Tokenomics

The VYN token has a fixed maximum supply of 10,000,000,000 VYN. The distribution is designed to favor long-term community alignment and ecosystem growth. No inflation. No hidden minting.

Supply Allocation

Deflationary Mechanics

• 50% Fee Burn: 50% of every gas fee is permanently removed from circulation, creating deflationary pressure proportional to network usage
• Fixed Supply Cap: 10,000,000,000 VYN hard cap — no mechanism exists to mint additional tokens
• Predictable Economics: Fixed 0.005 VYN transaction fee with transparent distribution

Revenue Model

• Transaction Fees: Fixed 0.005 VYN per transaction — 50% validators, 50% burned
• SocialFi Premium Features: Optional premium features for creators and power users
• Ecosystem Fund: Treasury allocated to ecosystem grants and strategic initiatives

Network Information

The Vyniq Chain testnet is the primary environment for developers to build, test, and integrate applications before mainnet launch.

Testnet Details

Getting Testnet Tokens

Use the testnet faucet to request VYN tokens for development purposes:

# Request 100 testnet VYN
curl -X GET "https://testnet-rpc.vyniq.xyz/faucet?address=0xYOUR_ADDRESS"

The faucet dispenses 100 VYN per request with a 24-hour cooldown per address.

Chain Configuration

Add the following configuration to your wallet or application:

{
  "chainId": "vyniq-testnet-1",
  "chainName": "Vyniq Testnet",
  "rpcUrls": ["https://testnet-rpc.vyniq.xyz/rpc"],
  "nativeCurrency": {
    "name": "VYN",
    "symbol": "VYN",
    "decimals": 18
  }
}

SocialFi Overview

Vyniq Chain's SocialFi ecosystem is a decentralized social platform built directly into the protocol layer. Users can post content, like, comment, curate, and moderate — all while earning VYN rewards based on the quality of their contributions.

Core Components

• Content Layer: Decentralized storage and indexing of user-generated content (posts, comments, media)
• Reward Algorithm: Quality-weighted distribution using engagement metrics, reputation scores, and originality analysis
• Reputation Engine: On-chain reputation tracking user contributions, content quality, and community standing
• Moderation System: Community-driven moderation with reputation-weighted voting on content flags
• Sybil Resistance: Multi-factor sybil detection combining economic, behavioral, and reputation signals

Reward Distribution

Reward Flow

User Activity (post, like, comment, curate, moderate)
    |
    v
SocialFi Reward Algorithm
    |
    +-- Quality-weighted scoring (engagement, reputation, originality)
    +-- Sybil resistance checks
    +-- Daily/weekly reward pool allocation
    |
    v
VYN Token Distribution
    |
    +-- Creator Pool (40%)
    +-- Curator Pool (25%)
    +-- Community Pool (20%)
    +-- Reputation Pool (15%)
    |
    v
User Wallet & Reputation Update

Reputation Engine

The Reputation Engine is an on-chain system that tracks user contributions and content quality. Reputation scores influence reward multipliers, governance weight, and access to platform features.

Scoring Factors

• Content Quality: Engagement metrics, originality analysis, and community feedback
• Activity Consistency: Regular positive contributions over time
• Curation Accuracy: Track record of surfacing high-quality content
• Community Standing: Peer recognition and moderation history
• Sybil Resistance: Account age, transaction history, and behavioral patterns

Reputation Tiers

Mobile Node Architecture

Mobile light nodes enable smartphones to participate in network validation. Built in Rust, these nodes are optimized for low bandwidth, battery efficiency, and intermittent connectivity.

Key Design Principles

• Minimal Bandwidth: Only block headers and relevant state are transmitted to mobile nodes
• Battery Efficient: Optimized sync intervals and sleep modes preserve battery life
• Intermittent Connectivity: Graceful reconnection and state recovery on network resume
• Validation Participation: Mobile nodes contribute to network security through lightweight validation

Governance Model

Vyniq Chain's governance model evolves from core team stewardship to full DAO control. The transition is phased and aligned with network maturity.

Governance Phases

DAO Governance Features

• VYN staker voting with reputation-weighted influence
• Proposal submission with minimum stake requirement
• Timelock delays on executed proposals
• Treasury management and fund allocation
• Emergency pause mechanism for security incidents

Validator System

Vyniq Chain operates a Proof of Authority validator network. Trusted validators are responsible for block production, transaction validation, and network security.

Validator Requirements

• Operate secure VPS servers with high uptime and reliability
• Approved by the Vyniq Governance process
• Comply with protocol consensus rules and block signing requirements
• Active participation in network governance (future)
• Future roadmap includes decentralized validator onboarding

Validator Rewards

Security Model

Vyniq Chain employs industry-standard cryptographic primitives and follows an open-source security philosophy.

Cryptographic Foundations

• Ed25519: High-speed signatures for validator block signing and transaction authentication
• SHA-256: Hash function for block integrity, address derivation, and chain verification
• Noise Protocol: Encrypted P2P communication between nodes

Audit Roadmap

• Professional third-party security audit of core protocol
• SocialFi-specific security review
• Open-source community audit and bug bounty program
• Continuous integration security scanning

SDK Reference

Installation

npm install vyniq-sdk

Client Setup

import { VyniqClient } from "vyniq-sdk";

const client = new VyniqClient({
  rpcUrl: "https://testnet-rpc.vyniq.xyz",
  chainId: "vyniq-testnet-1",
  timeout: 10000
});

// Get blockchain info
const info = await client.getInfo();
console.log(info.blockHeight);

// Get account balance
const balance = await client.getBalance("0xabc123...");
console.log("Balance:", balance);

// Send a transaction
const hash = await client.sendTransaction({
  from: "0xabc123...",
  to: "0xdef456...",
  amount: "1000000000000000000",
  privateKey: "0x..."
});
console.log("Tx hash:", hash);

API Methods

Smart Contracts (Future)

Vyniq Chain has EVM compatibility on the long-term roadmap, planned for 2029+. This section outlines the planned architecture and developer preparation steps.

Planned EVM Integration

• Full Ethereum Virtual Machine compatibility via a custom implementation
• Support for Solidity smart contract deployment and execution
• Existing Ethereum tooling compatibility: Hardhat, Foundry, Truffle
• EIP-1559-style fee market with VYN as the native gas token
• Precompile contracts for Ed25519 signature verification

Preparing for EVM compatibility: Developers building on Vyniq Chain today can prepare by writing smart contracts in Solidity and testing them on standard EVM testnets. Deployment on Vyniq Chain will require minimal configuration changes once the EVM layer is live.

Planned The EVM integration is a future roadmap item. The current Vyniq Chain protocol supports native transaction scripts. Subscribe to GitHub or Telegram for timeline updates.

Contributing

Vyniq Chain is an open-source project under the MIT license. Contributions from the community are welcome across all areas of the protocol.

How to Contribute

• Code: Submit pull requests to the GitHub repository. Follow the coding standards documented in CONTRIBUTING.md.
• Documentation: Improve or translate documentation. Technical accuracy is prioritized over stylistic polish.
• Testing: Run the test suite and report issues. Testnet participation helps harden the protocol.
• Security: Report vulnerabilities privately via GitHub security advisories or Telegram.

Development Setup

# Clone the repository
git clone https://github.com/mib316127-bit/vyniq-chain.git
cd vyniq-chain

# Install dependencies
npm install

# Start local development node
npm run dev

# Run tests
npm test

Frequently Asked Questions

What is Vyniq Chain?

Vyniq Chain is a Mobile-First Layer 2 appchain with a decentralized SocialFi ecosystem, anchored to BNB Chain. It combines blockchain infrastructure with social networking, reputation systems, and a creator economy.

Is VYN token deployed on any network?

No. The VYN token is currently a design proposal. It has not been deployed on any network. Tokenomics are subject to revision based on community input and regulatory requirements.

How does the SocialFi reward system work?

Users earn VYN rewards through quality-weighted distribution. Creators receive 40% of SocialFi rewards, curators 25%, community pool 20%, and reputation pool 15%. Rewards are distributed daily/weekly based on quality scores, engagement metrics, and sybil resistance checks.

How is the gas fee distributed?

Each transaction pays a fixed fee of 0.005 VYN, distributed as: 50% to validators, 50% burned permanently. All tokens are pre-allocated at genesis — no new tokens are minted.

How do I get testnet VYN tokens?

Use the faucet endpoint at https://testnet-rpc.vyniq.xyz/faucet?address=YOUR_ADDRESS. The faucet dispenses 100 VYN per request with a 24-hour cooldown.

What is the relationship with BNB Chain?

Vyniq Chain is designed as a complementary L2 appchain anchored to BNB Chain. BNB Chain provides settlement finality and security anchoring. The bridge is a future roadmap item.

When will EVM compatibility be available?

EVM compatibility is planned for 2029+. This is a long-term roadmap goal. Developers should monitor the GitHub repository and Telegram channel for updates.

How do validators earn rewards?

Validators earn rewards from 50% of every transaction fee (0.005 VYN per transaction) and the Validator Incentives allocation (10% of total supply). All tokens are pre-allocated at genesis — no new tokens are minted.

Vyniq Chain — Technical Documentation v2.2
MIT License © 2026 Vyniq Technologies