wao 0.12.4 → 0.13.0

package/esm/aoconnect-base.js

@@ -25,7 +25,7 @@ import {
   o,
   reverse,
 } from "ramda"
-
+let count = 0
 export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
   return (mem, { cache, log = false, extensions = {} } = {}) => {
     const isMem = mem?.__type__ === "mem"
@@ -62,6 +62,15 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
 
     const genMsg = async (Id, p, data, Tags, from, Owner, dry = false) => {
       if (!dry) p.height += 1
+      let __tags = Tags?.length ? Tags : []
+      let cap = {
+        authority: "Authority",
+        action: "Action",
+        "on-boot": "On-Boot",
+        scheduler: "Scheduler",
+        module: "Module",
+      }
+      for (let v of __tags) v.name = cap[v.name] ?? v.name
       return {
         Id,
         Target: p.id,
@@ -72,7 +81,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         Module: p.module,
         From: from,
         Cron: false,
-        Tags: Tags?.length ? Tags : [],
+        Tags: __tags,
       }
     }
 
@@ -89,41 +98,53 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         },
       }
     }
+
     const spawn = async (opt = {}) => {
       if (!opt.module) throw Error("module missing")
       if (!opt.scheduler) throw Error("scheduler missing")
       const { mod, wasm, format } = await mem.getWasm(opt.module, mem)
-      opt.tags = buildTags(
-        null,
-        mergeLeft(tags(opt.tags ?? []), {
-          "Data-Protocol": "ao",
-          Variant: "ao.TN.1",
-          Type: "Process",
-          SDK: "aoconnect",
-          Module: mod,
-          Scheduler: opt.scheduler,
-          "Content-Type": "text/plain",
-          Authority: mu.addr,
-        }),
-      )
-      let ex = false
-      for (let v of opt.tags) if (v.name === "Type") ex = true
-      if (!ex) opt.tags.push({ name: "Type", value: "Process" })
-      if (opt.for) opt.tags.push({ name: "Pushed-For", value: opt.for })
-      const {
-        id,
-        owner,
-        item,
-        tags: __tags,
-      } = await ar.dataitem({
-        item: opt.item,
-        data: opt.data,
-        signer: opt.signer,
-        tags: tags(opt.tags),
-      })
-      opt.tags = buildTags(null, __tags)
-      if (opt.item) opt.data = base64url.decode(item.data)
-      await ar.postItems(item, su.jwk)
+      let id, owner, item, __tags
+      let msg_owner = mu.addr
+      if (ar.isHttpMsg(opt.http_msg)) {
+        ;({ owner, item, tags: __tags } = await ar.httpmsg(opt.http_msg))
+        id = opt.http_msg.target
+        opt.tags = buildTags(null, __tags)
+        opt.data = opt.http_msg.data
+        msg_owner = owner
+      } else {
+        opt.tags = buildTags(
+          null,
+          mergeLeft(tags(opt.tags ?? []), {
+            "Data-Protocol": "ao",
+            Variant: "ao.TN.1",
+            Type: "Process",
+            SDK: "aoconnect",
+            Module: mod,
+            Scheduler: opt.scheduler,
+            "Content-Type": "text/plain",
+            Authority: mu.addr,
+          })
+        )
+        let ex = false
+        for (let v of opt.tags) if (v.name === "Type") ex = true
+        if (!ex) opt.tags.push({ name: "Type", value: "Process" })
+        if (opt.for) opt.tags.push({ name: "Pushed-For", value: opt.for })
+        ;({
+          id,
+          owner,
+          item,
+          tags: __tags,
+        } = await ar.dataitem({
+          item: opt.item,
+          data: opt.data,
+          signer: opt.signer,
+          tags: tags(opt.tags),
+        }))
+        opt.tags = buildTags(null, __tags)
+        if (opt.item) opt.data = base64url.decode(item.data)
+        await ar.postItems(item, su.jwk)
+      }
+
       const now = Date.now
       const t = tags(opt.tags)
       const ext = t.Extension || "WeaveDrive"
@@ -133,10 +154,12 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         handle = await AoLoader(wasm, {
           format,
           WeaveDrive: wdrive,
-          spawn: item,
-          module: await mem.getTx(mod),
+          spawn: item, // todo: httpmsg
+          module: await mem.getTx(mod), // todo: httpmsg
         })
-      } catch (e) {}
+      } catch (e) {
+        console.log(mod, e)
+      }
       if (!handle) return null
       let _module = null
       _module = { handle, id: mod }
@@ -163,7 +186,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         let data = ""
         if (_tags["On-Boot"] === "Data") data = opt.data ?? ""
         else data = (await mem.get("msgs", _tags["On-Boot"]))?.data ?? ""
-        let msg = await genMsg(id, p, data, opt.tags, owner, mu.addr, true)
+        let msg = await genMsg(id, p, data, opt.tags, owner, msg_owner, true)
         const _env = await genEnv({
           pid: p.id,
           owner: p.owner,
@@ -245,7 +268,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
           Process: opt.process,
           Message: opt.message,
           "Hash-Chain": hash,
-        }),
+        })
       )
       p.epochs.push([opt.message])
       const { id, owner, item } = await ar.dataitem({
@@ -270,7 +293,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
             if (!from) {
               const raw_owner = _opt.item.rawOwner
               const hashBuffer = Buffer.from(
-                await crypto.subtle.digest("SHA-256", raw_owner),
+                await crypto.subtle.digest("SHA-256", raw_owner)
               )
               from = base64url.encode(hashBuffer)
             }
@@ -348,12 +371,18 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
     const message = async opt => {
       const p = await mem.get("env", opt.process)
       if (!p) return null
-      let ex = false
-      let id = opt?.item?.id ?? ""
-      let owner = opt.owner ?? ""
-      let item = opt.item
+      let id = ""
+      let owner = ""
+      let item = null
+      if (ar.isHttpMsg(opt.http_msg)) {
+        ;({ owner, item } = await ar.httpmsg(opt.http_msg))
+        id = opt.http_msg.target
+      } else {
+        let id = opt?.item?.id ?? ""
+        let owner = opt.owner ?? ""
+        let item = opt.item
+      }
       if (!opt.item && opt.signer) {
-        for (let v of opt.tags) if (v.name === "Type") ex = true
         opt.tags = buildTags(
           null,
           mergeLeft(tags(opt.tags ?? []), {
@@ -361,7 +390,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
             Variant: "ao.TN.1",
             Type: "Message",
             SDK: "aoconnect",
-          }),
+          })
         )
         if (opt.for) {
           opt.tags.push({ name: "Pushed-For", value: opt.for })
@@ -379,13 +408,52 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
       }
       const _msg = dissoc("signer", opt)
       await mem.set(_msg, "msgs", id)
-      await assign({
-        message_item: item,
-        message: id,
-        process: opt.process,
-        from: owner,
-        signer: mu.signer,
-      })
+      if (ar.isHttpMsg(opt.http_msg)) {
+        p.epochs.push([id])
+        let _opt = opt
+        try {
+          // todo: not sure if this is correct
+          let from = _opt.from ?? opt.from ?? owner
+          let data = opt.http_msg.data ?? ""
+          let _tags = _opt.http_msg.tags
+          // todo: check if owner=mu.addr right?
+          const msg = await genMsg(opt.http_msg, p, data, _tags, from, owner)
+          const _env = await genEnv({
+            pid: p.id,
+            owner: p.owner,
+            module: p.module,
+          })
+          if (!p.handle) {
+            const { format, mod, wasm } = await mem.getWasm(p.modulea)
+            const wdrive = extensions[p.extention]
+            p.handle = await AoLoader(wasm, {
+              format,
+              WeaveDrive: wdrive,
+              spawn: (await mem.getTx(p.id)).item,
+              module: await mem.getTx(mod),
+            })
+            mem.env[opt.process].handle = p.handle
+          }
+          const res = await p.handle(p.memory, msg, _env)
+          p.memory = res.Memory
+          delete res.Memory
+          p.results.push(id)
+          await mem.set(p, "env", opt.process)
+          const _msg = { ...dissoc("signer", _opt), res }
+          await mem.set(_msg, "msgs", id)
+          return id
+        } catch (e) {
+          console.log(e)
+        }
+      } else {
+        await assign({
+          message_item: item,
+          message: id,
+          process: opt.process,
+          from: owner,
+          signer: mu.signer,
+        })
+      }
       return id
     }
     const result = async opt => (await mem.get("msgs", opt.message))?.res
@@ -439,7 +507,7 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
         const p = await mem.get("env", opt.process)
         if (!p) return null
         let id = opt.id ?? ""
-        let owner = opt.owner ?? ""
+        let owner = opt.owner ?? mu.addr
         if (!opt.id && opt.signer) {
           ;({ id, owner } = await ar.dataitem({ ...opt, target: opt.process }))
         }
@@ -450,8 +518,8 @@ export default ({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem } = {}) => {
             opt.data ?? "",
             opt.tags,
             owner,
-            mu.addr,
-            true,
+            owner,
+            true
           )
           const _env = await genEnv({
             pid: p.id,

package/esm/armem-base.js

@@ -2,7 +2,7 @@ import _Arweave from "arweave"
 const Arweave = _Arweave.default ?? _Arweave
 import { Bundle } from "arbundles"
 import { compress, decompress } from "./compress.js"
-import { last, assoc, is } from "ramda"
+import { last, assoc, is, isNil } from "ramda"
 import { buildTags, tags } from "./utils.js"
 import base64url from "base64url"
 
@@ -47,7 +47,7 @@ export default class ArMemBase {
   }
   async owner(di) {
     return base64url.encode(
-      Buffer.from(await crypto.subtle.digest("SHA-256", di.rawOwner)),
+      Buffer.from(await crypto.subtle.digest("SHA-256", di.rawOwner))
     )
   }
   getAnchor() {
@@ -80,7 +80,7 @@ export default class ArMemBase {
           this[key][field].original_size = val.memory.length
           await this.db.put(
             `${key}.${field}`,
-            assoc("memory", memory, this[key][field]),
+            assoc("memory", memory, this[key][field])
           )
         } else {
           await this.db.put(`${key}.${field}`, this[key][field])
@@ -99,6 +99,7 @@ export default class ArMemBase {
       aos2_0_1: "Do_Uc2Sju_ffp6Ev0AnLVdPtot15rvMjP-a9VVaA5fM",
       aos1: "cNlipBptaF9JeFAf4wUmpi43EojNanIBos3EfNrEOWo",
       sqlite: "ghSkge2sIUD_F00ym5sEimC63BDBuBrq4b5OcwxOjiw",
+      aos_mainnet: "JArYBF-D8q2OmZ4Mok00sD2Y_6SYEQ7Hjx-6VZ_jl3g",
     }
     this.modmap = {}
     this.msgs = {}
@@ -115,6 +116,10 @@ export default class ArMemBase {
         file: "sqlite",
         format: "wasm64-unknown-emscripten-draft_2024_02_15",
       },
+      "JArYBF-D8q2OmZ4Mok00sD2Y_6SYEQ7Hjx-6VZ_jl3g": {
+        file: "aos_mainnet",
+        format: "wasm64-unknown-emscripten-draft_2024_02_15",
+      },
     }
     let txs = []
     for (const k in this.modules) {
@@ -195,7 +200,6 @@ export default class ArMemBase {
               if (is(Uint8Array, v3.memory)) {
                 try {
                   v3.memory = this.waosm.decompress(v3.memory, v3.original_size)
-                  console.log(v3)
                 } catch (e) {
                   console.log(e)
                   v3.memory = decompress(v3.memory)
@@ -217,6 +221,7 @@ export default class ArMemBase {
   }
   async getTx(id) {
     let tx = this.txs[id]
+    if (isNil(tx)) return null
     if (tx.bundle) {
       try {
         let bundle = new Bundle(this.txs[tx.bundle].data)

package/esm/bar.js

@@ -8,6 +8,17 @@ import base64url from "base64url"
 import GQL from "./tgql.js"
 import { last, is, includes, isNil } from "ramda"
 
+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 }
+}
+
 class AR extends MAR {
   constructor(opt = {}) {
     super({ ...opt, in_memory: true })
@@ -17,9 +28,23 @@ class AR extends MAR {
     this.gql = new GQL({ mem: this.mem })
     this.arweave = this.mem.arweave
   }
+  isHttpMsg(item) {
+    if (typeof item === "object" && item !== null) {
+      const tags = t(item.tags)
+      if (!isNil(tags["signature-input"])) return true
+    }
+    return false
+  }
+  async httpmsg(msg) {
+    const tags = t(msg.tags)
+    const { keyid: n } = parseSignatureInput(tags["signature-input"])
+    const owner = await this.arweave.wallets.jwkToAddress({ n })
+    await this.mem.set(msg, "txs", msg.id)
+    return { item: msg, id: tags.id, tags, owner }
+  }
   async owner(di) {
     return base64url.encode(
-      Buffer.from(await crypto.subtle.digest("SHA-256", di.rawOwner)),
+      Buffer.from(await crypto.subtle.digest("SHA-256", di.rawOwner))
     )
   }
   async dataitem({ target = "", data = "1984", tags = {}, signer, item }) {
@@ -40,7 +65,6 @@ class AR extends MAR {
     for (const v of buildTags(null, tags)) tx.addTag(v.name, v.value)
     return await this.postTx(tx, jwk)
   }
-
   async postItems(items, jwk) {
     let err = null
     ;({ err, jwk } = await this.checkWallet({ jwk }))
@@ -72,7 +96,7 @@ class AR extends MAR {
     const bundle = await bundleAndSignData(items, new ArweaveSigner(jwk))
     const tx = await this.mem.arweave.createTransaction(
       { data: bundle.binary },
-      jwk,
+      jwk
     )
     tx.addTag("Bundle-Format", "binary")
     tx.addTag("Bundle-Version", "2.0.0")
@@ -140,7 +164,7 @@ class AR extends MAR {
           format: __tags["Module-Format"],
         },
         "wasms",
-        tx.id,
+        tx.id
       )
     }
     tx.tags = _tags
@@ -162,7 +186,7 @@ class AR extends MAR {
     if (this.log) {
       if (msg) {
         console.log(
-          `New ${msg.type}:\t${msg.id}${msg.pid ? ` > ${msg.pid}` : ""}`,
+          `New ${msg.type}:\t${msg.id}${msg.pid ? ` > ${msg.pid}` : ""}`
         )
       } else {
         console.log(`New Post:\t${tx.id}`)
@@ -213,7 +237,7 @@ function tobuff(base64url) {
   const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/")
   const paddedBase64 = base64.padEnd(
     base64.length + ((4 - (base64.length % 4)) % 4),
-    "=",
+    "="
   )
   return Buffer.from(paddedBase64, "base64")
 }

package/esm/hb.js

@@ -0,0 +1,121 @@
+import { connect, createSigner } from "aoconnect-wao"
+import { mergeLeft } from "ramda"
+import { randomBytes } from "node:crypto"
+import { buildTags } from "./utils.js"
+class HB {
+  constructor({ url = "http://localhost:10000" } = {}) {
+    this.url = url
+  }
+
+  async metrics() {
+    const txt = await fetch(`${this.url}/metrics`).then(r => r.text())
+    const parts = txt.split(/\r?\n/)
+    let index = 0
+    let _metrics = {}
+    let vals = []
+    let desc = []
+    for (const v of parts) {
+      if (/^# /.test(v)) {
+        const [_, type, name, ...rest] = v.split(" ")
+        if (!_metrics[name]) _metrics[name] = { index: ++index, values: [] }
+        _metrics[name][type] = rest.join(" ")
+      } else if (v !== "") {
+        if (/{/.test(v)) {
+          const [name, rest] = v.split("{")
+          if (!_metrics[name]) _metrics[name] = { index: ++index, values: [] }
+          const [params, val] = rest.split("}")
+          let _params = {}
+          for (const v of params.split(",")) {
+            const [key, val] = v.trim().split("=")
+            _params[key] = val.replace(/"/g, "")
+          }
+          _metrics[name].values.push({ value: val.trim(), params: _params })
+        } else {
+          const [name, val] = v.split(" ")
+          if (!_metrics[name]) _metrics[name] = { index: ++index, values: [] }
+          _metrics[name].values.push({ value: val })
+        }
+      }
+    }
+    return _metrics
+  }
+
+  async info() {
+    const txt = await fetch(
+      `${this.url}/~meta@1.0/info/serialize~json@1.0`
+    ).then(r => r.json())
+    return txt
+  }
+
+  async init(jwk) {
+    this._info = await this.info()
+    const { request } = connect({
+      MODE: "mainnet",
+      URL: this.url,
+      device: "",
+      signer: createSigner(jwk),
+    })
+    this._request = request
+    return this
+  }
+
+  async process({ tags = {}, data = "1984" } = {}) {
+    tags = mergeLeft(tags, {
+      data,
+      Type: "Process",
+      "Data-Protocol": "ao",
+      Variant: "ao.N.1",
+      scheduler: this._info.address,
+      authority: this._info.address,
+      "scheduler-location": this.info.address,
+      "random-seed": randomBytes(16).toString("hex"),
+      module: "JArYBF-D8q2OmZ4Mok00sD2Y_6SYEQ7Hjx-6VZ_jl3g",
+      device: "process@1.0",
+      "scheduler-device": "scheduler@1.0",
+      "execution-device": "genesis-wasm@1.0",
+    })
+    return await this.post({ tags })
+  }
+
+  async schedule({ tags = {}, data, process, action = "Eval" } = {}) {
+    tags = mergeLeft(tags, {
+      path: `${process}/schedule`,
+      type: "Message",
+      action,
+      data,
+      "Data-Protocol": "ao",
+      Variant: "ao.N.1",
+    })
+    return (await this.post({ tags })).slot.text()
+  }
+
+  async compute({ tags = {}, process, slot } = {}) {
+    return await this.request({
+      method: "GET",
+      path: `/${process}/compute&slot+integer=${slot}/results/json`,
+    })
+  }
+
+  async dryrun({ tags = {}, process, action } = {}) {
+    if (typeof action === "string") tags.Action = action
+    return await fetch(
+      `${this.url}/~relay@1.0/call?relay-method=POST&relay-path=/dry-run?process-id=${process}/&content-type=application/json&body=${JSON.stringify({ Tags: buildTags(tags) })}`
+    ).then(r => r.json())
+  }
+
+  async get({ device, path = "~meta@1.0/info" }) {
+    return (await this.request({ device, path, method: "GET" })).body
+  }
+
+  async post({ device, tags, path = "/schedule" }) {
+    return await this.request({ tags, device, path, method: "POST" })
+  }
+
+  async request({ device, tags, method = "POST", path = "/schedule" }) {
+    let _tags = mergeLeft(tags, { path, method })
+    if (device) _tags.device = device
+    return await this._request(_tags)
+  }
+}
+
+export default HB

package/esm/index.js

@@ -1,5 +1,6 @@
 import AR from "./ar.js"
 import AO from "./ao.js"
+import HB from "./hb.js"
 import GQL from "./gql.js"
 
-export { AO, AR, GQL }
+export { AO, AR, HB, GQL }