Skip to main content

Ver$e ID Technical Architecture

🏗️ Core Protocol Design​

Ver$e ID revolutionizes Web3 identity through a separation of concerns architecture that enables universal identity scoring with modular token distribution.

Universal Layer Architecture​

The protocol maintains a constant, cross-platform identity system:

// Universal Identity Components
interface VerseID {
  bits: number;           // Basic Interaction Token Score
  beats: number;          // Achievement milestones
  track: 'align' | 'synergy' | 'alpha';
  reputation: number;     // Compound value score
  createdAt: timestamp;
  platforms: Platform[];  // All integrated platforms
}

BITS Generation System​

BITS (Basic Interaction Token Score) are the fundamental unit of contribution:

// BITS Generation Formula
function calculateBITS(action: Action): number {
  const baseReward = getBaseReward(action.type);
  const trackBonus = getTrackMultiplier(user.track);
  const consistency = getConsistencyBonus(user.history);

  return baseReward * action.multiplier * trackBonus * consistency;
}

// Base Reward Examples
const BASE_REWARDS = {
  daily_login: 10,
  quest_complete: 50-500,
  social_share: 10,
  viral_content_1k: 50,
  stake_1000_month: 100,
  l1_referral: 0.6 * referral_bits
};

BEATS Milestone System​

BEATS are earned at Fibonacci thresholds, creating natural progression:

// Fibonacci Progression
const BEAT_THRESHOLDS = [
  256,   // 1st BEAT 🏆
  512,   // 2nd BEAT 🏆
  1024,  // 3rd BEAT 🏆
  2048,  // 4th BEAT 🏆
  4096,  // 5th BEAT 🏆
  // Continues following Fibonacci pattern
];

// BEAT Value Calculation
function calculateBeatValue(beats: number): number {
  return beats * 100; // 1 BEAT = 100 BITS for distribution
}

📐 Triadic Track System​

The revolutionary three-track system solves Web3's 91/9/3 participation crisis through inverse distribution:

Track Distribution Model​

enum Track {
  ALIGN = 'align',      // 60% users → 10% rewards
  SYNERGY = 'synergy',  // 30% users → 30% rewards
  ALPHA = 'alpha'       // 10% users → 60% rewards
}

const TRACK_CONFIG = {
  align: {
    userPercentage: 0.60,
    rewardPercentage: 0.10,
    multiplier: 0.167,
    bitsBase: 8,
    agent: 'BigSis',
    color: '#00A1F1',
    ltv: [50, 500]
  },
  synergy: {
    userPercentage: 0.30,
    rewardPercentage: 0.30,
    multiplier: 1.0,
    bitsBase: 16,
    bonusMultiplier: 1.125, // 12.5% bonus
    agent: 'LilSis',
    color: '#7E3AF2',
    ltv: [500, 5000]
  },
  alpha: {
    userPercentage: 0.10,
    rewardPercentage: 0.60,
    multiplier: 6.0,
    bitsBase: 64,
    agent: 'Bro',
    color: '#FE5F00',
    ltv: [5000, 50000]
  }
};

Track Assignment Algorithm​

function assignTrack(user: User): Track {
  const activityScore = calculateActivityScore(user);
  const networkScore = calculateNetworkScore(user);
  const capitalScore = calculateCapitalScore(user);

  if (capitalScore > ALPHA_THRESHOLD) return Track.ALPHA;
  if (networkScore > SYNERGY_THRESHOLD) return Track.SYNERGY;
  return Track.ALIGN;
}

🔐 The 12.5% Guarantee Protocol​

The first Identity Safety Net in Web3 ensures value persistence:

// Smart Contract Implementation
contract VerseIDProtocol {
    uint256 constant VERSEID_GUARANTEE = 1250; // 12.5% in basis points

    modifier enforceGuarantee(uint256 distribution) {
        uint256 verseIdShare = (distribution * VERSEID_GUARANTEE) / 10000;
        require(verseIdShare >= minGuaranteeAmount, "Below minimum guarantee");
        _;
    }

    function distributeRewards(
        address hub,
        address token,
        uint256 amount
    ) external enforceGuarantee(amount) {
        // Calculate Ver$e ID holders' guaranteed share
        uint256 guaranteedAmount = (amount * VERSEID_GUARANTEE) / 10000;

        // Distribute to Ver$e ID holders first
        distributeToVerseIDHolders(token, guaranteedAmount);

        // Remaining distribution to hub-specific rules
        uint256 remaining = amount - guaranteedAmount;
        hubDistribution[hub].distribute(token, remaining);
    }
}

🔄 Modular Token Distribution​

Hot-Swappable Token Architecture​

// Modular Token Configuration
interface HubConfig {
  token: string;           // Any ERC20 token
  distribution: 'daily' | 'weekly' | 'monthly';
  verseIdGuarantee: 0.125; // Always 12.5%
  trackMultipliers: TrackMultipliers;
  customRules?: CustomDistribution;
}

// Example Implementations
const BROVERSE_CONFIG: HubConfig = {
  token: "$BRO",
  distribution: "monthly",
  verseIdGuarantee: 0.125,
  trackMultipliers: { align: 0.167, synergy: 1.0, alpha: 6.0 }
};

const ALPHAHUB_CONFIG: HubConfig = {
  token: "$CUSTOM",  // Hot-swappable!
  distribution: "weekly",
  verseIdGuarantee: 0.125,
  customRules: true  // Hub-specific modifications
};

Distribution Calculation Engine​

function calculateTokenDistribution(
  user: User,
  hub: Hub,
  period: Period
): TokenAmount {
  // Step 1: Calculate period score
  const periodScore = user.bits + (user.beats * 100);

  // Step 2: Apply track multiplier
  const trackAdjusted = periodScore * TRACK_CONFIG[user.track].multiplier;

  // Step 3: Calculate share of pool
  const totalPoolScore = hub.getTotalPoolScore(period);
  const userShare = trackAdjusted / totalPoolScore;

  // Step 4: Calculate token amount
  const tokenAmount = userShare * hub.monthlyRewards;

  // Step 5: Ensure 12.5% guarantee
  return Math.max(tokenAmount, hub.minimumGuarantee);
}

🤖 Four Agent Operational Model​

Agent Architecture​

interface Agent {
  id: string;
  name: string;
  color: string;
  role: string;
  operations: Operation[];
}

const AGENTS = {
  bigsis: {
    id: 'bigsis',
    name: 'BigSis',
    color: '#00A1F1',
    role: 'IDENTITY_GUARDIAN',
    operations: [
      'manage_verseid_protocol',
      'sync_cross_platform',
      'maintain_reputation',
      'persistent_digital_self'
    ]
  },
  bro: {
    id: 'bro',
    name: 'Bro',
    color: '#FE5F00',
    role: 'ACTIVITY_TRACKER',
    operations: [
      'distribute_bits',
      'realtime_scoring',
      'track_contributions',
      'validate_actions'
    ]
  },
  lilsis: {
    id: 'lilsis',
    name: 'LilSis',
    color: '#7E3AF2',
    role: 'ACHIEVEMENT_CELEBRATOR',
    operations: [
      'award_beats',
      'trigger_celebrations',
      'manage_progression',
      'milestone_recognition'
    ]
  },
  cbo: {
    id: 'cbo',
    name: 'CBO',
    color: '#3EB85F',
    role: 'VALUE_DISTRIBUTOR',
    operations: [
      'convert_bits_beats_tokens',
      'manage_all_token_types',
      'ensure_guarantee',
      'wealth_distribution'
    ]
  }
};

🌐 Universal Portability System​

Cross-Platform Identity Sync​

class VerseIDSync {
  private identityContract: Contract;
  private platformRegistry: Map<string, Platform>;

  async syncIdentity(userId: string, platforms: string[]) {
    const identity = await this.identityContract.getIdentity(userId);

    for (const platformId of platforms) {
      const platform = this.platformRegistry.get(platformId);
      await platform.updateIdentity({
        bits: identity.bits,
        beats: identity.beats,
        track: identity.track,
        reputation: identity.reputation
      });
    }

    return {
      synced: platforms.length,
      totalBits: identity.bits,
      totalBeats: identity.beats
    };
  }
}

Compounding Value Mechanism​

function calculateCompoundValue(identity: VerseID): number {
  const factors = {
    bits: identity.bits,
    hubMultiplier: getActiveHubsMultiplier(identity),
    timeDecay: calculateTimeDecay(identity.createdAt),
    networkEffect: Math.pow(identity.connections, 1.2),
    reputation: identity.reputation
  };

  return factors.bits *
         factors.hubMultiplier *
         factors.timeDecay *
         factors.networkEffect *
         factors.reputation;
}

// Growth Projections
const VALUE_PROGRESSION = {
  month_1: { bits: 100, value: 10 },
  month_3: { bits: 500, value: 75 },
  month_6: { bits: 2000, value: 400 },
  year_1: { bits: 10000, value: 2500 },
  year_2: { bits: 50000, value: 15000 }
};

🔌 API Architecture​

Core Endpoints​

// Ver$e ID API Structure
const API_ROUTES = {
  // Identity Management
  '/api/verseid/create': 'POST',           // Mint new Ver$e ID
  '/api/verseid/:id': 'GET',               // Retrieve identity
  '/api/verseid/:id/sync': 'POST',         // Sync across platforms

  // BITS Operations
  '/api/bits/award': 'POST',               // Award BITS for actions
  '/api/bits/history/:userId': 'GET',      // BITS history
  '/api/bits/leaderboard': 'GET',          // Top BITS holders

  // BEATS Management
  '/api/beats/check/:userId': 'GET',       // Check for new BEATS
  '/api/beats/celebrate': 'POST',          // Trigger celebration
  '/api/beats/milestones': 'GET',          // All milestones

  // Distribution Engine
  '/api/distribution/calculate': 'POST',    // Calculate rewards
  '/api/distribution/claim': 'POST',        // Claim tokens
  '/api/distribution/history': 'GET',       // Distribution history

  // Hub Integration
  '/api/hub/register': 'POST',              // Register new hub
  '/api/hub/:id/config': 'PUT',            // Update hub config
  '/api/hub/:id/stats': 'GET',             // Hub statistics

  // Guarantee Verification
  '/api/guarantee/verify/:hubId': 'GET',    // Verify 12.5% compliance
  '/api/guarantee/audit': 'GET',            // Full guarantee audit
};

WebSocket Events​

// Real-time Events
const WEBSOCKET_EVENTS = {
  // BITS Events
  'bits:awarded': { userId, amount, action, timestamp },
  'bits:milestone': { userId, total, nextBeat },

  // BEATS Events
  'beat:earned': { userId, beatNumber, celebration },
  'beat:leaderboard': { updates, rankings },

  // Distribution Events
  'distribution:calculated': { period, amounts },
  'distribution:ready': { userId, claimable },

  // System Events
  'identity:synced': { userId, platforms },
  'guarantee:verified': { hubId, compliant }
};

📊 Network Effects Formula​

function calculateNetworkValue(ecosystem: Ecosystem): number {
  const verseIds = ecosystem.totalIdentities;
  const platforms = ecosystem.integratedPlatforms;
  const users = ecosystem.activeUsers;

  // Each Ver$e ID creates 1000x potential value
  const identityValue = verseIds * 1000;

  // Each platform adds 100x network effect
  const platformEffect = platforms * 100;

  // Users squared creates viral growth
  const viralEffect = Math.pow(users, 2) * 0.1;

  return identityValue * platformEffect * viralEffect;
}

🔧 Smart Contract Architecture​

Main Protocol Contract​

pragma solidity ^0.8.19;

contract VerseIDProtocol {
    // State Variables
    mapping(address => VerseID) public identities;
    mapping(address => uint256) public bits;
    mapping(address => uint256) public beats;
    mapping(address => Track) public tracks;

    // Hub Registry
    mapping(address => Hub) public hubs;
    mapping(address => IERC20) public hubTokens;

    // Constants
    uint256 constant VERSEID_GUARANTEE = 1250; // 12.5%
    uint256[] BEAT_THRESHOLDS = [256, 512, 1024, 2048, 4096];

    // Events
    event BitsAwarded(address user, uint256 amount, string action);
    event BeatEarned(address user, uint256 beatNumber);
    event RewardsDistributed(address hub, uint256 amount);

    // Core Functions
    function awardBits(
        address user,
        uint256 amount,
        string memory action
    ) external onlyAuthorized {
        bits[user] += amount;
        checkBeatProgress(user);
        emit BitsAwarded(user, amount, action);
    }

    function checkBeatProgress(address user) internal {
        uint256 userBits = bits[user];
        uint256 currentBeats = beats[user];

        for (uint i = currentBeats; i < BEAT_THRESHOLDS.length; i++) {
            if (userBits >= BEAT_THRESHOLDS[i]) {
                beats[user]++;
                emit BeatEarned(user, beats[user]);
            } else {
                break;
            }
        }
    }
}

Building the universal identity layer for Web3 - where your identity IS your wealth.