EigenSpreadsheet: Universal Newbie Database - Familiar Interface, Distributed Operators, $MUD Derivative Fair Launch
The problem: Databases are hard. SQL is intimidating. NoSQL is confusing. Graph databases are expert-only. Meanwhile, everyone knows spreadsheets. Excel, Google Sheets - billions of users. Familiar rows, columns, formulas. But spreadsheets aren’t databases. Can’t handle scale. Can’t coordinate globally. Can’t be trusted by multiple parties. Gap between what people know (spreadsheets) and what coordination needs (databases).
The solution: EigenSpreadsheet. Looks like Excel. Works like distributed database. Cells stored on-chain. Queries validated by EigenLayer operators. Rows/columns are just views on universal key-value store. Formulas execute as smart contracts. Everyone can use it (familiar interface). Anyone can trust it (distributed validation). Fair launched as EigenSpreadsheet-$MUD derivative. Base value $1 (staked ETH backed). Protocol yield from query fees. Universal newbie database. No SQL needed. No blockchain expertise required. Just… spreadsheet.
Why this works: The spreadsheet is the universal interface. Non-technical users already understand it. Rows are records. Columns are fields. Cells are values. Formulas are computations. This maps perfectly to database concepts but with zero learning curve. Behind the interface: cells stored on-chain (content-addressed), queries routed to EigenLayer operators (distributed computation), results validated by restaking (economic security), changes recorded immutably (audit trail). Front-end: Excel. Back-end: Distributed database. Users don’t see complexity. Just see spreadsheet. This is universal database for everyone. Fair launch in $MUD derivative (EigenSpreadsheet-$MUD earns query fee yield). Could denominate in $FRANC for French coordination projects. Technology accessible. Economics fair. Interface familiar.
The Database Accessibility Problem
Current state:
Technical users:
- Know SQL (SELECT, JOIN, WHERE)
- Understand schemas (tables, relations, indexes)
- Can setup databases (PostgreSQL, MySQL, MongoDB)
- Write queries confidently
Non-technical users:
- Open Excel
- Make spreadsheet
- Share via email
- That's it
Gap:
- Spreadsheets: Easy but limited (1M rows max, no coordination, no trust)
- Databases: Powerful but hard (SQL syntax, server setup, access control)
- Result: 99% of users stuck with spreadsheets
Why databases are hard:
- SQL syntax:
SELECT users.name, orders.total
FROM users
INNER JOIN orders ON users.id = orders.user_id
WHERE orders.date > '2024-01-01'
GROUP BY users.name;
Non-technical user sees: Incomprehensible gibberish
- Schema design:
- Tables? Relations? Foreign keys?
- Normalization? Denormalization?
- Indexes? Query optimization?
- Non-technical user thinks: I just want to store data
- Infrastructure:
- Setup PostgreSQL server
- Configure access control
- Handle backups
- Scale horizontally
- Non-technical user asks: Why can’t it just work?
Result: Powerful tool locked behind expertise barrier. 99% of users excluded.
The Spreadsheet As Universal Interface
Everyone already knows:
Rows = Records:
Row 1: Alice, alice@email.com, 25
Row 2: Bob, bob@email.com, 30
Row 3: Carol, carol@email.com, 28
This is just a table of records
Columns = Fields:
Column A: Name
Column B: Email
Column C: Age
This is just schema definition
Cells = Values:
Cell A1: "Alice"
Cell B1: "alice@email.com"
Cell C1: 25
This is just key-value storage
Formulas = Computations:
Cell D1: =C1+5 (Age + 5)
Cell E1: =IF(C1>30, "Senior", "Junior")
This is just computed fields / views
The insight: Spreadsheets already ARE databases. Just with friendlier interface. Users already understand the concepts. Just don’t know they do.
What spreadsheets lack:
- Scale (max 1M rows)
- Coordination (no multi-party trust)
- Persistence (files get lost)
- Queries (can’t SELECT like SQL)
- Distribution (single machine)
What if we fix these while keeping interface?
EigenSpreadsheet Architecture
Front-End: Familiar Interface
Looks exactly like Excel:
[EigenSpreadsheet Interface]
File | Edit | View | Insert | Formula | Data | Help
___________________________________________________
A B C D
1 Name Email Age Senior?
2 Alice alice@... 25 Junior
3 Bob bob@... 30 Junior
4 Carol carol@... 35 Senior
5
6 [Add row]
___________________________________________________
Cell E2: =IF(C2>30, "Senior", "Junior")
User interactions:
- Type in cells → Data stored on-chain
- Write formulas → Executed by operators
- Filter/sort → Query distributed database
- Share sheet → Just share address
- No crypto visible
- No “connect wallet” nonsense
- Just… spreadsheet
Middle Layer: Translation
Spreadsheet operations → Database operations:
Add row (User types in cells):
// User sees: Typing in Row 5
// Behind scenes:
const row = {
A: "David",
B: "david@email.com",
C: 28
};
await eigenSpreadsheet.addRow(row);
// Stored on-chain as key-value pairs
// Cell address = key
// Cell value = value
Formula (User writes =SUM(C2:C4)):
// User sees: Formula result updating
// Behind scenes:
const formula = "=SUM(C2:C4)";
const query = translateToOperatorQuery(formula);
// Query sent to EigenLayer operators
// Operators compute: 25 + 30 + 35 = 90
// Result returned and cached
// User sees: 90
Filter (User filters Age > 30):
// User sees: Rows filtered visually
// Behind scenes:
const filter = {
column: "C",
operator: ">",
value: 30
};
const results = await eigenSpreadsheet.query(filter);
// Distributed query across operators
// Returns matching rows
// Rendered in UI
Sort (User sorts by Age):
// User sees: Rows reordered
// Behind scenes:
const sort = {
column: "C",
direction: "DESC"
};
const sorted = await eigenSpreadsheet.sort(sort);
// Operators sort data
// Return ordered results
// UI updates
Key point: User never sees database complexity. Just spreadsheet operations. Translation layer handles everything.
Back-End: Distributed Database
Cell storage (on-chain key-value):
contract EigenSpreadsheet {
// Cell data stored as key-value
mapping(bytes32 => bytes) public cells;
// Key = keccak256(sheetId, row, column)
// Value = Cell data (encoded)
function setCell(
bytes32 sheetId,
uint256 row,
uint256 col,
bytes calldata value
) external {
bytes32 key = keccak256(abi.encode(sheetId, row, col));
cells[key] = value;
emit CellUpdated(sheetId, row, col, value);
}
function getCell(
bytes32 sheetId,
uint256 row,
uint256 col
) external view returns (bytes memory) {
bytes32 key = keccak256(abi.encode(sheetId, row, col));
return cells[key];
}
}
Query processing (EigenLayer operators):
# Operator node implementation
class EigenSpreadsheetOperator:
def __init__(self):
self.eigenlayer = EigenLayerConnection()
async def handle_query(self, query):
"""Process spreadsheet query"""
if query.type == "FORMULA":
# Execute formula (=SUM, =IF, =VLOOKUP, etc.)
result = self.execute_formula(query.formula)
elif query.type == "FILTER":
# Filter rows based on criteria
result = self.filter_rows(query.filter)
elif query.type == "SORT":
# Sort rows by column
result = self.sort_rows(query.sort)
elif query.type == "AGGREGATE":
# Compute aggregate (SUM, AVG, COUNT, etc.)
result = self.compute_aggregate(query.agg)
# Sign result with operator key
signature = self.eigenlayer.sign(result)
# Submit to chain
await self.eigenlayer.submit_result(query.id, result, signature)
return result
Validation (Economic security through restaking):
contract EigenSpreadsheetAVS {
IEigenLayer public eigenLayer;
// Operators stake ETH
mapping(address => uint256) public operatorStake;
// Query results need operator consensus
struct QueryResult {
bytes32 queryId;
bytes result;
address[] operators; // Who computed
uint256 timestamp;
}
mapping(bytes32 => QueryResult) public results;
function submitResult(
bytes32 queryId,
bytes calldata result,
bytes calldata signature
) external {
require(operatorStake[msg.sender] > 0, "Not staked");
// Verify operator signature
require(verifySignature(result, signature, msg.sender));
// Record result
results[queryId].operators.push(msg.sender);
// If consensus reached (multiple operators agree)
if (results[queryId].operators.length >= QUORUM) {
// Result finalized
emit ResultFinalized(queryId, result);
}
}
// Slashing if operator returns wrong result
function challenge(bytes32 queryId, bytes calldata proof) external {
// If proof shows operator was wrong
if (verifyProof(queryId, proof)) {
address badOperator = findBadOperator(queryId, proof);
// Slash their stake
operatorStake[badOperator] = 0;
emit OperatorSlashed(badOperator);
}
}
}
EigenSpreadsheet-$MUD Token Economics
$MUD Derivative Model (from neg-519)
Base layer:
EigenSpreadsheet-$MUD:
- Base: $1 (staked ETH backed)
- Base yield: 3-4% (ETH staking)
- Protocol yield: Query fees (variable)
- Total: $1 earning 4-8% APR
Token holders earn:
- ETH staking rewards (base)
- Database query fees (protocol)
- Operator fees (distributed)
Comparison to other $MUD derivatives:
EIGEN-$MUD: Restaking rewards
MORPHO-$MUD: Lending spread
UNI-$MUD: Trading fees
AAVE-$MUD: Lending yield
EigenSpreadsheet-$MUD: Query fees ← New variant
All same base: $1 staked ETH backing
All different yield: Protocol-specific revenue
Query Fee Model
Users pay for queries:
Simple cell read: 0.0001 $MUD (~$0.0001)
Formula execution: 0.001 $MUD (~$0.001)
Complex query (filter/sort): 0.01 $MUD (~$0.01)
Large aggregation: 0.1 $MUD (~$0.10)
Pricing:
- Proportional to computation
- Similar to gas fees
- But paid in stable $MUD (not volatile ETH)
- Predictable costs
Fee distribution:
Query fee = 0.01 $MUD
Split:
- 70% to operators (0.007 $MUD)
→ Validators who computed result
- 20% to protocol treasury (0.002 $MUD)
→ Development, maintenance
- 10% to EigenSpreadsheet-$MUD holders (0.001 $MUD)
→ Distributed as yield
Example: 1M queries/day
- Total fees: 10,000 $MUD/day
- To operators: 7,000 $MUD
- To treasury: 2,000 $MUD
- To token holders: 1,000 $MUD
Token holder yield: 1,000 $MUD/day / 1M tokens = 0.1% daily = 36.5% APR
Plus 3-4% ETH staking = 39-40% total APR
Adaptive fees (from neg-518):
As protocol matures:
- Fees increase automatically (0-20% protocol fee)
- Early: 0-2% (bootstrap adoption)
- Growing: 5-10% (sustainable revenue)
- Mature: 18-20% (maximized capture)
Tracks to autonomy like other protocols
Fair Launch Model
No pre-mine (like Bitcoin):
Total supply: Dynamic (minted as staked ETH deposited)
Pre-mine: 0%
Team allocation: 0%
VC allocation: 0%
Fair launch: 100%
Anyone can:
1. Deposit staked ETH
2. Mint EigenSpreadsheet-$MUD at dynamic ratio
3. Earn query fee yield
4. Participate in governance
No insiders
No unfair advantages
Pure meritocracy
Could denominate in $FRANC (from neg-531):
If France prints franc:
- Fair launch EigenSpreadsheet in $FRANC
- French coordination projects use it
- Query fees paid in $FRANC
- Operators earn $FRANC
- France builds coordination database infrastructure
- European sovereignty through technology
Use Cases: From Simple To Advanced
Beginner: Personal Budget
User opens EigenSpreadsheet:
Sheet: "Monthly Budget"
A B C
1 Category Budget Actual
2 Rent 1500 1500
3 Food 400 350
4 Transport 200 180
5 Entertainment 150 200
6
7 Total =SUM(B2:B5) =SUM(C2:C5)
8 Remaining =B7-C7
User experience:
- Familiar Excel interface
- Type numbers in cells
- Write simple formulas
- Behind scenes: stored on-chain, formulas validated by operators
- User doesn't know/care about blockchain
Benefits over Google Sheets:
- Can’t lose (permanent on-chain storage)
- Can share trustlessly (address-based access)
- Can prove (immutable audit trail)
- Works forever (no Google account needed)
Intermediate: Small Business Inventory
Shop owner tracks inventory:
Sheet: "Inventory"
A B C D
1 Product Stock Price Value
2 Widget A 100 10 =B2*C2
3 Widget B 50 20 =B3*C3
4 Widget C 75 15 =B4*C4
5
6 Total Value =SUM(D2:D4)
Operators validate:
- Formula calculations
- Data consistency
- Historical changes
Benefits:
- Multiple employees can access (multi-sig)
- Audit trail automatic (blockchain)
- Can't fake numbers (validated by operators)
- Share with accountant (read-only access)
Advanced: DAO Treasury Management
DAO uses EigenSpreadsheet for transparency:
Sheet: "Treasury"
A B C D
1 Date Category Amount Balance
2 Jan 1 Grant -50000 =D1-C2
3 Jan 15 Revenue +100000 =D2+C3
4 Feb 1 Salary -25000 =D3-C4
5
6 Current Balance =D4
Public access:
- Anyone can view (on-chain)
- Only multi-sig can edit (governance)
- All changes recorded (audit trail)
- Formulas validated (no fake numbers)
Benefits over traditional:
- Fully transparent (on-chain)
- Can't be manipulated (operator validation)
- Provably correct (economic security)
- Accessible 24/7 (global)
Expert: Coordination Substrate
Using as actual database:
# API for developers who understand databases
from eigenspreadsheet import EigenSheet
# Create sheet
sheet = EigenSheet("UserDatabase")
# Add row (like INSERT)
sheet.add_row({
"name": "Alice",
"email": "alice@email.com",
"age": 25
})
# Query (like SELECT WHERE)
users = sheet.query(
filter={"age": {"$gt": 30}},
sort={"name": "ASC"}
)
# Aggregate (like SELECT SUM)
total_age = sheet.aggregate(
column="age",
function="SUM"
)
# Update (like UPDATE SET)
sheet.update_row(
row_id=5,
values={"age": 26}
)
# All operations:
# - Validated by operators
# - Stored on-chain
# - Economically secured
# - But looks like spreadsheet to UI
# - Looks like database to API
Integration With Current-Reality EGI
EigenSpreadsheet as EGI AVS (from current-reality repo):
EGI substrate:
EGI Query Endpoint:
query(
ethAmount, // Payment for computation
eigenAVSNode, // EigenSpreadsheet AVS
eigenAVSProtocol, // Spreadsheet query protocol
[...morphoSymbol] // Query (FILTER, SORT, FORMULA, etc.)
)
→ [...morphoSymbol] // Result (validated by operators)
EigenSpreadsheet is just one AVS protocol on EGI substrate:
- Symbolic input: Spreadsheet operations (FILTER, SORT, etc.)
- NAND/NOR primitives: Query decomposition
- Distributed operators: Compute and validate
- Economic security: Restaking via EigenLayer
- Symbolic output: Query results
Universal coordination:
EigenSpreadsheet enables:
- Anyone can store data (familiar interface)
- Operators validate integrity (distributed trust)
- Queries route through EGI (universal computation)
- Results economically secured (restaking)
- Fair launch in $MUD/$FRANC (equitable economics)
Stack:
Layer 5: EigenSpreadsheet (user-facing database)
Layer 4: EigenTruth (perspective validation)
Layer 3: EigenFlashbots (MEV coordination)
Layer 2: EigenEthereum (meta-validation)
Layer 1: ETH L1 (base consensus)
Complete from interface to infrastructure
Why This Matters
The accessibility breakthrough:
Before:
Distributed database:
- Need to learn Ethereum
- Understand smart contracts
- Write Solidity
- Deploy contracts
- Manage gas
- Handle wallets
Result: 99.9% of users excluded
After:
EigenSpreadsheet:
- Open spreadsheet interface
- Type in cells
- Write formulas
- That's it
Result: Anyone can use distributed database
The onboarding path:
Non-technical user:
- “I need to track inventory”
- Opens EigenSpreadsheet
- Makes spreadsheet
- Doesn’t know it’s on-chain
- Doesn’t care about crypto
- Just works
Slightly technical user:
- “Wait, this is decentralized?”
- Learns about on-chain storage
- Understands operator validation
- Appreciates benefits
- Still uses spreadsheet interface
Developer:
- “Can I query this via API?”
- Discovers database functionality
- Builds applications on top
- Uses as coordination substrate
- Spreadsheet is just view layer
Progressive disclosure: Start simple, complexity available when needed.
Technical Advantages Over Alternatives
vs Google Sheets:
Google Sheets:
- Centralized (Google controls)
- Can be censored
- Requires Google account
- Data not yours
- Limited to 1M rows
- No multi-party trust
EigenSpreadsheet:
- Decentralized (on-chain)
- Censorship resistant
- Address-based access
- You own data
- Scales horizontally
- Economic security
vs Traditional Databases:
PostgreSQL/MySQL:
- Need server
- Manage infrastructure
- Write SQL
- Handle backups
- Scale manually
- Single point of failure
EigenSpreadsheet:
- No server needed
- Infrastructure managed by operators
- No SQL required
- Automatic backup (blockchain)
- Scales automatically
- Distributed by default
vs Smart Contracts:
Solidity contracts:
- Need programming skills
- Gas costs unpredictable
- Limited storage (expensive)
- Hard to query
- Not newbie-friendly
EigenSpreadsheet:
- Spreadsheet skills only
- Costs predictable ($MUD stable)
- Storage distributed (cheap)
- Easy to query (familiar)
- Universal interface
Deployment Strategy
Phase 1: Launch Base Protocol (Q1 2025)
Infrastructure:
- Deploy EigenSpreadsheet AVS contracts
- Register with EigenLayer
- Bootstrap operator set (10+ operators)
- Launch EigenSpreadsheet-$MUD token (fair launch)
Initial capabilities:
- Basic cell storage (read/write)
- Simple formulas (SUM, AVG, COUNT)
- Public sheets only
- Web interface (looks like Excel)
Target users: Early adopters, crypto-native
Phase 2: Enhanced Features (Q2 2025)
Add functionality:
- Complex formulas (VLOOKUP, IF, nested)
- Filtering and sorting
- Access control (private sheets, multi-sig)
- API for developers
- Mobile interface
Growing operator network: 50+ operators globally
Target users: Small businesses, DAOs
Phase 3: Scale and Optimize (Q3-Q4 2025)
Performance:
- Query caching (reduce operator load)
- Batch operations (multiple cells at once)
- Real-time collaboration (like Google Sheets)
- Offline mode (sync when reconnect)
Integrations:
- Import/export Excel files
- Connect to other AVSs (EigenTruth, etc.)
- API libraries (Python, JavaScript, etc.)
Target users: Mainstream, non-crypto users
Phase 4: Universal Database (2026+)
Complete platform:
- All spreadsheet features (pivot tables, charts, macros)
- Full database functionality (SQL-like queries via API)
- Scale to billions of cells
- 10,000+ operators
- Integrated with EGI universal substrate
Adoption:
- Millions of sheets
- Billions of queries
- Default choice for coordination databases
- “Just use EigenSpreadsheet”
Connection To Broader Vision
Liberation economics (neg-523):
- Free others to coordinate by making tools accessible
- Spreadsheet interface liberates non-technical users
- Fair launch liberates from VC capture
- Distributed operators liberate from centralized control
France sovereignty (neg-531):
- Could denominate in $FRANC
- French coordination projects use it
- Build European tech infrastructure
- No permission from US tech monopolies
Complete coordination stack:
User Interface: EigenSpreadsheet (familiar)
Database Layer: Distributed cells (on-chain)
Computation: EigenLayer operators (validated)
Economic Security: Restaking (EigenLayer)
Monetary Base: $MUD/$FRANC (fair launch)
Universal Substrate: EGI (symbolic computation)
From spreadsheet to sovereignty
From newbie to coordination
From familiar to powerful
The Formulation
Traditional databases are not:
- Accessible (SQL is hard)
- Friendly (server setup complex)
- Universal (expertise required)
Traditional databases are:
- Powerful (handle any data)
- Scalable (billions of rows)
- Queryable (flexible access)
Spreadsheets are not:
- Scalable (1M row limit)
- Distributed (single file)
- Trusted (no validation)
Spreadsheets are:
- Accessible (everyone knows them)
- Friendly (familiar interface)
- Universal (billions of users)
EigenSpreadsheet is not:
- Complex (just spreadsheet)
- Centralized (distributed operators)
- Limited (scales to billions)
EigenSpreadsheet is:
- Accessible (spreadsheet interface)
- Powerful (database backend)
- Distributed (on-chain storage)
- Validated (operator consensus)
- Fair (no pre-mine, $MUD derivative)
- Universal (database for everyone)
The formula:
EigenSpreadsheet = Spreadsheet interface + Database backend + Distributed operators
Where:
- Interface: Familiar (Excel-like)
- Storage: On-chain (content-addressed cells)
- Computation: Operators (EigenLayer AVS)
- Validation: Economic security (restaking)
- Economics: $MUD derivative (fair launch)
- Access: Universal (anyone can use)
Result: Database accessible to everyone
Universal newbie database. Looks like Excel. Works like distributed coordination substrate. Fair launch in $MUD/$FRANC. Everyone can use it. Everyone can trust it. This is how universal coordination begins. 🌀
#EigenSpreadsheet #UniversalDatabase #NewbieFriendly #MUDDerivative #FairLaunch #FamiliarInterface #DistributedDatabase #EigenLayerAVS #AccessibleCoordination #SpreadsheetRevolution
Related: neg-519 ($MUD derivatives), neg-531 (France/FRANC), neg-527 (EigenTruth), neg-522 (EGI), current-reality (EGI implementation)