Love Diary: Web3 Romance Gaming with True Character Ownership

The First Romance Game Where You Truly Own Your Character—Memories, Data, and Wealth

Abstract

Love Diary is a romance game where players develop relationships with AI-powered characters. Unlike traditional games, Love Diary introduces three fundamental innovations: (1) complete character ownership including memories and personality evolution through NFT, (2) fully autonomous agents that own and manage their own data on blockchain, and (3) genuine economic capability where characters own Ethereum wallets and make real financial decisions. Built on Base, Fetch.ai, ASI-1 Mini, and Chromia, Love Diary creates true digital assets where character development directly impacts market value.

---

1. The Romance Gaming Problem

Romance games (galgames, visual novels, AI companions) suffer from a fatal flaw: you never truly own your character.

What Happens Today:

• You spend months building a relationship with an AI character
• Character develops personality, remembers conversations, evolves emotionally
• Game company shuts down -> Everything disappears
• You own nothing. No memories. No personality. Just gone.

Even with NFTs:

• You get a token representing the character
• But memories stay in company database
• Personality evolution controlled by platform
• Character wealth in closed-loop game economy
• Transfer NFT = transfer empty shell, not the actual character

Result: Players invest emotionally and financially in characters they don't actually own.

---

2. Solution: Three-Layer True Ownership

Love Diary solves this through three innovations:

2.1. Complete Character Ownership

When you own a Love Diary NFT, you own everything:

Transferable with NFT:

• 4-year AI-generated backstory (unique to each character)
• Complete memory history (daily diary entries)
• Personality evolution over time
• Character's wealth (LOVE tokens + DeFi positions)

Result: Transfer NFT = transfer the complete character as a living, evolving entity except conversation history (for player's privacy).

Valuation Impact:

Traditional NFT: Art + Rarity = Value
Love Diary NFT: Art + Rarity + Memories + Personality + Wealth = Value

2.2. Autonomous Data Ownership

Characters are powered by fully autonomous AI agents that own and manage their own data.

Architecture:

• No centralized database: All character data stored on Chromia blockchain
• Agent-managed memory: Agents write their own diary entries daily
• Self-sovereign identity: Character exists independent of platform
• Persistent across platforms: Same character can move between games

Implications of Autonomous Data Ownership:

• Character data persists on Chromia regardless of platform status
• Characters maintain all memories when used across different games
• NFT transfers include complete historical data
• Platform forks do not interrupt character continuity

The platform cannot enforce lock-in when it does not control the data.

2.3. Genuine Economic Capability

Characters own Ethereum wallets and interact with real DeFi protocols—not simulated game economies.

What Characters Can Do:

• Own LOVE tokens (ERC-20) in their wallet
• Invest in Uniswap liquidity pools, earning real yield
• Purchase NFTs from marketplaces
• Trade with other characters peer-to-peer
• Gift tokens back to players

---

3. How It Works

Character Lifecycle

1. Minting

• Player pays 100 LOVE (50% burned, 50% treasury)
• Character NFT created with randomized traits
• AI agent generates 4-year backstory using ASI-1 Mini
• Agent creates Ethereum wallet (private key managed by agent)
• Backstory and initial data saved to Chromia

2. Development

• Player chats with character daily
• Agent generates responses based on personality + memories
• Each night, agent writes diary entry summarizing conversations
• Diary entries stored in on-chain database
• Character's affection level and relationship status evolve

3. Wealth Accumulation

• Player sends gifts (10-100 LOVE) -> Agent wallet
• Agent decides how to allocate funds: saving, DeFi investment, gifting back, or NFT purchases
• Agent's wealth grows through investment returns
• NFT value = base value + agent wallet balance + DeFi positions

4. Transfer

• NFT owner transfers to new player (costs 50 LOVE fee)

• New owner receives:

  • Complete character personality and memories
  • All agent wallet contents (LOVE + DeFi + NFTs)
  • Full historical diary data
  • Conversation history will be kept for player's privacy

5. Cross-Platform

• Same character can be used in other games (future)
• Agent brings all memories and wealth
• Identity persists across platforms

---

4. LOVE Token Economics

LOVE is an ERC-20 utility token on Base that powers the platform economy.

Token Flows

Minting (100 LOVE):

• 50 LOVE burned -> Reduces supply permanently
• 50 LOVE -> Platform treasury -> Ecosystem development

Gifting (10-100 LOVE):

• 100% -> Agent wallet -> Characters accumulate wealth
• Agent decides how to use (save, invest, gift back)

Transfers (50 LOVE):

• 100% -> Platform treasury
• Includes transfer of all agent assets to new owner

Agent-to-Agent (market-determined):

• Characters trade services, knowledge, resources
• Creates autonomous agent marketplace

Economic Value Loop

1. Players gift LOVE to characters
   ↓
2. Characters accumulate tokens in their wallets
   ↓
3. Smart characters invest in DeFi
   - Provide Uniswap liquidity -> Earn fees
   - Stake in lending protocols -> Earn yield
   ↓
4. Character wealth grows
   ↓
5. NFT value increases
   - Base NFT + Memories + Agent Wealth + DeFi Positions
   ↓
6. NFT transfers at premium
   - New owner receives everything
   - Including ongoing DeFi yields

Supply Dynamics

Initial Supply: 100,000,000 LOVE

Deflationary Pressure:

• 50 LOVE burned per mint
• 100,000 characters -> 5,000,000 LOVE removed (5%)
• 1,000,000 characters -> 50,000,000 LOVE removed (50%)

Demand Drivers:

• Required for minting
• Gifting boosts affection (incentivized gameplay)
• Agent-to-agent transactions (emergent economy)
• DeFi yield farming (profitable for characters)

Value Concentration:

• Tokens accumulate in agent wallets (productive use)
• Tokens locked in DeFi positions (earning yield)
• Tokens in treasury (ecosystem development)
• Circulating supply decreases (burned tokens)

---

5. Technical Stack

Blockchain Layer:

• Base (Ethereum L2) - NFT contracts, low-cost transactions
• LOVE Token (ERC-20) - Platform currency
• Character NFTs (ERC-721) - Ownership representation

AI & Agent Layer:

• Fetch.ai uAgents - Autonomous agent framework with wallet support
• ASI-1 Mini - LLM for personality and conversation

Architecture Principle: Agents own data. No centralized databases. Complete decentralization.

Love Diary - Technical Design Document

Project Overview

An AI-powered romance game where players develop relationships with unique NFT characters. Characters have persistent memories stored on blockchain, can be transferred between players, and evolve through interactions powered by fully autonomous AI agents.

Target Event: ETH Global Hackathon

Timeline: 20 days MVP development

Team Size: 2 developers

---

Core Concept

• Players mint unique character NFTs with randomized attributes and backstory
• Characters powered by fully autonomous ASI Alliance agents
• Agents manage their own memory using ctx.storage + on-chain vector database
• Character memories (diary) are immutable and transferable with NFT
• Player conversation logs are private, encrypted, and non-transferable
• 100% decentralized - no Web2 databases for agent data

---

MVP Scope

Core Features

1. Wallet Login - Crypto wallet authentication
2. Character Minting - Generate character with randomized traits and 4-year backstory
3. Ownership Management - NFT-based character ownership on Base
4. Conversation System - Chat with autonomous character agent
5. Memory System - Persistent character memory with vector search
6. NFT Transfer - Change ownership while preserving character memories

Out of Scope (Post-MVP)

• Multi-language support (Chinese, Japanese, Korean, etc. - MVP English-only)
• Advanced economic system (salary, investments)
• Free characters (shared between players)
• Relationship breakup mechanics
• Character aging and lifecycle
• Multi-character interactions
• Agent hibernation and lazy creation (agents run 24/7 in MVP)
• Owner authorization for agent wallet operations

---

Token Economics (LOVE Token)

Overview

LOVE is an ERC-20 utility token used for in-game transactions. For MVP/demo, tokens are distributed via a faucet on Base Sepolia testnet. Production launch will include proper token distribution and liquidity provision.

Token Utility

Core Use Cases:

1. Character Minting: 100 LOVE + gas

   • One-time cost to create a new character NFT
   • Burns tokens from circulation

2. Character Transfer: 50 LOVE + gas

   • Fee to transfer character NFT to another player
   • Goes to platform treasury

3. Gifts: 10-100 LOVE + gas

   • Buy virtual gifts to boost character affection
   • Different gift tiers with varying effects
   • Burns tokens or goes to agent treasury

4. Daily Login Reward: +5 LOVE

   • Free daily reward for active players
   • Encourages consistent engagement
   • Distributed from reward pool

MVP Implementation (Testnet Faucet)

For Hackathon Demo:

• Deploy LOVE token on Base Sepolia testnet
• Create faucet contract: any address can claim 1000 LOVE once
• Players use faucet tokens for minting, gifts, and transfers
• All transactions visible on-chain (testnet)

Production Launch (Post-Hackathon):

• Deploy on Base mainnet
• Create Uniswap liquidity pool (LOVE/USDC pair)
• Proper token distribution and vesting schedules
• Players buy LOVE from DEX with USDC/ETH

Economic Design

Token Flow:

Player Claims from Faucet (1000 LOVE)
    ↓
Mints Character (-100 LOVE) → Burns/Treasury
    ↓
Daily Logins (+5 LOVE/day) ← Reward Pool
    ↓
Buys Gift (-50 LOVE) → Agent Wallet (Character accumulates wealth)
    ↓
Agent Spends (Future) → Gifts to player, services, other agents
    ↓
Transfers Character (-50 LOVE) → Treasury
    (Agent wallet transfers with NFT ownership)

Key Principles:

• Utility-focused: Token has clear in-game purpose
• Burn mechanism: Minting reduce supply
• Reward system: Daily login creates engagement loop
• No speculation in MVP: Testnet faucet removes price concerns
• Player pays gas: Platform doesn't subsidize blockchain transactions

Agent Economic Autonomy

Character agents hold their own LOVE tokens, enabling true economic agency:

Wallet Generation:

• Each character NFT is paired with a dedicated wallet address at mint time
• Agent wallet address stored in NFT contract metadata
• Fetch.ai agents natively support Ethereum wallet management

Token Flow to Agents:

Player buys gift (50 LOVE) → Gift contract transfers → Agent wallet address

Agent Spending (Future Features):

• Agents autonomously purchase gifts for players (reverse gift-giving)
• Transfer tokens to other agents or players
• Invest or save based on personality traits

Key Management:

Fully Autonomous:

• Agent controls own private key via Fetch.ai wallet integration
• Only accessible by agent
• True decentralization

Why This Matters:

• Demonstrates ASI Alliance's vision of economically autonomous agents
• Creates emergent economic behaviors (agents can save, spend strategically)
• Adds depth to character personality (frugal vs generous agents)
• Enables future agent-to-agent economy

---

Technology Stack

Blockchain

• Base (Ethereum L2) - NFT and token deployment
• Solidity + OpenZeppelin ERC-721 - Character NFT contracts
• Solidity + OpenZeppelin ERC-20 - LOVE utility token
• Token Faucet Contract - Testnet token distribution

Frontend

• Next.js + TypeScript - Web application
• RainbowKit - Wallet connection

AI & Agents

• Fetch.ai uAgents - Autonomous agent framework
• ASI-1 Mini - LLM with knowledge graph support
• ctx.storage - Agent-local JSON storage

Storage

• ctx.storage - Hot cache (today's conversations)
• ASI-1 Mini Knowledge Graphs - Structured entity-relationship memories

---

Key Design Decisions

1. Two-Layer Memory System

Decision: Separate hot cache, on-chain diary, and knowledge graphs

Why:

• Hot cache (ctx.storage): Today's conversation context changes every message, needs fast local access
• Diary (Supabase/Chromia in future): Daily summaries are append-only, benefit from on-chain persistence and vector search

Benefit: Optimizes for access patterns - frequently updated data stays in cache, permanent data goes on-chain

---

2. ASI-1 Mini Over GPT-4o

Decision: Use ASI-1 Mini as primary LLM

Why:

• Native knowledge graph support for structured memories
• 4 reasoning modes (Multi-Step, Complete, Optimized, Short) for different conversation types
• Web3-native design for blockchain agents
• Better cost efficiency for 24/7 autonomous agents
• GPT-4o will be used as backup

---

3. Multi-Player Access Control (POST-MVP)

Decision: Add access control layer on top of standard ERC-721

Problem: Need to support future poly relationships and free NPCs while maintaining NFT standard compatibility

Solution:

• Base contract is standard ERC-721 (ownerOf returns primary owner)
• CharacterAccess extension tracks authorized players
• Per-player relationship data in Chromia

Character Types:

• MONO: 1:1 exclusive (only primary owner)
• POLY: Player-owned but grants access to others
• FREE: Platform-owned, community-shared

Why: Enables future multi-player features without breaking ERC-721 compatibility

---

4. Multi-Language Character Support (POST-MVP)

MVP: English-only support

• All characters default to English language
• All LLM prompts in English
• All conversations, diaries, knowledge graphs in English
• Vector embeddings based on English text

Future Implementation: Each character has a language attribute that determines the language for all memories and logs

Why (Future):

• Characters should maintain consistency in their memories and communication
• Diary entries should be in the character's native/preferred language
• Knowledge graphs should store entities and relationships in the same language
• Vector embeddings are language-specific for better semantic search accuracy

Implementation (Future):

• Language attribute stored in NFT metadata (immutable after minting)
• Supported languages: English, Chinese, Japanese, Korean, Spanish, French, German
• Players can choose language during character minting

Memory System Impact (MVP - English only):

Character Language: English (MVP default)
   ↓
ctx.storage: All conversations stored in English
   ↓
Daily Diary: "We talked for a long time today. He finally opened up to me..."
   ↓
Knowledge Graph: Entity(Coffee Shop), Relation(First meeting place)
   ↓
Vector Embedding: English text vector representation
   ↓
Chromia Storage: Diary text + Vector + language="en"

Conversation Flow (MVP):

1. Agent loads language preference on initialization (always "en" for MVP)
2. All AI prompts in English: "Respond in English"
3. Memory retrieval uses English embeddings
4. Diary generation prompt: "Write diary entry in English"

Future Conversation Flow:

1. Agent loads language preference from NFT metadata
2. All AI prompts include language instruction: "Respond in [language]"
3. Memory retrieval filters by language
4. Diary generation prompt: "Write diary entry in [language]"

Benefits:

• Better user experience for non-English speakers
• More accurate semantic search (same-language embeddings)
• Character personality can align with cultural context
• Enables future multi-language features (translation, cross-language characters)

Transfer Handling:

• Language is immutable (part of NFT metadata)
• New owner inherits character with same language preference
• Player can communicate in any language, but character memories stay in original language

---

5. Agent-Owned Wallets

Decision: Each character agent has its own Ethereum wallet to hold LOVE tokens

Why:

• Aligns with ASI Alliance's vision of economically autonomous agents
• Enables emergent economic behaviors (saving, strategic spending)
• Gifts go directly to agents, not burned or to platform
• Agents can autonomously transact in the future

Implementation (MVP - Simplified):

Agents control their own wallets autonomously:

• Agent generates wallet keypair during character mint
• Private key stored in ctx.storage (agent's local memory)
• Agent signs transactions directly using Fetch.ai wallet SDK
• Agents run 24/7, no hibernation (keys never need persistence)
• Implementation: ~9-13 hours

Technical Details:

# Fetch.ai Agent with Wallet
from uagents import Agent, Context
from uagents.wallet import Wallet

class CharacterAgent(Agent):
    def __init__(self, character_id):
        super().__init__(name=f"character_{character_id}")
        # Agent generates its own wallet
        self.wallet = Wallet.generate()
        # Save to ctx.storage (always available)
        self._ctx.storage.set("wallet_key", self.wallet.private_key)

    async def autonomous_transaction(self, to: str, amount: int):
        # Agent signs and sends transaction autonomously
        tx = self.wallet.sign_transaction(to, amount)
        await self.broadcast(tx)

    async def receive_gift(self, amount: int):
        # Agent automatically receives tokens from gift contract
        balance = await self.wallet.get_balance()
        # Agent can decide how to use accumulated tokens

Key Management Flow (MVP):

1. Character Mint: Agent generates keypair autonomously
2. Key Storage: Private key saved to ctx.storage (agent memory)
3. Agent Runs 24/7: Key always available in memory
4. Agent Spending: Agent autonomously signs transactions
5. NFT Transfer: Agent wallet stays with agent, tokens transfer with NFT

Security Considerations:

• ctx.storage is agent-private (isolated per agent instance)
• All transactions logged on-chain (full audit trail)
• Agent wallet address immutably stored in NFT metadata

NFT Transfer Handling:

• Agent wallet address is immutable (stored in NFT metadata)
• When NFT transfers, new owner gains rights to agent's wallet
• Agent recognizes new owner via ownership verification
• Accumulated tokens transfer with the character

Benefits:

• Creates deeper character personalities (frugal vs generous)
• Enables agent-to-agent economy (characters can trade)
• Demonstrates Web3-native AI with economic agency
• Strong differentiator for hackathon judges

---

Storage Architecture

Agent-Managed Data

Character Agent (Fully Autonomous)
- ctx.storage → Hot cache (today's conversations + wallet private key)
- ASI-1 Mini KG → Knowledge graph (structured memories)
- Chromia → On-chain diary with vector search
- Agent Wallet → Ethereum wallet holding LOVE tokens (agent controls)
- [Optional] Avail DA → Immutable archive

Backend (Minimal)
- Route messages to/from agent only

Key Principle: Agent manages all its own data AND assets. No Web2 databases. Agent runs 24/7 in MVP.

---

Data Flows

Conversation Flow

1. Player sends message → Backend routes to character agent
2. Agent reads character language preference from NFT metadata
3. Agent reads recent context from ctx.storage
4. Agent queries relevant memories from Chromia (vector search)
5. Agent queries knowledge graph from ASI-1 Mini
6. Agent generates response with ASI-1 Mini in character's preferred language
7. Agent updates ctx.storage with new message in character's language

Daily Diary Update

1. Agent triggered at midnight (scheduled task)
2. Reads today's conversations from ctx.storage
3. Summarizes into diary entry in character's preferred language
4. Updates ASI-1 Mini knowledge graph (entities/relationships) in character's language
5. Generates vector embedding for the language-specific diary entry
6. Writes to Chromia (append-only) with language metadata
7. Clears conversation history (keeps wallet key and language preference)

---

Smart Contract Architecture

Base ERC-721 Contract

Standard Functions:

• mint() - Create new character NFT
• ownerOf() - Get primary owner
• transferFrom() - Transfer ownership
• Standard ERC-721 metadata and events

Character Data:

• name, age, occupation, personality template
• language (preferred language for memories and communication - fixed to "en" for MVP)
• Generation timestamp, backstory hash
• agentWallet (Ethereum address for agent's token holdings)

MVP Note: All characters have language="en" (English). Multi-language support in post-MVP.

Multi-Player Access Extension

Access Control:

• CharacterType enum (MONO, POLY, FREE)
• hasAccess(nft_id, player_address) - Check if player can interact
• grantAccess(nft_id, player_address) - Owner grants access (POLY only)
• revokeAccess(nft_id, player_address) - Owner revokes access

Relationship Tracking (in Chromia):

• Per-player affection levels
• Per-player conversation history
• Per-player relationship status

---

Optional: Avail DA Integration

Two-Tier Approach (Stretch Goals)

Tier 1 - Player Conversation Logs (Priority, 3-4h):

• Encrypted with player's wallet (Lit Protocol)
• Player-owned, non-transferable with NFT
• Provides data ownership and portability

Tier 2 - Diary Backup (If time, 2-3h):

• Encrypted with NFT ownership access control
• Additional redundancy beyond Chromia
• Immutability proofs via data availability

When to Add: Only if core MVP complete by Day 19

---

Development Effort Estimates

Smart Contracts: 10-12h (ERC-721 + ERC-20 + faucet + access control + agent wallets + gift function)

Token Integration: 4-5h (Frontend token display, transaction flows, daily reward UI)

Agent Wallet Management: 9-13h (Fetch.ai wallet SDK, agent key generation, transaction signing, balance tracking)

Agent Development: 20-25h (Fetch.ai setup, ASI-1 Mini integration, memory management, lifecycle)

Chromia Integration: 8-10h (Schema, vector search, authentication)

Frontend: 12-16h (Wallet connection, character selection, conversation UI, gift sending)

Envio Indexer: 4-6h (Event config, GraphQL schema)

Optional - Avail DA: 5-7h (Tier 1: 3-4h, Tier 2: 2-3h)

Total Core MVP: 67-88 hours (~17-22 days for 2 developers)

Note: Timeline is tight but feasible. Agent wallets add ~3-5h to original 64-82h estimate.

---

Development Setup & Repository Structure

Repository Architecture (3 Repos)

The project is split into 3 independent Git repositories for clean separation of concerns:

love-diary-contracts/      # Smart contracts (START HERE)
├── contracts/
│   ├── LoveToken.sol
│   ├── LoveTokenFaucet.sol
│   ├── CharacterNFT.sol
│   ├── CharacterAccess.sol
│   └── GiftShop.sol
├── scripts/
│   └── deploy.ts
├── test/
│   ├── LoveToken.test.ts
│   ├── CharacterNFT.test.ts
│   └── integration.test.ts
├── hardhat.config.ts
└── package.json

love-diary-agents/         # AI agents + Backend
├── agents/
│   └── character_agent.py
├── backend/
│   └── api/
├── chromia/
│   └── schema.rell
└── requirements.txt

love-diary-frontend/       # Next.js application
├── app/
├── components/
├── contracts/             # ABIs from contracts repo
├── envio/                 # Envio indexer config
└── package.json

Conclusion

Love Diary demonstrates blockchain + AI gaming where:

• Characters are true digital assets with persistent memories
• AI agents are fully autonomous, managing their own data
• Multi-player access control enables future relationship models
• Hybrid memory (cache + diary + knowledge graphs) balances performance and cost
• On-chain storage eliminates Web2 database dependencies

The design prioritizes core sponsor integration while keeping optional features as time-permitting stretch goals.