← Back to Hub
Access & activation

Priced to be half of typical online college, structured as an accelerated 4-year degree with direct job placement.

  • Tuition receiver: barbrickdesign@gmail.com (PayPal)
  • Includes: Gamified .edu-style curriculum, AI mentor, marketplace, badges, printable certificates
  • Local-first: Your data remains on your device; sync with admin hub on demand
We bind this device and issue your local vault.

Optional: Pay via PayPal below and wait for activation.

If PayPal isn’t configured yet, proceed with manual activation.
Device setup

Link your local vault and keys. Regenerate if you change devices.

QR appears after activation
Sync status

    Welcome

    Accelerated .edu track with learn-to-earn and placement.
    GBUV
    Level1
    XP0
    Streak0 days
    GBUV tokens0
    Recent activity
      Subscription

      Status: Inactive

      Next renewal: —

      Accelerated 4-year structure

      Eight semesters mapped into accelerated modules with practicum and marketplace placement. Final capstone: create a course to keep the curriculum current.

      Placement and learn-to-earn
      • Marketplace: Build real projects; earnings add value to the $GBUV pool.
      • Recruitment: Certified devs can invite and bid for newly certified devs to join teams.
      • Value profile: Teams form based on skills, certifications, and project outcomes.
      Active quests
      Anti-cheat checks

      We enforce integrity so your skills are real.

      • Randomization: Rotating prompts and test seeds per attempt.
      • Timing: Timed sections and idle detection.
      • Environment: Browser integrity checks and restricted resources.
      • Plagiarism signals: Hash similarity and structure analysis.
      
            
      
          
      
        
      
        
      
          
      
            
      Rewards
      
            
      
              
        
              
        
                
                
              
        
            
        
          
        
          
        
            
        Streak
        
            
        
              
        Daily momentum increases $GBUV rewards.
        
              
            
        
          
        
        
        
      
        
    
        

    
    
        
      
        
        
        
          
        
            
        Code runner
        
            
        
              
              
        
                
                
                
              
        
              
        
            
        
          
        
        
        
        
        
          
        
            
        AI mentor
        
            
        
              
        Prompt templates and guidance to structure your work.
        
              
              
              
        
                
                
              
        
              
        
            
        
          
        
        
        
      
        
    
        

    
    
        
      
        
        
        
          
        
            
        Projects marketplace
        
            
        
              
        
                
                
              
        
              
        
                
        IDTitlePayoutSkillsActions
        
                
              
        
            
        
          
        
        
        
        
        
          
        
            
        Teams & recruiting
        
            
        
              
        Certified devs can invite and bid for newly certified devs.
        
              
        
                
                
              
        
              
          
            
          
          
          
          
          
            
          Value profile
          
            
          
              
            
            
            
          
            
        
            
      
            
    
            

    
    
            
      
            
        
            
          
            
            
            Certifications
            
            
            
              
            Each certification costs $420 and includes practical builds with anti-cheat proctoring. Certificates include verifiable metadata and optional on-chain attestation.
            
              
            
              
            
              
            Printable certificate preview
            
              
              
            
                
                
                
              
            
              
            
              
            Note: We provide verifiable, value-backed certifications. Degree accreditation is a separate process; certificates include verifiers, rubrics, and attestations designed to meet .edu-style standards of transparency.
            
            
            
          
            
        
            
        
            
          
            
            
            Badges
            
            
              
          
              
        
              
      
              
    
              

    
    
              
      
              
        
              
          
              
            
              Referral links
              
            
              
              
              Invite others and boost your learn-to-earn rewards. Referral bonuses add XP and $GBUV, and your referred learners get a starter boost.
              
              
              
                
                
              
              
              
              
                
              —
              
              
              
              
                
            
                
          
                
        
                
        
                
          
                
            
                Referral rewards
                
            
                
              
                  
                
                • Referrer: +100 XP, +10 $GBUV per activated learner.
                  • 
                
                • Learner: +50 XP starter boost on activation.
                  • 
                
                • Milestones: Extra badges for 5/10/25 successful referrals.
                  • 
              
                
            
                
          
                
        
                
      
                
    
                

    
    
                
      
                
        
                
          
                
            
                Tuition payments
                
            
                
              
                Pay upfront for the full accelerated program, or start with the low entry cost and monthly subscription. Receiver: barbrickdesign@gmail.com.
                
              
                
                
                
                  
                
                    
                Upfront full program
                
                    
                Best value; covers all modules, assessments, and certificates issuance fees.
                
                    
                
                    
                  
                
                
                
                
                
                  
                
                    
                Entry + monthly
                
                    
                $40.20 initial + $4.20/month. Cert exams $420 each when ready.
                
                    
                
                  
                
                
                
              
                
              
                Disclosure: Program is structured to deliver real-world value and skills with verifiable outcomes; alignment with .edu standards focuses on transparent rubrics, verifiers, and integrity systems.
                
            
                
          
                
        
                
        
                
          
                
            
                Policies (.edu-style)
                
            
                
              
                  
                
                • Assessments: Rubric-based with anti-cheat and practical builds.
                  • 
                
                • Verifiers: Public certificate validation with hashes and issuer signatures.
                  • 
                
                • Records: Transparent logs of progress, assessments, and issuances.
                  • 
                
                • Appeals: Reassessment and review windows with audit trails.
                  • 
                
                • Capstone: Course creation to demonstrate mastery and contribute back.
                  • 
              
                
            
                
          
                
        
                
      
                
    
                

    
    
                
      
                
        
                
          Admin hub
          Role: Viewer
        
                
        
                
          
          
                
            
                
              
                
                
                
              
                
              
                
                
                IDEmailStatusSubCertsActions
                
                
              
                
            
                
            
                
              
                
                
                IDUserTypeAmountStatusTx
                
                
              
                
            
                
            
                
              
                
                
                
              
                
              
                  
            
                  
            
                  
              
                  
                
                  IDTitlePayoutStatusTeam
                  
                
              
                  
            
                  
            
                  
              
                  Propose changes and vote using $GBUV.
                  
              
                  
              
                  
              
                  
                
                
              
                  
              
                  
              
                    
            
                    
          
                    
        
                    
      
                    
    
                    

    
    
                    
  
                    

  
  
                    

  
  
  
  
  

  
  
  
    
    
                    
        🤖 AUL-enabled
    
                    
    

    
    
  
");
      w.document.close(); w.focus(); w.print(); w.close();
    }
    $("#printCertificateBtn").addEventListener("click", printCert);
    $("#printCertificateBtn2").addEventListener("click", printCert);

    // -----------------------------------------------------------
    // Referrals
    // -----------------------------------------------------------
    $("#generateReferralBtn").addEventListener("click", async () => {
      const u = await currentUser(); if (!u) return;
      let existing = (await all("referrals")).find(r => r.userId === u.id);
      if (!existing) {
        existing = { id: "ref_" + Date.now(), userId: u.id, code: ("R" + Math.random().toString(36).slice(2,8)).toUpperCase(), count: 0 };
        await put("referrals", existing);
      }
      const link = location.origin + location.pathname + "#ref=" + existing.code;
      $("#referralLinkOutput").textContent = link; renderReferrals();
      toast("Referral link generated.", "success"); logEvent("referral_generate", { userId: u.id, code: existing.code });
    });
    $("#copyReferralBtn").addEventListener("click", () => {
      const text = $("#referralLinkOutput").textContent;
      navigator.clipboard.writeText(text).then(() => toast("Referral link copied.", "primary"));
    });
    async function renderReferrals() {
      const u = await currentUser(); if (!u) return;
      const list = $("#referralsList"); list.innerHTML = "";
      const r = (await all("referrals")).filter(x => x.userId === u.id);
      r.forEach(item => {
        const li = document.createElement("li"); li.className = "list-group-item d-flex justify-content-between";
        li.innerHTML = `Code ${item.code}${item.count} activations`; list.appendChild(li);
      });
    }

    // -----------------------------------------------------------
    // Admin hub
    // -----------------------------------------------------------
    async function renderAdmin() {
      const users = await all("users");
      const payments = await all("payments");
      const logs = await all("logs");
      const certs = await all("certs");
      const tbodyU = $("#adminUsersTbody"); tbodyU.innerHTML = "";
      const subs = await all("subs");
      users.forEach(u => {
        const tr = document.createElement("tr");
        const certCount = certs.filter(c => c.userId === u.id).length;
        tr.innerHTML = `${u.id.slice(0,8)}${u.email}${u.status}${subs.find(s => s.userId === u.id && s.status === "active") ? "Active" : "—"}${certCount}
          
            
            
          `;
        tbodyU.appendChild(tr);
      });
      const tbodyP = $("#adminPaymentsTbody"); tbodyP.innerHTML = "";
      payments.forEach(p => {
        const tr = document.createElement("tr");
        tr.innerHTML = `${p.id.slice(0,8)}${p.userId.slice(0,8)}${p.type}$${p.amount.toFixed(2)}${p.status}${p.tx_id || "—"}`;
        tbodyP.appendChild(tr);
      });
      const elLogs = $("#adminLogsList"); elLogs.innerHTML = "";
      logs.slice(-50).forEach(l => {
        const li = document.createElement("li"); li.className = "list-group-item small";
        li.textContent = `[${new Date(l.ts).toLocaleString()}] ${l.kind} :: ${JSON.stringify(l.payload)}`;
        elLogs.appendChild(li);
      });
      renderAdminMarket();
    }
    async function renderAdminMarket() {
      const items = await all("market");
      const tbody = $("#adminMarketTbody"); if (!tbody) return; tbody.innerHTML = "";
      items.forEach(p => {
        const tr = document.createElement("tr");
        tr.innerHTML = `${p.id.slice(0,8)}${p.title}$${p.payout.toFixed(2)}${p.status}${p.team || "—"}`;
        tbody.appendChild(tr);
      });
    }
    document.addEventListener("click", async (e) => {
      const act = e.target.closest("[data-admin-activate]");
      const rev = e.target.closest("[data-admin-revoke]");
      if (act) {
        const uid = act.dataset.adminActivate;
        const u = await get("users", uid); if (!u) return;
        const otp = Math.random().toString(36).slice(2,8).toUpperCase();
        toast(`Access code for ${u.email}: ${otp}`, "primary", 4000);
        logEvent("admin_resend_access", { userId: uid, otp });
      }
      if (rev) {
        const uid = rev.dataset.adminRevoke;
        const u = await get("users", uid); if (!u) return;
        u.status = "revoked"; await put("users", u);
        toast(`Revoked ${u.email}.`, "danger"); logEvent("admin_revoke", { userId: uid });
        renderAdmin();
      }
    });
    $("#createProposalBtn").addEventListener("click", async () => {
      const title = $("#proposalTitleInput").value.trim();
      const body = $("#proposalBodyInput").value.trim();
      if (!title || !body) return toast("Provide title and body.", "warning");
      const id = "prop_" + Date.now();
      await put("proposals", { id, title, body, ts: Date.now(), votes: { yes: 0, no: 0 } });
      toast("Proposal created.", "success"); logEvent("proposal_create", { id, title }); renderProposals();
    });
    $("#snapshotVoteBtn").addEventListener("click", async () => { toast("Snapshot taken (local).", "primary"); logEvent("snapshot_vote", { ts: Date.now() }); });
    async function renderProposals() {
      const props = await all("proposals");
      const propList = $("#proposalList"); propList.innerHTML = "";
      props.forEach(p => {
        const li = document.createElement("li"); li.className = "list-group-item";
        li.innerHTML = `${p.title}
                    ${new Date(p.ts).toLocaleString()}
                    ${p.body}
                    
        
                    
        
                    `;
        propList.appendChild(li);
      });
    }
    document.addEventListener("click", async (e) => {
      const vYes = e.target.closest("[data-prop-yes]");
      const vNo = e.target.closest("[data-prop-no]");
      if (vYes || vNo) {
        const id = (vYes || vNo).dataset.propYes || (vNo?.dataset.propNo);
        const p = await get("proposals", id);
        p.votes = p.votes || { yes: 0, no: 0 };
        if (vYes) p.votes.yes += 1; else p.votes.no += 1;
        await put("proposals", p);
        toast("Vote recorded.", "success"); logEvent("proposal_vote", { id, yes: !!vYes }); renderProposals();
      }
    });

    $("#exportLogsBtn").addEventListener("click", async () => {
      const logs = await all("logs");
      const blob = new Blob([JSON.stringify(logs, null, 2)], { type: "application/json" });
      const url = URL.createObjectURL(blob);
      const a = document.createElement("a"); a.href = url; a.download = "logs.json"; a.click();
      URL.revokeObjectURL(url); toast("Logs exported.", "success");
    });
    $("#verifyLogsBtn").addEventListener("click", async () => {
      const logs = await all("logs");
      const ok = logs.every(l => !!l.checksum);
      toast(ok ? "Checksums OK." : "Missing checksums.", ok ? "success" : "warning");
    });

    // -----------------------------------------------------------
    // Logging
    // -----------------------------------------------------------
    async function logEvent(kind, payload) {
      const id = "log_" + Date.now() + "_" + Math.random().toString(16).slice(2);
      const checksum = await sha256(kind + "|" + JSON.stringify(payload) + "|" + id);
      await put("logs", { id, kind, payload, checksum, ts: Date.now() });
      const item = document.createElement("li");
      item.className = "list-group-item small"; item.textContent = `${kind} :: ${checksum}`;
      $("#syncLogList")?.appendChild(item);
    }

    // -----------------------------------------------------------
    // Wallet connect
    // -----------------------------------------------------------
    async function connectWallet() {
      try {
        if (window.solana && window.solana.isPhantom) {
          const resp = await window.solana.connect();
          $("#walletStatus").textContent = "Wallet: " + resp.publicKey.toString().slice(0,8) + "…";
          toast("Wallet connected.", "success"); logEvent("wallet_connect", { pubkey: resp.publicKey.toString() });
        } else toast("Phantom not found. Install wallet.", "warning");
      } catch(err) { toast("Wallet error: " + err.message, "danger"); }
    }
    $("#connectWalletBtn").addEventListener("click", connectWallet);

    // -----------------------------------------------------------
    // PayPal Buttons — routes payments directly to BarbrickDesign@gmail.com
    // -----------------------------------------------------------
    function renderPayPalButtons() {
      // Initiation $40.20
      try {
        PayPalIntegration.renderButton("paypal-buttons-container", {
          amount: CONFIG.pricing.init,
          description: "GBUV School — Initiation Fee",
          label: "💳 Pay $" + CONFIG.pricing.init.toFixed(2) + " via PayPal",
          onSuccess: async function(data) {
            const u = await currentUser(); const id = "pay_" + Date.now();
            await put("payments", { id, userId: u?.id || "anon", type: "init", amount: CONFIG.pricing.init, status: "completed", tx_id: data.orderID || id, createdAt: Date.now() });
            toast("Payment captured. Await activation.", "success"); logEvent("payment_init", { orderID: data.orderID });
          }
        });
      } catch(err) {}

      // Subscription $4.20/month
      try {
        PayPalIntegration.renderButton("paypal-subscription-buttons", {
          amount: CONFIG.pricing.monthly,
          description: "GBUV School — Monthly Subscription",
          label: "💳 Subscribe $" + CONFIG.pricing.monthly.toFixed(2) + "/month via PayPal",
          onSuccess: async function(data) { await startSubscription(); }
        });
      } catch(err) {}

      // Certification $420
      try {
        PayPalIntegration.renderButton("paypal-cert-buttons", {
          amount: CONFIG.pricing.cert,
          description: "GBUV School — Certification",
          label: "💳 Pay $" + CONFIG.pricing.cert.toFixed(2) + " via PayPal",
          onSuccess: async function(data) {
            const u = await currentUser(); const id = "pay_" + Date.now();
            await put("payments", { id, userId: u?.id || "anon", type: "cert", amount: CONFIG.pricing.cert, status: "completed", tx_id: data.orderID || id, createdAt: Date.now() });
            toast("Certification payment captured.", "success"); logEvent("payment_cert", { orderID: data.orderID });
          }
        });
      } catch(err) {}

      // Tuition upfront
      try {
        PayPalIntegration.renderButton("paypal-tuition-upfront", {
          amount: CONFIG.pricing.upfrontProgram,
          description: "GBUV School — Upfront Tuition",
          label: "💳 Pay $" + CONFIG.pricing.upfrontProgram.toFixed(2) + " via PayPal",
          onSuccess: async function(data) {
            const u = await currentUser(); const id = "pay_" + Date.now();
            await put("payments", { id, userId: u?.id || "anon", type: "tuition_upfront", amount: CONFIG.pricing.upfrontProgram, status: "completed", tx_id: data.orderID || id, createdAt: Date.now() });
            toast("Upfront tuition captured.", "success"); logEvent("tuition_upfront", { orderID: data.orderID });
          }
        });
      } catch(err) {}

      // Tuition entry $40.20
      try {
        PayPalIntegration.renderButton("paypal-tuition-entry", {
          amount: CONFIG.pricing.init,
          description: "GBUV School — Entry Tuition",
          label: "💳 Pay $" + CONFIG.pricing.init.toFixed(2) + " (entry) via PayPal",
          onSuccess: async function(data) {
            const u = await currentUser(); const id = "pay_" + Date.now();
            await put("payments", { id, userId: u?.id || "anon", type: "init", amount: CONFIG.pricing.init, status: "completed", tx_id: data.orderID || id, createdAt: Date.now() });
            toast("Entry tuition captured.", "success"); logEvent("tuition_entry", { orderID: data.orderID });
          }
        });
      } catch(err) {}
    }
    $("#recordTuitionUpfrontBtn").addEventListener("click", async () => {
      const u = await currentUser(); if (!u) return;
      const id = "pay_" + Date.now();
      await put("payments", { id, userId: u.id, type: "tuition_upfront", amount: CONFIG.pricing.upfrontProgram, status: "completed", tx_id: "manual_" + id, createdAt: Date.now() });
      toast("Upfront tuition recorded.", "success"); logEvent("tuition_upfront_manual", { id });
    });

    // -----------------------------------------------------------
    // Sync (local-to-admin)
    // -----------------------------------------------------------
    async function syncNow() {
      const payload = {
        users: await all("users"), subs: await all("subs"), payments: await all("payments"),
        progress: await all("progress"), certs: await all("certs"), badges: await all("badges"),
        logs: (await all("logs")).slice(-100), market: await all("market"), teams: await all("teams"),
        referrals: await all("referrals")
      };
      const hash = await sha256(JSON.stringify(payload));
      logEvent("sync", { hash, counts: Object.fromEntries(Object.entries(payload).map(([k,v]) => [k, v.length])) });
      toast("Synced with admin hub (local).", "success");
      renderAdmin();
    }
    $("#syncBtn").addEventListener("click", syncNow);

    // -----------------------------------------------------------
    // Service Worker via Blob
    // -----------------------------------------------------------
    async function registerSW() {
      if (!('serviceWorker' in navigator)) return;
      const swCode = `
        self.addEventListener('install', (e) => { self.skipWaiting(); });
        self.addEventListener('activate', (e) => { clients.claim(); });
        self.addEventListener('fetch', (e) => {
          e.respondWith(fetch(e.request).catch(() => new Response('Offline', { status: 200 })));
        });
      `;
      const blob = new Blob([swCode], { type: "text/javascript" });
      const url = URL.createObjectURL(blob);
      try { await navigator.serviceWorker.register(url); toast("Service Worker registered.", "success"); } catch(err) {}
    }

    // -----------------------------------------------------------
    // Event bindings
    // -----------------------------------------------------------
    $("#activateBtn").addEventListener("click", async () => {
      const paramsRef = (location.hash || "").split("ref=").pop();
      const referralCode = paramsRef && paramsRef.length > 2 ? paramsRef : null;
      await activateAccess($("#emailInput").value.trim(), $("#otpInput").value.trim(), referralCode);
    });
    $("#generateLocalPasswordBtn").addEventListener("click", async () => {
      const otp = Math.random().toString(36).slice(2,8).toUpperCase();
      $("#otpInput").value = otp; toast("Generated device-bound password.", "primary");
    });
    $("#initDeviceBtn").addEventListener("click", async () => {
      const kp = await genKeypair(); $("#qrPlaceholder").textContent = "Device ID: " + kp.id.slice(0,10) + "…"; toast("Device vault initialized.", "success");
    });
    $("#rotateKeysBtn").addEventListener("click", async () => {
      const kp = await genKeypair(); $("#qrPlaceholder").textContent = "New Device ID: " + kp.id.slice(0,10) + "…"; toast("Keys rotated.", "warning");
    });
    $("#startSubscriptionBtn").addEventListener("click", startSubscription);
    $("#pauseSubscriptionBtn").addEventListener("click", pauseSubscription);
    $("#cancelSubscriptionBtn").addEventListener("click", cancelSubscription);
    $("#logoutBtn").addEventListener("click", logout);

    // -----------------------------------------------------------
    // Boot
    // -----------------------------------------------------------
    (async function boot(){
      await openDB(); await registerSW();
      renderCertCatalog(); renderBadges();
      loadQuests(); renderRewards(); renderAdmin(); renderProposals();
      renderMarket(); renderTeams(); renderDegree(); renderReferrals();
      renderPayPalButtons();
      const users = await all("users");
      const route = localStorage.getItem("route") || (users.length ? "dashboard" : "onboarding");
      // Always call hydrateUI to properly show/hide UI elements based on auth state
      hydrateUI(users.length ? users[0] : null);
      routeTo(route);
      toast("GBUV School ready.", "primary");
    })();
  
  
  



    
    
                    
        🤖 AUL-enabled