wao 0.31.2 → 0.32.1

package/esm/hb2.js

@@ -0,0 +1,439 @@
+import { connect, createSigner } from "@permaweb/aoconnect"
+import { isEmpty, last, isNotNil, mergeLeft, clone } from "ramda"
+import { rsaid, hmacid, toAddr, buildTags } from "./utils.js"
+import { sign, signer } from "./signer.js"
+import { send as _send } from "./send.js"
+import hyper_aos from "./lua/hyper-aos.js"
+import aos_wamr from "./lua/aos_wamr.js"
+import { from } from "./httpsig.js"
+
+const seed = num => {
+  const array = new Array(num)
+  for (let i = 0; i < num; i++) array[i] = Math.floor(Math.random() * 256)
+  return Buffer.from(array).toString("base64")
+}
+
+class HB {
+  constructor({
+    url = "http://localhost:10001",
+    cu = "http://localhost:6363",
+    jwk,
+  } = {}) {
+    this.cu = cu
+    this.url = url
+    if (jwk) this._init(jwk)
+  }
+  async signEncoded(encoded) {
+    const { path, ...msg } = encoded
+    return await sign({
+      jwk: this.jwk,
+      msg,
+      path,
+      url: this.url,
+    })
+  }
+
+  _init(jwk) {
+    this.jwk = jwk
+    this.signer = createSigner(jwk, this.url)
+    this.addr = toAddr(jwk.n)
+    this.sign = signer({ signer: this.signer, url: this.url })
+
+    const { request } = connect({
+      MODE: "mainnet",
+      URL: this.url,
+      device: "",
+      signer: this.signer,
+    })
+
+    this._request = request
+  }
+
+  async setInfo() {
+    if (!this._info) {
+      try {
+        this._info = await this.g("/~meta@1.0/info")
+      } catch (e) {}
+    }
+  }
+
+  async init(jwk) {
+    this._init(jwk)
+    await this.setInfo()
+    return this
+  }
+
+  async send(msg) {
+    return await _send(msg)
+  }
+
+  async getImage() {
+    const wasm = Buffer.from(aos_wamr, "base64")
+    const id = await this.cacheBinary(wasm, "application/wasm")
+    this.image ??= id
+    return id
+  }
+
+  async getLua() {
+    const lua = Buffer.from(hyper_aos, "base64")
+    const id = await this.cacheScript(lua, "application/lua")
+    this.lua ??= id
+    return id
+  }
+
+  async scheduleAOS({ pid, action = "Eval", tags = {}, data }) {
+    pid ??= this.pid
+    let _tags = mergeLeft(tags, {
+      device: "process@1.0",
+      method: "POST",
+      type: "Message",
+      Action: action,
+      target: pid,
+    })
+
+    if (data) _tags.data = data
+    const msg = { body: _tags, path: `/${pid}~process@1.0/schedule` }
+    let res = await this.post(msg)
+    const slot = res.headers.slot
+    return { slot, res, pid }
+  }
+
+  async messageAOS(args) {
+    const { slot, pid } = await this.scheduleAOS(args)
+    return { slot, outbox: await this.computeAOS({ pid, slot }) }
+  }
+
+  async messageLegacy(args) {
+    const { slot, pid } = await this.scheduleLegacy(args)
+    return { slot, res: await this.computeLegacy({ pid, slot }) }
+  }
+
+  async computeAOS({ pid, slot }) {
+    return await this.getJSON({ path: `/${pid}/compute/results/outbox`, slot })
+  }
+
+  async computeLua({ pid, slot }) {
+    return await this.getJSON({ path: `/${pid}/compute/results`, slot })
+  }
+
+  async compute({ pid, slot, path = "" }) {
+    if (path && !/^\//.test(path)) path = "/" + path
+    return await this.getJSON({ path: `/${pid}/compute${path}`, slot })
+  }
+
+  async computeLegacy({ pid, slot }) {
+    const json = await this.compute({ pid, slot })
+    return JSON.parse(json.results.json.body)
+  }
+
+  async spawn(tags = {}) {
+    const addr = await this.g("/~meta@1.0/info/address")
+    this.scheduler ??= addr
+    const _tags = mergeLeft(tags, {
+      device: "process@1.0",
+      scheduler: this.scheduler,
+      "random-seed": seed(16),
+      type: "Process",
+      "execution-device": "test-device@1.0",
+    })
+    const msg = {
+      device: "process@1.0",
+      path: "schedule",
+      body: _tags,
+      scheduler: this.scheduler,
+    }
+    const res = await this.post(msg)
+    return { res, pid: res.headers.process }
+  }
+
+  async cacheScript(data, type = "application/lua") {
+    if (!this.cache) {
+      const { pid } = await this.spawn({})
+      this.cache = pid
+    }
+    const { slot } = await this.schedule({
+      data,
+      pid: this.cache,
+      "content-type": type,
+    })
+    const msgs = await this.messages({ pid: this.cache, from: slot, limit: 1 })
+    return msgs.edges[0].node.message.Id
+  }
+
+  async cacheBinary(data, type) {
+    const res = await this.post({ path: "/~wao@1.0/cache_module", data, type })
+    return res.headers.id
+  }
+
+  async message(args) {
+    const pid = args.pid
+    const { slot } = await this.schedule(args)
+    const res = await this.compute({ pid, slot })
+    return { slot, pid, res }
+  }
+
+  async scheduleLegacy({
+    pid,
+    action = "Eval",
+    tags = {},
+    data,
+    scheduler,
+  } = {}) {
+    if (action) tags.Action = action
+    return await this.schedule({ pid, tags, data, scheduler })
+  }
+
+  async scheduleLua(...args) {
+    return await this.scheduleLegacy(...args)
+  }
+
+  async schedule({ pid, tags = {}, data } = {}) {
+    pid ??= this.pid
+    let _tags = mergeLeft(tags, { type: "Message", target: pid })
+    if (data) _tags.data = data
+    const msg = {
+      device: "process@1.0",
+      method: "POST",
+      path: "schedule",
+      body: _tags,
+    }
+
+    let res = await this.post(msg)
+    return { slot: res.headers.slot, res, pid }
+  }
+
+  async spawnAOS(image) {
+    const addr = await this.g("/~meta@1.0/info/address")
+    this.scheduler ??= addr
+    image ??= this.image ?? (await this.getImage())
+    const _tags = {
+      device: "process@1.0",
+      scheduler: this.scheduler,
+      "data-protocol": "ao",
+      variant: "ao.N.1",
+      "scheduler-location": this.scheduler,
+      authority: this.scheduler,
+      "random-seed": seed(16),
+      type: "Process",
+      image,
+      "execution-device": "stack@1.0",
+      "push-device": "push@1.0",
+      "device-stack": [
+        "wasi@1.0",
+        "json-iface@1.0",
+        "wasm-64@1.0",
+        "patch@1.0",
+        "multipass@1.0",
+      ],
+      "output-prefix": "wasm",
+      "patch-from": "/results/outbox",
+      "patch-mode": "patches",
+      "stack-keys": ["init", "compute", "snapshot", "normalize"],
+      passes: 2,
+    }
+    const msg = {
+      device: "process@1.0",
+      path: "schedule",
+      body: _tags,
+      scheduler: this.scheduler,
+    }
+
+    const res = await this.post(msg)
+    const pid = res.headers.process
+    this.pid ??= pid
+    return { pid, res }
+  }
+
+  async spawnLua(lua) {
+    const addr = await this.g("/~meta@1.0/info/address")
+    this.scheduler ??= addr
+    lua ??= this.lua ?? (await this.getLua())
+    const _tags = {
+      device: "process@1.0",
+      scheduler: this.scheduler,
+      "data-protocol": "ao",
+      variant: "ao.N.1",
+      "scheduler-location": this.scheduler,
+      authority: this.scheduler,
+      "random-seed": seed(16),
+      type: "Process",
+      module: lua,
+      "execution-device": "lua@5.3a",
+      "push-device": "push@1.0",
+      "patch-from": "/results/outbox",
+    }
+    const msg = {
+      device: "process@1.0",
+      path: "schedule",
+      body: _tags,
+    }
+
+    const res = await this.post(msg)
+    const pid = res.headers.process
+    this.pid ??= pid
+    return { pid, res }
+  }
+
+  async now({ pid, path = "" }) {
+    if (path && !/^\//.test(path)) path = "/" + path
+    return await this.getJSON({ path: `/${pid}/now${path}` })
+  }
+
+  async slot({ pid, path = "" }) {
+    if (path && !/^\//.test(path)) path = "/" + path
+    return await this.getJSON({ path: `/${pid}/slot${path}` })
+  }
+
+  async messages({ pid, from, to } = {}) {
+    let params = `target=${pid}`
+    if (isNotNil(from)) params += `&from=${from}`
+    if (isNotNil(to)) params += `&to=${to}`
+    params += `&accept=application/aos-2`
+    let res = await fetch(`${this.url}/~scheduler@1.0/schedule?${params}`).then(
+      r => r.json()
+    )
+    if (res.page_info.has_next_page) {
+      res.next = async () => {
+        const from2 = last(res.edges).cursor + 1
+        return await this.messages({ pid, from: from2, to })
+      }
+    }
+    return res
+  }
+
+  async spawnLegacy({ module, tags = {}, data } = {}) {
+    await this.setInfo()
+    let t = {
+      type: "Process",
+      "data-protocol": "ao",
+      variant: "ao.TN.1",
+      scheduler: this._info.address,
+      authority: this._info.address,
+      "scheduler-location": this._info.address,
+      "random-seed": seed(16),
+      module: module ?? "ISShJH1ij-hPPt9St5UFFr_8Ys3Kj5cyg7zrMGt7H9s",
+      device: "process@1.0",
+      "scheduler-device": "scheduler@1.0",
+      "execution-device": "stack@1.0",
+      "push-device": "push@1.0",
+      "device-stack": ["genesis-wasm@1.0", "patch@1.0"],
+      "patch-from": "/results/outbox",
+      "stack-keys": ["init", "compute", "snapshot", "normalize"],
+    }
+    if (data) t.data = data
+    tags = mergeLeft(tags, t)
+    return await this.spawn(tags)
+  }
+
+  async results({ process, limit, sort = "DESC", from, to } = {}) {
+    let params = ""
+    const addParam = (key, val) => {
+      params += params === "" ? "?" : "&"
+      params += `${key}=${val}`
+    }
+    if (limit) addParam("limit", limit)
+    if (sort) addParam("sort", sort)
+    if (from) addParam("from", from)
+    if (to) addParam("to", to)
+    const res = await this.post({
+      path: "/~relay@1.0/call",
+      method: "GET",
+      "relay-path": `${this.cu}/results/${process}${params}`,
+      "content-type": "application/json",
+    })
+    return JSON.parse(res.body)
+  }
+
+  async dryrun({ tags = {}, pid, action, data } = {}) {
+    if (typeof action === "string") tags.Action = action
+    let json = { Tags: buildTags({ ...tags }), Owner: this.addr }
+    if (data) json.Data = data
+    const res = await this.post({
+      path: "/~relay@1.0/call",
+      method: "POST",
+      "relay-path": `${this.cu}/dry-run?process-id=${pid}`,
+      "content-type": "application/json",
+      "relay-body": JSON.stringify(json),
+    })
+    return JSON.parse(res.body)
+  }
+
+  async commit(obj, opts) {
+    const msg = await this.sign(obj, opts)
+    const hmacId = hmacid(msg.headers)
+    const rsaId = rsaid(msg.headers)
+    const committer = this.addr
+    const meta = { alg: "rsa-pss-sha512", "commitment-device": "httpsig@1.0" }
+    const meta2 = { alg: "hmac-sha256", "commitment-device": "httpsig@1.0" }
+    const sigs = {
+      signature: msg.headers.signature,
+      "signature-input": msg.headers["signature-input"],
+    }
+    return {
+      commitments: {
+        [rsaId]: { ...meta, committer, ...sigs },
+        [hmacId]: { ...meta2, ...sigs },
+      },
+      ...obj,
+    }
+  }
+
+  async p(path, ...args) {
+    let _args = clone(args)
+    _args[0] ??= {}
+    _args[0].path ??= path
+    return (await this.post(..._args))?.out ?? null
+  }
+
+  async post(obj, opt = {}) {
+    const _json = opt.json ? "/~json@1.0/serialize" : ""
+    obj.path += _json
+    const signed = await this.sign(obj, opt)
+    return await this.send(signed)
+  }
+
+  async g(path, ...args) {
+    let _args = clone(args)
+    _args[0] ??= {}
+    _args[0].path ??= path
+    return (await this.get(..._args))?.out ?? null
+  }
+
+  async get({ path, ...params }, opt = {}) {
+    const _json = opt.json ? "/~json@1.0/serialize" : ""
+    path ??= "/~message@1.0"
+    if (!/^\//.test(path)) path = "/" + path
+    let _params = ""
+    if (!isEmpty(params)) {
+      let i = 0
+      for (const k in params) {
+        _params += `${i === 0 ? "?" : "&"}${k}=${params[k]}`
+        i++
+      }
+    }
+    const response = await fetch(`${this.url}${path}${_json}${_params}`)
+    let headers = {}
+    response.headers.forEach((v, k) => (headers[k] = v))
+    const http = {
+      headers,
+      body: await response.text(),
+      status: response.status,
+    }
+    return {
+      ...from(http),
+      ...http,
+    }
+  }
+
+  async postJSON(args, opt = {}) {
+    const res = await this.post(args, { ...opt, json: true })
+    return JSON.parse(res.body)
+  }
+
+  async getJSON(args, opt = {}) {
+    const res = await this.get(args, { ...opt, json: true })
+    return JSON.parse(res.body)
+  }
+}
+
+export default HB