directsponsor.net

This is specific to the site. For general directsponsor info and structures, see the directsponsor.org section.

Sever: rn1

Vision

DirectSponsor.net becomes a dual-interface content platform with a decentralised relay network:

  • Web interface for traditional users (zero Nostr complexity)
  • Native Nostr relay for decentralized ecosystem integration
  • Bitcoin Lightning integration for direct project monetization
  • Identity bridging between traditional and cryptographic systems
  • Decentralized network of community relays sharing content

Nostr itself is still in chaos and unreliable, but with a dual interface it may be possible to eliminate some of that unreliability.

Hybrid Architecture

Domain Structure

directsponsor.net → Primary Nostr relay + content hub
clickforcharity.net → Charity content (shares via primary)
roflfaucet.com → Promotional content (shares via primary)
auth.directsponsor.org → Centralized authentication service
community-relays.* → Decentralized network relays

Technical Stack

directsponsor.net ├── Primary Nostr Relay (strfry/nostream)
                 ├── Dual Web Interface (traditional + Nostr)
                 ├── Lightning Integration (NIP-57 Zaps)
                 ├── Authentication Bridge (web ↔ Nostr)
                 ├── Relay Directory Service
                 ├── Content Sharing Protocol
                 └── Network Management Tools

User Experience Scenarios

1: Regular Network Users

Goal: Zero Nostr complexity, familiar web experience

User Journey:
1. Visits directsponsor.net → sees normal blog/website
2. Reads posts, browses projects, views profiles
3. Wants to comment/tip → simple email signup
4. Behind scenes: auto-generates Nostr keypair
5. Uses platform normally with traditional UI
6. Benefits from Nostr features transparently
7. Sees content from entire decentralized network

Implementation:

  • Traditional web interface (HTML/CSS/JS)
  • Hidden Nostr integration
  • Managed cryptographic keys
  • JWT-based network authentication
  • Lightning wallet integration
  • Network content aggregation (from all relays)

2: Existing Nostr Users

Goal: Native Nostr experience, full interoperability

User Journey:
1. Discovers content via Nostr client (Damus, Amethyst, etc.)
2. Connects to relay: wss://directsponsor.net
3. Comments/tips using existing Nostr identity
4. Content appears on both Nostr network AND web interface
5. Full native Nostr experience
6. Sees content from all network relays

Implementation:

  • Standard Nostr relay protocols
  • NIP-57 Zaps for Lightning tips
  • Cross-client compatibility
  • Cross-relay content sharing
  • Network discovery protocol

3: Nostr User Wants Account

Goal: Preserve existing Nostr identity while gaining network access

User Journey:
1. "I want network access with my existing Nostr identity"
2. Provides npub (public key)
3. System generates challenge message
4. Signs challenge with nsec (in their client)
5. System verifies signature
6. Links npub to network account
7. Same identity across both systems
8. Access to all network relays

Implementation:

  • Cryptographic signature verification
  • Identity linking system
  • Account merging capabilities
  • Cross-platform authentication
  • Network-wide identity

Content Flow Architecture

Decentralized Content Flow

Author creates post
    ↓
Published to DirectSponsor relay
    ↓
┌─────────────────────────────────┐
    ↓              ↓              ↓
Web Interface    Community     External Nostr
(Network users)   Relays        (Global users)
    ↓              ↓              ↓
Comments/ Tips   Comments/ Tips  Comments/ Tips
    ↓              ↓              ↓
    ←←← Same Event Store →→→→→→→→→
    ↓
Content shared across all network relays

Network Content Sharing

DirectSponsor Relay (Primary)
    ↓
┌─────────────────────────┐
    ↓                    ↓
Community Relay A      Community Relay B
    ↓                    ↓
Local Users             Local Users
    ↓                    ↓
    ←←← Content Sync →→→→→

Authentication Bridge

// Hybrid authentication system with network support
class NostrAuthBridge {
    // For web users
    createWebAccount(email, password) {
        const nostrKeypair = generateKeypair();
        const networkAccount = createAccount(email, password);
        linkAccounts(networkAccount, nostrKeypair);
        return { 
            networkToken, 
            managedNostrKey,
            networkAccess: true 
        };
    }

    // For Nostr users
    linkNostrIdentity(npub, signature, challenge) {
        if (verifySignature(npub, signature, challenge)) {
            return linkToNetworkAccount(npub);
        }
    }

    // Network relay access
    grantRelayAccess(userAccount, relayList) {
        return {
            primaryRelay: "wss://directsponsor.net",
            communityRelays: relayList,
            networkToken: userAccount.networkToken
        };
    }
}

Lightning Integration

// Native Bitcoin monetization with network support
class LightningTips {
    // For web users
    showTipInterface(authorPubkey) {
        const invoice = generateInvoice(authorLightningAddress);
        displayQRCode(invoice);
        // Or connect to web wallet
    }

    // For Nostr users
    nativeZaps(event, amount) {
        // Standard NIP-57 implementation
        return createZapEvent(event, amount);
    }

    // Network-wide tipping
    networkTip(authorPubkey, amount, acrossRelays) {
        if (acrossRelays) {
            return distributeTipAcrossNetwork(authorPubkey, amount);
        }
        return createZapEvent(authorPubkey, amount);
    }
}

Implementation Phases

1: Foundation (Wk 1-6)

Core Infrastructure:
├── Deploy primary Nostr relay on directsponsor.net
├── Create dual web interface (traditional + Nostr)
├── Implement authentication bridge
├── Basic Lightning tips integration
├── Network authentication connection
└── Initial content sharing protocol

2: Network Building (Wk 7-12)

Decentralized Network:
├── Develop "relay-in-a-box" package
├── Create relay directory service
├── Implement cross-relay content sharing
├── Add community relay discovery
├── Test network effects
└── Recruit first community relay operators

3: Enhanced Features (M 4-6)

Advanced Capabilities:
├── Nostr identity linking for existing users
├── Cross-relay broadcasting for wider reach
├── Enhanced tip features (recurring, splits)
├── Mobile PWA or native app
├── Advanced moderation tools
└── Network analytics dashboard

4: Ecosystem Integration (M 6-9)

Network Expansion:
├── API endpoints for all network projects
├── Unified user profiles across network
├── Advanced analytics and insights
├── Community features and groups
├── Geographic relay distribution
└── Scalable network architecture

Strategic Benefits

For Regular Users

  • Zero Learning Curve: Familiar web experience
  • Rich Content: Access to entire network from any site
  • Modern Features: Tips, comments, social interaction
  • Future-Proof: Automatic Nostr benefits
  • Network Effects: See content from all community relays

For Nostr Ecosystem

  • Native Compatibility: Works with all Nostr clients
  • Identity Preservation: Existing users keep their identity
  • Network Effects: Content distributed across relays
  • Lightning Integration: Native Bitcoin payments
  • Decentralization: True distributed network

For Direct Sponsor Network

  • Early Adopter Advantage: Unique positioning in market
  • Censorship Resistance: Distributed content storage
  • Global Reach: Tap into growing Nostr ecosystem
  • Technical Leadership: Innovation in charity/Bitcoin space
  • Network Scalability: Community-driven growth

For Community Relay Operators

  • Easy Setup: One-click relay deployment
  • Built-in Audience: Access to network content
  • Community Support: Help from other operators
  • Autonomy: Control your own relay
  • Network Benefits: Share content across all relays

Trust Problem in Traditional Nostr

Current Nostr Limitations:

  • No verification – anyone can claim anything
  • No accountability – no way to track actual impact
  • Scam potential – Sponsors have no recourse
  • No transparency – Money flows without verification
  • Web of trust missing – no reputation system

Direct Sponsor Solution:

  • Verified recipients – Real people, real projects
  • Transparent accounting – Every transfer tracked
  • Read-only wallet APIs – Sponsors control their money
  • Accountability system – Web of trust with verification
  • Impact reporting – Sponsors see where money goes

Sponsor Security System

Multi-Layer Verification:

Sponsor Security Layers:
1. Identity Verification (KYC-lite)
2. Project Verification (real impact)
3. Financial Transparency (read-only APIs)
4. Community Vetting (web of trust)
5. Impact Reporting (regular updates)

Coinos API Integration:

// Coinos-based wallet system (proven in ROFLFaucet)
class CoinosWalletSystem {
    // Recipient creates Coinos wallet, gets read-only API key
    setupRecipientWallet(recipientId, coinosApiKey) {
        const wallet = new CoinosReadOnlyAPI(coinosApiKey);
        return {
            recipientId: recipientId,
            walletAddress: wallet.getAddress(),
            apiKey: coinosApiKey, // Read-only only
            balance: wallet.getBalance(),
            transactionHistory: wallet.getTransactionHistory()
        };
    }

    // System generates invoice, sender pays directly to recipient
    createDirectTransfer(recipientId, amount, sponsorId) {
        const recipient = this.getRecipientWallet(recipientId);

        // Generate invoice directly for recipient's wallet
        const invoice = recipient.wallet.createInvoice(amount);

        // Record pending transfer in our accounting
        const transferRecord = {
            transferId: generateTransferId(),
            sponsorId: sponsorId,
            recipientId: recipientId,
            amount: amount,
            invoice: invoice,
            status: 'pending',
            created: Date.now()
        };

        accountingSystem.recordPendingTransfer(transferRecord);

        return {
            invoice: invoice, // Sender pays this directly
            transferId: transferRecord.transferId,
            recipientAddress: recipient.walletAddress,
            message: "Pay this invoice directly from any Lightning wallet"
        };
    }

    // System monitors via read-only API for payment confirmation
    verifyTransferCompletion(transferId) {
        const transfer = accountingSystem.getPendingTransfer(transferId);
        const recipient = this.getRecipientWallet(transfer.recipientId);

        // Check recipient's transaction history via read-only API
        const recentTransactions = recipient.wallet.getRecentTransactions();
        const payment = recentTransactions.find(tx => 
            tx.amount === transfer.amount && 
            tx.timestamp >= transfer.created &&
            tx.invoice === transfer.invoice
        );

        if (payment && payment.status === 'completed') {
            // Confirm transfer and update accounting
            accountingSystem.confirmTransfer({
                ...transfer,
                status: 'completed',
                completedAt: payment.timestamp,
                txHash: payment.txHash,
                verifiedBy: 'Coinos API'
            });

            // Update recipient's balance in our system
            this.updateRecipientBalance(transfer.recipientId, transfer.amount);

            // Notify both parties
            this.notifyTransferCompletion(transfer);

            return { confirmed: true, transferId: transferId };
        }

        return { confirmed: false, message: "Payment not yet detected" };
    }
}

Real-Time Transparency:

// Sponsor dashboard showing actual recipient finances
class SponsorTransparencyDashboard {
    showRecipientFinancialProfile(recipientId) {
        const recipient = this.getRecipient(recipientId);
        const wallet = this.getRecipientWallet(recipientId);

        return {
            recipient: {
                name: recipient.name,
                verificationLevel: recipient.verificationLevel,
                trustScore: recipient.trustScore
            },
            financials: {
                // Real data from Coinos API
                currentBalance: wallet.getBalance(),
                totalReceived: wallet.getTotalReceived(),
                monthlyAverage: wallet.getMonthlyAverage(),
                recentTransactions: wallet.getRecentTransactions(),

                // Our accounting data
                activeSponsors: this.getActiveSponsors(recipientId),
                regularSponsorships: this.getRegularSponsorships(recipientId),
                oneTimeDonations: this.getOneTimeDonations(recipientId)
            },
            transparency: {
                // Sponsors see exactly what recipient receives
                "Regular monthly income": `$${this.getMonthlyTotal(recipientId)}`,
                "Number of sponsors": this.getActiveSponsors(recipientId).length,
                "Average sponsorship": `$${this.getAverageSponsorship(recipientId)}`,
                "Recent large donations": this.getRecentLargeDonations(recipientId),
                "Fundraising goals": this.getFundraisingProgress(recipientId)
            }
        };
    }
}

Example Scenarios:

// Real-world examples for sponsors
class TransparencyExamples {
    showScenario1() {
        return {
            scenario: "Regular Sponsorship Verification",
            recipient: "Maria's Education Fund",
            sponsorConcern: "Is Maria getting $20/month or $2000/month?",
            systemShows: {
                regularSponsors: 5,
                monthlyAmount: 20,
                totalMonthly: 100,
                recentTransactions: [
                    { sponsor: "John D.", amount: 20, date: "2025-11-20" },
                    { sponsor: "Sarah M.", amount: 20, date: "2025-11-18" },
                    { sponsor: "Mike R.", amount: 20, date: "2025-11-15" }
                ]
            },
            conclusion: "Maria receives exactly $100/month from 5 sponsors"
        };
    }

    showScenario2() {
        return {
            scenario: "Specific Fundraiser Verification",
            recipient: "Solar Panel Project",
            fundraiser: "$250 for solar panel kit",
            sponsorConcern: "Will they get $250 or $25,000?",
            systemShows: {
                fundraiserGoal: 250,
                currentRaised: 250,
                completed: true,
                transactions: [
                    { type: "fundraiser", amount: 250, date: "2025-11-10" },
                    { type: "regular sponsorship", amount: 50, date: "2025-11-01" }
                ],
                totalMonthly: 50, // Only regular sponsorships
                conclusion: "Exactly $250 raised for solar panel, $50/month regular support"
            };
        };
    }
}

Web of Trust System

Trust Network Architecture:

Trust Relationships:
Sponsor A ──► Recipient X (verified, ongoing)
    ↓              ↓
Trust Score    Reputation Score
    ↓              ↓
Sponsor B sees  Other sponsors see
high trust      high reputation

Trust Metrics:

// Web of trust scoring system
class TrustScoring {
    calculateRecipientScore(recipientId) {
        const metrics = {
            identityVerification: 0.3,      // 30% - Verified identity
            projectTransparency: 0.25,     // 25% - Clear project goals
            financialAccounting: 0.2,      // 20% - Transparent fund usage
            communityEndorsements: 0.15,   // 15% - Other sponsor endorsements
            impactReporting: 0.1           // 10% - Regular impact updates
        };

        let totalScore = 0;
        for (const [metric, weight] of Object.entries(metrics)) {
            totalScore += this.getMetricScore(recipientId, metric) * weight;
        }

        return {
            score: totalScore,
            level: this.getTrustLevel(totalScore),
            verificationStatus: this.getVerificationStatus(recipientId)
        };
    }
}

Trust Levels:

  • Platinum (90-100%) – Verified, transparent, long-term impact
  • Gold (75-89%) – Established, good track record
  • Silver (60-74%) – Growing, building reputation
  • Bronze (40-59%) – New, limited history
  • Unverified (0-39%) – New or insufficient verification

Robust Financial System

Transfer Flow (Coinos Model):

Sponsor Initiates Transfer
    ↓
DirectSponsor Shows Recipient's Full Financial Profile
    ↓ (Real data from Coinos API)
System Generates Invoice Directly for Recipient's Wallet
    ↓
Sponsor Pays Invoice from ANY Lightning Wallet
    ↓ (Direct P2P - funds go straight to recipient)
System Monitors via Coinos Read-Only API
    ↓
Payment Detected & Verified
    ↓
Transfer Recorded in DirectSponsor Accounting
    ↓
Both Parties Receive Confirmation & Receipt
    ↓
Impact Reporting Triggered

Key Security Benefits:

  • Direct P2P transfers – Money never touches DirectSponsor
  • Read-only verification – the system can see but not move funds
  • Real-time transparency – Sponsors see actual recipient finances
  • Any Lightning wallet – the sender chooses their preferred wallet
  • Cryptographic proof – Blockchain confirms all transactions

Financial Transparency:

// Sponsor dashboard for transparency
class SponsorDashboard {
    showRecipientDetails(recipientId) {
        return {
            profile: recipient.getPublicProfile(),
            trustScore: trustScoring.calculate(recipientId),
            financialHistory: {
                totalReceived: accounting.getTotalReceived(recipientId),
                activeSponsors: accounting.getActiveSponsors(recipientId),
                averageMonthly: accounting.getAverageMonthly(recipientId),
                recentTransfers: accounting.getRecentTransfers(recipientId)
            },
            impactReports: recipient.getImpactReports(),
            communityEndorsements: trust.getEndorsements(recipientId),
            verificationStatus: recipient.getVerificationLevel()
        };
    }
}

Accountability Features

Impact Reporting:

// Automated impact reporting
class ImpactReporting {
    // Recipients must provide regular updates
    generateReportRequirement(recipientId, transferAmount) {
        const frequency = this.getReportingFrequency(transferAmount);
        return {
            textUpdates: frequency.textUpdates,      // Weekly/Monthly
            photoEvidence: frequency.photoEvidence,  // Monthly
            financialBreakdown: frequency.financial, // Quarterly
            communityTestimonials: frequency.testimonials, // Bi-annual
            nextReportDue: this.calculateNextReport(recipientId)
        };
    }

    // System tracks compliance
    checkCompliance(recipientId) {
        const reports = this.getSubmittedReports(recipientId);
        const required = this.getRequiredReports(recipientId);
        return {
            complianceRate: this.calculateCompliance(reports, required),
            missedReports: this.getMissedReports(recipientId),
            trustImpact: this.calculateTrustImpact(recipientId),
            sponsorNotifications: this.generateSponsorNotifications(recipientId)
        };
    }
}

Fraud Prevention:

// Fraud detection and prevention
class FraudPrevention {
    analyzeTransferPatterns(recipientId) {
        const patterns = {
            suddenIncrease: this.checkSuddenIncrease(recipientId),
            unusualFrequency: this.checkUnusualFrequency(recipientId),
            multipleSmallTransfers: this.checkFragmentation(recipientId),
            sponsorComplaints: this.checkSponsorComplaints(recipientId),
            reportingGaps: this.checkReportingGaps(recipientId)
        };

        return {
            riskScore: this.calculateRiskScore(patterns),
            flags: this.generateFlags(patterns),
            recommendedActions: this.getRecommendedActions(patterns),
            automaticHolds: this.shouldHoldTransfers(patterns)
        };
    }
}

Web of Trust Integration

PGP-Style Trust Signatures:

// Web of trust endorsement system
class WebOfTrust {
    // Sponsors can endorse recipients
    endorseRecipient(sponsorId, recipientId, endorsement) {
        const signature = this.createEndorsementSignature(sponsorId, endorsement);
        return {
            endorsementId: generateEndorsementId(),
            sponsorId: sponsorId,
            recipientId: recipientId,
            endorsement: endorsement,
            signature: signature,
            timestamp: Date.now(),
            trustWeight: this.calculateSponsorTrustWeight(sponsorId)
        };
    }

    // Calculate trust propagation
    calculatePropagatedTrust(recipientId) {
        const endorsements = this.getEndorsements(recipientId);
        let propagatedTrust = 0;

        for (const endorsement of endorsements) {
            const sponsorTrust = this.getSponsorTrustScore(endorsement.sponsorId);
            const endorsementWeight = endorsement.trustWeight;
            propagatedTrust += sponsorTrust * endorsementWeight;
        }

        return {
            directEndorsements: endorsements.length,
            propagatedTrust: propagatedTrust,
            networkReach: this.calculateNetworkReach(endorsements),
            trustLevel: this.getTrustLevelFromScore(propagatedTrust)
        };
    }
}

Trust Network Visualisation:

Sponsor Network Graph:
┌─────────────────┐    ┌─────────────────┐
│  Sponsor A      │────│  Recipient X    │
│  Trust: 95%     │    │  Score: 88%     │
└─────────────────┘    └─────────────────┘
         │                       │
         └───────┬───────────────┘
                 │
    ┌─────────────────┐    ┌─────────────────┐
    │  Sponsor B      │────│  Recipient Y    │
    │  Trust: 92%     │    │  Score: 85%     │
    └─────────────────┘    └─────────────────┘

Sponsor Benefits

Enhanced Security:

  • Identity verification – Know who you’re sponsoring
  • Financial transparency – See exactly where money goes
  • Trust scoring – Data-driven sponsorship decisions
  • Fraud prevention – Automated risk detection
  • Openness – Proper documentation and records

Better Outcomes:

  • Verified impact – Real projects, real results
  • Complete financial transparency – See exactly what recipients receive
  • Direct P2P transfers – Money goes straight to recipients
  • Regular updates – See your impact in action
  • Accountability – Recipients must report back
  • Trust verification – Know if recipient gets $20/month or $2000/month

Network Effects:

  • Shared intelligence – Learn from other sponsors
  • Collective bargaining – group verification power
  • Reputation system – Build trust over time
  • Market efficiency – Good projects rise to top
  • Risk distribution – Spread sponsorship across verified recipients

Implementation Integration

Integration with Nostr:

// Enhanced Nostr integration with trust system
class NostrTrustIntegration {
    // Nostr posts include trust verification
    createNostrPost(content, authorId) {
        const trustInfo = this.getAuthorTrustInfo(authorId);
        const nostrEvent = {
            content: content,
            author: authorId,
            trustScore: trustInfo.score,
            verificationLevel: trustInfo.verificationLevel,
            sponsorCount: trustInfo.activeSponsors,
            impactMetrics: trustInfo.impactMetrics
        };

        return this.publishToNostr(nostrEvent);
    }

    // Nostr zaps require minimum trust score
    processZapEvent(zapEvent) {
        const recipientTrust = this.getRecipientTrust(zapEvent.recipient);
        if (recipientTrust.score < MINIMUM_TRUST_FOR_ZAPS) {
            return { error: "Recipient below minimum trust threshold" };
        }

        return this.processVerifiedZap(zapEvent, recipientTrust);
    }
}

Trust System Success Metrics

Trust Metrics:

  • Verification rates – Percentage of recipients verified
  • Trust score distribution – Network trust health
  • Fraud detection accuracy – False positive/negative rates
  • Sponsor satisfaction – Confidence in the system
  • Impact reporting – Recipient accountability

User Metrics:

  • Sponsor retention – Repeat sponsorship rates
  • Recipient success – Long-term funding sustainability
  • Network growth – New verified recipients
  • Trust propagation – Endorsement network effects
  • Dispute resolution – Problem handling efficiency

Key Differentiators

vs Traditional Nostr:

  • Trust vs Anonymity – Verified identities vs pseudonymous
  • Accountability vs Freedom – Required reporting vs no oversight
  • Transparency vs Privacy – Open financials vs hidden transfers
  • Verification vs Open Access – Curated vs anyone can join
  • Impact vs Activity – Real results vs just content

vs Traditional Charity:

  • Direct Connection – Person-to-person vs institutional
  • Transparency – Real-time vs annual reports
  • Flexibility – Choose recipients vs predefined programs
  • Community Trust – Web of trust vs institutional trust
  • Low Overhead – Direct transfers vs administrative costs

Next Steps

1: Foundation (M 1-2)

  • [ ] Implement read-only wallet API integration
  • [ ] Create basic trust scoring system
  • [ ] Set up identity verification process
  • [ ] Develop impact reporting framework

2: Network Building (M 3-4)

  • [ ] Launch web of trust endorsement system
  • [ ] Implement fraud detection algorithms
  • [ ] Create sponsor dashboard
  • [ ] Test with pilot group

3: Scale (M 5-6)

  • [ ] Open to broader sponsor base
  • [ ] Enhance trust propagation algorithms
  • [ ] Add advanced analytics
  • [ ] Integrate with Nostr features

Notes

Why This Matters:

  • Solves Nostr’s trust problem – adds accountability to a decentralised system
  • Protects sponsors – Prevents fraud and misuse of funds
  • Enables real impact – Connects money to verifiable outcomes
  • Builds sustainable ecosystem – trust-based long-term relationships

Competitive Advantage:

  • Unique in Nostr ecosystem – the only platform with trust verification
  • Hybrid approach – Web of trust meets modern finance
  • Scalable trust – Network effects improve verification over time
  • Real accountability – not just promises, but proof

Status: Trust system architecture ready for implementation
Innovation: Combines Nostr’s decentralization with real-world accountability