wao 0.40.2 → 0.41.0

package/esm/bar.js

@@ -27,6 +27,10 @@ class AR extends MAR {
     this.mem = opt.mem ?? new opt.ArMem()
     this.gql = new GQL({ mem: this.mem })
     this.arweave = this.mem.arweave
+    // Block batching (DB path only)
+    this._pendingBatch = []
+    this._flushTimer = null
+    this._batchWindow = opt.batchWindow ?? 0 // ms, 0 = disabled
   }
   isHttpMsg(item) {
     if (typeof item === "object" && item !== null) {
@@ -77,6 +81,21 @@ class AR extends MAR {
   }
 
   async postItems(items, jwk) {
+    // Remote mode: forward bundle to main AR via HTTP
+    if (this.mem._remote) {
+      let err = null
+      ;({ err, jwk } = await this.checkWallet({ jwk }))
+      if (err) return { err }
+      if (!is(Array, items)) items = [items]
+      const bundle = await bundleAndSignData(items, new ArweaveSigner(jwk))
+      const tx = await this.mem.arweave.createTransaction(
+        { data: bundle.binary },
+        jwk
+      )
+      tx.addTag("Bundle-Format", "binary")
+      tx.addTag("Bundle-Version", "2.0.0")
+      return await this.postTx(tx, jwk, items.map(i => ({ id: i.id })))
+    }
     let err = null
     ;({ err, jwk } = await this.checkWallet({ jwk }))
     if (err) return { err }
@@ -90,6 +109,10 @@ class AR extends MAR {
         if (t.name === "Content-Type") data_type = t.value
       const owner = await this.owner(di)
       await this.mem.set({ key: di.owner, address: owner }, "addrmap", owner)
+      // D1: write addrmap
+      if (this.mem.db?.d1WriteAddrmap) {
+        try { await this.mem.db.d1WriteAddrmap(owner, { key: di.owner, address: owner }) } catch (e) {}
+      }
       let _item = {
         _data: { size: data_size, type: data_type },
         anchor: di.anchor,
@@ -101,6 +124,12 @@ class AR extends MAR {
         tags: di.tags,
         data: di.data,
       }
+      // Extract raw data to R2
+      if (_item.data && this.mem.db?.r2PutTxData) {
+        await this.mem.db.r2PutTxData(_item.id, _item.data)
+        _item._r2_data = true
+        _item.data = ""
+      }
       await this.mem.set(_item, "txs", await di.id)
       _items.push(_item)
     }
@@ -115,19 +144,41 @@ class AR extends MAR {
   }
 
   async postTx(tx, jwk, items = []) {
+    // Remote mode: sign locally, POST to main AR
+    if (this.mem._remote) {
+      let err = null
+      ;({ err, jwk } = await this.checkWallet({ jwk }))
+      if (err) return { err }
+      if (!tx.id) await this.mem.arweave.transactions.sign(tx, jwk)
+      const res = await this.mem._remote.postTx(tx)
+      return { res: { id: tx.id, status: 200 }, err: null, id: tx.id }
+    }
     let err = null
     ;({ err, jwk } = await this.checkWallet({ jwk }))
     if (err) return { err }
 
     let res = null
     if (!tx.id) await this.mem.arweave.transactions.sign(tx, jwk)
-    let height = (await this.mem.get("height")) + 1
-    await this.mem.set(height, "height")
+    let height
+    if (this.mem._d1Ready) {
+      // D1 ready: increment in-memory, flush every 10 txs
+      this.mem.height = (this.mem.height ?? 0) + 1
+      height = this.mem.height
+      if (height % 10 === 0) {
+        await this.mem.set(height, "height")
+      }
+    } else {
+      height = (await this.mem.get("height")) + 1
+      await this.mem.set(height, "height")
+    }
+    let previous = this.mem._d1Ready
+      ? (this.mem.lastBlockId || "")
+      : (last(await this.mem.get("blocks")) ?? "")
     let block = {
       id: tx.id,
       timestamp: Date.now(),
       height,
-      previous: last(await this.mem.get("blocks")) ?? "",
+      previous,
       txs: [],
     }
     let msg = null
@@ -144,6 +195,7 @@ class AR extends MAR {
             "Process",
             "Module",
             "Scheduler-Location",
+            "Scheduler-Transfer",
             "Attestation",
             "Available",
           ])
@@ -157,7 +209,12 @@ class AR extends MAR {
         }
         block.txs.push(item.id)
         _txs.block = block.id
-        await this.mem.set({ bundle: tx.id }, "txs", item.id)
+        // Re-store item with parent/bundledIn/block, but drop the raw
+        // DataItem binary (item.item) to save space — data is in R2 or
+        // can be reconstructed from the wrapper bundle tx.
+        const slim = { ..._txs, bundle: tx.id }
+        delete slim.item
+        await this.mem.set(slim, "txs", item.id)
       }
     }
     let _tags = []
@@ -180,19 +237,64 @@ class AR extends MAR {
     }
     tx.tags = _tags
     tx.owner = await this.arweave.wallets.jwkToAddress({ n: tx.owner })
+    tx.recipient = tx.target || ""
     let _txs = tx
     block.txs.push(tx.id)
     _txs.block = block.id
+    // Extract raw data to R2
+    if (_txs.data && this.mem.db?.r2PutTxData) {
+      await this.mem.db.r2PutTxData(tx.id, _txs.data)
+      _txs._r2_data = true
+      _txs.data = ""
+    }
     await this.mem.set(_txs, "txs", tx.id)
-    let blocks = await this.mem.get("blocks")
-    blocks.push(block.id)
-    await this.mem.set(blocks, "blocks")
+    // Update block tracking — always maintain blocks array + blockmap
+    // so the O(n) scan fallback in tgql.js works even if D1 is stale
+    if (this.mem._d1Ready) {
+      await this.mem.set(block.id, "lastBlockId")
+      this.mem.lastBlockId = block.id
+    }
+    this.mem.blocks ??= []
+    this.mem.blocks.push(block.id)
+    await this.mem.set(this.mem.blocks, "blocks")
     await this.mem.set(block, "blockmap", block.id)
 
     if (jwk) {
       const owner = await this.arweave.wallets.jwkToAddress(jwk)
       await this.mem.set({ address: owner, key: jwk.n }, "addrmap", owner)
+      // D1: write addrmap
+      if (this.mem.db?.d1WriteAddrmap) {
+        try { await this.mem.db.d1WriteAddrmap(owner, { address: owner, key: jwk.n }) } catch (e) {}
+      }
+    }
+
+    // D1 write: block + txs + tags (only when D1 schema is verified ready)
+    if (this.mem._d1Ready && this.mem.db?.d1WriteBlock) {
+      const mainTx = {
+        id: tx.id,
+        owner: tx.owner,
+        recipient: tx.recipient || "",
+        anchor: tx.anchor || "",
+        signature: tx.signature || "",
+        tags: _tags,
+        _data: tx._data || { size: tx.data ? String(tx.data.length) : "0", type: "" },
+        bundledIn: tx.bundledIn,
+        parent: tx.parent,
+      }
+      if (this._batchWindow > 0) {
+        this._pendingBatch.push({ block, mainTx, items: [...items] })
+        if (!this._flushTimer) {
+          this._flushTimer = setTimeout(() => this._flushBatch(), this._batchWindow)
+        }
+      } else {
+        await this.mem.db.d1WriteBlock(block)
+        await this.mem.db.d1WriteTx(mainTx, block.id, block.height)
+        for (const item of items) {
+          await this.mem.db.d1WriteTx(item, block.id, block.height)
+        }
+      }
     }
+
     res = { id: tx.id, status: 200, statusText: "200" }
     if (this.log) {
       if (msg) {
@@ -206,6 +308,21 @@ class AR extends MAR {
     return { res, err, id: tx.id }
   }
 
+  async _flushBatch() {
+    this._flushTimer = null
+    if (!this._pendingBatch.length) return
+    const batch = this._pendingBatch.splice(0)
+    for (const { block, mainTx, items } of batch) {
+      await this.mem.db.d1WriteBlock(block)
+      await this.mem.db.d1WriteTx(mainTx, block.id, block.height)
+      for (const item of items) {
+        await this.mem.db.d1WriteTx(item, block.id, block.height)
+      }
+    }
+    // Flush height to DO after batch
+    await this.mem.set(this.mem.height, "height")
+  }
+
   async tx(id) {
     return await this.mem.getTx(id)
   }
@@ -219,15 +336,8 @@ class AR extends MAR {
     }
     let tx = await this.mem.getTx(id)
     let _data = tx?.data ?? null
-    if (tx?.format === 2 && _data) {
-      _data = Buffer.from(_data, "base64")
-    } else if (_data) {
-      // need to check production
-      if (tx._data.type === "") {
-        _data = tobuff(_data)
-      } else {
-        _data = Buffer.from(base64url.decode(_data))
-      }
+    if (_data && is(String, _data)) {
+      _data = tobuff(_data)
     }
     let isBuf = is(Uint8Array, _data) || is(ArrayBuffer, _data)
     let isStr = is(String, _data)

package/esm/car.js

@@ -0,0 +1,10 @@
+import BAR from "./bar.js"
+import ArMem from "./armem-cf.js"
+
+class AR extends BAR {
+  constructor(opt = {}) {
+    super({ ...opt, ArMem })
+  }
+}
+
+export default AR

package/esm/cf-env.js

@@ -0,0 +1,29 @@
+// CF Workers polyfill: make emscripten (ao-loader) detect "web" environment.
+// Must be imported BEFORE ao-loader.js so it runs first.
+if (typeof globalThis.window === "undefined") {
+  globalThis.window = globalThis
+}
+
+// CF Workers blocks WebAssembly.instantiate(buffer, imports) — only pre-compiled
+// WebAssembly.Module objects are allowed. Patch the API so that when a pre-compiled
+// module is queued (via cfWasmReady), emscripten's default async loading path works
+// unchanged, preserving Asyncify and all other internals.
+const _wasmInstantiate = WebAssembly.instantiate.bind(WebAssembly)
+let _cfWasmModule = null
+
+export function cfWasmReady(mod) {
+  _cfWasmModule = mod
+}
+
+WebAssembly.instantiate = async function (source, imports) {
+  if (
+    _cfWasmModule &&
+    (source instanceof ArrayBuffer || ArrayBuffer.isView(source))
+  ) {
+    const mod = _cfWasmModule
+    _cfWasmModule = null
+    const instance = await _wasmInstantiate(mod, imports)
+    return { instance, module: mod }
+  }
+  return _wasmInstantiate(source, imports)
+}

package/esm/cf.js

@@ -0,0 +1,11 @@
+import { acc, mu, su, cu } from "./accounts-web.js"
+import { connect } from "./aoconnect-cf.js"
+import Adaptor from "./adaptor-cf.js"
+import AO from "./wao.js"
+import AR from "./car.js"
+import GQL from "./tgql.js"
+import ArMem from "./armem-cf.js"
+import { dirname } from "./utils.js"
+const scheduler = "_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA"
+
+export { GQL, ArMem, AO, AR, connect, acc, mu, su, cu, scheduler, Adaptor }

package/esm/cli.js

@@ -192,7 +192,7 @@ const ask = question =>
 
 
 const HB_REPO = "https://github.com/permaweb/HyperBEAM.git"
-const HB_TAG = "v0.9-milestone-3-beta-3"
+const HB_TAG = "v0.9-FINAL"
 
 const which = async cmd => {
   try {
@@ -527,10 +527,14 @@ else {
       process.exit(2)
     }
 
+    // Node 24+ enables wasm-memory64 by default and rejects the
+    // experimental flag at startup; older Node still needs it.
+    const _nodeMajor = parseInt((process.versions.node || "0").split(".")[0], 10)
+    const _wasm64Flag = _nodeMajor >= 24 ? "" : "--experimental-wasm-memory64"
     pm2.start(
       {
         script: resolve(await dirname(), cmd.script),
-        nodeArgs: "--experimental-wasm-memory64",
+        nodeArgs: _wasm64Flag,
         instances: 1,
         force: true,
         args: args,

package/esm/create.js

@@ -141,7 +141,7 @@ const ask = (question) => new Promise(res => {
 })
 
 const HB_REPO = "https://github.com/permaweb/HyperBEAM.git"
-const HB_TAG = "v0.9-milestone-3-beta-3"
+const HB_TAG = "v0.9-FINAL"
 
 const yellow = t => `\x1b[33m${t}\x1b[39m`
 

package/esm/devs.js

@@ -40,6 +40,7 @@ export default {
   p4: { name: "p4@1.0", module: "dev_p4" },
   "node-process": { name: "node-process@1.0", module: "dev_node_process" },
   "simple-pay": { name: "simple-pay@1.0", module: "dev_simple_pay" },
+  metering: { name: "metering@1.0", module: "dev_metering" },
 
   // tested
   cron: { name: "cron@1.0", module: "dev_cron" },
@@ -51,12 +52,16 @@ export default {
   "local-name": { name: "local-name@1.0", module: "dev_local_name" },
   lookup: { name: "lookup@1.0", module: "dev_lookup" },
   name: { name: "name@1.0", module: "dev_name" },
+  location: { name: "location@1.0", module: "dev_location" },
+  trie: { name: "trie@1.0", module: "dev_trie" },
 
   // others
   compute: { name: "compute@1.0", module: "dev_cu" },
   dedup: { name: "dedup@1.0", module: "dev_dedup" },
   manifest: { name: "manifest@1.0", module: "dev_manifest" },
   monitor: { name: "monitor@1.0", module: "dev_monitor" },
+  blacklist: { name: "blacklist@1.0", module: "dev_blacklist" },
+  "rate-limit": { name: "rate-limit@1.0", module: "dev_rate_limit" },
 
   // advanced
   snp: { name: "snp@1.0", module: "dev_snp" },
@@ -68,4 +73,14 @@ export default {
   hyperbuddy: { name: "hyperbuddy@1.0", module: "dev_hyperbuddy" },
   ans104: { name: "ans104@1.0", module: "dev_codec_ans104" },
   cacheviz: { name: "cacheviz@1.0", module: "dev_cacheviz" },
+
+  // v0.9-FINAL additions
+  arweave: { name: "arweave@2.9", module: "dev_arweave" },
+  "b32-name": { name: "b32-name@1.0", module: "dev_b32_name" },
+  bundler: { name: "bundler@1.0", module: "dev_bundler" },
+  copycat: { name: "copycat@1.0", module: "dev_copycat" },
+  gzip: { name: "gzip@1.0", module: "dev_gzip" },
+  secret: { name: "secret@1.0", module: "dev_secret" },
+  tx: { name: "tx@1.0", module: "dev_codec_tx" },
+  whois: { name: "whois@1.0", module: "dev_whois" },
 }

package/esm/dodb.js

@@ -0,0 +1,26 @@
+// Strip functions and other non-serializable values before storing.
+// LMDB silently drops these; DO storage would throw on them.
+// The codebase handles missing `handle` by recreating it on read.
+function sanitize(val) {
+  if (val == null) return val
+  if (typeof val === "function") return null
+  if (typeof val !== "object") return val
+  if (val instanceof Uint8Array || val instanceof ArrayBuffer) return val
+  if (ArrayBuffer.isView(val)) return val
+  if (Array.isArray(val)) return val.map(sanitize)
+  const out = {}
+  for (const k of Object.keys(val)) {
+    const v = val[k]
+    if (typeof v !== "function") out[k] = sanitize(v)
+  }
+  return out
+}
+
+export default (storage) => ({
+  put: async (key, val) => await storage.put(key, sanitize(val)),
+  get: async (key) => await storage.get(key) ?? null,
+  getKeys: async ({ start, end }) => {
+    const map = await storage.list({ start, end })
+    return [...map.keys()]
+  },
+})

package/esm/hb.js

@@ -17,6 +17,83 @@ import aos_wamr from "./aos_wamr.js"
 import { ArweaveSigner } from "@ar.io/sdk"
 import { createData } from "@dha-team/arbundles"
 
+// Convert objects whose keys are sequential numeric strings (e.g.
+// `{1: "a", 2: "b"}`) into arrays. v0.9-FINAL's multipart re-encoder treats
+// numbered TABMs as lists; JS hbsig only emits `.="list"` in ao-types when
+// the value is an Array, so without this conversion the content-digest of
+// the request body diverges from HB's recomputation and rsa-pss verification
+// fails with `process_not_verified`.
+const normalizeNumberedObjects = v => {
+  if (v === null || v === undefined) return v
+  if (Array.isArray(v)) return v.map(normalizeNumberedObjects)
+  if (Buffer.isBuffer(v) || v instanceof Blob) return v
+  if (typeof v !== "object") return v
+  const keys = Object.keys(v)
+  if (
+    keys.length > 0 &&
+    keys.every(k => /^[1-9][0-9]*$/.test(k)) &&
+    keys
+      .map(k => parseInt(k, 10))
+      .sort((a, b) => a - b)
+      .every((n, i) => n === i + 1)
+  ) {
+    return keys
+      .map(k => parseInt(k, 10))
+      .sort((a, b) => a - b)
+      .map(i => normalizeNumberedObjects(v[String(i)]))
+  }
+  const out = {}
+  for (const [k, val] of Object.entries(v)) out[k] = normalizeNumberedObjects(val)
+  return out
+}
+
+// v0.9-FINAL returns Messages with lowercase fields (data, target, anchor, from)
+// where legacy AOS-format consumers expect capitalised (Data, Target, Anchor,
+// From). Also lower-cases tag {name, value} pairs and may emit them as a
+// numbered-key map under "tags" rather than an array under "Tags". Normalise
+// so existing callers that read `Messages[0].Data` keep working.
+const _normalizeLegacyResult = res => {
+  if (!res || typeof res !== "object") return res
+  const _msgs = res.Messages ?? res.messages
+  if (!Array.isArray(_msgs)) return res
+  const _tagsArray = t => {
+    if (!t) return []
+    if (Array.isArray(t)) {
+      return t.map(x => ({
+        name: x?.name ?? x?.Name,
+        value: x?.value ?? x?.Value,
+      })).filter(x => x.name != null)
+    }
+    if (typeof t === "object") {
+      return Object.keys(t)
+        .filter(k => /^\d+$/.test(k))
+        .sort((a, b) => Number(a) - Number(b))
+        .map(k => {
+          const x = t[k]
+          return {
+            name: x?.name ?? x?.Name,
+            value: x?.value ?? x?.Value,
+          }
+        })
+        .filter(x => x.name != null)
+    }
+    return []
+  }
+  const Messages = _msgs.map(m => {
+    if (!m || typeof m !== "object") return m
+    const tags = _tagsArray(m.Tags ?? m.tags)
+    return {
+      ...m,
+      Data: m.Data ?? m.data,
+      Target: m.Target ?? m.target,
+      Anchor: m.Anchor ?? m.anchor,
+      From: m.From ?? m.from,
+      Tags: tags,
+    }
+  })
+  return { ...res, Messages }
+}
+
 const toMsg = async req => {
   let msg = {}
   req?.headers?.forEach((v, k) => {
@@ -251,24 +328,17 @@ class HB {
   async computeLegacy({ pid, slot }) {
     // Match master: compute and parse results.json.body
     const json = await this.compute({ pid, slot })
+    let parsed = json
     if (json?.results?.json?.body) {
-      return JSON.parse(json.results.json.body)
-    }
-    // Fallback: try compute/results/json/body structure
-    if (json?.["compute/results/json"]?.body) {
-      return JSON.parse(json["compute/results/json"].body)
-    }
-    // Remote nodes return results.raw with CU format directly
-    if (json?.results?.raw) {
+      parsed = JSON.parse(json.results.json.body)
+    } else if (json?.["compute/results/json"]?.body) {
+      parsed = JSON.parse(json["compute/results/json"].body)
+    } else if (json?.results?.raw) {
       const raw = typeof json.results.raw === "string"
         ? JSON.parse(json.results.raw) : json.results.raw
-      if (raw?.Messages || raw?.Output) return raw
-    }
-    // Another fallback: check if it's the raw CU format
-    if (json?.Messages || json?.Output) {
-      return json
+      if (raw?.Messages || raw?.Output) parsed = raw
     }
-    return json
+    return _normalizeLegacyResult(parsed)
   }
 
   async cacheScript(data, type = "application/lua") {
@@ -448,6 +518,13 @@ class HB {
   }
   async spawn(tags = {}) {
     await this.setInfo()
+    // v0.9-FINAL multipart re-encoding sees a numbered-key object as a list
+    // (TABM with .="list" in ao-types). JS hbsig's structured codec encodes
+    // a plain numeric-keyed object without that marker, so HB's recomputed
+    // content-digest doesn't match what JS signed and verify fails. Pre-
+    // normalize any numbered-key object value into an array so the array
+    // path (which already emits .="list") is used.
+    tags = normalizeNumberedObjects(tags)
     let res = null
     if (this.format === "ans104") {
       res = await this.post104({
@@ -462,7 +539,7 @@ class HB {
       })
       return { res, pid: res.out.process }
     } else {
-      // Use httpsig-signed multipart POST (beta3-compatible approach)
+      // Use httpsig-signed multipart POST
       const spawnTags = mergeLeft(tags, {
         "random-seed": seed(16),
         type: "Process",
@@ -742,7 +819,7 @@ class HB {
         i++
       }
     }
-    // Add accept-bundle header to get inline data instead of links (beta3 compatibility)
+    // Add accept-bundle header to get inline data instead of links
     const url = `${this.url}${path}${_json}${_params}`
     let response
     for (let attempt = 0; attempt < 3; attempt++) {