wao 0.26.2 → 0.27.1

package/esm/hb.js

@@ -1,7 +1,8 @@
 import { connect, createSigner } from "@permaweb/aoconnect"
 import { isEmpty, last, isNotNil, mergeLeft } from "ramda"
 import { toAddr, buildTags } from "./utils.js"
-import { send as _send, createRequest } from "./signer.js"
+import { 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"
 
@@ -73,7 +74,7 @@ class HB {
   _init(jwk) {
     this.signer = createSigner(jwk, this.url)
     this.addr = toAddr(jwk.n)
-    this.sign = createRequest({ signer: this.signer, url: this.url })
+    this.sign = signer({ signer: this.signer, url: this.url })
 
     const { request } = connect({
       MODE: "mainnet",
@@ -87,7 +88,9 @@ class HB {
 
   async init(jwk) {
     this._init(jwk)
-    this._info = await this.dev.meta.info({})
+    try {
+      this._info = await this.dev.meta.info({})
+    } catch (e) {}
     return this
   }
 

package/esm/hyperbeam.js

@@ -7,7 +7,7 @@ export default class HyperBEAM {
   constructor({
     port = 10001,
     cu = 6363,
-    as = ["genesis_wasm"],
+    as,
     bundler,
     gateway,
     wallet,
@@ -22,7 +22,9 @@ export default class HyperBEAM {
     store_prefix,
     operator,
     console = true,
+    shell = true,
   } = {}) {
+    as ??= shell ? [] : ["genesis_wasm"]
     this.console = console
     if (clearCache) {
       const dirname = resolve(process.cwd(), cwd)
@@ -53,11 +55,11 @@ export default class HyperBEAM {
     this.gateway = gateway
     this.wallet = wallet
     this.cwd = cwd
-    this.run()
+    if (shell) this.shell()
   }
-  run() {
+  shell() {
     const _as = this.as.length === 0 ? [] : ["as", this.as.join(", ")]
-    this.hbeam = spawn(
+    this._shell = spawn(
       "rebar3",
       [
         ..._as,
@@ -71,16 +73,61 @@ export default class HyperBEAM {
       }
     )
     if (this.console) {
-      this.hbeam.stdout.on("data", chunk => console.log(chunk.toString()))
-      this.hbeam.stderr.on("data", err => console.error(err.toString()))
-      this.hbeam.on("error", err =>
+      this._shell.stdout.on("data", chunk => console.log(chunk.toString()))
+      this._shell.stderr.on("data", err => console.error(err.toString()))
+      this._shell.on("error", err =>
         console.error(`failed to start process: ${err}`)
       )
-      this.hbeam.on("close", code =>
+      this._shell.on("close", code => {
         console.log(`child process exited with code ${code}`)
-      )
+        delete this._shell
+      })
     }
   }
+  eunit(module, test) {
+    return new Promise(res => {
+      let isTest = !isNil(test)
+      if (Array.isArray(module)) {
+        for (const v of module) {
+          if (Array.isArray(v) || /:/.test(v)) {
+            isTest = true
+            break
+          }
+        }
+      }
+      const _as = this.as.length === 0 ? [] : ["as", this.as.join(", ")]
+      const _test = Array.isArray(test) ? test.join("+") : test
+      let _module = ""
+
+      if (Array.isArray(module)) {
+        for (const v of module) {
+          _module += _module === "" ? "" : ","
+          if (Array.isArray(v)) _module += `${v[0]}:${v[1].join("+")}`
+          else _module += v
+        }
+      } else {
+        _module = test ? `${module}:${_test}` : module
+      }
+
+      const _arg = isTest ? "--test" : "--module"
+      let params = [..._as, "eunit", _arg, _module]
+      const _eunit = spawn("rebar3", params, {
+        env: { ...process.env, ...this.genEnv() },
+        cwd: resolve(process.cwd(), this.cwd),
+      })
+      if (this.console) {
+        _eunit.stdout.on("data", chunk => console.log(chunk.toString()))
+        _eunit.stderr.on("data", err => console.error(err.toString()))
+        _eunit.on("error", err =>
+          console.error(`failed to start process: ${err}`)
+        )
+        _eunit.on("close", code => {
+          console.log(`child process exited with code ${code}`)
+          res()
+        })
+      }
+    })
+  }
   async ok() {
     try {
       const address = await fetch(
@@ -111,6 +158,7 @@ export default class HyperBEAM {
   }
   genEnv() {
     let _env = {}
+    if (this.diagnostic) _env.DIAGNOSTIC = this.diagnostic
     if (this.c) {
       _env.CC = `gcc-${this.c}`
       _env.CXX = `g++-${this.c}`
@@ -168,6 +216,6 @@ export default class HyperBEAM {
   }
 
   kill() {
-    this.hbeam.kill("SIGKILL")
+    this._shell.kill("SIGKILL")
   }
 }

package/esm/send.js

@@ -0,0 +1,126 @@
+import base64url from "base64url"
+import { httpbis } from "http-message-signatures"
+import { parseItem, serializeList } from "structured-headers"
+const {
+  augmentHeaders,
+  createSignatureBase,
+  createSigningParameters,
+  formatSignatureBase,
+} = httpbis
+
+export async function send(signedMsg, fetchImpl = fetch) {
+  const fetchOptions = {
+    method: signedMsg.method,
+    headers: signedMsg.headers,
+    redirect: "follow",
+  }
+  if (
+    signedMsg.body !== undefined &&
+    signedMsg.method !== "GET" &&
+    signedMsg.method !== "HEAD"
+  ) {
+    fetchOptions.body = signedMsg.body
+  }
+  const response = await fetchImpl(signedMsg.url, fetchOptions)
+
+  if (response.status >= 400) {
+    throw new Error(`${response.status}: ${await response.text()}`)
+  }
+
+  let headers = {}
+  if (response.headers && typeof response.headers.forEach === "function") {
+    response.headers.forEach((v, k) => (headers[k] = v))
+  } else headers = response.headers
+
+  return {
+    response,
+    headers,
+    body: await response.text(),
+    status: response.status,
+  }
+}
+
+const httpSigName = address => {
+  const decoded = base64url.toBuffer(address)
+  const hexString = [...decoded.subarray(1, 9)]
+    .map(byte => byte.toString(16).padStart(2, "0"))
+    .join("")
+  return `http-sig-${hexString}`
+}
+
+const toView = value => {
+  if (ArrayBuffer.isView(value)) {
+    return Buffer.from(value.buffer, value.byteOffset, value.byteLength)
+  } else if (typeof value === "string") return base64url.toBuffer(value)
+
+  throw new Error(
+    "Value must be Uint8Array, ArrayBuffer, or base64url-encoded string"
+  )
+}
+
+export const toHttpSigner = signer => {
+  const params = ["alg", "keyid"].sort()
+  return async ({ request, fields }) => {
+    let signatureBase
+    let signatureInput
+    let createCalled = false
+
+    const create = injected => {
+      createCalled = true
+
+      const { publicKey, alg = "rsa-pss-sha512" } = injected
+
+      const publicKeyBuffer = toView(publicKey)
+
+      const signingParameters = createSigningParameters({
+        params,
+        paramValues: {
+          keyid: base64url.encode(publicKeyBuffer),
+          alg,
+        },
+      })
+
+      const signatureBaseArray = createSignatureBase({ fields }, request)
+      signatureInput = serializeList([
+        [
+          signatureBaseArray.map(([item]) => parseItem(item)),
+          signingParameters,
+        ],
+      ])
+
+      signatureBaseArray.push(['"@signature-params"', [signatureInput]])
+      signatureBase = formatSignatureBase(signatureBaseArray)
+
+      return new TextEncoder().encode(signatureBase)
+    }
+
+    const result = await signer(create, "httpsig")
+
+    if (!createCalled) {
+      throw new Error(
+        "create() must be invoked in order to construct the data to sign"
+      )
+    }
+
+    if (!result.signature || !result.address) {
+      throw new Error("Signer must return signature and address")
+    }
+
+    const signatureBuffer = toView(result.signature)
+    const signedHeaders = augmentHeaders(
+      request.headers,
+      signatureBuffer,
+      signatureInput,
+      httpSigName(result.address)
+    )
+
+    const finalHeaders = {}
+    for (const [key, value] of Object.entries(signedHeaders)) {
+      if (key === "Signature" || key === "Signature-Input") {
+        finalHeaders[key.toLowerCase()] = value
+      } else finalHeaders[key] = value
+    }
+
+    return { ...request, headers: finalHeaders }
+  }
+}