wao 0.4.11 → 0.5.0

package/esm/armem.js

@@ -1,20 +1,15 @@
 import Arweave from "arweave"
 import { last } from "ramda"
-
+import { buildTags } from "./utils.js"
 export default class ArMem {
-  constructor() {
+  constructor({ MU_URL, CU_URL, SU_URL, GATEWAY_URL, scheduler } = {}) {
     this.__type__ = "mem"
     this.arweave = Arweave.init()
-    this.arweave.transactions.getTransactionAnchor = () => {
-      return this.blocks.length === 0
-        ? ""
-        : last(this.blockmap[last(this.blocks)].txs)
-    }
+    this.arweave.transactions.getTransactionAnchor = () => this.getAnchor()
     this.arweave.transactions.getPrice = () => 0
     this.addrmap = {}
     this.txs = {}
     this.jwks = {}
-    this.height = 0
     this.blocks = []
     this.blockmap = {}
     this.env = {}
@@ -39,5 +34,55 @@ export default class ArMem {
         format: "wasm64-unknown-emscripten-draft_2024_02_15",
       },
     }
+    let txs = []
+    for (const k in this.modules) {
+      const key = this.modules[k]
+      txs.push(key)
+      this.txs[key] = {
+        id: key,
+        block: 0,
+        tags: buildTags(null, {
+          "Data-Protocol": "ao",
+          Variant: "ao.TN.1",
+          Type: "Module",
+          "Module-Format": "wasm64-unknown-emscripten-draft_2024_02_15",
+          "Input-Encoding": "JSON-V1",
+          "Output-Encoding": "JSON-V1",
+          "Memory-Limit": "1-gb",
+          "Compute-Limit": "9000000000000",
+        }),
+      }
+    }
+    if (scheduler && SU_URL) {
+      const key = scheduler
+      txs.push(key)
+      this.addrmap[scheduler] = { address: scheduler }
+      this.txs[key] = {
+        id: key,
+        block: 0,
+        owner: scheduler,
+        tags: buildTags(null, {
+          "Data-Protocol": "ao",
+          Variant: "ao.TN.1",
+          Type: "Scheduler-Location",
+          Url: SU_URL,
+          "Time-To-Live": 1000 * 60 * 60 * 24 * 365 * 10,
+        }),
+      }
+    }
+    this.blockmap["0"] = {
+      txs,
+      timestamp: Date.now(),
+      height: 0,
+      previous: "",
+      id: "0",
+    }
+    this.blocks.push("0")
+    this.height = 1
+  }
+  getAnchor() {
+    return this.blocks.length === 0
+      ? "Do_Uc2Sju_ffp6Ev0AnLVdPtot15rvMjP-a9VVaA5fM"
+      : last(this.blockmap[last(this.blocks)].txs)
   }
 }

package/esm/run.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env -S node --experimental-wasm-memory64
+
+import Server from "./server.js"
+
+const main = async () => new Server()
+
+main()

package/esm/server.js

@@ -0,0 +1,375 @@
+import express from "express"
+import base64url from "base64url"
+import { DataItem } from "arbundles"
+import { tags } from "./utils.js"
+import { connect } from "./aoconnect.js"
+import { GQL, cu, su, mu } from "./test.js"
+import bodyParser from "body-parser"
+import { graphql, parse, validate, buildSchema } from "graphql"
+import { map } from "ramda"
+const schema = buildSchema(`
+  schema {
+    query: Query
+  }
+
+  type Query {
+    transactions(
+      ids: [ID!]
+      tags: [TagFilter!]
+      block: BlockFilter
+      after: String
+      first: Int
+    ): TransactionConnection!
+
+    block(id: ID, height: Int): Block
+  }
+
+  type TransactionConnection {
+    edges: [TransactionEdge!]!
+    pageInfo: PageInfo!
+  }
+
+  type TransactionEdge {
+    cursor: String!
+    node: Transaction!
+  }
+
+  type Transaction {
+    id: ID!
+    anchor: String
+    signature: String!
+    recipient: String
+    owner: Owner!
+    fee: Quantity!
+    quantity: Quantity!
+    data: Data!
+    tags: [Tag!]!
+    block: Block
+    parent: Transaction
+  }
+
+  type Owner {
+    address: String!
+    key: String!
+  }
+
+  type Quantity {
+    winston: String!
+    ar: String!
+  }
+
+  type Data {
+    size: String!
+    type: String
+  }
+
+  type Tag {
+    name: String!
+    value: String!
+  }
+
+  type Block {
+    id: ID!
+    timestamp: Int!
+    height: Int!
+    previous: String
+    transactions: [Transaction!]!
+    miner: String!
+    reward: String!
+    tags: [Tag!]!
+    indepHash: String!
+    nonce: String!
+  }
+
+  type PageInfo {
+    hasNextPage: Boolean!
+  }
+
+  input TagFilter {
+    name: String!
+    values: [String!]!
+  }
+
+  input BlockFilter {
+    min: Int
+    max: Int
+  }
+`)
+
+const root = {
+  transactions: ({ first }) => ({
+    edges: [],
+    pageInfo: {
+      hasNextPage: false,
+    },
+  }),
+  block: ({ id }) => ({
+    id,
+    timestamp: Date.now(),
+    height: 123456,
+    previous: "previous-block-id",
+    transactions: [],
+    miner: "example-miner",
+    reward: "1000",
+    tags: [],
+    indepHash: "example-indep-hash",
+    nonce: "000000",
+  }),
+}
+
+const mapParsed = (parsedQuery, variables) => {
+  const operation = parsedQuery.definitions[0]
+
+  if (operation.operation !== "query") {
+    throw new Error("Only 'query' operations are supported.")
+  }
+
+  const rootField = operation.selectionSet.selections[0]
+  const rootFieldName = rootField.name.value
+
+  const parseArgumentValue = argValue => {
+    if (argValue.kind === "Variable") {
+      return variables[argValue.name.value]
+    }
+
+    if (argValue.kind === "ListValue") {
+      return argValue.values.map(value => parseArgumentValue(value))
+    }
+
+    if (argValue.kind === "ObjectValue") {
+      return argValue.fields.reduce((obj, field) => {
+        obj[field.name.value] = parseArgumentValue(field.value)
+        return obj
+      }, {})
+    }
+
+    return argValue.value
+  }
+
+  const args = rootField.arguments.reduce((acc, arg) => {
+    acc[arg.name.value] = parseArgumentValue(arg.value)
+    return acc
+  }, {})
+
+  const extractFields = selectionSet => {
+    return selectionSet.selections.map(selection => {
+      const fieldName = selection.name.value
+
+      if (selection.selectionSet) {
+        return {
+          [fieldName]: extractFields(selection.selectionSet),
+        }
+      }
+      return fieldName
+    })
+  }
+
+  const fields = extractFields(rootField.selectionSet)
+
+  return { rootFieldName, args, fields }
+}
+
+class Server {
+  constructor({ ar = 4000, mu = 4002, su = 4003, cu = 4004, aoconnect } = {}) {
+    const {
+      ar: _ar,
+      message,
+      spawn,
+      dryrun,
+      result,
+      results,
+      mem,
+      monitor,
+      unmonitor,
+    } = connect(aoconnect)
+    this.monitor = monitor
+    this.unmonitor = unmonitor
+    this.spawn = spawn
+    this._ar = _ar
+    this.message = message
+    this.dryrun = dryrun
+    this.result = result
+    this.results = results
+    this.mem = mem
+    this.gql = new GQL({ mem })
+    this.ports = { ar, mu, su, cu }
+    this.servers = []
+    this.ar()
+    this.mu()
+    this.su()
+    this.cu()
+  }
+  ar() {
+    const app = express()
+    app.use(bodyParser.json({ limit: "100mb" }))
+    app.get("/tx/:id/offset", async (req, res) => {
+      res.status(500)
+      res.send(null)
+    })
+    app.get("/tx_anchor", async (req, res) => {
+      res.send(this.mem.getAnchor())
+    })
+    app.get("/mine", async (req, res) => {
+      res.json(req.params)
+    })
+    app.get("/:id", async (req, res) => {
+      const _data = await this._ar.data(req.params.id)
+      if (!_data) {
+        res.status(404)
+        res.send(null)
+      } else {
+        res.send(Buffer.from(_data, "base64"))
+      }
+    })
+    app.get("/price/:id", async (req, res) => {
+      res.send("0")
+    })
+    app.post("/graphql", async (req, res) => {
+      const { query, variables } = req.body
+      const parsedQuery = parse(query)
+      const errors = validate(schema, parsedQuery)
+      const parsed = mapParsed(parsedQuery, variables)
+      const tar = parsed.rootFieldName
+      const fields = parsed.fields[0].edges[0].node
+      const args = parsed.args
+      let res2 = null
+      if (tar === "transactions") {
+        res2 = await this.gql.txs({ ...args })
+      } else if (tar === "blocks") {
+        res2 = await this.gql.blocks()
+      }
+      const edges = map(v => ({ node: v, cursor: v.cursor }), res2)
+      res.json({ data: { transactions: { edges } } })
+    })
+
+    let data = {}
+    app.post("/:id", async (req, res) => {
+      if (req.body.chunk) {
+        if (data[req.body.data_root]) {
+          data[req.body.data_root].data += req.body.chunk
+          const buf = Buffer.from(req.body.chunk, "base64")
+          if (!data[req.body.data_root].chunks) {
+            data[req.body.data_root].chunks = buf
+          } else {
+            data[req.body.data_root].chunks = Buffer.concat([
+              data[req.body.data_root].chunks,
+              buf,
+            ])
+          }
+          delete req.body.chunk
+          if (
+            data[req.body.data_root].data_size <=
+            data[req.body.data_root].chunks.length
+          ) {
+            data[req.body.data_root].data =
+              data[req.body.data_root].chunks.toString("base64")
+            await this._ar.postTx(data[req.body.data_root])
+            delete data[req.body.data_root]
+          }
+        }
+        res.json({ id: req.body.id })
+      } else {
+        if (req.body.data_root && req.body.data === "") {
+          data[req.body.data_root] = req.body
+        } else {
+          await this._ar.postTx(req.body)
+        }
+        res.json({ id: req.body.id })
+      }
+    })
+    app.post("/tx", async (req, res) => {
+      await this._ar.postTx(req.body)
+      res.json({ id: req.body.id })
+    })
+    const server = app.listen(this.ports.ar, () => {
+      console.log(`AR on port ${this.ports.ar}`)
+    })
+    this.servers.push(server)
+  }
+  mu() {
+    const app = express()
+    app.use(express.raw({ type: "*/*" }))
+    app.get("/", (req, res) => res.send("ao messenger unit"))
+    app.post("/monitor/:id", async (req, res) => {
+      await this.monitor({ process: req.params.id })
+      res.json({ id: req.params.id, messag: "cron monitored!" })
+    })
+    app.delete("/monitor/:id", async (req, res) => {
+      await this.unmonitor({ process: req.params.id })
+      res.json({ id: req.params.id, message: "cron deleted!" })
+    })
+    app.post("/", async (req, res) => {
+      const binary = req.body
+      let valid = await DataItem.verify(binary)
+      let type = null
+      let item = null
+      if (valid) item = new DataItem(binary)
+      const _tags = tags(item.tags)
+      let err = null
+      if (_tags.Type === "Process") {
+        await this.spawn({
+          item,
+          module: _tags.Module,
+          scheduler: _tags.Scheduler,
+        })
+      } else if (_tags.Type === "Message") {
+        await this.message({ item, process: item.target })
+      } else {
+        err = true
+      }
+      if (err) res.status(500)
+      res.send({ id: item.id })
+    })
+    const server = app.listen(this.ports.mu, () =>
+      console.log(`MU on port ${this.ports.mu}`),
+    )
+    this.servers.push(server)
+  }
+  su() {
+    const app = express()
+    app.use(bodyParser.json())
+    app.get("/", (req, res) => res.json({ timestamp: Date.now() }))
+    const server = app.listen(this.ports.su, () =>
+      console.log(`SU on port ${this.ports.su}`),
+    )
+    this.servers.push(server)
+  }
+  cu() {
+    const app = express()
+    app.use(bodyParser.json())
+    app.get("/", (req, res) => res.json({ timestamp: Date.now() }))
+    app.get("/result/:mid", async (req, res) => {
+      const res2 = await this.result({
+        message: req.params.mid,
+        process: req.query["process-id"],
+      })
+      res.json(res2)
+    })
+    app.post("/dry-run", async (req, res) => {
+      const process = req.query["process-id"]
+      const { Id: id, Owner: owner, Tags: tags, Data: data } = req.body
+      const res2 = await this.dryrun({ id, owner, tags, data, process })
+      delete res2.Memory
+      res.json(res2)
+    })
+    const server = app.listen(this.ports.cu, () =>
+      console.log(`CU on port ${this.ports.cu}`),
+    )
+    this.servers.push(server)
+  }
+  end() {
+    return new Promise(res => {
+      let count = 0
+      for (const v of this.servers)
+        v.close(() => {
+          count += 1
+          if (count >= 4) {
+            console.log("servers closed!", count)
+            res()
+          }
+        })
+    })
+  }
+}
+
+export default Server

package/esm/tao.js

@@ -77,7 +77,7 @@ class AO extends MAO {
     this.message = message
     this.spawn = async (...opt) => {
       const res = await spawn(...opt)
-      await this.load({ data: log, pid: res })
+      //await this.load({ data: log, pid: res })
       return res
     }
     this.dryrun = async (...opt) => {
@@ -117,7 +117,7 @@ class AO extends MAO {
     const { id, owner } = await this.ar.dataitem({ tags: _tags, data, signer })
     await this.ar.post({ data, tags: t, jwk })
     this.mem.wasms[id] = { data, format: t["Module-Format"] }
-    return id
+    return { id }
   }
 }
 

package/esm/tar.js

@@ -1,5 +1,5 @@
 import MAR from "./ar.js"
-import { buildTags } from "./utils.js"
+import { buildTags, tags as t } from "./utils.js"
 import * as WarpArBundles from "warp-arbundles"
 const pkg = WarpArBundles.default ?? WarpArBundles
 const { DataItem } = pkg
@@ -17,16 +17,21 @@ class AR extends MAR {
     this.arweave = this.mem.arweave
   }
 
-  async dataitem({ target = "", data = "1984", tags = {}, signer }) {
-    const _tags = buildTags(tags)
-    const item = await signer({ data, tags: _tags, target })
-    const di = new DataItem(item.raw)
+  async dataitem({ target = "", data = "1984", tags = {}, signer, item }) {
+    let di = item
+    if (!di) {
+      const _tags = buildTags(tags)
+      const _item = await signer({ data, tags: _tags, target })
+      di = new DataItem(_item.raw)
+    } else {
+      tags = t(di.tags)
+    }
     const raw_owner = di.rawOwner
     const hashBuffer = Buffer.from(
       await crypto.subtle.digest("SHA-256", raw_owner),
     )
     const owner = base64url.encode(hashBuffer)
-    return { id: item.id, owner, item }
+    return { id: await di.id, owner, item: di, tags }
   }
 
   async post({ data = "1984", tags = {}, jwk }) {
@@ -43,11 +48,13 @@ class AR extends MAR {
     })
   }
 
-  async postItem(item, jwk) {
-    const tx = await this.mem.arweave.createTransaction({ data: item.raw }, jwk)
+  async postItem(di, jwk) {
+    const tx = await this.mem.arweave.createTransaction(
+      { data: di.binary },
+      jwk,
+    )
     tx.addTag("Bundle-Format", "binary")
     tx.addTag("Bundle-Version", "2.0.0")
-    const di = new DataItem(item.raw)
     const data_size = Buffer.byteLength(di.rawData).toString()
     let data_type = ""
     for (const t of di.tags) if (t.name === "Content-Type") data_type = t.value
@@ -66,33 +73,33 @@ class AR extends MAR {
       anchor: di.anchor,
       signature: di.signature,
       recipient: di.target,
-      id: item.id,
+      id: await di.id,
       item: di,
       owner,
       tags: di.tags,
       data,
     }
-    this.mem.txs[item.id] = _item
+    this.mem.txs[await di.id] = _item
     return await this.postTx(tx, jwk, _item)
   }
 
   async postTx(tx, jwk, item) {
     let [res, err] = [null, null]
-    await this.mem.arweave.transactions.sign(tx, jwk)
+    if (!tx.id) await this.mem.arweave.transactions.sign(tx, jwk)
+    this.mem.height += 1
+    let block = {
+      id: tx.id,
+      timestamp: Date.now(),
+      height: this.mem.height,
+      previous: last(this.mem.blocks) ?? "",
+    }
     if (item) {
-      this.mem.height += 1
-      const block = {
-        id: tx.id,
-        timestamp: Date.now(),
-        height: this.mem.height,
-        previous: last(this.mem.blocks) ?? "",
-      }
       if (!item.id) {
         item.id = tx.id
-        this.mem.txs[item.id] = item
-        this.mem.txs[item.id].parent = null
-        this.mem.txs[item.id].signature = tx.signature
-        this.mem.txs[item.id].anchor = tx.last_tx
+        this.mem.txs[tx.id] = item
+        this.mem.txs[tx.id].parent = null
+        this.mem.txs[tx.id].signature = tx.signature
+        this.mem.txs[tx.id].anchor = tx.last_tx
         let data_type = ""
         for (const v of tx.tags) {
           if (
@@ -101,27 +108,45 @@ class AR extends MAR {
             data_type = v.get("value", { decode: true, string: true })
           }
         }
-        this.mem.txs[item.id]._data = { size: tx.data_size, type: data_type }
+        this.mem.txs[tx.id]._data = { size: tx.data_size, type: data_type }
       } else {
         this.mem.txs[item.id].parent = { id: block.id }
       }
       block.txs = [item.id]
       this.mem.txs[item.id].block = block.id
-      this.mem.blocks.push(block.id)
-      this.mem.blockmap[block.id] = block
+    } else {
+      let _tags = []
+      for (const v of tx.tags) {
+        _tags.push({
+          name: base64url.decode(v.name),
+          value: base64url.decode(v.value),
+        })
+      }
+      tx.tags = _tags
+      this.mem.txs[tx.id] = tx
+      block.txs = [tx.id]
+      this.mem.txs[tx.id].block = block.id
+    }
+    this.mem.blocks.push(block.id)
+    this.mem.blockmap[block.id] = block
+
+    if (jwk) {
+      const owner = await this.arweave.wallets.jwkToAddress(jwk)
+      this.mem.addrmap[owner] = jwk.n
     }
     res = { id: tx.id, status: 200, statusText: "200" }
-    const owner = await this.arweave.wallets.jwkToAddress(jwk)
-    this.mem.addrmap[owner] = jwk.n
     return { res, err, id: tx.id }
   }
 
-  tx(id) {
+  async tx(id) {
     return this.mem.txs[id]
   }
 
-  data(id) {
-    return this.mem.txs[id].data
+  async data(id, string) {
+    let tx = this.mem.txs[id]
+    let _data = this.mem.txs[id]?.data ?? null
+    if (tx.format === 2 && _data && string) _data = base64url.decode(_data)
+    return _data
   }
 }
 

package/esm/test.js

@@ -8,12 +8,15 @@ import GQL from "./tgql.js"
 import ArMem from "./armem.js"
 import { dirname } from "./utils.js"
 import { Src, setup, ok, fail } from "./helpers.js"
+import Server from "./server.js"
+
 const blueprint = async pkg => {
   return readFileSync(resolve(await dirname(), `lua/${pkg}.lua`), "utf8")
 }
-const scheduler = "GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA"
+const scheduler = "_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA"
 
 export {
+  Server,
   GQL,
   ArMem,
   AO,

package/esm/tgql.js

@@ -80,7 +80,6 @@ export default class GQL {
     let ids = null
     if (is(Array, opt.ids)) ids = opt.ids
     else if (is(String, opt.id)) ids = [opt.id]
-
     let data = []
     let blocks = this.mem.blocks
     if (opt.asc !== true) blocks = reverse(blocks)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wao",
-  "version": "0.4.11",
+  "version": "0.5.0",
   "description": "",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -27,6 +27,16 @@
     "arbundles": "^0.11.1",
     "arweave": "^1.15.1",
     "base64url": "^3.0.1",
+    "body-parser": "^1.20.3",
+    "express": "^4.21.2",
+    "graphql": "^16.10.0",
     "ramda": "^0.30.1"
+  },
+  "bin": {
+    "wao": "./cjs/run.js",
+    "wao-esm": "./esm/run.js"
+  },
+  "scripts": {
+    "server": "node --experimental-wasm-memory64 cjs/run.js"
   }
 }