wao 0.5.6 → 0.6.0

package/esm/tar.js

@@ -3,20 +3,27 @@ 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 ArMem from "./armem.js"
 import GQL from "./tgql.js"
-import { last } from "ramda"
+import { last, is, includes, isNil } from "ramda"
 class AR extends MAR {
   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) {
@@ -26,65 +33,68 @@ class AR extends MAR {
     } else {
       tags = t(di.tags)
     }
-    const raw_owner = di.rawOwner
-    const hashBuffer = Buffer.from(
-      await crypto.subtle.digest("SHA-256", raw_owner),
-    )
-    const owner = base64url.encode(hashBuffer)
+    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)
-    const owner = await this.arweave.wallets.jwkToAddress(jwk)
-    this.mem.addrmap[owner] = { address: owner, key: jwk.n }
-    return await this.postTx(tx, jwk, {
-      recipient: "",
-      tags: _tags,
-      data,
-      owner,
-    })
+    return await this.postTx(tx, jwk)
   }
 
-  async postItem(di, 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)
+      this.mem.addrmap[owner] = { key: di.owner, address: owner }
+      let data = di.data
+      try {
+        data = base64url.decode(di.data)
+      } catch (e) {}
+      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,
+      }
+      this.mem.txs[await di.id] = _item
+      _items.push(_item)
+    }
+    const bundle = await bundleAndSignData(items, new ArweaveSigner(jwk))
     const tx = await this.mem.arweave.createTransaction(
-      { data: di.binary },
+      { data: bundle.binary },
       jwk,
     )
     tx.addTag("Bundle-Format", "binary")
     tx.addTag("Bundle-Version", "2.0.0")
-    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 rowner = di.rawOwner
-    const hashBuffer = Buffer.from(
-      await crypto.subtle.digest("SHA-256", rowner),
-    )
-    const owner = base64url.encode(hashBuffer)
-    this.mem.addrmap[owner] = { key: di.owner, address: owner }
-    let data = di.data
-    try {
-      data = base64url.decode(di.data)
-    } catch (e) {}
-    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,
-    }
-    this.mem.txs[await di.id] = _item
-    return await this.postTx(tx, jwk, _item)
+    return await this.postTx(tx, jwk, _items)
   }
 
-  async postTx(tx, jwk, item) {
-    let [res, err] = [null, null]
+  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)
     this.mem.height += 1
     let block = {
@@ -92,42 +102,51 @@ class AR extends MAR {
       timestamp: Date.now(),
       height: this.mem.height,
       previous: last(this.mem.blocks) ?? "",
+      txs: [],
     }
-    if (item) {
-      if (!item.id) {
-        item.id = tx.id
-        this.mem.txs[tx.id] = item
-        this.mem.txs[tx.id].parent = null
-        this.mem.txs[tx.id].signature = tx.signature
-        this.mem.txs[tx.id].anchor = tx.last_tx
+    let msg = null
+    if (items) {
+      for (const item of items) {
+        this.mem.txs[item.id] = item
+        this.mem.txs[item.id].parent = { id: tx.id }
+        this.mem.txs[item.id].bundledIn = { id: tx.id }
+        this.mem.txs[item.id].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 tx.tags) {
-          if (
-            v.get("name", { decode: true, string: true }) === "Content-Type"
-          ) {
-            data_type = v.get("value", { decode: true, string: true })
-          }
+        for (const v of item.item.tags) {
+          if (v.name === "Content-Type") data_type = v.value
         }
-        this.mem.txs[tx.id]._data = { size: tx.data_size, type: data_type }
-      } else {
-        this.mem.txs[item.id].parent = { id: block.id }
+        //this.mem.txs[tx.id]._data = { size: tx.data_size, type: data_type }
+        block.txs.push(item.id)
+        this.mem.txs[item.id].block = block.id
       }
-      block.txs = [item.id]
-      this.mem.txs[item.id].block = block.id
-    } else {
-      let _tags = []
-      for (const v of tx.tags) {
-        _tags.push({
-          name: base64url.decode(v.name),
-          value: base64url.decode(v.value),
-        })
-      }
-      tx.tags = _tags
-      tx.owner = await this.arweave.wallets.jwkToAddress({ n: tx.owner })
-      this.mem.txs[tx.id] = tx
-      block.txs = [tx.id]
-      this.mem.txs[tx.id].block = block.id
     }
+
+    let _tags = []
+    for (const v of tx.tags) {
+      _tags.push({
+        name: base64url.decode(v.name),
+        value: base64url.decode(v.value),
+      })
+    }
+    tx.tags = _tags
+    tx.owner = await this.arweave.wallets.jwkToAddress({ n: tx.owner })
+    this.mem.txs[tx.id] = tx
+    block.txs.push(tx.id)
+    this.mem.txs[tx.id].block = block.id
     this.mem.blocks.push(block.id)
     this.mem.blockmap[block.id] = block
 
@@ -136,6 +155,15 @@ class AR extends MAR {
       this.mem.addrmap[owner] = { address: owner, key: jwk.n }
     }
     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 }
   }
 
@@ -143,15 +171,27 @@ class AR extends MAR {
     return this.mem.txs[id]
   }
 
-  async data(id, string) {
+  async data(id, _string) {
+    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 = this.mem.txs[id]
-    let _data = this.mem.txs[id]?.data ?? null
-    try {
-      JSON.parse(_data)
-      _data = Buffer.from(_data).toString("base64")
-    } catch (e) {}
-    if (tx.format === 2 && _data && string) {
-      _data = base64url.decode(_data)
+    let _data = tx?.data ?? null
+    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 Buffer.from(_data).toString()
+      } else if (isStr && string !== true) {
+        return new TextEncoder().encode(_data)
+      }
     }
     return _data
   }

package/esm/test.js

@@ -7,7 +7,7 @@ import AR from "./tar.js"
 import GQL from "./tgql.js"
 import ArMem from "./armem.js"
 import { dirname } from "./utils.js"
-import { Src, setup, ok, fail } from "./helpers.js"
+import { Testnet, Src, setup, ok, fail } from "./helpers.js"
 import Server from "./server.js"
 
 const blueprint = async pkg => {
@@ -16,6 +16,7 @@ const blueprint = async pkg => {
 const scheduler = "_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA"
 
 export {
+  Testnet,
   Server,
   GQL,
   ArMem,

package/esm/tgql.js

@@ -8,6 +8,7 @@ const subs = {
   tags: ["name", "value"],
   block: ["id", "timestamp", "height", "previous"],
   parent: ["id"],
+  bundledIn: ["id"],
 }
 const field = (key, val = true) => {
   if (includes(key, ["id", "anchor", "signature", "recipient"])) {
@@ -59,8 +60,11 @@ export default class GQL {
       _block = {}
       if (!isNil(opt.block[0])) _block.min = opt.block[0]
       if (!isNil(opt.block[1])) _block.max = opt.block[1]
+    } else if (is(Object, opt.block)) {
+      if (!isNil(opt.block.min)) _block.min = opt.block.min
+      if (!isNil(opt.block.max)) _block.max = opt.block.max
     }
-    let first = opt.first ?? 20
+    let first = opt.first ?? 10
     let tags = []
     for (const k in opt.tags ?? {}) {
       if (is(String, opt.tags[k])) {
@@ -126,14 +130,18 @@ export default class GQL {
         if (tag_unmatch) continue
         let _tx = {
           cursor: tx.id,
-          ...tx,
+          id: tx.id,
+          recipient: tx.recipient ?? "",
           data: tx._data,
+          tags: tx.tags,
+          parent: tx.parent ?? { id: "" },
+          bundledIn: tx.bundledIn ?? { id: "" },
           block: pick(["id", "timestamp", "height", "previous"], block),
           anchor: tx.anchor ?? "",
           signature: tx.signature ?? "",
           owner: { address: tx.owner, key: this.mem.addrmap[tx.owner] },
-          fee: { ar: "0", winston: "0" },
-          quantity: { ar: "0", winston: "0" },
+          fee: { ar: "0.000000000000", winston: "0" },
+          quantity: { ar: "0.000000000000", winston: "0" },
           data: { size: "0", type: "" },
         }
         if (!isNil(opt.fields)) {

package/esm/utils.js

@@ -1,3 +1,5 @@
+import { graphql, parse, validate, buildSchema } from "graphql"
+
 import { clone, is, includes, fromPairs, map, isNil } from "ramda"
 
 const allows = [
@@ -293,7 +295,232 @@ function isJSON(obj) {
 const jsonToStr = obj =>
   isJSON(obj) || (is(Number, obj) ? Number(obj).toString() : obj)
 
+const schema = buildSchema(`
+type Query {
+  transaction(id: ID!): Transaction
+  transactions(
+    ids: [ID!]
+    owners: [String!]
+    recipients: [String!]
+    tags: [TagFilter!]
+    bundledIn: [ID!]
+    block: BlockFilter
+    first: Int = 10
+    after: String
+    sort: SortOrder = HEIGHT_DESC
+  ): TransactionConnection!
+  block(id: String): Block
+  blocks(
+    ids: [ID!]
+    height: BlockFilter
+    first: Int = 10
+    after: String
+    sort: SortOrder = HEIGHT_DESC
+  ): BlockConnection!
+}
+
+enum SortOrder {
+  HEIGHT_ASC
+  HEIGHT_DESC
+}
+
+input TagFilter {
+  name: String!
+  values: [String!]!
+  op: TagOperator = EQ
+}
+
+input BlockFilter {
+  min: Int
+  max: Int
+}
+
+type BlockConnection {
+  pageInfo: PageInfo!
+  edges: [BlockEdge!]!
+}
+
+type BlockEdge {
+  cursor: String!
+  node: Block!
+}
+
+type TransactionConnection {
+  pageInfo: PageInfo!
+  edges: [TransactionEdge!]!
+}
+
+type TransactionEdge {
+  cursor: String!
+  node: Transaction!
+}
+
+type PageInfo {
+  hasNextPage: Boolean!
+}
+
+type Transaction {
+  id: ID!
+  anchor: String!
+  signature: String!
+  recipient: String!
+  owner: Owner!
+  fee: Amount!
+  quantity: Amount!
+  data: MetaData!
+  tags: [Tag!]!
+  block: Block
+  parent: Parent @deprecated(reason: "Use \`bundledIn\`")
+  bundledIn: Bundle
+}
+
+type Parent {
+  id: ID!
+}
+
+type Bundle {
+  id: ID!
+}
+
+type Block {
+  id: ID!
+  timestamp: Int!
+  height: Int!
+  previous: ID!
+}
+
+type MetaData {
+  size: String!
+  type: String
+}
+
+type Amount {
+  winston: String!
+  ar: String!
+}
+
+type Owner {
+  address: String!
+  key: String!
+}
+
+type Tag {
+  name: String!
+  value: String!
+}
+
+enum TagOperator {
+  EQ
+  NEQ
+}
+`)
+
+const root = {
+  transactions: ({ first }) => ({
+    edges: [],
+    pageInfo: {
+      hasNextPage: false,
+    },
+  }),
+  block: ({ id }) => ({
+    id,
+    timestamp: Date.now(),
+    height: 123456,
+    previous: "previous-block-id",
+    transactions: [],
+    miner: "example-miner",
+    reward: "1000",
+    tags: [],
+    indepHash: "example-indep-hash",
+    nonce: "000000",
+  }),
+}
+
+const mapParsed = (parsedQuery, variables) => {
+  const operation = parsedQuery.definitions[0]
+
+  if (operation.operation !== "query") {
+    throw new Error("Only 'query' operations are supported.")
+  }
+
+  const rootField = operation.selectionSet.selections[0]
+  const rootFieldName = rootField.name.value
+
+  const parseArgumentValue = argValue => {
+    if (argValue.kind === "Variable") {
+      return variables[argValue.name.value]
+    }
+
+    if (argValue.kind === "ListValue") {
+      return argValue.values.map(value => parseArgumentValue(value))
+    }
+
+    if (argValue.kind === "ObjectValue") {
+      return argValue.fields.reduce((obj, field) => {
+        obj[field.name.value] = parseArgumentValue(field.value)
+        return obj
+      }, {})
+    }
+
+    return argValue.value
+  }
+
+  const args = rootField.arguments.reduce((acc, arg) => {
+    acc[arg.name.value] = parseArgumentValue(arg.value)
+    return acc
+  }, {})
+
+  const extractFields = selectionSet => {
+    return selectionSet.selections.map(selection => {
+      const fieldName = selection.name.value
+
+      if (selection.selectionSet) {
+        return {
+          [fieldName]: extractFields(selection.selectionSet),
+        }
+      }
+      return fieldName
+    })
+  }
+
+  const fields = extractFields(rootField.selectionSet)
+
+  return { rootFieldName, args, fields }
+}
+
+const toGraphObj = ({ query, variables }) => {
+  const parsedQuery = parse(query)
+  const errors = validate(schema, parsedQuery)
+  const parsed = mapParsed(parsedQuery, variables)
+  const tar = parsed.rootFieldName
+  let fields = null
+  for (const v of parsed.fields) {
+    if (v.edges) {
+      for (const v2 of v.edges) {
+        if (v2.node) {
+          fields = v2.node
+          break
+        }
+      }
+    }
+  }
+  const args = parsed.args
+  if (args.block) {
+    for (const k in args.block) args.block[k] *= 1
+  }
+  if (args.first) args.first *= 1
+  if (fields) args.fields = fields
+  if (args.sort && args.sort === "HEIGHT_ASC") args.asc = true
+  delete args.sort
+  if (args.tags) {
+    let _tags = {}
+    for (const v of args.tags) _tags[v.name] = v.values
+    args.tags = _tags
+  }
+  return { tar, args }
+}
 export {
+  toGraphObj,
   jsonToStr,
   mergeChecks,
   isCheckComplete,

package/esm/weavedrive.js

@@ -1,10 +1,13 @@
 import Arweave from "arweave"
+import { toGraphObj } from "./utils.js"
+import { map } from "ramda"
+
 const KB = 1024
 const MB = KB * 1024
 const CACHE_SZ = 32 * KB
 const CHUNK_SZ = 128 * MB
 const NOTIFY_SZ = 512 * MB
-
+const log = console.log
 export default class WeaveDrive {
   constructor(ar) {
     this.drive = function WeaveDrive(mod, FS) {
@@ -76,9 +79,9 @@ export default class WeaveDrive {
       var bytesLength = await this.customFetch(`/${id}`, {
         method: "HEAD",
         }).then(res => res.headers.get("Content-Length"))
-      */
+          */
           let data = await ar.data(id)
-          const bytesLength = data ? new TextEncoder().encode(data).length : 100
+          const bytesLength = data?.length ?? 0
           node.total_size = Number(bytesLength)
           node.cache = new Uint8Array(0)
           node.position = 0
@@ -370,11 +373,8 @@ export default class WeaveDrive {
       })
 
       const reader = response.body.getReader()
-      */
-          const data = new TextEncoder().encode(
-            (await ar.data(stream.node.name)) ?? "",
-          )
-
+          */
+          const data = await ar.data(stream.node.name)
           // Extract the Range header to determine the start and end of the requested chunk
           const start = 0
           const end = data.length
@@ -520,7 +520,6 @@ export default class WeaveDrive {
             // CAUTION: If the module is initiated with `mode = test` we don't check availability.
             return true
           }
-
           // Check if we are attempting to load the On-Boot id, if so allow it
           // this was added for AOP 6 Boot loader See: https://github.com/permaweb/aos/issues/342
           const bootTag = this.getTagValue("On-Boot", mod.spawn.tags)
@@ -533,6 +532,7 @@ export default class WeaveDrive {
             mod.module.tags,
           )
           const moduleHasWeaveDrive = moduleExtensions.includes("WeaveDrive")
+
           const processExtensions = this.getTagValues(
             "Extension",
             mod.spawn.tags,
@@ -577,9 +577,9 @@ export default class WeaveDrive {
               ...this.getTagValues("Attestor", mod.spawn.tags),
             ].filter(t => !!t),
           )
-
           // Init a set of GraphQL queries to run in order to find a valid attestation
           // Every WeaveDrive process has at least the "Assignments" availability check form.
+
           const assignmentsHaveID = await this.queryHasResult(
             `query {
           transactions(
@@ -603,10 +603,7 @@ export default class WeaveDrive {
           }
         }`,
           )
-
-          if (assignmentsHaveID) {
-            return true
-          }
+          if (assignmentsHaveID) return true
 
           if (processMode == "Individual") {
             const individualsHaveID = await this.queryHasResult(
@@ -633,9 +630,7 @@ export default class WeaveDrive {
           }`,
             )
 
-            if (individualsHaveID) {
-              return true
-            }
+            if (individualsHaveID) return true
           }
 
           // Halt message processing if the process requires Library mode.
@@ -657,7 +652,7 @@ export default class WeaveDrive {
 
         getTagValues(key, tags) {
           var values = []
-          for (i = 0; i < tags.length; i++) {
+          for (let i = 0; i < tags.length; i++) {
             if (tags[i].name == key) {
               values.push(tags[i].value)
             }
@@ -674,7 +669,6 @@ export default class WeaveDrive {
           const json = await this.gqlQuery(query, variables).then(res =>
             res.json(),
           )
-
           return !!json?.data?.transactions?.edges?.length
         },
 
@@ -695,13 +689,25 @@ export default class WeaveDrive {
         },
 
         async gqlQuery(query, variables) {
-          const options = {
-            method: "POST",
-            body: JSON.stringify({ query, variables }),
-            headers: { "Content-Type": "application/json" },
+          let json = null
+          try {
+            const { tar, args } = toGraphObj({ query, variables })
+            let res2 = null
+            if (tar === "transactions") {
+              res2 = await ar.gql.txs({ ...args })
+            } else if (tar === "blocks") {
+              res2 = await ar.gql.blocks({ ...args })
+            }
+            const edges = map(v => ({ node: v, cursor: v.cursor }), res2)
+            json = {
+              data: {
+                transactions: { pageInfo: { hasNextPage: true }, edges },
+              },
+            }
+          } catch (e) {
+            log(e)
           }
-
-          return this.customFetch("graphql", options)
+          return { json: () => json }
         },
       }
     }