wao 0.41.3 → 0.41.5

package/src/adaptor-base.js

@@ -0,0 +1,622 @@
+import HB from "./hb.js"
+import { DataItem } from "arbundles"
+import {
+  toANS104Request,
+  parseSignatureInput,
+  tags,
+  toGraphObj,
+} from "./utils.js"
+import { keys, map, isNil, reverse, omit } from "ramda"
+
+class Adaptor {
+  constructor({
+    hb_url,
+    aoconnect,
+    log = false,
+    db,
+    storage,
+    connect,
+    GQL,
+    cu,
+    su,
+    mu,
+    d1,
+    r2,
+    kv,
+    network = "ao.DN.1",
+  }) {
+    this.network = network
+    this.data = {}
+    this._dataTimestamps = {}
+    // Clean up abandoned chunk uploads every 60 seconds.
+    // unref() so this interval doesn't keep the Node event loop alive after
+    // the host server closes — without it, test processes that use Server
+    // (e.g. test/hyperbeam/relay.test.js) hang indefinitely waiting on this
+    // timer even after every other handle is cleaned up.
+    this._chunkCleanupInterval = setInterval(() => {
+      const now = Date.now()
+      for (const key of Object.keys(this._dataTimestamps)) {
+        if (now - this._dataTimestamps[key] > 5 * 60 * 1000) { // 5 min timeout
+          delete this.data[key]
+          delete this._dataTimestamps[key]
+        }
+      }
+    }, 60 * 1000)
+    if (typeof this._chunkCleanupInterval?.unref === "function") {
+      this._chunkCleanupInterval.unref()
+    }
+    let hb = null
+    if (hb_url) hb = new HB({ url: hb_url })
+    const {
+      ar: _ar,
+      message,
+      spawn,
+      dryrun,
+      result,
+      results,
+      mem,
+      monitor,
+      unmonitor,
+      recover,
+      evaluate,
+    } = connect(aoconnect, { log, cache: db, storage, hb, d1, r2, kv })
+    this.su_signer = su
+    this.cu_signer = cu
+    this.mu_signer = mu
+    this.recover = recover
+    this.monitor = monitor
+    this.unmonitor = unmonitor
+    this.evaluate = evaluate
+    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, d1: d1 || null })
+  }
+  async get(req, res) {
+    return res(await this[req.device](req))
+  }
+  async bd(req) {
+    return await this[`bd_${req.method.toLowerCase()}`](req)
+  }
+  async ar(req) {
+    return await this[`ar_${req.method.toLowerCase()}`](req)
+  }
+  async su(req) {
+    return await this[`su_${req.method.toLowerCase()}`](req)
+  }
+  async mu(req) {
+    return await this[`mu_${req.method.toLowerCase()}`](req)
+  }
+  async cu(req) {
+    return await this[`cu_${req.method.toLowerCase()}`](req)
+  }
+  async bd_get(req) {
+    switch (req.path) {
+      default:
+    }
+  }
+
+  async bd_post(req) {
+    switch (req.path) {
+      case "/tx":
+        return await this.bd_post_tx(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async ar_get(req) {
+    switch (req.path) {
+      case "/":
+        return await this.ar_get_root(req)
+      case "/wallet/:id/balance":
+        return await this.ar_get_wallet_balance(req)
+      case "/mint/:id/:amount":
+        return await this.ar_get_mint(req)
+      case "/tx/:id/offset":
+        return await this.ar_get_tx_offset(req)
+      case "/tx_anchor":
+        return await this.ar_get_tx_anchor(req)
+      case "/mine":
+        return await this.ar_get_mine(req)
+      case "/:id":
+        return await this.ar_get_id(req)
+      case "/price/:id":
+        return await this.ar_get_price(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async ar_post(req) {
+    switch (req.path) {
+      case "/graphql":
+        return await this.ar_post_graphql(req)
+      case "/:id":
+        return await this.ar_post_id(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async su_get(req) {
+    switch (req.path) {
+      case "/":
+        return await this.su_get_root(req)
+      case "/timestamp":
+        return await this.su_get_timestamp(req)
+      case "/:pid":
+        return await this.su_get_pid(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async su_post(req) {
+    switch (req.path) {
+      default:
+        return await this.bad()
+    }
+  }
+
+  async mu_get(req) {
+    switch (req.path) {
+      case "/":
+        return await this.mu_get_root(req)
+      case "/monitor:pid":
+        return await this.mu_get_monitor(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async mu_delete(req) {
+    switch (req.path) {
+      case "/monitor:pid":
+        return await this.mu_delete_monitor(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async mu_post(req) {
+    switch (req.path) {
+      case "/":
+        return await this.mu_post_root(req)
+      case "/monitor:pid":
+        return await this.mu_post_monitor(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async cu_get(req) {
+    switch (req.path) {
+      case "/":
+        return await this.cu_get_root(req)
+      case "/result/:mid":
+        return await this.cu_get_result(req)
+      case "/results/:pid":
+        return await this.cu_get_results(req)
+      case "/state/:pid":
+        return await this.cu_get_state(req)
+      default:
+        return await this.bad()
+    }
+  }
+
+  async cu_post(req) {
+    switch (req.path) {
+      case "/result/:mid": // not in the AO spec, but HyperBEAM queries it
+        return await this.cu_post_result(req)
+      case "/dry-run": // not in the AO spec
+        return await this.cu_post_dryrun(req)
+      case "/evaluate":
+        return await this.cu_post_evaluate(req)
+      default:
+        return await this.bad()
+    }
+  }
+  async bad({}) {
+    return { status: 400, error: "bad request" }
+  }
+
+  async bd_post_tx({ query, params, body, headers, method }) {
+    // todo: items from HB has wrong sigs and ids
+    return { send: "Success" }
+    if (!Buffer.isBuffer(body)) {
+      console.log("BD: Invalid body | expected raw Buffer")
+      return { status: 400, send: "Invalid body: expected raw Buffer" }
+    }
+    const lines = 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 = headers.process
+    sigs.slot = headers.slot
+    /*
+    const input = parseSignatureInput(headers["signature-input"])
+    const key = { kty: "RSA", n: input.keyid, e: "AQAB" }
+    const verifier = createVerifier(
+      createPublicKey({ key, format: "jwk" }),
+      "rsa-pss-sha512"
+    )*/
+    let id = null
+    try {
+      /*
+      const isValid = await verifyMessage(
+        { keyLookup: params => ({ verify: verifier }) },
+        {
+          method: method,
+          headers: headers,
+          url: `http://ao.com${headers.path}`,
+        }
+      )*/
+      const item = toANS104Request(sigs).item
+
+      if (sigs.slot === "0" || sigs.type === "Process") {
+        for (let v of item.tags) if (v.name === "Type") v.value = "Process"
+        const res = await this.spawn({
+          http_msg: item,
+          module: sigs.module,
+          scheduler: sigs.scheduler,
+        })
+      } else if (sigs.type === "Message") {
+        for (let v of item.tags) if (v.name === "id") item.target = v.value
+        const res = await this.message({
+          slot: sigs.slot,
+          http_msg: item,
+          process: sigs.target,
+        })
+      }
+    } catch (e) {
+      console.log(e)
+    }
+    return { send: "Success" }
+  }
+
+  async cu_get_root({ query, params, body, headers, method }) {
+    return { json: { timestamp: Date.now(), address: this.cu_signer.addr } }
+  }
+
+  async cu_get_state({ query, params, body, headers, method }) {
+    const pid = params.pid
+    const p = await this.mem.get("env", pid)
+    const memory = p?.memory ?? null
+    if (!memory) {
+      return {
+        status: 404,
+        error: `TransactionNotFound: Process ${pid} was not found on gateway`,
+      }
+    } else return { send: Buffer.from(memory) }
+  }
+
+  async cu_post_dryrun({ query, params, body, headers, method }) {
+    const process = query["process-id"]
+    const { Id: id, Owner: owner, Tags: tags, Data: data } = body
+    const res2 = await this.dryrun({ id, owner, tags, data, process })
+    if (!res2) return { status: 400, error: true }
+    else {
+      delete res2.Memory
+      return { json: res2 }
+    }
+  }
+  async cu_get_results({ query, params, body, headers, method }) {
+    const pid = params.pid
+    const { from = null, to = null, sort = "ASC", limit = 25 } = query
+    const p = await this.mem.get("env", pid)
+    let results = p?.results ?? []
+    if (sort === "DESC") results = reverse(results)
+    let _res = []
+    let i = 1
+    let count = 0
+    let started = isNil(from)
+    for (let v of results) {
+      if (started) {
+        const msg = await this.mem.get("msgs", v)
+        _res.push({ cursor: v, node: msg?.res })
+        count++
+        if (!isNil(to) && v === to) break
+        if (limit <= count) break
+      } else if (from === v) started = true
+
+      i++
+    }
+    return { json: { edges: _res } }
+  }
+
+  async cu_get_result({ query, params, body, headers, method }) {
+    let message = params.mid
+    const process = query["process-id"]
+    // check if recovery is ongoing and
+    let p = await this.mem.get("env", process)
+    if (isNil(p)) {
+      const { success } = await this.recover(process)
+      if (!success) {
+        console.log("process not found:", query["process-id"])
+        return { status: 404, error: "not Found" }
+      }
+      p = await this.mem.get("env", process)
+    }
+    const slot = message
+    if (!/^[0-9a-zA-Z_-]{43,44}$/.test(message)) {
+      message = p?.results?.[slot]
+    }
+    if (isNil(message)) {
+      await this.recover(process)
+      p = await this.mem.get("env", process)
+      message = p?.results?.[slot]
+      if (isNil(message)) return { status: 404, error: "not Found" }
+    }
+    const res2 = await this.result({ message, process })
+    return { json: res2 }
+  }
+  async cu_post_result(...args) {
+    return await this.cu_get_result(...args)
+  }
+  async cu_post_evaluate({ query, params, body, headers, method }) {
+    const { message, process, data, tags: msgTags, from, is_spawn } = body
+    if (!process) return { status: 400, json: { error: "process required" } }
+    try {
+      const res = await this.evaluate({
+        message,
+        process,
+        data: data || "",
+        tags: msgTags,
+        from,
+        is_spawn,
+        module: body.module || (msgTags && tags(msgTags)?.Module),
+        scheduler: body.scheduler || (msgTags && tags(msgTags)?.Scheduler),
+      })
+      return { json: res || {} }
+    } catch (e) {
+      console.log("cu_post_evaluate error:", e)
+      return { status: 500, json: { error: e.message } }
+    }
+  }
+  async su_get_root({ query, params, body, headers, method }) {
+    return {
+      json: {
+        Unit: "Scheduler",
+        Timestamp: Date.now(),
+        Address: this.su_signer.addr,
+        Processes: await this.mem.getFieldKeys("env"),
+      },
+    }
+  }
+
+  async su_get_timestamp({ query, params, body, headers, method }) {
+    return { json: { timestamp: Date.now(), block_height: await this.mem.get("height") } }
+  }
+  async su_get_pid({ query, params, body, headers, method }) {
+    const pid = params.pid
+    const p = await this.mem.get("env", pid)
+    const edges = map(async v => {
+      const tx = await this.mem.getTx(v)
+      const _tags = tags(v.tags)
+      const mid = _tags.Message
+      const mtx = await this.mem.getTx(mid)
+      const mtxOwner = await this.mem.get("addrmap", mtx.owner)
+      const txOwner = await this.mem.get("addrmap", tx.owner)
+      return {
+        cursor: v,
+        node: {
+          message: {
+            id: mtx.id,
+            tags: mtx.tags,
+            owner: mtxOwner,
+            anchor: mtx.anchor ?? null,
+            target: pid,
+            signature: mtx.signature,
+            data: tx.data,
+          },
+          assignment: {
+            id: tx.id,
+            tags: tx.tags,
+            owner: txOwner,
+            anchor: tx.anchor ?? null,
+            target: null,
+            signature: tx.signature,
+          },
+        },
+      }
+    })(reverse(p?.results ?? [])) // need mod
+    return { json: { page_info: { has_next_page: false }, edges } }
+  }
+
+  async mu_get_root({ query, params, body, headers, method }) {
+    return { send: "ao messenger unit" }
+  }
+
+  async mu_post_root({ query, params, body, headers, method }) {
+    if (body.type === "Buffer" && Array.isArray(body.data)) {
+      body = new Uint8Array(body.data)
+    }
+    let valid = false
+    // todo: cannot verify node -> broser items
+    try {
+      valid = await DataItem.verify(body)
+    } catch (e) {
+      // verification may fail for cross-env items (node→browser); proceed anyway
+    }
+    let type = null
+    let item = null
+    if (valid || true) item = new DataItem(body)
+    await item.setSignature(item.rawSignature)
+    const _tags = tags(item.tags)
+    // Allow both ao.TN.1 (legacy testnet) and ao.DN.1 (WAO Devnet) variants
+    // through the local emulator. The variant is informational here; the
+    // local emulator doesn't actually need to enforce a strict network.
+    const _allowedNetworks = new Set([this.network, "ao.TN.1", "ao.DN.1"])
+    if (_tags.Variant && !_allowedNetworks.has(_tags.Variant)) {
+      return { status: 400, json: { error: `Variant mismatch: expected ${this.network}, got ${_tags.Variant}` } }
+    }
+    let err = null
+    if (_tags.Type === "Process") {
+      try {
+        const res = await this.spawn({
+          item,
+          module: _tags.Module,
+          scheduler: _tags.Scheduler,
+          _cu_url: _tags["CU-URL"] || undefined,
+        })
+        if (!res) err = "bad requrest"
+      } catch (e) {
+        console.error("MU spawn error:", e.message, e.stack)
+        return { status: 500, json: { error: e.message, stack: (e.stack || "").split("\n").slice(0, 8) } }
+      }
+    } else if (_tags.Type === "Message") {
+      try {
+        await this.message({ item, process: item.target })
+      } catch (e) {
+        console.error("MU message error:", e.message, e.stack)
+        err = e.message
+      }
+    } else if (_tags.Type === "Scheduler-Location" || _tags.Type === "Scheduler-Transfer") {
+      try {
+        await this._ar.postItems(item, this.su_signer.jwk)
+      } catch (e) {
+        console.error(`MU ${_tags.Type} error:`, e.message, e.stack)
+        err = e.message
+      }
+    } else err = true
+
+    if (err) return { status: 400, error: err }
+    else return { json: { id: item.id } }
+  }
+
+  async mu_post_monitor({ query, params, body, headers, method }) {
+    await this.monitor({ process: params.pid })
+    return { json: { id: params.pid, messag: "cron monitored!" } }
+  }
+  async mu_delete_monitor({ query, params, body, headers, method }) {
+    await this.unmonitor({ process: params.pid })
+    return { json: { id: params.pid, message: "cron deleted!" } }
+  }
+
+  async ar_get_root({ query, params, body, headers, method }) {
+    return {
+      json: {
+        version: 1,
+        timestamp: Date.now(),
+        height: await this.mem.get("height"),
+        network: this.network,
+        current: this.mem.getAnchor(),
+      },
+    }
+  }
+  async ar_get_wallet_balance({ query, params, body, headers, method }) {
+    return { send: "0" }
+  }
+  async ar_get_mint({ query, params, body, headers, method }) {
+    return { json: { id: "0" } }
+  }
+  async ar_get_tx_offset({ query, params, body, headers, method }) {
+    return { status: 400, send: null }
+  }
+  async ar_get_tx_anchor({ query, params, body, headers, method }) {
+    return { send: this.mem.getAnchor() }
+  }
+  async ar_get_mine({ query, params, body, headers, method }) {
+    return { json: params }
+  }
+  async ar_get_id({ query, params, body, headers, method }) {
+    const _data = await this._ar.data(params.id)
+    if (!_data) return { status: 404, send: null }
+    const tx = await this.mem.getTx(params.id)
+    let contentType = tx?._data?.type || ""
+    if (!contentType && tx?.tags) {
+      const ctTag = tx.tags.find(t => t.name === "Content-Type")
+      if (ctTag) contentType = ctTag.value
+    }
+    if (!contentType) contentType = "application/octet-stream"
+    const send = Buffer.isBuffer(_data) || _data instanceof Uint8Array
+      ? _data
+      : Buffer.from(String(_data), "base64")
+    return {
+      send,
+      headers: { "Content-Type": contentType },
+    }
+  }
+  async ar_get_price({ query, params, body, headers, method }) {
+    return { send: "0" }
+  }
+  async ar_post_graphql({ query, params, body, headers, method }) {
+    try {
+      const { query, variables } = body
+      const { tar, args } = toGraphObj({ query, variables })
+      const first = args.first ?? 10
+      let res2 = null
+      const fn = tar === "blocks" ? "blocks" : "txs"
+      res2 = await this.gql[fn]({ ...args, first: first + 1 })
+      const hasNextPage = res2.length > first
+      if (hasNextPage) res2 = res2.slice(0, first)
+      const edges = map(v => ({ node: v, cursor: v.cursor }), res2)
+      return {
+        json: {
+          data: { [tar]: { pageInfo: { hasNextPage }, edges } },
+        },
+      }
+    } catch (e) {
+      console.log(e)
+      return { status: 400, error: "bad request" }
+    }
+  }
+  async ar_post_id({ query, params, body, headers, method }) {
+    // id = "tx" | "chunk"
+    if (body.chunk) {
+      if (this.data[body.data_root]) {
+        this._dataTimestamps[body.data_root] = Date.now()
+        this.data[body.data_root].data += body.chunk
+        const buf = Buffer.from(body.chunk, "base64")
+        if (!this.data[body.data_root].chunks) {
+          this.data[body.data_root].chunks = buf
+        } else {
+          this.data[body.data_root].chunks = Buffer.concat([
+            this.data[body.data_root].chunks,
+            buf,
+          ])
+        }
+        delete body.chunk
+        if (
+          this.data[body.data_root].data_size <=
+          this.data[body.data_root].chunks.length
+        ) {
+          this.data[body.data_root].data =
+            this.data[body.data_root].chunks.toString("base64")
+          await this._ar.postTx(this.data[body.data_root])
+          delete this.data[body.data_root]
+          delete this._dataTimestamps[body.data_root]
+        }
+      }
+      return { json: { id: body.id } }
+    } else {
+      if (body.data_root && body.data === "") {
+        this.data[body.data_root] = body
+        this._dataTimestamps[body.data_root] = Date.now()
+      } else {
+        await this._ar.postTx(body)
+      }
+      return { json: { id: body.id } }
+    }
+  }
+}
+export default Adaptor

package/src/adaptor-cf.js

@@ -0,0 +1,11 @@
+import { connect } from "./aoconnect-cf.js"
+import { cu, su, mu } from "./accounts-web.js"
+import GQL from "./tgql.js"
+import Base from "./adaptor-base.js"
+
+class Adaptor extends Base {
+  constructor(obj) {
+    super({ ...obj, GQL, cu, su, mu, connect })
+  }
+}
+export default Adaptor

package/src/adaptor-web.js

@@ -0,0 +1,11 @@
+import { connect } from "./aoconnect-web.js"
+import { cu, su, mu } from "./accounts-web.js"
+import GQL from "./tgql.js"
+import Base from "./adaptor-base.js"
+
+class Adaptor extends Base {
+  constructor(obj) {
+    super({ ...obj, GQL, cu, su, mu, connect })
+  }
+}
+export default Adaptor

package/src/adaptor.js

@@ -0,0 +1,10 @@
+import { connect } from "./aoconnect.js"
+import { GQL, cu, su, mu } from "./test.js"
+import Base from "./adaptor-base.js"
+
+class Adaptor extends Base {
+  constructor(obj) {
+    super({ ...obj, GQL, cu, su, mu, connect })
+  }
+}
+export default Adaptor