wao 0.9.0 → 0.9.2

package/esm/aoconnect-web.js

@@ -1,484 +1,8 @@
-import * as WarpArBundles from "warp-arbundles"
-const pkg = WarpArBundles.default ?? WarpArBundles
-const { DataItem } = pkg
-
-import crypto from "crypto"
-import base64url from "base64url"
-
-import {
-  tags,
-  action,
-  tag,
-  buildTags,
-  isJSON,
-  jsonToStr,
-  dirname,
-} from "./utils.js"
-import ArMem from "./armem-web.js"
-import weavedrive from "./weavedrive.js"
-import AoLoader from "./ao-loader.js"
-import { scheduler, mu, su, cu, acc } from "./web.js"
-import { is, clone, fromPairs, map, mergeLeft, isNil } from "ramda"
+import base from "./aoconnect-base.js"
 import AR from "./war.js"
+import { mu, su, cu, acc } from "./web.js"
+import AoLoader from "./ao-loader.js"
+import ArMem from "./armem-web.js"
+const scheduler = "_GQ33BkPtZrqxA84vM8Zk-N2aO0toNNu_C-l-rawrBA"
 
-export const connect = (mem, { cache, log = false, extensions = {} } = {}) => {
-  const isMem = mem?.__type__ === "mem"
-  if (!isMem) {
-    let args = { cache }
-    if (mem?.SU_URL) {
-      args = mergeLeft(mem, args)
-      args.scheduler = scheduler
-    }
-    mem = new ArMem(args)
-  }
-  const ar = new AR({ mem, log })
-  for (const k in extensions) extensions[k] = new extensions[k](ar).ext
-  extensions.WeaveDrive = new weavedrive(ar).ext
-
-  const transform = input => {
-    const output = { Tags: [] }
-    if (input.Data) output.Data = input.Data
-    Object.entries(input).forEach(([key, value]) => {
-      if (key !== "Data" && key !== "Tags" && typeof value === "string") {
-        output.Tags.push({ name: key, value })
-      }
-    })
-    input.Tags?.forEach(tag => {
-      const tagKey = Object.keys(tag)[0]
-      const tagValue = tag[tagKey]
-      if (typeof tagValue === "string") {
-        output.Tags.push({ name: tagKey, value: tagValue })
-      }
-    })
-
-    return output
-  }
-
-  const genMsg = async (Id, p, data, Tags, from, Owner, dry = false) => {
-    if (!dry) p.height += 1
-    return {
-      Id,
-      Target: p.id,
-      Owner,
-      Data: data?.length ? data : "",
-      "Block-Height": (await mem.get("height")).toString(),
-      Timestamp: Date.now().toString(),
-      Module: p.module,
-      From: from,
-      Cron: false,
-      Tags: Tags?.length ? Tags : [],
-    }
-  }
-
-  const genEnv = async ({ pid, owner = "", module = "" }) => {
-    return {
-      Process: {
-        Id: pid,
-        Tags: (await mem.get("txs", pid))?.tags ?? [],
-        Owner: owner,
-      },
-      Module: {
-        Id: module,
-        Tags: (await mem.get("txs", module))?.tags ?? [],
-      },
-    }
-  }
-  const spawn = async (opt = {}) => {
-    if (!opt.module) throw Error("module missing")
-    if (!opt.scheduler) throw Error("scheduler missing")
-    const { mod, wasm, format } = await mem.getWasm(opt.module, mem)
-    opt.tags = buildTags(
-      null,
-      mergeLeft(tags(opt.tags ?? []), {
-        "Data-Protocol": "ao",
-        Variant: "ao.TN.1",
-        Type: "Process",
-        SDK: "aoconnect",
-        Module: mod,
-        Scheduler: opt.scheduler,
-        "Content-Type": "text/plain",
-        Authority: mu.addr,
-      }),
-    )
-    let ex = false
-    for (let v of opt.tags) if (v.name === "Type") ex = true
-    if (!ex) opt.tags.push({ name: "Type", value: "Process" })
-    if (opt.for) opt.tags.push({ name: "Pushed-For", value: opt.for })
-    const {
-      id,
-      owner,
-      item,
-      tags: __tags,
-    } = await ar.dataitem({
-      item: opt.item,
-      data: opt.data,
-      signer: opt.signer,
-      tags: tags(opt.tags),
-    })
-    opt.tags = buildTags(null, __tags)
-    if (opt.item) opt.data = base64url.decode(item.data)
-    await ar.postItems(item, su.jwk)
-    const now = Date.now
-    const t = tags(opt.tags)
-    const ext = t.Extension || "WeaveDrive"
-    const wdrive = extensions[ext]
-    let handle = null
-    try {
-      handle = await AoLoader(wasm, {
-        format,
-        WeaveDrive: wdrive,
-        spawn: item,
-        module: await mem.get("txs", mod),
-      })
-    } catch (e) {}
-    if (!handle) return null
-    let _module = null
-    _module = { handle, id: mod }
-    Date.now = now
-    const _tags = tags(opt.tags)
-    let res = null
-    let memory = opt.memory ?? null
-    let p = {
-      extension: ext,
-      item: item?.binary,
-      format,
-      id: id,
-      epochs: [],
-      handle: _module.handle,
-      module: _module.id,
-      hash: id,
-      memory,
-      owner,
-      height: 0,
-      res: { [id]: res },
-      results: [id],
-      txs: [],
-      opt,
-    }
-    if (memory) {
-      // forking...
-    } else if (_tags["On-Boot"] || true) {
-      let data = ""
-      if (_tags["On-Boot"] === "Data") data = opt.data ?? ""
-      else data = (await mem.get("msgs", _tags["On-Boot"]))?.data ?? ""
-      let msg = await genMsg(id, p, data, opt.tags, owner, mu.addr, true)
-      const _env = await genEnv({
-        pid: p.id,
-        owner: p.owner,
-        module: p.module,
-      })
-      res = await _module.handle(null, msg, _env)
-      p.memory = res.Memory
-      delete res.Memory
-      p.res[id] = res
-    } else {
-      p.height += 1
-    }
-    await mem.set(opt, "msgs", id)
-    if (_tags["Cron-Interval"]) {
-      let [num, unit] = _tags["Cron-Interval"].split("-")
-      let int = 0
-      switch (unit.replace(/s$/, "")) {
-        case "millisecond":
-          int = num
-          break
-        case "second":
-          int = num * 1000
-          break
-        case "minute":
-          int = num * 1000 * 60
-          break
-        case "hour":
-          int = num * 1000 * 60 * 60
-          break
-        case "day":
-          int = num * 1000 * 60 * 60 * 24
-          break
-        case "month":
-          int = num * 1000 * 60 * 60 * 24 * 30
-          break
-        case "year":
-          int = num * 1000 * 60 * 60 * 24 * 365
-          break
-      }
-      let cronTags = []
-      for (const k in _tags) {
-        if (/^Cron-Tag-/.test(k)) {
-          cronTags.push({ name: k.replace(/Cron-Tag-/, ""), value: _tags[k] })
-        }
-      }
-      p.cronTags = cronTags
-      p.span = int
-    }
-    await mem.set(p, "env", id)
-    return id
-  }
-
-  function genHashChain(previousHash, previousMessageId = null) {
-    const hasher = crypto.createHash("sha256")
-    hasher.update(Buffer.from(previousHash, "base64"))
-    if (previousMessageId) {
-      hasher.update(Buffer.from(previousMessageId, "base64"))
-    }
-    return base64url(hasher.digest())
-  }
-
-  const assign = async opt => {
-    const p = await mem.get("env", opt.process)
-    if (!p) return null
-    let _opt = await mem.get("msgs", opt.message)
-    let hash = genHashChain(p.hash, opt.message)
-    p.hash = hash
-    opt.tags = buildTags(
-      null,
-      mergeLeft(tags(opt.tags ?? []), {
-        Timestamp: Date.now(),
-        Epoch: p.epochs.length,
-        Nonce: "0",
-        "Data-Protocol": "ao",
-        Variant: "ao.TN.1",
-        SDK: "aoconnect",
-        Type: "Assignment",
-        "Block-Height": await mem.get("height"),
-        Process: opt.process,
-        Message: opt.message,
-        "Hash-Chain": hash,
-      }),
-    )
-    p.epochs.push([opt.message])
-    const { id, owner, item } = await ar.dataitem({
-      data: opt.data,
-      signer: opt.signer,
-      tags: tags(opt.tags),
-      target: opt.process,
-    })
-    if (opt.message_item) {
-      await ar.postItems([opt.message_item, item], su.jwk)
-    } else {
-      await ar.postItems(item, su.jwk)
-    }
-    try {
-      let data = _opt.data ?? ""
-      let _tags = _opt.tags
-      let from = _opt.from ?? opt.from ?? owner
-      if (_opt.item) {
-        try {
-          data = base64url.decode(_opt.item.data)
-          _tags = _opt.item.tags
-          if (!from) {
-            const raw_owner = _opt.item.rawOwner
-            const hashBuffer = Buffer.from(
-              await crypto.subtle.digest("SHA-256", raw_owner),
-            )
-            from = base64url.encode(hashBuffer)
-          }
-        } catch (e) {
-          console.log(e)
-        }
-      }
-      // check: is owner=mu.addr right?
-      const msg = await genMsg(opt.message, p, data, _tags, from, mu.addr)
-      const _env = await genEnv({
-        pid: p.id,
-        owner: p.owner,
-        module: p.module,
-      })
-      if (!p.handle) {
-        const { format, mod, wasm } = await mem.getWasm(p.modulea)
-        const wdrive = extensions[p.extention]
-        p.handle = await AoLoader(wasm, {
-          format,
-          WeaveDrive: wdrive,
-          spawn: new DataItem(p.item),
-          module: await mem.get("txs", mod),
-        })
-        mem.env[opt.process].handle = p.handle
-      }
-      const res = await p.handle(p.memory, msg, _env)
-      p.memory = res.Memory
-      delete res.Memory
-      p.res[opt.message] = res
-      p.results.push(opt.message)
-      p.txs.unshift({ id, ...opt })
-      await mem.set(p, "env", opt.process)
-      await mem.set(_opt, "msgs", opt.message)
-      for (const v of res.Messages ?? []) {
-        if (await mem.get("env", v.Target)) {
-          await message({
-            for: opt.message,
-            process: v.Target,
-            tags: v.Tags,
-            data: v.Data,
-            signer: mu.signer,
-            from: opt.process,
-          })
-        }
-      }
-      for (const v of res.Spawns ?? []) {
-        const __tags = tags(v.Tags)
-        await spawn({
-          for: opt.message,
-          module: __tags.Module,
-          scheduler,
-          tags: v.Tags,
-          data: v.Data,
-          from: __tags["From-Process"],
-          signer: mu.signer,
-        })
-      }
-      for (const v of res.Assignments ?? []) {
-        for (const v2 of v.Processes) {
-          await assign({
-            message: v.Message,
-            process: v2,
-            from: opt.process,
-            signer: mu.signer,
-          })
-        }
-      }
-
-      return id
-    } catch (e) {
-      console.log(e)
-    }
-    return null
-  }
-
-  const message = async opt => {
-    const p = await mem.get("env", opt.process)
-    if (!p) return null
-    let ex = false
-    let id = opt?.item?.id ?? ""
-    let owner = opt.owner ?? ""
-    let item = opt.item
-    if (!opt.item && opt.signer) {
-      for (let v of opt.tags) if (v.name === "Type") ex = true
-      opt.tags = buildTags(
-        null,
-        mergeLeft(tags(opt.tags ?? []), {
-          "Data-Protocol": "ao",
-          Variant: "ao.TN.1",
-          Type: "Message",
-          SDK: "aoconnect",
-        }),
-      )
-      if (opt.for) {
-        opt.tags.push({ name: "Pushed-For", value: opt.for })
-        opt.tags.push({ name: "From-Process", value: opt.from })
-        const pr = (await mem.get("txs", opt.from))?.tags ?? []
-        const module = tags(pr).Module
-        if (module) opt.tags.push({ name: "From-Module", value: module })
-      }
-      ;({ item, id, owner } = await ar.dataitem({
-        data: opt.data,
-        signer: opt.signer,
-        tags: tags(opt.tags),
-        target: opt.process,
-      }))
-    }
-    await mem.set(opt, "msgs", id)
-    await assign({
-      message_item: item,
-      message: id,
-      process: opt.process,
-      from: owner,
-      signer: mu.signer,
-    })
-    return id
-  }
-
-  return {
-    message,
-    unmonitor: async opt => {
-      const p = await mem.get("env", opt.process)
-      try {
-        clearInterval(p.cron)
-        p.cron = null
-      } catch (e) {}
-    },
-    monitor: async opt => {
-      const p = await mem.get("env", opt.process)
-      if (isNil(p.cron)) {
-        p.cron = setInterval(async () => {
-          await message({
-            tags: p.cronTags,
-            process: opt.process,
-            signer: mu.signer,
-            from: mu.addr,
-          })
-        }, p.span)
-      }
-    },
-    spawn,
-    assign,
-    ar,
-    result: async opt => (await mem.get("env", opt.process))?.res[opt.message],
-    results: async opt => {
-      const p = await mem.get("env", opt.process)
-      let results = []
-      const limit = opt.limit ?? 25
-      if (opt.sort === "DESC") {
-        for (let i = p.results.length - 1; 0 < i; i--) {
-          results.push({ cursor: p.results[i], node: p.res[p.results[i]] })
-          if (results.length >= limit) break
-        }
-      } else {
-        for (let i = 0; i < p.results.length; i++) {
-          results.push({ node: p.res[p.results[i]] })
-          if (results.length >= limit) break
-        }
-      }
-      return { edges: results }
-    },
-    dryrun: async opt => {
-      const p = await mem.get("env", opt.process)
-      if (!p) return null
-      let id = opt.id ?? ""
-      let owner = opt.owner ?? ""
-      if (!opt.id && opt.signer) {
-        ;({ id, owner } = await ar.dataitem({ ...opt, target: opt.process }))
-      }
-      try {
-        const msg = await genMsg(
-          id,
-          p,
-          opt.data ?? "",
-          opt.tags,
-          owner,
-          mu.addr,
-          true,
-        )
-        const _env = await genEnv({
-          pid: p.id,
-          owner: p.owner,
-          module: p.module,
-        })
-        function cloneMemory(memory) {
-          const buffer = memory.buffer.slice(0)
-          return new WebAssembly.Memory({
-            initial: memory.buffer.byteLength / 65536,
-            maximum: memory.maximum || undefined,
-            shared: memory.shared || false,
-          })
-        }
-        if (!p.handle) {
-          const { format, mod, wasm } = await mem.getWasm(p.modulea)
-          const wdrive = extensions[p.extention]
-          p.handle = await AoLoader(wasm, {
-            format,
-            WeaveDrive: wdrive,
-            spawn: new DataItem(p.item),
-            module: await mem.get("txs", mod),
-          })
-          mem.env[opt.process].handle = p.handle
-        }
-        const res = await p.handle(p.memory, msg, _env)
-        return res
-      } catch (e) {
-        console.log(e)
-      }
-      return null
-    },
-    mem,
-  }
-}
+export const connect = base({ AR, scheduler, mu, su, cu, acc, AoLoader, ArMem })