rebrand bog5 server as APDS

README.md

···
-# Bog5 Protocol
-
-The 5th Bogbook protocol implementation.
-
-Try it at https://bog5.deno.dev/ 
-
-Please note the above link is not networked. For a fuller and networked version be sure to check out https://wiredove.net/
-
-### The Protocol
-
-Bogbook has been thru a few iterations. For the fans, thanks for sticking with me. For the people who want standards, I solicit your feedback. And now, the protocol...
-
-We send around sha256 hashes since we're using content-addressable storage for everything. First we request the hash that finds us a **protocol message**:
-
-```
-<ed25519 pubkey><ed25519 sig>
-```
+# APDS 
 
-This opens to:
+A personal data server (pds) for ANProto https://anproto.com/
 
-```
-<unix timestamp><sha256 hash>
-```
-
-The timestamp is required since this is a social network. The sha256 hashlinks either locally or over the gossip network to a **content message**, which is Yaml file that contains everything else we need to make a post render while not duplicating too much of what we might have already such as avatar photos.
-
-Everything in the **protocol message** is we need to sort and authenticate a feed. Everything in the **content message** is what we need to render a message.
-
-```
-Text content
-```
-
-
-A full post might look like this: 
-
-```
----
-previous: sha256 hash previous protocol message
-name: Ev
-image: sha256 of image blob
-edit: sha256 hash of edited protocol message
----
-Content
-```
-
-This means you could in theory edit your name and/or image on a post! But we also want a record of what your name and image was on the original post, since it is a security issue with some actors on decentralized social networks if you allow publishers to change their name over their entire feed. Or, for example, in a hack it would be harder to rewrite history.
+Try it at https://pds.anproto.com/ 
 
 ---
 MIT

bogbot.js

···
-import nacl from './lib/nacl-fast-es.js'
-import { decode, encode } from './lib/base64.js'
+import { decode } from './lib/base64.js'
 import { cachekv } from './lib/cachekv.js'
 import { human } from './lib/human.js'
 import { vb } from './lib/vb.js'
+import { an } from 'https://esm.sh/gh/evbogue/anproto@f7cd761/an.js'
 
 let db
 let hashLog = []
···
 let newMessages = false
 let sort = true
 
-export const bogbot = {}
+export const apds = {}
 
-bogbot.start = async (appId) => {
+apds.start = async (appId) => {
   db = await cachekv(appId)
   
   setInterval(async () => {
···
         try {
           const obj = {
             hash,
-            sig: await bogbot.get(hash)
+            sig: await apds.get(hash)
           }
           obj.author = obj.sig.substring(0, 44)
-          obj.opened = await bogbot.open(obj.sig)
-          obj.text = await bogbot.get(obj.opened.substring(13))
+          obj.opened = await apds.open(obj.sig)
+          obj.text = await apds.get(obj.opened.substring(13))
           obj.ts = obj.opened.substring(0, 13)
           newArray.push(obj)
         } catch (err) { console.log(err) }
···
   }, 20000)
 }
 
-bogbot.generate = async () => {
-  const genkey = nacl.sign.keyPair()
-  const keygen = encode(genkey.publicKey) + encode(genkey.secretKey)
-  return keygen
+apds.generate = async () => {
+  const genkey = await an.gen()
+  return genkey
 }
 
-bogbot.keypair = async () => {
+apds.keypair = async () => {
   const keypair = await db.get('keypair')
   if (keypair) {
     return keypair
   }
 }
 
-bogbot.pubkey = async () => {
-  const keypair = await bogbot.keypair()
+apds.pubkey = async () => {
+  const keypair = await apds.keypair()
+  console.log(keypair)
   if (keypair) {
     return keypair.substring(0, 44)
   }
 }
 
-bogbot.privkey = async () => {
-  const keypair = await bogbot.keypair()
+apds.privkey = async () => {
+  const keypair = await apds.keypair()
   if (keypair) {
     return keypair.substring(44)
   }
 }
 
-bogbot.deletekey = async () => {
+apds.deletekey = async () => {
   db.rm('keypair')
 }
 
-bogbot.clear = async () => {
+apds.clear = async () => {
   db.clear()
 }
 
-bogbot.hash = async (data) => {
-  return encode(
-    Array.from(
-      new Uint8Array(
-        await crypto.subtle.digest("SHA-256", new TextEncoder().encode(data))
-      )
-    )
-  )
-}
+apds.hash = async (data) => { return await an.hash(data) }
 
-bogbot.sign = async (data) => {
-  const timestamp = Date.now()
-
-  const hash = await bogbot.make(data)
+apds.sign = async (data) => {
+  const hash = await apds.make(data)
+  const sig = await an.sign(hash, await apds.keypair())
+  console.log(sig)
+  await apds.add(sig)
+  const protocolMsg = await apds.make(sig)
 
-  const sig = encode(nacl.sign(new TextEncoder().encode(timestamp + hash), decode(await bogbot.privkey())))
-  await bogbot.add(await bogbot.pubkey() + sig)
-  const protocolMsg = await bogbot.make(await bogbot.pubkey() + sig)
   db.put('previous', protocolMsg)
   return protocolMsg
 }
 
-bogbot.open = async (msg) => {
+apds.open = async (msg) => {
   try {
-    const pubkey = msg.substring(0, 44)
-    const sig = msg.substring(44)
-
-    const opened = new TextDecoder().decode(nacl.sign.open(decode(sig), decode(pubkey)))
-
-    return opened
+    return await an.open(msg)
   } catch (err) {
     //console.log('Not a valid Bog5 protocol message')
   }
···
 
 import { yaml } from './lib/yaml.js'
 
-bogbot.parseYaml = async (doc) => {
+apds.parseYaml = async (doc) => {
   return await yaml.parse(doc)
 }
 
-bogbot.createYaml = async (obj, content) => {
+apds.createYaml = async (obj, content) => {
   return await yaml.create(obj, content)
 }
 
-bogbot.compose = async (content, prev) => {
+apds.compose = async (content, prev) => {
   let obj = {}
   if (prev) { obj = prev }
 
···
   if (previous) { obj.previous = previous}
 
   if (Object.keys(obj).length > 0) { 
-    const yaml = await bogbot.createYaml(obj, content)
-    return await bogbot.sign(yaml)
+    const yaml = await apds.createYaml(obj, content)
+    return await apds.sign(yaml)
   } else {
-    return await bogbot.sign(content)
+    return await apds.sign(content)
   } 
 }
 
-bogbot.make = async (data) => {
-  const hash = await bogbot.hash(data)
+apds.make = async (data) => {
+  const hash = await apds.hash(data)
 
   await db.put(hash, data)
 
   return hash
 }
 
-bogbot.get = async (hash) => {
+apds.get = async (hash) => {
   const blob = await db.get(hash)
 
   return blob
 }
 
-bogbot.put = async (key, value) => {
+apds.put = async (key, value) => {
   await db.put(key, value)
 }
 
-bogbot.rm = async (key) => {
+apds.rm = async (key) => {
   await db.rm(key)
 }
 
-bogbot.add = async (msg) => {
-  const opened = await bogbot.open(msg)
+apds.add = async (msg) => {
+  const opened = await apds.open(msg)
   if (opened) {
-    const hash = await bogbot.make(msg)
+    const hash = await apds.make(msg)
     if (!hashLog.includes(hash)) {
       hashLog.push(hash)
       const obj = {
···
       }
       obj.author = obj.sig.substring(0, 44)
       obj.opened = opened
-      obj.text = await bogbot.get(obj.opened.substring(13))
+      obj.text = await apds.get(obj.opened.substring(13))
       obj.ts = obj.opened.substring(0, 13)
       openedLog.push(obj)
       newMessages = true
···
   }
 }
 
-bogbot.getHashLog = async () => { return hashLog }
+apds.getHashLog = async () => { return hashLog }
 
-bogbot.getOpenedLog = async () => { return openedLog }
+apds.getOpenedLog = async () => { return openedLog }
 
-bogbot.query = async (query) => {
+apds.query = async (query) => {
   if (openedLog[0] && !query) { return openedLog }
   if (openedLog[0] && query.startsWith('?')) {
     const search = query.substring(1).replace(/%20/g, ' ').toUpperCase()
···
   }
 }
 
-bogbot.getPubkeys = async () => {
-  const arr = await bogbot.query()
+apds.getPubkeys = async () => {
+  const arr = await apds.query()
   const newSet = new Set()
   for (const msg of arr) {
     newSet.add(msg.author)
···
   return newArr
 }
 
-bogbot.getLatest = async (pubkey) => {
+apds.getLatest = async (pubkey) => {
   const q = openedLog.filter(msg => msg.author === pubkey)
   return q[q.length -1]
 }
 
-bogbot.human = async (ts) => {
+apds.human = async (ts) => {
   return await human(new Date(parseInt(ts)))
 }
 
-bogbot.visual = async (pubkey) => {
+apds.visual = async (pubkey) => {
   return vb(decode(pubkey), 256)
 }
 

composer.js

···
-import { bogbot } from './bogbot.js'
+import { apds } from './apds.js'
 import { render } from './render.js'
 
 export const composer = async () => {
···
   b.textContent = 'Sign'
   
   b.onclick = async () => {
-    const published = await bogbot.compose(ta.value)
+    const published = await apds.compose(ta.value)
     ta.value = ''
     const scroller = document.getElementById('scroller')
     await render.hash(published, scroller)

example.js

···
-import { bogbot } from './bogbot.js'
+import { apds } from './apds.js'
 import { profile } from './profile.js'
 import { composer } from './composer.js' 
 import { render } from './render.js'
 
-await bogbot.start('bog5example')
+await apds.start('apds1')
 
-if (!await bogbot.pubkey()) { 
-  const keypair = await bogbot.generate()
-  await bogbot.put('keypair', keypair)
+if (!await apds.pubkey()) { 
+  const keypair = await apds.generate()
+  console.log(keypair)
+  await apds.put('keypair', keypair)
 }
 
 document.body.appendChild(await profile())
···
 
 document.body.appendChild(scroller)
 
-const log = await bogbot.query()
+const log = await apds.query()
 
 log.forEach(async (obj) => {
   await render.hash(obj.hash, scroller)

profile.js

···
 import { h } from './lib/h.js' 
-import { bogbot } from './bogbot.js'
+import { apds } from './apds.js'
 
 export const profile = async () => {
   const div = h('div')
 
-  const avatarImg = await bogbot.visual(await bogbot.pubkey())
+  const avatarImg = await apds.visual(await apds.pubkey())
 
-  const existingImage = await bogbot.get('image')
+  const existingImage = await apds.get('image')
   
-  if (existingImage) { avatarImg.src = await bogbot.get(existingImage)}
+  if (existingImage) { avatarImg.src = await apds.get(existingImage)}
 
   avatarImg.style = 'height: 30px; width: 30px; float: left; margin-right: 5px; object-fit: cover;'
 
···
           ctx.drawImage(img, 0, 0, width, height, 0, 0, cropWidth, cropHeight)
           const croppedImage = canvas.toDataURL()
           avatarImg.src = croppedImage
-          const hash = await bogbot.make(croppedImage)
-          await bogbot.put('image', hash)
+          const hash = await apds.make(croppedImage)
+          await apds.put('image', hash)
         } else {
           const croppedImage = canvas.toDataURL()
           avatarImg.src = img.src
-          const hash = await bogbot.make(img.src)
-          await bogbot.put('image', hash)
+          const hash = await apds.make(img.src)
+          await apds.put('image', hash)
         }
       }
       img.src = e.target.result
···
 
   div.appendChild(avatarImg)
 
-  div.appendChild(h('div', [await bogbot.pubkey()]))
+  div.appendChild(h('div', [await apds.pubkey()]))
 
-  const name = await bogbot.get('name')
+  const name = await apds.get('name')
   
   const namer = h('input', {
     placeholder: name || 'Name yourself'
···
     h('button', {onclick: async () => {
       if (namer.value) {
         namer.placeholder = namer.value
-        await bogbot.put('name', namer.value)
+        await apds.put('name', namer.value)
         namer.value = ''
       }
     }}, ['Save'])

render.js

···
-import { bogbot } from './bogbot.js'
+import { apds } from './apds.js'
 import { h } from './lib/h.js'
 
 export const render = {}
 
 render.blob = async (blob) => {
-  const hash = await bogbot.hash(blob)
+  const hash = await apds.hash(blob)
 
   const div = await document.getElementById(hash)
 
   try {
-    const opened = await bogbot.open(blob)
-    const ts = h('span', [await bogbot.human(opened.substring(0, 13))])
+    const opened = await apds.open(blob)
+    const ts = h('span', [await apds.human(opened.substring(0, 13))])
     setInterval(async () => {
-      ts.textContent = await bogbot.human(opened.substring(0, 13))
+      ts.textContent = await apds.human(opened.substring(0, 13))
     }, 1000)
     if (div) {
-      const img = await bogbot.visual(blob.substring(0, 44))
+      const img = await apds.visual(blob.substring(0, 44))
       img.id = 'image'
       img.style = 'width: 30px; height: 30px; float: left; margin-right: 5px; object-fit: cover;'
       div.appendChild(img)
       div.appendChild(h('a', {href: '#' + blob.substring(0, 44), id: 'name'}, [blob.substring(0, 10)]))
       div.appendChild(h('a', {href: '#' + hash, style: 'float: right;'}, [ts]))
       div.appendChild(h('div', {id: opened.substring(13)}))
-      const content = await bogbot.get(opened.substring(13))
+      const content = await apds.get(opened.substring(13))
       if (content) {
         await render.blob(content)
       }
···
     }
   } catch (err) {
     console.log('Not a valid protocol message')
-    const yaml = await bogbot.parseYaml(blob)
+    const yaml = await apds.parseYaml(blob)
     if (div) {
       div.textContent = yaml.body
       div.parentNode.childNodes.forEach(async (node) => {
···
           node.textContent = yaml.name
         }
         if (yaml.image && node.id === 'image') {
-          const image = await bogbot.get(yaml.image)
+          const image = await apds.get(yaml.image)
           node.src = image
         }
       })
···
 
   scroller.insertBefore(div, scroller.firstChild)
 
-  const sig = await bogbot.get(hash)
+  const sig = await apds.get(hash)
 
   if (sig) {
     await render.blob(sig)