← Back to Main Documentation Core Systems Index

Brand Authority & Class-Level Brand Protection System

Overview

This document specifies how Plings implements Brand Authority at the class level to distinguish between verified brand claims from legitimate trademark owners versus generic product descriptions from individual users.

Core Principle: Source Authority Matters

The fundamental insight is that who makes the claim determines its trustworthiness:

  • “This is a Nike shoe says Nike Inc.” → Strong brand authority, cryptographically verifiable, legally protected
  • “This is a Nike shoe says John Smith” → Personal opinion, no brand authority, potential trademark violation
  • “This is a handmade shoe says John Smith” → Personal description, no brand claim, perfectly legitimate

Brand Authority Architecture

Class-Level Brand Protection

Brand authority is attached to product classes rather than manufacturers, enabling granular control over brand claims:

// Brand Authority Registry
const brandRegistry = {
    "Nike": {
        legal_owner: "Nike Inc.",
        trademark_status: "verified",
        protection_level: "HIGH",
        authorized_classes: [
            "15.1.1", // Nike Air Max
            "15.1.2", // Nike Air Force  
            "15.2.1", // Nike Pro Clothing
            "15.3.1"  // Nike Equipment
        ],
        unauthorized_usage_policy: "aggressive_enforcement"
    },
    
    "Rolex": {
        legal_owner: "Rolex SA",
        trademark_status: "verified", 
        protection_level: "ULTRA_HIGH",
        authorized_classes: [
            "23.1.1", // Submariner
            "23.1.2", // Daytona
            "23.2.1"  // Datejust
        ],
        unauthorized_usage_policy: "immediate_legal_action"
    }
};

// Generic/Unbranded Registry  
const genericRegistry = {
    "Plings_Generic": {
        legal_owner: "Plings Platform",
        trademark_status: "platform_content",
        protection_level: "NONE",
        authorized_classes: ["1.x.x"], // All generic paths
        user_content_policy: "user_responsibility"
    }
};

Organization vs Brand Authority Separation

// Organization Registry (Legal Entity)
const organizationRegistry = {
    "nike_inc": {
        organization_id: "org_147",
        legal_name: "Nike Inc.",
        verification_status: "verified_corporation",
        trademark_documents: ["USPTO #1234567", "EU #789012"],
        production_status: "PRODUCTION_AUTHORIZED",
        manufacturer_id: 15
    },
    
    "john_smith_personal": {
        organization_id: "org_3847", 
        legal_name: "John Smith",
        verification_status: "individual_user",
        trademark_documents: [],
        production_status: "GENERIC_ONLY", // Can only create generic items
        manufacturer_id: null // Uses Plings generic allocation
    }
};

// Class Authority Mapping
const classAuthorityRegistry = {
    "15.1.1": {
        class_name: "Nike Air Max",
        brand_authority: "Nike",
        authorized_organization: "nike_inc",
        brand_claim_strength: "VERIFIED_TRADEMARK_OWNER",
        created_by: "nike_inc",
        verification_level: "CRYPTOGRAPHIC_PROOF"
    },
    
    "1.1.1": {
        class_name: "Generic Sneakers",
        brand_authority: null,
        authorized_organization: "any_user",
        brand_claim_strength: "USER_CONTENT",
        created_by: "plings_platform",
        verification_level: "IDENTITY_ONLY"
    }
};

Verification Levels by Brand Authority

High Brand Authority (Verified Trademark Owner)

function verifyBrandedProduct(path, instanceKey) {
    // Parse: "1.15.1.1.1.5847" → Nike Air Max
    const classPath = extractClassPath(path); // "15.1.1"
    const classInfo = classAuthorityRegistry[classPath];
    
    if (classInfo.brand_authority && classInfo.brand_claim_strength === "VERIFIED_TRADEMARK_OWNER") {
        return {
            verification_status: "BRAND_VERIFIED",
            brand: classInfo.brand_authority,
            legal_authority: brandRegistry[classInfo.brand_authority].legal_owner,
            message: `✅ VERIFIED ${classInfo.brand_authority.toUpperCase()} PRODUCT`,
            description: `This product is cryptographically verified by ${classInfo.brand_authority} as an authentic ${classInfo.class_name}`,
            protection_level: brandRegistry[classInfo.brand_authority].protection_level,
            legal_backing: "Full trademark protection",
            consumer_confidence: "HIGHEST"
        };
    }
}

// Example result for scanning Nike shoe
const nikeVerification = {
    verification_status: "BRAND_VERIFIED",
    brand: "Nike", 
    legal_authority: "Nike Inc.",
    message: "✅ VERIFIED NIKE PRODUCT",
    description: "This product is cryptographically verified by Nike as an authentic Nike Air Max",
    protection_level: "HIGH",
    legal_backing: "Full trademark protection",
    consumer_confidence: "HIGHEST"
};

No Brand Authority (Generic/User Content)

function verifyGenericProduct(path, instanceKey) {
    // Parse: "1.1.1.5847" → Generic item created by user
    const classPath = extractClassPath(path); // "1.1.1"
    const classInfo = classAuthorityRegistry[classPath];
    
    if (!classInfo.brand_authority) {
        return {
            verification_status: "USER_CONTENT",
            brand: null,
            legal_authority: "Content creator",
            message: "ℹ️ USER-DESCRIBED PRODUCT",
            description: "Product description provided by creator. No brand verification.",
            protection_level: "NONE",
            legal_backing: "User content only",
            consumer_confidence: "CREATOR_DEPENDENT",
            disclaimer: "Plings verifies object authenticity, not brand claims"
        };
    }
}

// Example result for scanning homemade item
const genericVerification = {
    verification_status: "USER_CONTENT",
    brand: null,
    legal_authority: "Content creator", 
    message: "ℹ️ USER-DESCRIBED PRODUCT",
    description: "Product description provided by creator. No brand verification.",
    protection_level: "NONE",
    legal_backing: "User content only",
    consumer_confidence: "CREATOR_DEPENDENT",
    disclaimer: "Plings verifies object authenticity, not brand claims"
};

False Brand Authority (Counterfeit Detection)

function detectCounterfeitBrandClaim(path, instanceKey, userClaimedBrand) {
    const classPath = extractClassPath(path);
    const classInfo = classAuthorityRegistry[classPath];
    const actualBrandAuthority = classInfo.brand_authority;
    
    // User claims Nike but class has no Nike authority
    if (userClaimedBrand === "Nike" && actualBrandAuthority !== "Nike") {
        return {
            verification_status: "COUNTERFEIT_DETECTED",
            claimed_brand: userClaimedBrand,
            actual_authority: actualBrandAuthority || "none",
            message: "🚨 COUNTERFEIT DETECTED",
            description: `Product claims to be ${userClaimedBrand} but is not verified by ${userClaimedBrand}`,
            legal_violation: "Unauthorized trademark use",
            protection_level: "VIOLATION",
            consumer_confidence: "AVOID_PURCHASE",
            legal_advice: "Report to brand protection team"
        };
    }
}

// Example result for fake Nike
const counterfeitDetection = {
    verification_status: "COUNTERFEIT_DETECTED",
    claimed_brand: "Nike",
    actual_authority: "none",
    message: "🚨 COUNTERFEIT DETECTED", 
    description: "Product claims to be Nike but is not verified by Nike",
    legal_violation: "Unauthorized trademark use",
    protection_level: "VIOLATION",
    consumer_confidence: "AVOID_PURCHASE",
    legal_advice: "Report to Nike brand protection team"
};

Private Individual Use Cases

Legitimate Personal Usage

// John Smith creates homemade shoes with generic tags
const personalCreation = {
    user: "John Smith",
    organization: "john_smith_personal",
    path_allocation: "1.1.1.8472", // Generic Plings allocation
    product_description: "Handmade leather boots",
    brand_claim: null, // No brand claim made
    verification_result: "USER_CONTENT - Authentic object, user description"
};

// When scanned by consumer
function scanPersonalItem(path) {
    return {
        authenticity: "VERIFIED_OBJECT", // Object is real, not counterfeit Plings tag
        creator: "Individual user",
        brand_authority: "NONE",
        description: "Handmade leather boots (as described by creator)",
        consumer_message: "This is an authentic Plings-tagged object with user-provided description"
    };
}

Problematic Personal Usage

// John Smith tries to create fake Nike with generic tags  
const problematicUsage = {
    user: "John Smith",
    organization: "john_smith_personal", 
    path_allocation: "1.1.1.8473", // Generic allocation
    product_description: "Nike Air Max", // ← PROBLEM: Brand claim without authority
    brand_claim: "Nike", // Unauthorized
    system_response: "TRADEMARK_VIOLATION_DETECTED"
};

// System detection and response
function detectUnauthorizedBrandClaim(productDescription, userOrganization) {
    const detectedBrands = extractBrandNames(productDescription); // ["Nike"]
    
    for (const brand of detectedBrands) {
        const brandInfo = brandRegistry[brand];
        if (brandInfo && userOrganization !== brandInfo.authorized_organization) {
            return {
                violation_detected: true,
                unauthorized_brand: brand,
                user_organization: userOrganization,
                authorized_organization: brandInfo.authorized_organization,
                action: "FLAG_FOR_REVIEW",
                warning: `Unauthorized use of ${brand} trademark detected`
            };
        }
    }
}

Database Schema

Brand Authority Tables

-- Brands and their legal owners
CREATE TABLE brand_registry (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    brand_name VARCHAR(100) NOT NULL UNIQUE,
    legal_owner VARCHAR(200) NOT NULL,
    trademark_status VARCHAR(50) NOT NULL, -- 'verified', 'pending', 'disputed'
    protection_level VARCHAR(20) NOT NULL, -- 'HIGH', 'ULTRA_HIGH', 'NONE'
    trademark_documents TEXT[], -- Array of trademark registration numbers
    unauthorized_usage_policy VARCHAR(50) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW(),
    verified_at TIMESTAMP,
    
    CONSTRAINT valid_trademark_status CHECK (trademark_status IN ('verified', 'pending', 'disputed')),
    CONSTRAINT valid_protection_level CHECK (protection_level IN ('NONE', 'LOW', 'HIGH', 'ULTRA_HIGH'))
);

-- Class-level brand authority assignments
CREATE TABLE class_brand_authority (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    class_path VARCHAR(50) NOT NULL UNIQUE, -- e.g., "15.1.1"
    class_name VARCHAR(200) NOT NULL,
    brand_id UUID REFERENCES brand_registry(id),
    authorized_organization_id UUID REFERENCES organizations(id),
    brand_claim_strength VARCHAR(50) NOT NULL,
    verification_level VARCHAR(50) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW(),
    
    CONSTRAINT valid_claim_strength CHECK (brand_claim_strength IN ('USER_CONTENT', 'VERIFIED_TRADEMARK_OWNER')),
    CONSTRAINT valid_verification_level CHECK (verification_level IN ('IDENTITY_ONLY', 'CRYPTOGRAPHIC_PROOF'))
);

-- Track unauthorized brand usage attempts
CREATE TABLE brand_violations (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL,
    organization_id UUID REFERENCES organizations(id),
    claimed_brand VARCHAR(100) NOT NULL,
    actual_authority VARCHAR(100),
    violation_type VARCHAR(50) NOT NULL,
    object_path VARCHAR(100),
    detected_at TIMESTAMP DEFAULT NOW(),
    resolved_at TIMESTAMP,
    resolution_action VARCHAR(100),
    
    CONSTRAINT valid_violation_type CHECK (violation_type IN ('unauthorized_brand_claim', 'counterfeit_attempt', 'trademark_infringement'))
);

Organization Production Permissions

-- Enhanced organization permissions
ALTER TABLE organizations 
ADD COLUMN production_status VARCHAR(50) DEFAULT 'GENERIC_ONLY',
ADD COLUMN brand_authorization_level VARCHAR(50) DEFAULT 'NONE',
ADD COLUMN allowed_brand_claims TEXT[] DEFAULT '{}';

-- Production status constraints
ALTER TABLE organizations 
ADD CONSTRAINT valid_production_status CHECK (
    production_status IN ('PRODUCTION_AUTHORIZED', 'GENERIC_ONLY', 'PRODUCTION_SUSPENDED', 'REVOKED_TRADEMARK_INFRINGEMENT')
);

-- Brand authorization levels
ALTER TABLE organizations
ADD CONSTRAINT valid_brand_authorization CHECK (
    brand_authorization_level IN ('NONE', 'VERIFIED_TRADEMARK_OWNER', 'LICENSED_MANUFACTURER')
);

API Implementation

Brand Authority Verification

// GraphQL resolver for product verification
async function resolveProductVerification(parent, args, context) {
    const { path, instanceKey } = args;
    
    // 1. Basic cryptographic verification
    const cryptoVerification = await verifyCryptographicAuthenticity(path, instanceKey);
    if (!cryptoVerification.valid) {
        return { status: 'INVALID_IDENTIFIER', ...cryptoVerification };
    }
    
    // 2. Extract class information
    const classPath = extractClassPath(path);
    const classAuthority = await getClassBrandAuthority(classPath);
    
    // 3. Determine verification level based on brand authority
    if (classAuthority.brand_claim_strength === 'VERIFIED_TRADEMARK_OWNER') {
        return await verifyBrandedProduct(path, instanceKey, classAuthority);
    } else {
        return await verifyGenericProduct(path, instanceKey, classAuthority);
    }
}

// Brand authority assignment (admin only)
async function assignBrandAuthority(classPath, brandName, organizationId) {
    // Verify organization owns the trademark
    const organization = await getOrganization(organizationId);
    const brand = await getBrandRegistry(brandName);
    
    if (organization.id !== brand.authorized_organization_id) {
        throw new Error('Organization not authorized for this brand');
    }
    
    // Create class brand authority
    await createClassBrandAuthority({
        class_path: classPath,
        brand_id: brand.id,
        authorized_organization_id: organizationId,
        brand_claim_strength: 'VERIFIED_TRADEMARK_OWNER',
        verification_level: 'CRYPTOGRAPHIC_PROOF'
    });
    
    return { success: true, brand_authority_assigned: true };
}

Consumer-Facing Verification API

// Simple consumer verification endpoint
app.get('/api/verify/:path/:instanceKey', async (req, res) => {
    const { path, instanceKey } = req.params;
    
    try {
        const verification = await resolveProductVerification(null, { path, instanceKey }, {});
        
        // Format for consumer display
        const consumerResult = {
            authenticity: verification.status,
            brand: verification.brand || null,
            brand_verified: verification.brand_claim_strength === 'VERIFIED_TRADEMARK_OWNER',
            message: verification.consumer_message,
            confidence_level: verification.consumer_confidence,
            warnings: verification.warnings || [],
            safe_to_purchase: verification.consumer_confidence !== 'AVOID_PURCHASE'
        };
        
        res.json(consumerResult);
    } catch (error) {
        res.status(400).json({ error: 'Verification failed', details: error.message });
    }
});

Consumer Interface Examples

Brand-Verified Product Scan

┌─────────────────────────────┐
│   ✅ VERIFIED NIKE PRODUCT  │
│                             │
│   [Product Image]           │
│                             │
│   Nike Air Max 90          │
│   Style: DJ4604-100        │
│                             │
│   ✓ Verified by Nike Inc.   │
│   ✓ Authentic guarantee     │
│   ✓ Full warranty coverage  │
│                             │
│   Manufactured: March 2024  │
│   First Sale: Nike.com      │
│                             │
│   [View Nike Warranty]      │
│   [Contact Nike Support]    │
│   [Report Issue]            │
└─────────────────────────────┘

User Content (No Brand Authority)

┌─────────────────────────────┐
│   ℹ️ USER-DESCRIBED ITEM    │
│                             │
│   [Product Image]           │
│                             │
│   Handmade Leather Boots    │
│   Made by: John Smith       │
│                             │
│   ⚠️ No brand verification   │
│   Description by creator    │
│                             │
│   Created: January 2024     │
│   Creator: @johnsmith_craft │
│                             │
│   [Contact Creator]         │
│   [View Creator Profile]    │
│   [Report Content]          │
└─────────────────────────────┘

Counterfeit Detection

┌─────────────────────────────┐
│   🚨 COUNTERFEIT DETECTED   │
│                             │
│   [Product Image]           │
│                             │
│   Claims: "Nike Air Max"    │
│   Reality: Unauthorized     │
│                             │
│   ❌ NOT verified by Nike   │
│   ❌ Trademark violation    │
│   ❌ Avoid purchase         │
│                             │
│   This item illegally uses │
│   the Nike trademark       │
│                             │
│   [Report to Nike]          │
│   [Find Authentic Nike]     │
│   [Learn About Fakes]       │
└─────────────────────────────┘

For Trademark Owners

  • Strong Protection: Cryptographic verification prevents counterfeiting
  • Clear Authority: Obvious distinction between authorized and unauthorized products
  • Automated Enforcement: System automatically detects trademark violations
  • Legal Evidence: Complete audit trail for legal proceedings

For Consumers

  • Purchase Confidence: Clear indication of brand authority level
  • Counterfeit Protection: Automatic detection of fake brand claims
  • Transparency: Understanding of verification level and limitations
  • Safe Shopping: Confidence in authentic branded products

For Plings Platform

  • Legal Safety: Clear separation between platform verification and brand claims
  • Trademark Compliance: Proactive protection of trademark rights
  • User Trust: Honest representation of verification capabilities
  • Scalability: System works for both major brands and individual creators

Implementation Roadmap

Phase 1: Core Brand Authority System

  • Brand registry database implementation
  • Class-level brand authority assignment
  • Basic verification level distinction
  • Admin tools for brand management

Phase 2: Consumer Protection Features

  • Counterfeit detection algorithms
  • Consumer-friendly verification displays
  • Brand violation reporting system
  • Trademark owner notification system

Phase 3: Advanced Features

  • Machine learning for brand claim detection
  • Integration with trademark databases
  • Automated brand protection workflows
  • Consumer education resources

This specification ensures that Plings provides strong brand protection for trademark owners while maintaining clear boundaries around platform verification capabilities versus brand authority claims.