wao 0.41.3 → 0.41.5

package/src/hub/bundler.js

@@ -0,0 +1,123 @@
+import express from "express"
+import cors from "cors"
+import bodyParser from "body-parser"
+import _Arweave from "arweave"
+const Arweave = _Arweave.default ?? _Arweave
+const arweave = Arweave.init()
+import { generateId, toANS104Request, parseSignatureInput } from "./utils.js"
+
+// todo: bundler is unusable due to incorrect ids and signature
+const bundler = (sus, cbs, hbs) => {
+  const app = express()
+  app.use(cors())
+  app.use("/tx", bodyParser.raw({ type: "*/*", limit: "100mb" }))
+  app.post("/tx", async (req, res) => {
+    if (!Buffer.isBuffer(req.body)) {
+      console.log("BD: Invalid body | expected raw Buffer")
+      return res.status(400).send("Invalid body: expected raw Buffer")
+    }
+    const lines = req.body.toString("utf8").split(/\r?\n/)
+    const sigs = {}
+    let currentKey = null
+    for (let line of lines) {
+      const trimmed = line.trim()
+      if (/^--[a-zA-Z0-9_\-=]+/.test(trimmed)) {
+        currentKey = null
+        continue
+      }
+      const headerMatch = trimmed.match(/^([a-zA-Z0-9_-]+):\s*(.*)$/)
+      if (headerMatch && !headerMatch[2].includes(": ")) {
+        const key = headerMatch[1]
+        const value = headerMatch[2]
+        sigs[key] = value
+        currentKey = key
+      } else if (currentKey) sigs[currentKey] += "\n" + line
+    }
+    sigs.target = req.headers.process
+    sigs.slot = req.headers.slot
+
+    const input = parseSignatureInput(req.headers["signature-input"])
+    const key = { kty: "RSA", n: input.keyid, e: "AQAB" }
+    const address = await arweave.wallets.jwkToAddress(key)
+    hbs[address] ??= {}
+    hbs[address].update = Date.now()
+    /*
+      const verifier = createVerifier(
+      createPublicKey({ key, format: "jwk" }),
+      "rsa-pss-sha512"
+      )*/
+    try {
+      /*const isValid = await verifyMessage(
+      { keyLookup: params => ({ verify: verifier }) },
+      {
+        method: req.method,
+        headers: req.headers,
+        url: `http://ao.com${req.headers.path}`,
+      }
+      )*/
+      const item = toANS104Request(sigs).item
+      if ((sigs.slot === "0" || sigs.type === "Process") && sigs.module) {
+        for (let v of item.tags) if (v.name === "Type") v.value = "Process"
+        await message(
+          {
+            http_msg: item,
+            module: sigs.module,
+            scheduler: sigs.scheduler,
+            address,
+          },
+          res
+        )
+      } else if (sigs.type === "Message") {
+        for (let v of item.tags) if (v.name === "id") item.target = v.value
+        await message(
+          {
+            slot: sigs.slot,
+            http_msg: item,
+            process: sigs.target,
+            address,
+          },
+          res
+        )
+      } else {
+        return res.status(500).send("unknown error")
+      }
+    } catch (e) {
+      return res.status(500).send("unknown error")
+    }
+  })
+
+  async function message(opt, res) {
+    const id = generateId()
+    cbs[id] = res
+    let exists = false
+    for (let k in sus) {
+      let hb = sus[k].accept.hb[opt.address]
+      let pid = opt.process
+      let p = sus[k].accept.pid[pid]
+      if (hb?.["*"] || hb?.[pid] || p?.["*"] || p?.[opt.address]) {
+        const socket = sus[k].socket
+        /*exists = true
+        socket.send(
+          JSON.stringify({ type: "msg", subtype: "message", id, message: opt })
+        )*/
+      }
+    }
+    res.status(200).send("success")
+    delete cbs[id]
+    /*
+    if (!exists) {
+      res.status(200).send("success")
+      delete cbs[id]
+    } else {
+      setTimeout(() => {
+        if (cbs[id]) {
+          res.status(200).send("success")
+          delete cbs[id]
+        }
+      }, 10000)
+    }*/
+  }
+
+  const server = app.listen(4001, () => console.log(`BD on port 4001`))
+}
+export default bundler

package/src/hub/cu.js

@@ -0,0 +1,74 @@
+import express from "express"
+import cors from "cors"
+import bodyParser from "body-parser"
+const app2 = express()
+import { generateId, toANS104Request, parseSignatureInput } from "./utils.js"
+
+const cu = (sus, cbs) => {
+  app2.use(cors())
+  app2.use(bodyParser.json())
+  app2.post("/result/:mid", result)
+  app2.get("/result/:mid", result)
+
+  app2.post("/dry-run", async (req, res) => {
+    const process = req.query["process-id"]
+    const { Id: id, Owner: owner, Tags: tags, Data: data } = req.body
+    dryrun({ id, owner, tags, data, process }, res)
+  })
+
+  const server2 = app2.listen(4004, () => console.log(`CU on port 4004`))
+
+  // todo: request doesn't contain any info about hb node, how to handle it?
+  async function result(req, res) {
+    const id = generateId()
+    cbs[id] = res
+    let message = req.params.mid
+    let exists = false
+    const process = req.query["process-id"]
+    for (let k in sus) {
+      const socket = sus[k].socket
+      exists = true
+      socket.send(
+        JSON.stringify({ type: "msg", subtype: "result", message, process, id })
+      )
+    }
+    if (!exists) {
+      res.status(404).send("success")
+      delete cbs[id]
+    } else {
+      setTimeout(() => {
+        if (cbs[id]) {
+          res.status(404).send("success")
+          delete cbs[id]
+        }
+      }, 10000)
+    }
+  }
+
+  // todo: request doesn't contain any info about hb node, how to handle it?
+  async function dryrun(opt, res) {
+    const id = generateId()
+    cbs[id] = res
+    let exists = false
+    for (let k in sus) {
+      const socket = sus[k].socket
+      exists = true
+      socket.send(
+        JSON.stringify({ type: "msg", subtype: "dryrun", message: opt, id })
+      )
+    }
+    if (!exists) {
+      res.status(404).send("success")
+      delete cbs[id]
+    } else {
+      setTimeout(() => {
+        if (cbs[id]) {
+          res.status(404).send("success")
+          delete cbs[id]
+        }
+      }, 3000)
+    }
+  }
+}
+
+export default cu

package/src/hub/fs.js

@@ -0,0 +1,157 @@
+import chokidar from "chokidar"
+import { generateId } from "./utils.js"
+import WebSocket from "ws"
+import yargs from "yargs"
+let { port = 4006 } = yargs(process.argv.slice(2)).argv
+const ws_server = new WebSocket.Server({ port })
+import { keys, omit, isNil, mergeLeft } from "ramda"
+import { resolve } from "path"
+import { writeFileSync, readFileSync } from "fs"
+const _dir = process.argv[2] ?? "./"
+let sus = {}
+let cbs = {}
+let dir = null
+let _socket = null
+const cwd = process.cwd()
+ws_server.on("connection", socket => {
+  _socket = socket
+  const clientId = generateId()
+  console.log("new ws:", clientId)
+  sus[clientId] = {
+    socket,
+    su: false,
+    connections: {},
+    address: null,
+  }
+  socket.send(JSON.stringify({ type: "registered", id: clientId, dir }))
+  socket.on("message", message => {
+    const data = JSON.parse(message)
+    if (data.type === "save") {
+      writeFileSync(
+        resolve(cwd, _dir, data.path.replace(/^\//, "")),
+        data.content
+      )
+    } else if (data.type === "data") {
+      const content = readFileSync(
+        resolve(cwd, _dir, data.path.replace(/^\//, "")),
+        "utf8"
+      )
+      socket.send(
+        JSON.stringify({
+          content,
+          type: "msg",
+          path: data.path,
+          subtype: "content",
+        })
+      )
+    }
+  })
+
+  socket.on("close", () => {
+    console.log("ws disconnected", clientId)
+    delete sus[clientId]
+  })
+})
+const sendDir = () => {
+  if (_socket) {
+    _socket.send(
+      JSON.stringify({ type: "msg", subtype: "dir_change", dir: dir })
+    )
+  }
+}
+const sendContent = (content, path) => {
+  if (_socket) {
+    _socket.send(
+      JSON.stringify({
+        content,
+        type: "msg",
+        path,
+        subtype: "content",
+      })
+    )
+  }
+}
+
+console.log(`WAO FS running on port ${port}`)
+const wd = resolve(cwd, _dir)
+console.log("Directory:", wd)
+chokidar
+  .watch(wd, {
+    ignored: (e, stats) => {
+      const _e = resolve(cwd, e)
+      return new RegExp(wd + "/node_modules").test(_e)
+    },
+  })
+  .on("change", (e, p) => {
+    const _e = resolve(cwd, e)
+    const rel = _e.replace(new RegExp(wd + "/"), "")
+    let paths = rel.split("/")
+    let _dir = dir
+    const content = readFileSync(resolve(cwd, _dir, _e), "utf8")
+    sendContent(content, e.replace(wd, ""))
+  })
+  .on("add", (e, p) => {
+    const _e = resolve(cwd, e)
+    const rel = _e.replace(new RegExp(wd + "/"), "")
+    let paths = rel.split("/")
+    let _dir = dir
+    while (paths.length > 0) {
+      const p = paths.shift()
+      if (paths.length === 0) {
+        _dir[p] = Date.now()
+      } else {
+        _dir = _dir[p]
+      }
+    }
+    sendDir()
+  })
+  .on("addDir", (e, p) => {
+    const _e = resolve(cwd, e)
+    if (_e === wd) {
+      dir = {}
+      return
+    }
+    const rel = _e.replace(new RegExp(wd + "/"), "")
+    let paths = rel.split("/")
+    let _dir = dir
+    while (paths.length > 0) {
+      const p = paths.shift()
+      _dir[p] ??= {}
+      _dir = _dir[p]
+    }
+    sendDir()
+  })
+  .on("unlink", (e, p) => {
+    const _e = resolve(cwd, e)
+    const rel = _e.replace(new RegExp(wd + "/"), "")
+    let paths = rel.split("/")
+    let _dir = dir
+    while (paths.length > 0) {
+      const p = paths.shift()
+      if (paths.length === 0) {
+        delete _dir[p]
+      } else {
+        _dir = _dir[p]
+      }
+    }
+    sendDir()
+  })
+  .on("unlinkDir", (e, p) => {
+    const _e = resolve(cwd, e)
+    if (_e === wd) {
+      dir = null
+      return null
+    }
+    const rel = _e.replace(new RegExp(wd + "/"), "")
+    let paths = rel.split("/")
+    let _dir = dir
+    while (paths.length > 0) {
+      const p = paths.shift()
+      if (paths.length === 0) {
+        delete _dir[p]
+      } else {
+        _dir = _dir[p]
+      }
+    }
+    sendDir()
+  })

package/src/hub/index.js

@@ -0,0 +1,85 @@
+import express from "express"
+import cors from "cors"
+import bodyParser from "body-parser"
+import { keys, omit, isNil, mergeLeft } from "ramda"
+import { generateId, toANS104Request, parseSignatureInput } from "./utils.js"
+import bundler from "./bundler.js"
+import cu from "./cu.js"
+import yargs from "yargs"
+let { port = 8080 } = yargs(process.argv.slice(2)).argv
+import WebSocket from "ws"
+const ws_server = new WebSocket.Server({ port })
+
+let sus = {}
+let cbs = {}
+let hbs = {
+  O74OhzD1O_zE0uaKbaTQD1rfgTZEGMeXQ6M6M60TW_o: { update: Date.now() },
+}
+
+bundler(sus, cbs, hbs)
+cu(sus, cbs, hbs)
+
+ws_server.on("connection", socket => {
+  const clientId = generateId()
+  console.log("new ws:", clientId)
+  sus[clientId] = {
+    socket,
+    su: false,
+    connections: {},
+    address: null,
+    accept: {
+      pid: {},
+      hb: {},
+    },
+  }
+  socket.send(JSON.stringify({ type: "registered", id: clientId }))
+  socket.on("message", message => {
+    const data = JSON.parse(message)
+    if (data.type === "list") {
+      if (data.target === "hb") {
+        let hb = []
+        for (const k in hbs) {
+          hb.push({ address: k, update: hbs[k].update })
+        }
+        socket.send(JSON.stringify({ hb, type: "list" }))
+      } else {
+        socket.send(JSON.stringify({ error: "unknown target" }))
+      }
+    } else if (data.type === "subscribe") {
+      sus[clientId].accept = mergeLeft(data.accept, sus[clientId].accept)
+      socket.send(
+        JSON.stringify({ type: "subscribe", accept: sus[clientId].accept })
+      )
+    } else if (data.type === "msg") {
+      if (cbs[data.id]) {
+        cbs[data.id].status(data.status).send(data.msg)
+        delete cbs[data.id]
+      }
+    } else if (data.type === "register") {
+      sus[clientId].su = true
+    } else if (data.type === "sus") {
+      let keys = []
+      for (let k in sus) if (sus[k].su) keys.push(k)
+      socket.send(JSON.stringify({ type: "sus", ids: keys }))
+    } else if (data.type === "offer") {
+      sus[data.su].socket.send(
+        JSON.stringify({ type: "offer", id: clientId, offer: data.offer })
+      )
+    } else if (data.type === "answer") {
+      sus[data.client].socket.send(
+        JSON.stringify({
+          type: "answer",
+          id: data.clientId,
+          answer: data.answer,
+        })
+      )
+    }
+  })
+
+  socket.on("close", () => {
+    console.log("ws disconnected", clientId)
+    delete sus[clientId]
+  })
+})
+
+console.log("WAO hub running on port 8080")

package/src/hub/utils.js

@@ -0,0 +1,64 @@
+import { keys, omit, isNil } from "ramda"
+
+function generateId() {
+  return Math.random().toString(36).substring(2, 15)
+}
+
+function toANS104Request(fields) {
+  const dataItem = {
+    target: fields.target,
+    anchor: fields.anchor ?? "",
+    tags: keys(
+      omit(
+        [
+          "Target",
+          "target",
+          "Anchor",
+          "anchor",
+          "Data",
+          "data",
+          "data-protocol",
+          "Data-Protocol",
+          "variant",
+          "Variant",
+          "dryrun",
+          "Dryrun",
+          "Type",
+          "type",
+          "path",
+          "method",
+        ],
+        fields
+      )
+    )
+      .map(function (key) {
+        return { name: key, value: fields[key] }
+      }, fields)
+      .concat([
+        { name: "Data-Protocol", value: "ao" },
+        { name: "Type", value: fields.Type ?? "Message" },
+        { name: "Variant", value: fields.Variant ?? "ao.TN.1" },
+      ]),
+    data: fields?.data || "",
+  }
+  return {
+    headers: {
+      "Content-Type": "application/ans104",
+      "codec-device": "ans104@1.0",
+    },
+    item: dataItem,
+  }
+}
+
+function parseSignatureInput(input) {
+  const match = input.match(
+    /^([^=]+)=\(([^)]+)\);alg="([^"]+)";keyid="([^"]+)"$/
+  )
+  if (!match) throw new Error("Invalid signature-input format")
+
+  const [, label, fieldsStr, alg, keyid] = match
+  const fields = fieldsStr.split('" "').map(f => f.replace(/"/g, ""))
+  return { label, fields, alg, keyid }
+}
+
+export { toANS104Request, parseSignatureInput, generateId }

package/src/hub/ws-proxy.js

@@ -0,0 +1,67 @@
+import yargs from "yargs"
+let { port = 4000 } = yargs(process.argv.slice(2)).argv
+import { Server } from "../test.js"
+import { generateId } from "./utils.js"
+import WebSocket from "ws"
+const proxy_port = port + 5
+const ws_server = new WebSocket.Server({ port: proxy_port })
+import { keys, omit, isNil, mergeLeft } from "ramda"
+import { resolve } from "path"
+import { writeFileSync, readFileSync } from "fs"
+let sus = {}
+let cbs = {}
+console.log(`Starting WAO Proxy servers...`)
+class Adaptor {
+  constructor({ hb_url, aoconnect, log = false, db } = {}) {}
+  async get(req, res) {
+    try {
+      if (_socket) {
+        const id = generateId()
+        cbs[id] = res
+        _socket.send(JSON.stringify({ type: "msg", req, id }))
+        setTimeout(() => {
+          if (cbs[id]) {
+            res({ status: 404, error: "error" })
+            delete cbs[id]
+          }
+        }, 3000)
+      } else {
+        res({ status: 404, error: "connection not found" })
+      }
+    } catch (e) {
+      res({ status: 404, error: "connection not found" })
+    }
+  }
+}
+
+const main = async () => new Server({ log: true, port, adaptor: new Adaptor() })
+
+main()
+
+let _socket = null
+ws_server.on("connection", socket => {
+  _socket = socket
+  const clientId = generateId()
+  console.log("new ws:", clientId)
+  sus[clientId] = {
+    socket,
+    su: false,
+    connections: {},
+    address: null,
+  }
+  socket.send(JSON.stringify({ type: "registered", id: clientId }))
+  socket.on("message", message => {
+    const data = JSON.parse(message)
+    if (data.type === "msg") {
+      if (cbs[data.id]) {
+        cbs[data.id](data.res)
+        delete cbs[data.id]
+      }
+    }
+  })
+  socket.on("close", () => {
+    console.log("ws disconnected", clientId)
+    delete sus[clientId]
+  })
+})
+setTimeout(() => console.log(`WS on port ${proxy_port}`), 10)