wao 0.9.0 → 0.9.2

package/esm/lfdb.js

@@ -0,0 +1,68 @@
+import lf from "localforage"
+import { is, keys } from "ramda"
+
+export default _this => {
+  return {
+    put: async (key, val) => {
+      let _val = null
+      if (typeof val === "object" && !is(Array, val)) {
+        _val = {}
+        for (let k in val) {
+          if (typeof val[k] !== "function") {
+            if (is(Array, val[k])) {
+              let _arr = []
+              for (let v of val[k]) {
+                if (
+                  typeof v === "object" &&
+                  !is(Array, v) &&
+                  !(v instanceof Uint8Array) &&
+                  !(v instanceof ArrayBuffer)
+                ) {
+                  let __val = {}
+                  for (let k2 in v) {
+                    if (typeof v[k2] !== "function") __val[k2] = v[k2]
+                  }
+                  _arr.push(__val)
+                } else {
+                  _arr.push(v)
+                }
+              }
+              _val[k] = _arr
+            } else if (
+              typeof val[k] === "object" &&
+              !(val[k] instanceof Uint8Array) &&
+              !(val[k] instanceof ArrayBuffer)
+            ) {
+              let __val = {}
+              for (let k2 in val[k]) {
+                if (typeof val[k][k2] !== "function") __val[k2] = val[k][k2]
+              }
+              _val[k] = __val
+            } else {
+              _val[k] = val[k]
+            }
+          }
+        }
+      } else _val = val
+      await lf.setItem(key, _val)
+      _this.keys[key] = true
+      await lf.setItem("keys", keys(_this.keys))
+    },
+    get: async key => {
+      return await lf.getItem(key)
+    },
+    getKeys: async ({ start, end }) => {
+      if (!_this.keyInit) {
+        const _keys = (await lf.getItem("keys")) ?? []
+        _this.keys = {}
+        for (const v of _keys) _this.keys[v] = true
+      }
+      let __keys = []
+      for (const k in _this.keys) {
+        const sp = k.split(".")
+        if (sp[0] === start) __keys.push(k)
+      }
+      return __keys
+    },
+  }
+}

package/esm/tao.js

@@ -1,127 +1,10 @@
-import MAO from "./ao.js"
-import { createDataItemSigner } from "@permaweb/aoconnect"
-import { srcs, buildTags } from "./utils.js"
-import AR from "./tar.js"
+import BAO from "./bao.js"
 import { connect } from "./aoconnect.js"
-import { acc, mu } from "./test.js"
-import { mergeLeft, is, map } from "ramda"
-
-let log = `
-local json = require("json")
-ao = ao or {}
-
-function ao.log(...)
-    local args = {...}
-    local txt = json.encode(args)
-    if type(ao.outbox.Output) == 'string' then
-      ao.outbox.Output = {ao.outbox.Output}
-    end
-    table.insert(ao.outbox.Output, txt)
-    ao.outbox.Logs = ao.outbox.Logs or {}
-    table.insert(ao.outbox.Logs, txt)
-end
-
-function ao.result(result)
-    if ao.outbox.Error or result.Error then
-      return { Error = result.Error or ao.outbox.Error, Output = ao.outbox.Logs }
-    end
-    return {
-        Output = ao.outbox.Logs or result.Output or ao.outbox.Output,
-        Messages = ao.outbox.Messages,
-        Spawns = ao.outbox.Spawns,
-        Assignments = ao.outbox.Assignments,
-    }
-end
-`
-
-const renderLogs = logs => {
-  if (is(Array, logs) && logs.length > 0) {
-    for (const v of logs) {
-      let l = v
-      try {
-        const p = JSON.parse(v)
-        if (JSON.stringify(p) === v) l = p
-        console.log(...l)
-      } catch (e) {
-        console.log(l)
-      }
-    }
-  }
-}
+import AR from "./tar.js"
 
-class AO extends MAO {
+class AO extends BAO {
   constructor(opt = {}) {
-    super({ ...opt, in_memory: true })
-    this.in_memory = true
-    const {
-      modules,
-      results,
-      assign,
-      result,
-      message,
-      spawn,
-      dryrun,
-      monitor,
-      unmonitor,
-      mem,
-    } = connect(opt.mem, {
-      extensions: opt.extensions,
-      cache: opt.cache,
-      reset: opt.reset,
-    })
-    this.assign = assign
-    this.result = async (...opt) => {
-      const res = await result(...opt)
-      renderLogs(res.Output)
-      return res
-    }
-
-    this.results = results
-    this.message = message
-    this.spawn = async (...opt) => {
-      const res = await spawn(...opt)
-      await this.load({ data: log, pid: res })
-      return res
-    }
-    this.dryrun = async (...opt) => {
-      const res = await dryrun(...opt)
-      renderLogs(res.Output)
-      return res
-    }
-    this.monitor = monitor
-    this.unmonitor = unmonitor
-    this.mem = mem
-    this.ar = new AR({ mem })
-  }
-
-  async init(jwk) {
-    if (!jwk && this.acc[0]) jwk = this.acc[0].jwk
-    await this.ar.init(jwk)
-    return this
-  }
-
-  async postModule({ data, tags = {}, jwk }) {
-    let err = null
-    ;({ jwk, err } = await this.ar.checkWallet({ jwk }))
-    if (err) return { err }
-    const t = mergeLeft(tags, {
-      "Data-Protocol": "ao",
-      Variant: "ao.TN.1",
-      Type: "Module",
-      "Module-Format": "wasm64-unknown-emscripten-draft_2024_02_15",
-      "Input-Encoding": "JSON-V1",
-      "Output-Encoding": "JSON-V1",
-      "Memory-Limit": "1-gb",
-      "Compute-Limit": "9000000000000",
-    })
-    const signer = createDataItemSigner(jwk)
-    const { id, owner, item } = await this.ar.dataitem({
-      tags: t,
-      data,
-      signer,
-    })
-    await this.ar.postItems(item, jwk)
-    return { id }
+    super({ ...opt, connect, AR })
   }
 }
 

package/esm/tar.js

@@ -1,215 +1,9 @@
-import MAR from "./ar.js"
-import { buildTags, tags as t } from "./utils.js"
-import * as WarpArBundles from "warp-arbundles"
-const pkg = WarpArBundles.default ?? WarpArBundles
-const { DataItem } = pkg
-import { bundleAndSignData, ArweaveSigner } from "arbundles"
-import base64url from "base64url"
+import BAR from "./ar-base.js"
 import ArMem from "./armem.js"
-import GQL from "./tgql.js"
-import { last, is, includes, isNil } from "ramda"
 
-class AR extends MAR {
+class AR extends BAR {
   constructor(opt = {}) {
-    super({ ...opt, in_memory: true })
-    this.log = opt.log === true
-    this.in_memory = true
-    this.mem = opt.mem ?? new ArMem()
-    this.gql = new GQL({ mem: this.mem })
-    this.arweave = this.mem.arweave
-  }
-  async owner(di) {
-    const raw_owner = di.rawOwner
-    const hashBuffer = Buffer.from(
-      await crypto.subtle.digest("SHA-256", raw_owner),
-    )
-    return base64url.encode(hashBuffer)
-  }
-  async dataitem({ target = "", data = "1984", tags = {}, signer, item }) {
-    let di = item
-    if (!di) {
-      const _tags = buildTags(tags)
-      const _item = await signer({ data, tags: _tags, target })
-      di = new DataItem(_item.raw)
-    } else {
-      tags = t(di.tags)
-    }
-    const owner = await this.owner(di)
-    return { id: await di.id, owner, item: di, tags }
-  }
-
-  async post({ data = "1984", tags = {}, jwk }) {
-    let err = null
-    ;({ err, jwk } = await this.checkWallet({ jwk }))
-    if (err) return { err }
-    let tx = await this.arweave.createTransaction({ data: data })
-    let _tags = buildTags(null, tags)
-    for (const v of _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 }))
-    if (err) return { err }
-    if (!is(Array, items)) items = [items]
-    let _items = []
-    for (const di of items) {
-      di._id = await di.id
-      const data_size = Buffer.byteLength(di.rawData).toString()
-      let data_type = ""
-      for (const t of di.tags)
-        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)
-      let data = di.data
-      let _item = {
-        _data: { size: data_size, type: data_type },
-        anchor: di.anchor,
-        signature: di.signature,
-        recipient: di.target,
-        id: await di.id,
-        item: di,
-        owner,
-        tags: di.tags,
-        data,
-      }
-      await this.mem.set(_item, "txs", await di.id)
-      _items.push(_item)
-    }
-    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)
-  }
-
-  async postTx(tx, jwk, items = []) {
-    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 block = {
-      id: tx.id,
-      timestamp: Date.now(),
-      height,
-      previous: last(await this.mem.get("blocks")) ?? "",
-      txs: [],
-    }
-    let msg = null
-    if (items) {
-      for (const item of items) {
-        let _txs = item
-        _txs.parent = { id: tx.id }
-        _txs.bundledIn = { id: tx.id }
-        _txs.anchor = ""
-        const _tags = t(item.tags)
-        if (
-          includes(_tags.Type, [
-            "Message",
-            "Process",
-            "Module",
-            "Scheduler-Location",
-            "Attestation",
-            "Available",
-          ])
-        ) {
-          msg = { id: item.id, type: _tags.Type }
-          if (msg.type === "Process") msg.pid = item.recipient
-        }
-        let data_type = ""
-        for (const v of item.item.tags) {
-          if (v.name === "Content-Type") data_type = v.value
-        }
-        block.txs.push(item.id)
-        _txs.block = block.id
-        await this.mem.set(_txs, "txs", item.id)
-      }
-    }
-    let _tags = []
-    for (const v of tx.tags) {
-      _tags.push({
-        name: base64url.decode(v.name),
-        value: base64url.decode(v.value),
-      })
-    }
-    const __tags = t(_tags)
-    if (__tags.Type === "Module") {
-      await this.mem.set(
-        {
-          data: Buffer.from(tx.data, "base64"),
-          format: __tags["Module-Format"],
-        },
-        "wasms",
-        tx.id,
-      )
-    }
-    tx.tags = _tags
-    tx.owner = await this.arweave.wallets.jwkToAddress({ n: tx.owner })
-    let _txs = tx
-    block.txs.push(tx.id)
-    _txs.block = block.id
-    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")
-    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)
-    }
-    res = { id: tx.id, status: 200, statusText: "200" }
-    if (this.log) {
-      if (msg) {
-        console.log(
-          `New ${msg.type}:\t${msg.id}${msg.pid ? ` > ${msg.pid}` : ""}`,
-        )
-      } else {
-        console.log(`New Post:\t${tx.id}`)
-      }
-    }
-    return { res, err, id: tx.id }
-  }
-
-  async tx(id) {
-    return await this.mem.get("txs", id)
-  }
-
-  async data(id, _string, log) {
-    let decode = true
-    let string = _string
-    if (is(Object, _string)) {
-      if (!isNil(_string.decode)) decode = _string.decode
-      if (!isNil(_string.string)) string = _string.string
-    }
-    let tx = await this.mem.get("txs", id)
-    let _data = tx?.data ?? null
-    if (tx?.format === 2 && _data) {
-      _data = Buffer.from(_data, "base64")
-    } else if (_data) {
-      _data = Buffer.from(base64url.decode(_data))
-    }
-    let isBuf = is(Uint8Array, _data) || is(ArrayBuffer, _data)
-    let isStr = is(String, _data)
-    if (decode === false) {
-      if (isStr) _data = new TextEncoder().encode(_data)
-      return base64url.encode(_data)
-    } else {
-      if (isBuf && string) {
-        return _data.toString()
-      } else if (isStr && string !== true) {
-        return new TextEncoder().encode(_data)
-      }
-    }
-    return _data
+    super({ ...opt, ArMem })
   }
 }
 

package/esm/wao.js

@@ -1,127 +1,10 @@
-import MAO from "./ao.js"
-import { createDataItemSigner } from "@permaweb/aoconnect"
-import { srcs, buildTags } from "./utils.js"
-import AR from "./war.js"
+import BAO from "./bao.js"
 import { connect } from "./aoconnect-web.js"
-import { acc, mu } from "./web.js"
-import { mergeLeft, is, map } from "ramda"
-
-let log = `
-local json = require("json")
-ao = ao or {}
-
-function ao.log(...)
-    local args = {...}
-    local txt = json.encode(args)
-    if type(ao.outbox.Output) == 'string' then
-      ao.outbox.Output = {ao.outbox.Output}
-    end
-    table.insert(ao.outbox.Output, txt)
-    ao.outbox.Logs = ao.outbox.Logs or {}
-    table.insert(ao.outbox.Logs, txt)
-end
-
-function ao.result(result)
-    if ao.outbox.Error or result.Error then
-      return { Error = result.Error or ao.outbox.Error, Output = ao.outbox.Logs }
-    end
-    return {
-        Output = ao.outbox.Logs or result.Output or ao.outbox.Output,
-        Messages = ao.outbox.Messages,
-        Spawns = ao.outbox.Spawns,
-        Assignments = ao.outbox.Assignments,
-    }
-end
-`
-
-const renderLogs = logs => {
-  if (is(Array, logs) && logs.length > 0) {
-    for (const v of logs) {
-      let l = v
-      try {
-        const p = JSON.parse(v)
-        if (JSON.stringify(p) === v) l = p
-        console.log(...l)
-      } catch (e) {
-        console.log(l)
-      }
-    }
-  }
-}
+import AR from "./war.js"
 
-class AO extends MAO {
+class AO extends BAO {
   constructor(opt = {}) {
-    super({ ...opt, in_memory: true })
-    this.in_memory = true
-    const {
-      modules,
-      results,
-      assign,
-      result,
-      message,
-      spawn,
-      dryrun,
-      monitor,
-      unmonitor,
-      mem,
-    } = connect(opt.mem, {
-      extensions: opt.extensions,
-      cache: opt.cache,
-      reset: opt.reset,
-    })
-    this.assign = assign
-    this.result = async (...opt) => {
-      const res = await result(...opt)
-      renderLogs(res.Output)
-      return res
-    }
-
-    this.results = results
-    this.message = message
-    this.spawn = async (...opt) => {
-      const res = await spawn(...opt)
-      await this.load({ data: log, pid: res })
-      return res
-    }
-    this.dryrun = async (...opt) => {
-      const res = await dryrun(...opt)
-      renderLogs(res.Output)
-      return res
-    }
-    this.monitor = monitor
-    this.unmonitor = unmonitor
-    this.mem = mem
-    this.ar = new AR({ mem })
-  }
-
-  async init(jwk) {
-    if (!jwk && this.acc[0]) jwk = this.acc[0].jwk
-    await this.ar.init(jwk)
-    return this
-  }
-
-  async postModule({ data, tags = {}, jwk }) {
-    let err = null
-    ;({ jwk, err } = await this.ar.checkWallet({ jwk }))
-    if (err) return { err }
-    const t = mergeLeft(tags, {
-      "Data-Protocol": "ao",
-      Variant: "ao.TN.1",
-      Type: "Module",
-      "Module-Format": "wasm64-unknown-emscripten-draft_2024_02_15",
-      "Input-Encoding": "JSON-V1",
-      "Output-Encoding": "JSON-V1",
-      "Memory-Limit": "1-gb",
-      "Compute-Limit": "9000000000000",
-    })
-    const signer = createDataItemSigner(jwk)
-    const { id, owner, item } = await this.ar.dataitem({
-      tags: t,
-      data,
-      signer,
-    })
-    await this.ar.postItems(item, jwk)
-    return { id }
+    super({ ...opt, connect, AR })
   }
 }