@aigentic/economy-wasm - CRDT Credit Economy for Distributed Compute

A CRDT-based autonomous credit economy for distributed compute networks. Provides conflict-free P2P credit tracking, stake/slash mechanics, and reputation scoring - a blockchain alternative for edge computing and AI agent coordination.

Key Features

• CRDT Ledger: G-Counter and PN-Counter for P2P-safe credit tracking with guaranteed eventual consistency
• 10x Early Adopter Curve: Contribution multiplier decaying from 10x to 1x baseline as network grows
• Stake/Slash Mechanics: Participation requirements with slashing for sybil attacks, double-spending, and bad behavior
• Reputation Scoring: Multi-factor composite score based on accuracy, uptime, and stake weight
• Merkle State Root: Fast ledger verification with cryptographic proofs
• WASM-Optimized: Runs in browsers, Node.js, and edge runtimes

Installation

npm install ruvector-economy-wasm
# or
yarn add ruvector-economy-wasm
# or
pnpm add ruvector-economy-wasm

Quick Start

TypeScript/JavaScript

import init, {
  CreditLedger,
  ReputationScore,
  StakeManager,
  contribution_multiplier,
  SlashReason
} from 'ruvector-economy-wasm';

// Initialize WASM module
await init();

// Create a credit ledger for a node
const ledger = new CreditLedger("node-123");

// Earn credits for completed tasks
ledger.credit(100n, "task:compute-job-456");
console.log(`Balance: ${ledger.balance()}`);

// Check early adopter multiplier
const mult = contribution_multiplier(50000.0);  // 50K network compute hours
console.log(`Multiplier: ${mult.toFixed(2)}x`);  // ~8.5x for early adopters

// Credit with multiplier applied
ledger.creditWithMultiplier(50n, "task:bonus-789");

// Track reputation
const rep = new ReputationScore(0.95, 0.98, 1000n);
console.log(`Composite score: ${rep.compositeScore()}`);
console.log(`Tier: ${rep.tierName()}`);

Understanding CRDTs

Conflict-free Replicated Data Types (CRDTs) enable distributed systems to:

• Merge updates in any order with identical results
• Operate offline and sync later without conflicts
• Scale horizontally without coordination bottlenecks

This package uses:

• G-Counter: Grow-only counter for earned credits (monotonically increasing)
• PN-Counter: Positive-negative counter for spending (allows refunds/disputes)

// P2P merge example - works regardless of message order
const nodeA = new CreditLedger("node-A");
const nodeB = new CreditLedger("node-B");

// Both nodes earn credits independently
nodeA.credit(100n, "job-1");
nodeB.credit(50n, "job-2");

// Export for P2P sync
const earnedA = nodeA.exportEarned();
const spentA = nodeA.exportSpent();

// Merge on node B - associative, commutative, idempotent
const merged = nodeB.merge(earnedA, spentA);
console.log(`Merged ${merged} updates`);

Contribution Curve

Early network contributors receive higher rewards that decay as the network matures:

Multiplier = 1 + 9 * exp(-compute_hours / 100,000)

Network Hours  | Multiplier
---------------|------------
0              | 10.0x (Genesis)
10,000         | ~9.0x
50,000         | ~6.0x
100,000        | ~4.3x
200,000        | ~2.2x
500,000        | ~1.0x (Baseline)

import { contribution_multiplier, get_tier_name, get_tiers_json } from 'ruvector-economy-wasm';

// Check current multiplier
const hours = 25000;
const mult = contribution_multiplier(hours);
console.log(`At ${hours} hours: ${mult.toFixed(2)}x multiplier`);

// Get tier name
const tier = get_tier_name(hours);  // "Pioneer"

// Get all tier definitions
const tiers = JSON.parse(get_tiers_json());

Stake/Slash Mechanics

import { StakeManager, SlashReason } from 'ruvector-economy-wasm';

const stakeManager = new StakeManager();

// Stake credits for network participation
stakeManager.stake("node-123", 1000n);
console.log(`Staked: ${stakeManager.getStake("node-123")}`);

// Check if node meets minimum stake
if (stakeManager.meetsMinimum("node-123")) {
  console.log("Node can participate");
}

// Delegate stake to another node
stakeManager.delegate("node-123", "validator-1", 500n);
console.log(`Effective stake: ${stakeManager.getEffectiveStake("validator-1")}`);

// Slash for bad behavior
const slashedAmount = stakeManager.slash(
  "bad-actor",
  SlashReason.DoubleSpend,
  "Evidence: duplicate transaction IDs"
);
console.log(`Slashed ${slashedAmount} credits`);

Slash Reasons

| Reason | Severity | Description | |--------|----------|-------------| | InvalidResult | Medium | Submitted incorrect computation results | | DoubleSpend | High | Attempted to spend same credits twice | | SybilAttack | Critical | Multiple fake identities detected | | Downtime | Low | Excessive offline periods | | Spam | Medium | Flooding the network | | Malicious | Critical | Intentional harmful behavior |

Reputation System

import { ReputationScore, composite_reputation } from 'ruvector-economy-wasm';

// Create reputation with tracking
const rep = ReputationScore.newWithTracking(
  950n,  // tasks completed
  50n,   // tasks failed
  BigInt(30 * 24 * 3600),  // uptime seconds
  BigInt(31 * 24 * 3600),  // total seconds
  5000n  // stake amount
);

// Record task outcomes
rep.recordSuccess();
rep.recordFailure();

// Calculate composite score
// Formula: accuracy^2 * uptime * stake_weight
const score = rep.compositeScore();
console.log(`Composite: ${(score * 100).toFixed(1)}%`);

// Get tier
console.log(`Tier: ${rep.tierName()}`);  // "Elite", "Trusted", "Standard", etc.

// Check participation eligibility
if (rep.meetsMinimum(0.9, 0.95, 100n)) {
  console.log("Eligible for premium tasks");
}

// Compare reputations
const rep2 = new ReputationScore(0.92, 0.96, 3000n);
console.log(`Better reputation: ${rep.isBetterThan(rep2) ? 'rep1' : 'rep2'}`);

Reputation Tiers

| Tier | Score Range | Benefits | |------|-------------|----------| | Elite | >= 0.95 | Priority task assignment, lowest fees | | Trusted | >= 0.85 | High-value tasks, reduced collateral | | Standard | >= 0.70 | Normal participation | | Probation | >= 0.50 | Limited task types | | Restricted | < 0.50 | Basic tasks only, increased monitoring |

Merkle State Verification

const ledger = new CreditLedger("node-123");
ledger.credit(100n, "job-1");
ledger.credit(200n, "job-2");

// Get state root for verification
const stateRoot = ledger.stateRoot();
const stateRootHex = ledger.stateRootHex();
console.log(`State root: ${stateRootHex}`);

// Verify state integrity
const isValid = ledger.verifyStateRoot(expectedRoot);

API Reference

CreditLedger

| Method | Description | |--------|-------------| | new(node_id) | Create ledger for node | | credit(amount, reason) | Earn credits | | creditWithMultiplier(base_amount, reason) | Earn with network multiplier | | deduct(amount) | Spend credits | | refund(event_id, amount) | Refund a deduction | | balance() | Get available balance | | stake(amount) | Lock credits for participation | | slash(amount) | Penalty for bad behavior | | merge(other_earned, other_spent) | CRDT merge operation | | exportEarned() / exportSpent() | Export for P2P sync | | stateRoot() / stateRootHex() | Merkle verification |

ReputationScore

| Method | Description | |--------|-------------| | new(accuracy, uptime, stake) | Create with scores | | newWithTracking(...) | Create with detailed tracking | | compositeScore() | Calculate composite (0.0-1.0) | | tierName() | Get reputation tier | | recordSuccess() / recordFailure() | Track task outcomes | | stakeWeight() | Logarithmic stake weight | | meetsMinimum(accuracy, uptime, stake) | Check eligibility |

StakeManager

| Method | Description | |--------|-------------| | new() | Create manager | | stake(node_id, amount) | Stake credits | | unstake(node_id, amount) | Unstake (if unlocked) | | delegate(from, to, amount) | Delegate to another node | | slash(node_id, reason, evidence) | Slash for violation | | getEffectiveStake(node_id) | Own + delegated stake | | meetsMinimum(node_id) | Check stake requirement |

Use Cases

• Distributed AI Training: Reward compute contributors fairly
• Edge Computing Networks: Track and reward edge node participation
• Federated Learning: Incentivize model training contributions
• P2P Storage: Credit-based storage allocation
• Agent Coordination: Economic layer for multi-agent systems
• Decentralized Inference: Pay-per-inference without blockchain overhead

Bundle Size

• WASM binary: ~177KB (uncompressed)
• Gzip compressed: ~65KB
• JavaScript glue: ~8KB

Related Packages

• ruvector-learning-wasm - MicroLoRA adaptation
• ruvector-exotic-wasm - NAO governance, morphogenetic networks
• ruvector-nervous-system-wasm - Bio-inspired neural components

License

MIT

Links

• GitHub Repository
• Full Documentation
• Bug Reports

Keywords: CRDT, distributed systems, credits, P2P, peer-to-peer, blockchain alternative, reputation, stake, slash, economy, WebAssembly, WASM, edge computing, decentralized, conflict-free, eventual consistency, G-Counter, PN-Counter