wao 0.3.1 → 0.4.1

package/esm/ar.js

@@ -1,21 +1,25 @@
 import Arweave from "arweave"
 import { ArweaveSigner, bundleAndSignData, createData } from "arbundles"
-import { buildTags, tag, query, queries, isLocalhost } from "./utils.js"
+import { buildTags, tag, isLocalhost } from "./utils.js"
 import { is } from "ramda"
+import GQL from "./gql.js"
 
 class AR {
   constructor({ host, port = 443, protocol } = {}) {
     this.__type__ = "ar"
     let _arweave = { host, port, protocol }
     if (!_arweave.host)
-      _arweave.host = port === 443 ? "arweave.net" : "127.0.0.1"
+      _arweave.host = port === 443 ? "arweave.net" : "localhost"
     if (!_arweave.protocol)
       _arweave.protocol = isLocalhost(_arweave.host) ? "http" : "https"
     if (!_arweave.port) _arweave.port = isLocalhost(_arweave.host) ? 1984 : 443
     this.port = _arweave.port
-    this.arweave = Arweave.init(_arweave)
     this.host = _arweave.host
     this.protocol = _arweave.protocol
+    this.arweave = Arweave.init(_arweave)
+    this.gql = new GQL({
+      url: `${_arweave.protocol}://${_arweave.host}:${_arweave.port}/graphql`,
+    })
   }
 
   isArConnect(jwk) {
@@ -211,27 +215,7 @@ class AR {
   }
 
   async tx(txid) {
-    const json = await fetch(
-      `${this.protocol}://${this.host}:${this.port}/graphql`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ query: query(txid) }),
-      },
-    ).then(r => r.json())
-    return json.data.transactions.edges.map(v => v.node)[0] ?? null
-  }
-
-  async txs(to) {
-    const json = await fetch(
-      `${this.protocol}://${this.host}:${this.port}/graphql`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ query: queries(to) }),
-      },
-    ).then(r => r.json())
-    return json.data.transactions.edges.map(v => v.node)
+    return (await this.gql.txs({ id: txid }))[0] ?? null
   }
 
   async data(txid, string = false) {

package/esm/armem.js

@@ -0,0 +1,42 @@
+import Arweave from "arweave"
+import { last } from "ramda"
+
+export default class ArMem {
+  constructor() {
+    this.__type__ = "mem"
+    this.arweave = Arweave.init()
+    this.arweave.transactions.getTransactionAnchor = () => {
+      return this.blocks.length === 0
+        ? ""
+        : last(this.blockmap[last(this.blocks)].txs)
+    }
+    this.arweave.transactions.getPrice = () => 0
+    this.txs = {}
+    this.jwks = {}
+    this.height = 0
+    this.blocks = []
+    this.blockmap = {}
+    this.env = {}
+    this.modules = {
+      aos2_0_1: "Do_Uc2Sju_ffp6Ev0AnLVdPtot15rvMjP-a9VVaA5fM",
+      aos1: "cNlipBptaF9JeFAf4wUmpi43EojNanIBos3EfNrEOWo",
+      sqlite: "ghSkge2sIUD_F00ym5sEimC63BDBuBrq4b5OcwxOjiw",
+    }
+    this.modmap = {}
+    this.msgs = {}
+    this.wasms = {
+      "Do_Uc2Sju_ffp6Ev0AnLVdPtot15rvMjP-a9VVaA5fM": {
+        file: "aos2_0_1",
+        format: "wasm64-unknown-emscripten-draft_2024_02_15",
+      },
+      cNlipBptaF9JeFAf4wUmpi43EojNanIBos3EfNrEOWo: {
+        file: "aos_1",
+        format: "wasm64-unknown-emscripten-draft_2024_02_15",
+      },
+      ghSkge2sIUD_F00ym5sEimC63BDBuBrq4b5OcwxOjiw: {
+        file: "sqlite",
+        format: "wasm64-unknown-emscripten-draft_2024_02_15",
+      },
+    }
+  }
+}

package/esm/gql.js

@@ -0,0 +1,219 @@
+import { includes, map, is, isNil, last, clone } from "ramda"
+
+const full = `id anchor signature recipient owner { address key } fee { winston ar } quantity { winston ar } data { size type } tags { name value } block { id timestamp height previous } parent { id }`
+const full_blocks = `id timestamp height previous`
+
+const subs = {
+  owner: ["address", "key"],
+  fee: ["winston", "ar"],
+  quantity: ["winston", "ar"],
+  data: ["size", "type"],
+  tags: ["name", "value"],
+  block: ["id", "timestamp", "height", "previous"],
+  parent: ["id"],
+}
+const field = (key, val = true) => {
+  if (includes(key, ["id", "anchor", "signature", "recipient"])) {
+    return key
+  } else if (subs[key]) {
+    let _subs = []
+    if (val === true) val = subs[key]
+    else if (is(Object, val) && !is(Array, val)) {
+      let _val = []
+      let isTrue = false
+      let isFalse = false
+      for (const k in val)
+        if (val[k] === true) isTrue = true
+        else if (val[k] === false) isFalse = true
+      if (!isTrue && isFalse) {
+        for (const k of subs[key]) if (val[k] !== false) _val.push(k)
+      } else {
+        for (const k in val) if (val[k] === true) _val.push(k)
+      }
+      val = _val
+    } else if (!is(Array, val)) val = subs[key]
+    for (const v2 of val) {
+      if (is(String, v2) && includes(v2, subs[key])) _subs.push(v2)
+    }
+    if (_subs.length === 0) return null
+    return `${key} { ${_subs.join(" ")} }`
+  }
+  return null
+}
+
+const field_blocks = (key, val = true) => {
+  if (includes(key, ["id", "timestamp", "height", "previous"])) {
+    return key
+  }
+  return null
+}
+
+const query = (opt = {}) => {
+  let cond = []
+  let tags = []
+  for (const k in opt.tags ?? {}) {
+    if (is(String, opt.tags[k])) {
+      tags.push(`{ name: "${k}", values: ["${opt.tags[k]}"] }`)
+    } else if (is(Array, opt.tags[k])) {
+      tags.push(
+        `{ name: "${k}", values: [${map(v => `"${v}"`, opt.tags[k]).join(", ")}] }`,
+      )
+    }
+  }
+  if (tags.length > 0) cond.push(`tags: [${tags.join(", ")}]`)
+  let recipients = null
+  if (is(Array, opt.recipients)) recipients = opt.recipients
+  else if (is(String, opt.recipient)) recipients = [opt.recipient]
+  if (!isNil(recipients) && recipients.length > 0) {
+    cond.push(`recipients: [${map(v => `"${v}"`, recipients).join(", ")}]`)
+  }
+
+  let owners = null
+  if (is(Array, opt.owners)) owners = opt.owners
+  else if (is(String, opt.owner)) owners = [opt.owner]
+  if (!isNil(owners) && owners.length > 0) {
+    cond.push(`owners: [${map(v => `"${v}"`, owners).join(", ")}]`)
+  }
+
+  let ids = null
+  if (is(Array, opt.ids)) ids = opt.ids
+  else if (is(String, opt.id)) ids = [opt.id]
+  if (!isNil(ids) && ids.length > 0) {
+    cond.push(`ids: [${map(v => `"${v}"`, ids).join(", ")}]`)
+  }
+
+  let _block = opt.block
+  if (is(Number, opt.block)) {
+    _block = { min: opt.block, max: opt.block }
+  } else if (is(Array, opt.block) && opt.block.length > 0) {
+    _block = {}
+    if (!isNil(opt.block[0])) _block.min = opt.block[0]
+    if (!isNil(opt.block[1])) _block.max = opt.block[1]
+  }
+  if (!isNil(_block?.max) || !isNil(_block?.min)) {
+    let block = []
+    if (!isNil(_block.min)) block.push(`min: ${_block.min}`)
+    if (!isNil(_block.max)) block.push(`max: ${_block.max}`)
+    if (block.length > 0) cond.push(`block : {${block.join(", ")}}`)
+  }
+  if (opt.first) cond.push(`first: ${opt.first}`)
+  if (opt.after) cond.push(`after: "${opt.after}"`)
+  if (opt.asc) cond.push(`sort: HEIGHT_ASC`)
+
+  let _cond = ""
+  if (cond.length > 0) _cond = `(${cond.join(", ")})`
+  let fields = []
+  if (is(Array, opt.fields) && opt.fields.length > 0) {
+    for (const v of opt.fields) {
+      if (is(String, v)) {
+        const fld = field(v)
+        if (fld) fields.push(fld)
+      } else if (is(Object, v) && !is(Array, v)) {
+        for (const k in v) {
+          const fld = field(k, v[k])
+          if (fld) fields.push(fld)
+        }
+      }
+    }
+  } else if (is(Object, opt.fields) && !is(Array, opt.fields)) {
+    for (const k in opt.fields) {
+      const fld = field(k, opt.fields[k])
+      if (fld) fields.push(fld)
+    }
+  }
+  let _fields = fields.length > 0 ? fields.join(" ") : full
+  return `query {
+  transactions ${_cond}{
+    edges { cursor node { ${_fields} } }
+  }
+}`
+}
+
+const query_blocks = (opt = {}) => {
+  let cond = []
+
+  let _height = opt.height
+  if (is(Number, opt.height)) {
+    _height = { min: opt.height, max: opt.height }
+  } else if (is(Array, opt.height) && opt.height.length > 0) {
+    _height = {}
+    if (!isNil(opt.height[0])) _height.min = opt.height[0]
+    if (!isNil(opt.height[1])) _height.max = opt.height[1]
+  }
+  if (!isNil(_height?.max) || !isNil(_height?.min)) {
+    let height = []
+    if (!isNil(_height.min)) height.push(`min: ${_height.min}`)
+    if (!isNil(_height.max)) height.push(`max: ${_height.max}`)
+    if (height.length > 0) cond.push(`height : {${height.join(", ")}}`)
+  }
+
+  if (opt.first) cond.push(`first: ${opt.first}`)
+  if (opt.after) cond.push(`after: "${opt.after}"`)
+  if (opt.asc) cond.push(`sort: HEIGHT_ASC`)
+
+  let _cond = ""
+  if (cond.length > 0) _cond = `(${cond.join(", ")})`
+  let fields = []
+  if (is(Array, opt.fields) && opt.fields.length > 0) {
+    let fields = []
+    for (const v of opt.fields) {
+      if (is(String, v)) {
+        const fld = field_blocks(v)
+        if (fld) fields.push(fld)
+      } else if (is(Object, v) && !is(Array, v)) {
+        for (const k in v) {
+          const fld = field_blocks(k, v[k])
+          if (fld) fields.push(fld)
+        }
+      }
+    }
+  } else if (is(Object, opt.fields) && !is(Array, opt.fields)) {
+    for (const k in opt.fields) {
+      const fld = field_blocks(k, opt.fields[k])
+      if (fld) fields.push(fld)
+    }
+  }
+  let _fields = fields.length > 0 ? fields.join(" ") : full_blocks
+  return `query {
+  blocks ${_cond}{
+    edges { cursor node { ${_fields} } }
+  }
+}`
+}
+
+export default class GQL {
+  constructor({ url = "https://arweave.net/graphql" }) {
+    this.url = url
+  }
+  async _fetch(query, tar) {
+    const json = await fetch(this.url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query }),
+    }).then(r => r.json())
+    return map(v => ({ cursor: v.cursor, ...v.node }))(json.data[tar].edges)
+  }
+  async fetch(opt = {}, query, tar = "transactions") {
+    const data = await this._fetch(query, tar)
+    if (opt.next === true) {
+      let cursor = null
+      if (data.length > 0) cursor = last(data).cursor
+      const next = !cursor
+        ? null
+        : async () => {
+            let _opt = clone(opt)
+            _opt.after = cursor
+            return await this.txs(_opt)
+          }
+      return { data, next }
+    } else {
+      return data
+    }
+  }
+  async txs(opt = {}) {
+    return await this.fetch(opt, query(opt))
+  }
+  async blocks(opt = {}) {
+    return await this.fetch(opt, query_blocks(opt), "blocks")
+  }
+}

package/esm/index.js

@@ -1,4 +1,5 @@
 import AR from "./ar.js"
 import AO from "./ao.js"
+import GQL from "./gql.js"
 
-export { AO, AR }
+export { AO, AR, GQL }

package/esm/tao.js

@@ -1,14 +1,13 @@
 import MAO from "./ao.js"
 import { srcs } from "./utils.js"
-import AR from "./ar.js"
+import AR from "./tar.js"
 import { connect } from "./aoconnect.js"
-
+import { acc } from "./test.js"
 class AO extends MAO {
   constructor(opt = {}) {
     super({ ...opt, in_memory: true })
     this.in_memory = true
     const {
-      accounts,
       modules,
       results,
       assign,
@@ -18,23 +17,22 @@ class AO extends MAO {
       dryrun,
       monitor,
       unmonitor,
-      txs,
-    } = connect()
-    this.module = modules.aos2_0_1
+      mem,
+    } = connect(opt.mem)
+    this.module = mem.modules.aos2_0_1
     this.assign = assign
     this.result = result
     this.results = results
     this.message = message
     this.spawn = spawn
     this.dryrun = dryrun
-    this.ar.txs = txs
     this.monitor = monitor
     this.unmonitor = unmonitor
-    this.accounts = accounts
+    this.ar = new AR({ mem })
   }
 
   async init(jwk) {
-    if (!jwk && this.accounts?.[0]) jwk = this.accounts[0].jwk
+    if (!jwk && this.acc[0]) jwk = this.acc[0].jwk
     await this.ar.init(jwk)
     return this
   }

package/esm/tar.js

@@ -0,0 +1,106 @@
+import MAR from "./ar.js"
+import { buildTags } from "./utils.js"
+import { DataItem } from "warp-arbundles"
+import base64url from "base64url"
+import ArMem from "./armem.js"
+import GQL from "./tgql.js"
+import { last } from "ramda"
+class AR extends MAR {
+  constructor(opt = {}) {
+    super({ ...opt, in_memory: true })
+    this.in_memory = true
+    this.mem = opt.mem ?? new ArMem()
+    this.gql = new GQL({ mem: this.mem })
+    this.arweave = this.mem.arweave
+  }
+
+  async dataitem({ target = "", data = "1984", tags = {}, signer }) {
+    const _tags = buildTags(tags)
+    const item = await signer({ data, tags: _tags, target })
+    const di = new DataItem(item.raw)
+    const raw_owner = di.rawOwner
+    const hashBuffer = Buffer.from(
+      await crypto.subtle.digest("SHA-256", raw_owner),
+    )
+    const owner = base64url.encode(hashBuffer)
+    return { id: item.id, owner, item }
+  }
+
+  async post({ data = "1984", tags = {}, jwk }) {
+    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, {
+      recipient: "",
+      tags: _tags,
+      data,
+      owner: await this.arweave.wallets.jwkToAddress(jwk),
+    })
+  }
+
+  async postItem(item, jwk) {
+    const tx = await this.mem.arweave.createTransaction({ data: item.raw }, jwk)
+    tx.addTag("Bundle-Format", "binary")
+    tx.addTag("Bundle-Version", "2.0.0")
+    const di = new DataItem(item.raw)
+    const rowner = di.rawOwner
+    const hashBuffer = Buffer.from(
+      await crypto.subtle.digest("SHA-256", rowner),
+    )
+    const owner = base64url.encode(hashBuffer)
+    let data = di.data
+    try {
+      data = base64url.decode(di.data)
+    } catch (e) {}
+    let _item = {
+      recipient: di.target,
+      id: item.id,
+      item: di,
+      owner,
+      tags: di.tags,
+      data,
+    }
+    this.mem.txs[item.id] = _item
+    return await this.postTx(tx, jwk, _item)
+  }
+
+  async postTx(tx, jwk, item) {
+    let [res, err] = [null, null]
+    await this.mem.arweave.transactions.sign(tx, jwk)
+    if (item) {
+      this.mem.height += 1
+
+      const block = {
+        id: tx.id,
+        timestamp: Date.now(),
+        height: this.mem.height,
+        previous: last(this.mem.blocks) ?? "",
+      }
+
+      if (!item.id) {
+        item.id = tx.id
+        this.mem.txs[item.id] = item
+        this.mem.txs[item.id].parent = { id: block.id }
+      } else {
+        this.mem.txs[item.id].parent = { id: "" }
+      }
+      block.txs = [item.id]
+      this.mem.txs[item.id].block = block.id
+      this.mem.txs[item.id].parent = { id: block.id }
+      this.mem.blocks.push(block.id)
+      this.mem.blockmap[block.id] = block
+    }
+    res = { id: tx.id, status: 200, statusText: "200" }
+    return { res, err, id: tx.id }
+  }
+
+  tx(id) {
+    return this.mem.txs[id]
+  }
+
+  data(id) {
+    return this.mem.txs[id].data
+  }
+}
+
+export default AR

package/esm/test.js

@@ -1,3 +1,14 @@
-import { connect, acc, mu } from "./aoconnect.js"
+import { readFileSync } from "fs"
+import { resolve } from "path"
+import { acc, mu, su, cu } from "./accounts.js"
+import { connect } from "./aoconnect.js"
 import AO from "./tao.js"
-export { AO, connect, acc, mu }
+import AR from "./tar.js"
+import { dirname } from "./utils.js"
+
+const blueprint = async pkg => {
+  return readFileSync(resolve(await dirname(), `lua/${pkg}.lua`), "utf8")
+}
+const scheduler = "GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA"
+
+export { AO, AR, connect, acc, mu, su, cu, blueprint, scheduler }