Abstract
Lodicoin is a decentralized social protocol that tokenizes attention, reputation, and onboarding. It allows creators, influencers, and communities to form on-chain squads where participation and impact are transparently scored and rewarded with $LODI. Instead of proof-of-work, Lodicoin is built on Proof-of-Onboarding - a model that rewards verified network growth, not speculation.
1. Vision
Bitcoin proved that digital scarcity can be achieved through cryptographic consensus. Lodicoin extends that idea to social capital: proving that influence can be measured, verified, and rewarded without central authority.
Every follower, post, and quest becomes a verifiable transaction - not of coins, but of community energy. By turning onboarding into an economic act, Lodicoin realigns the creator economy around authenticity and contribution.
"If Bitcoin solved value transfer, Lodicoin solves value of influence."
2. System Overview
The protocol has four pillars: identity and attestations, scoring, emissions, and governance. Clients submit attestations, the scorer produces reputation, emissions mint or allocate $LODI based on verifiable growth, and governance tunes parameters.
// High level modules
type Attestation = {
id: string
actor: string // wallet or platform identity
platform: 'onchain' | 'telegram' | 'discord' | 'x'
type: 'join' | 'quest' | 'referral' | 'contribute'
referrer?: string // squad or KOL that brought the actor
timestamp: number
proof: string // signature or platform proof id
}
type Reputation = {
subject: string // squad or KOL id
value: number // computed score
window: 'daily' | 'weekly'
}
type Emission = {
subject: string
amount: number
reason: 'onboarding' | 'quest' | 'milestone'
epoch: number
}3. Proof-of-Onboarding
Proof-of-Onboarding rewards creators and squads for verified user growth. Each verified join event produces a contribution score adjusted by quality and anti-sybil weights. Rewards accrue to the referrer and to the squad that hosts the journey.
// Pseudocode: Proof-of-Onboarding
function recordOnboard(referrer, newUser) {
assert(isVerified(referrer));
assert(!hasJoinedBefore(newUser));
let score = computeScore(referrer, newUser);
addReputation(referrer, score);
mintLODI(referrer, score * TOKEN_RATE);
log("onboard_event", referrer, newUser, score);
}4. How It Works - End to End
- Client collects a wallet signature that binds new user and optional referrer.
- Client posts the attestation to the API with signature and context.
- API verifies signature, de-duplicates events, and persists a canonical attestation.
- Scorer service batches attestations, applies anti-sybil and quality weights, updates reputation.
- Emission service allocates $LODI per epoch based on net verified onboarding.
- Leaderboard indexes reputation and emissions for real-time display.
Client request example:
POST /api/attestations
Content-Type: application/json
{
"actor": "9xZ...abc",
"platform": "onchain",
"type": "join",
"referrer": "KOL:squad:bosskeng",
"timestamp": 1730956800,
"signature": "base58-signature-of-hash(actor|timestamp|referrer)"
}Minimal server verification sketch:
// verify.ts
import bs58 from 'bs58'
import { verifyMessage } from '@solana/web3.js'
export async function verifyAttestation(body) {
const msg = `${body.actor}|\${body.timestamp}|\${body.referrer ?? ''}`
const sig = bs58.decode(body.signature)
const ok = await verifyMessage(new TextEncoder().encode(msg), sig, body.actor)
return ok
}5. Token Economy
- Ticker: $LODI
- Supply: Dynamic, governed by on-chain reward curves
- Distribution: Fairlaunch via Meteora bonding curve, incubated by RevShare - no presale, no private allocation
- Utility: Squad creation, leaderboard staking, reward claim, and governance
Each verified onboarding mints $LODI via a curve that decays as weekly growth rises to reduce inflation and reward consistency.
// Dynamic emission model
function getEmissionRate(weeklyGrowth) {
const BASE = 100;
const DECAY = 0.75;
return BASE * Math.pow(DECAY, weeklyGrowth / 10000);
}
function mintForScore(score, weeklyGrowth) {
const rate = getEmissionRate(weeklyGrowth)
return score * rate
}6. The Squad Paradigm
Squads are address-linked identities that accumulate reputation and share rewards with members. Reputation encourages long-term credibility over short-term hype.
// Squad reputation logic
function updateSquadScore(squad) {
const members = getMembers(squad);
const avg = mean(members.map(m => m.reputation));
squad.score = weighted(avg, members.length);
updateLeaderboard(squad);
}7. Scoring and Anti-sybil
Scores combine event type weights, referrer trust, and anti-sybil signals. A minimum viable formula is shown below.
// scoring.ts
function computeScore(referrer, newUser) {
const base = 1.0
const quality = retentionWeight(newUser) * socialProofWeight(newUser)
const referrerTrust = reputationOf(referrer) ** 0.25
const sybil = sybilPenalty(newUser) // 0..1
const score = base * quality * referrerTrust * sybil
return Math.max(0, score)
}
function sybilPenalty(newUser) {
// heuristics - device fingerprint rarity, IP entropy, social graph overlap, time anomalies
const s = blend([
rarity(newUser.device),
entropy(newUser.ipRange),
1 - overlap(newUser.graph, suspiciousGraph),
timeVariance(newUser.joinPattern)
])
return clamp(s, 0.1, 1.0)
}8. API and SDK Examples
TypeScript SDK sketch for client apps:
// sdk.ts
export async function submitJoin({ actor, referrer, sign }) {
const timestamp = Math.floor(Date.now() / 1000)
const message = `${actor}|\${timestamp}|\${referrer ?? ''}`
const signature = await sign(message) // wallet signs bytes
const r = await fetch('/api/attestations', {
method: 'POST',
headers: { 'content-type': 'application/json' },
body: JSON.stringify({ actor, platform: 'onchain', type: 'join', referrer, timestamp, signature })
})
if (!r.ok) throw new Error('attestation_failed')
return r.json()
}Leaderboard query:
GET /api/leaderboard/top?limit=30
{
"items": [
{ "rank": 1, "handle": "@BossKeng", "score": 128400, "change24h": 9, "season": "Season 0" }
]
}9. On-chain Interface Example
IDL-like sketch of a minimal program entry:
// program.idl.json - minimal
{
"name": "lodicoin_poo",
"instructions": [
{
"name": "recordOnboard",
"accounts": [
{ "name": "referrer", "isMut": true, "isSigner": false },
{ "name": "newUser", "isMut": false, "isSigner": false },
{ "name": "authority", "isMut": false, "isSigner": true }
],
"args": [
{ "name": "timestamp", "type": "u64" },
{ "name": "proofHash", "type": "bytes" }
]
}
]
}10. Security Model
- Non-custodial by design - never request seed phrase or private key.
- All sensitive writes require verifiable signatures or platform-native proofs.
- Defense in depth - rate limits, anomaly detection, and reputation throttling.
- Transparent metrics - community can audit emissions and leaderboard artifacts.
11. Governance
Lodicoin is governed by on-chain proposals and reputation-weighted votes. Token holders and verified squads can change emission ratios, verification policies, and integrations through a transparent process.
// Simplified DAO voting example
contract Governance {
mapping(address => uint) public reputation;
function propose(bytes calldata change) public onlyVerified {
uint id = proposals.length++;
proposals[id] = change;
}
function vote(uint id, bool support) public {
require(isVerified(msg.sender));
votes[id][msg.sender] = support ? reputation[msg.sender] : 0;
}
}12. Road Ahead
- Multi-chain attestations via Wormhole
- Reputation NFTs for squad leaders
- Decentralized quest market for KOLs
- Automated scoring via AI reputation oracles
Conclusion
Lodicoin turns social credibility into an economic primitive. Where Bitcoin separated money from banks, Lodicoin separates reputation from platforms. It is not a meme, but a movement - where squads become sovereign, and community becomes currency.