wao 0.1.0

package/test/aoconnect.js

@@ -0,0 +1,318 @@
+import { DataItem } from "warp-arbundles"
+import base64url from "base64url"
+import AoLoader from "@permaweb/ao-loader"
+import { readFileSync } from "fs"
+import { resolve } from "path"
+import { is, clone, fromPairs, map, mergeLeft } from "ramda"
+import accounts from "./accounts.js"
+
+function isJSON(obj) {
+  if (obj === null || obj === undefined) return false
+  if (
+    typeof obj !== "object" ||
+    obj instanceof Buffer ||
+    obj instanceof ArrayBuffer ||
+    Array.isArray(obj)
+  ) {
+    return false
+  }
+
+  try {
+    const str = JSON.stringify(obj)
+    const parsed = JSON.parse(str)
+    const isjson = typeof parsed === "object" && parsed !== null
+    return isjson ? str : false
+  } catch (e) {
+    return false
+  }
+}
+
+const jsonToStr = obj =>
+  isJSON(obj) || (is(Number, obj) ? Number(obj).toString() : obj)
+
+const dirname = async () =>
+  typeof __dirname != "undefined"
+    ? __dirname
+    : (await import("./dirname.js")).default
+
+const tags = tags => fromPairs(map(v => [v.name, v.value])(tags))
+const action = value => tag("Action", value)
+const tag = (name, value) => ({ name, value: jsonToStr(value) })
+
+const buildTags = (act, tags) => {
+  let _tags = []
+  if (act) _tags.push(action(act))
+  for (const k in tags) {
+    if (is(Array)(tags[k])) for (const v of tags[k]) _tags.push(tag(k, v))
+    else _tags.push(tag(k, tags[k]))
+  }
+  return _tags
+}
+
+export const connect = () => {
+  let wasms = {
+    T9W7AieZu7VZgv4NsjIGSPZSxGDWlTCixeLuFYo4WCM: {
+      file: "aos2_0_1",
+      format: "wasm64-unknown-emscripten-draft_2024_02_15",
+    },
+  }
+  let modules = {
+    aos_2_0_1: "T9W7AieZu7VZgv4NsjIGSPZSxGDWlTCixeLuFYo4WCM",
+  }
+  let modmap = {}
+  let env = { msgs: {} }
+  let mu = accounts.mu
+  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 = (p, data, Tags, from, owner, dry = false) => {
+    if (!dry) p.height += 1
+    return {
+      Id: p.height,
+      Target: p.id,
+      Owner: owner,
+      Data: data?.length ? data : "",
+      "Block-Height": p.height.toString(),
+      Timestamp: Date.now().toString(),
+      Module: p.module,
+      From: from,
+      Cron: false,
+      Tags: Tags?.length ? Tags : [],
+    }
+  }
+
+  const genEnv = ({ pid, owner = "", module = "", auth = "" }) => {
+    return {
+      Process: {
+        Id: pid,
+        Tags: [
+          { name: "Data-Protocol", value: "ao" },
+          { name: "Variant", value: "ao.TN.1" },
+          { name: "Type", value: "Process" },
+          { name: "Authority", value: auth },
+        ],
+        Owner: owner,
+      },
+      Module: {
+        Id: module,
+        Tags: [
+          { name: "Data-Protocol", value: "ao" },
+          { name: "Variant", value: "ao.TN.1" },
+          { name: "Type", value: "Module" },
+        ],
+      },
+    }
+  }
+
+  const parse = async opt => {
+    const item = await opt.signer({ data: opt.data ?? "", tags: opt.tags })
+    const rowner = new DataItem(item.raw).rawOwner
+    const hashBuffer = Buffer.from(
+      await crypto.subtle.digest("SHA-256", rowner),
+    )
+    const owner = base64url.encode(hashBuffer)
+    return { id: item.id, owner }
+  }
+
+  const postModule = async ({ data, tags = {}, signer }) => {
+    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 _tags = buildTags(t)
+    const { id, owner } = await parse({ tags: _tags, data, signer })
+    const handle = await AoLoader(data, { format: t["Module-Format"] })
+    modmap[id] = { handle, id }
+    return id
+  }
+
+  const message = async opt => {
+    const p = env[opt.process]
+    let ex = false
+    for (let v of opt.tags) {
+      if (v.name === "Type") ex = true
+    }
+    if (!ex) opt.tags.push({ name: "Type", value: "Message" })
+    const { id, owner } = await parse(opt)
+    try {
+      const msg = genMsg(
+        p,
+        opt.data ?? "",
+        opt.tags,
+        opt.from ?? owner,
+        mu.addr,
+      )
+      const _env = genEnv({
+        pid: p.id,
+        owner: p.owner,
+        module: p.module,
+        auth: mu.addr,
+      })
+      const res = await p.handle(p.memory, msg, _env)
+      p.memory = res.Memory
+      delete res.Memory
+      p.res[id] = res
+      p.results.push(id)
+      p.txs.unshift({ id: id, ...opt })
+      env.msgs[id] = opt
+      for (const v of res.Messages ?? []) {
+        if (env[v.Target]) {
+          await message({
+            process: v.Target,
+            tags: v.Tags,
+            data: v.Data,
+            signer: mu.signer,
+            from: opt.process,
+          })
+        }
+      }
+      return id
+    } catch (e) {
+      console.log(e)
+    }
+    return null
+  }
+
+  return {
+    modules,
+    accounts: accounts.users,
+    message,
+    txs: async pid => {
+      let _txs = []
+      for (let v of env[pid].txs) _txs.push({ tags: v.tags, id: v.id })
+      return _txs
+    },
+    spawn: async (opt = {}) => {
+      let mod = opt.module ?? modules["aos_2_0_1"]
+      if (!modmap[mod] && wasms[mod]) {
+        const __dirname = await dirname()
+        const wasm = readFileSync(
+          resolve(__dirname, `lua/${wasms[mod].file}.wasm`),
+        )
+        const handle = await AoLoader(wasm, { format: wasms[mod].format })
+        modmap[mod] = { handle, id: mod }
+      }
+      if (!mod) throw Error("module not found")
+      const _module = modmap[mod]
+      let ex = false
+      opt.tags ??= []
+      for (let v of opt.tags) if (v.name === "Type") ex = true
+      if (!ex) opt.tags.push({ name: "Type", value: "Process" })
+      const { id, owner } = await parse(opt)
+      env.msgs[id] = opt
+      env[id] = {
+        id: id,
+        handle: _module.handle,
+        module: _module.id,
+        memory: null,
+        owner,
+        height: 1,
+        res: { id: null },
+        results: [id],
+        txs: [],
+      }
+      return id
+    },
+    assign: async opt => {
+      const p = env[opt.process]
+      let _opt = clone(env.msgs[opt.message])
+      const { id, owner } = await parse(_opt)
+      try {
+        const msg = genMsg(
+          p,
+          _opt.data ?? "",
+          _opt.tags,
+          _opt.from ?? owner,
+          mu.addr,
+        )
+        const _env = genEnv({
+          pid: p.id,
+          owner: p.owner,
+          module: p.module,
+          auth: mu.addr,
+        })
+        const res = await p.handle(p.memory, msg, _env)
+        p.memory = res.Memory
+        delete res.Memory
+        p.res[id] = res
+        p.results.push(id)
+        p.txs.unshift({ id: id, ..._opt })
+        env.msgs[id] = _opt
+        for (const v of res.Messages ?? []) {
+          if (env[v.Target]) {
+            await message({
+              process: v.Target,
+              tags: v.Tags,
+              data: v.Data,
+              signer: mu.signer,
+              from: opt.process,
+            })
+          }
+        }
+        return id
+      } catch (e) {
+        console.log(e)
+      }
+      return null
+    },
+    result: async opt => env[opt.process].res[opt.message],
+    results: async opt => {
+      const p = 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 = env[opt.process]
+      const { id, owner } = await parse(opt)
+      try {
+        const msg = genMsg(p, opt.data ?? "", opt.tags, owner, mu.addr, true)
+        const _env = genEnv({
+          pid: p.id,
+          owner: p.owner,
+          module: p.module,
+          auth: mu.addr,
+        })
+        const res = await p.handle(p.memory, msg, _env)
+        return res
+      } catch (e) {
+        console.log(e)
+      }
+      return null
+    },
+  }
+}

package/test/ar.js

@@ -0,0 +1,243 @@
+import Arweave from "arweave"
+import { ArweaveSigner, bundleAndSignData, createData } from "arbundles"
+import { buildTags, tag, query, queries, isLocalhost } from "./utils.js"
+import { is } from "ramda"
+
+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"
+    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
+  }
+
+  isArConnect(jwk) {
+    return this.jwk?.id || this.jwk?.walletName === "ArConnect"
+  }
+
+  async init(jwk) {
+    let isGen = false
+    if (!jwk && typeof window === "object") jwk = window.arweaveWallet
+    if (!jwk) isGen = true
+    else {
+      this.jwk = jwk
+      const isWallet = this.isArConnect(this.jwk)
+      if (isWallet) {
+        try {
+          await this.jwk.connect([
+            "ACCESS_ADDRESS",
+            "ACCESS_PUBLIC_KEY",
+            "SIGN_TRANSACTION",
+          ])
+          this.addr = await this.jwk.getActiveAddress()
+          this.pub = await this.jwk.getActivePublicKey()
+          this.isWallet = true
+        } catch (e) {
+          isGen = true
+        }
+      } else {
+        this.addr = await this.toAddr(jwk)
+        this.pub = jwk.n
+      }
+    }
+    if (isGen) {
+      this.isWallet = false
+      this.addr = this.pub = this.jwk = null
+      await this.gen("100")
+    }
+    return this
+  }
+
+  async mine() {
+    await this.arweave.api.get(`/mine`)
+  }
+
+  async checkWallet({ jwk } = {}) {
+    if (jwk) return { err: null, jwk }
+    let [err, addr, pub] = [null, null, null]
+    let existWallet = typeof window === "object" && window.arweaveWallet
+    let isJwkWallet = this.isArConnect(this.jwk)
+    if (!this.jwk) {
+      if (this._jwk) {
+        jwk = this._jwk
+        pub = this._jwk.n
+        addr = await this.toAddr(jwk)
+      } else {
+        ;({ jwk, addr, pub } = await this.gen("100", false))
+      }
+    } else if (this.jwk && !isJwkWallet) {
+      jwk = this.jwk
+      addr = this.addr
+      pub = this.pub
+    } else if (existWallet) {
+      await arweaveWallet.connect([
+        "ACCESS_ADDRESS",
+        "ACCESS_PUBLIC_KEY",
+        "SIGN_TRANSACTION",
+      ])
+      const _addr = await arweaveWallet.getActiveAddress()
+      if (_addr) {
+        if (this.addr && this.addr !== _addr) err = "the wrong wallet"
+        else {
+          addr = _addr
+          pub = await arweaveWallet.getActivePublicKey()
+          jwk = arweaveWallet
+        }
+      } else {
+        err = "no wallet found"
+      }
+    } else {
+      err = "no wallet found"
+    }
+    return { addr, jwk, pub, err }
+  }
+
+  async balance(addr = this.addr) {
+    if (!addr) {
+      ;({ addr } = await this.checkWallet())
+    }
+    return this.toAR(await this.arweave.wallets.getBalance(addr))
+  }
+
+  async mint(addr, amount = "1.0") {
+    await this.arweave.api.get(`/mint/${addr}/${this.toWinston(amount)}`)
+    await this.mine()
+    return await this.balance(addr)
+  }
+
+  toWinston(ar) {
+    return this.arweave.ar.arToWinston(ar)
+  }
+
+  toAR(w) {
+    return this.arweave.ar.winstonToAr(w)
+  }
+
+  async toAddr(jwk) {
+    ;({ jwk } = await this.checkWallet({ jwk }))
+    if (this.isArConnect(jwk)) return await jwk.getActiveAddress()
+    else {
+      return await this.arweave.wallets.jwkToAddress(jwk)
+    }
+  }
+
+  async gen(amount, overwrite) {
+    const jwk = await this.arweave.wallets.generate()
+    const addr = await this.toAddr(jwk)
+    if (overwrite === false) {
+      this._jwk = jwk
+    } else if (!this.jwk || overwrite) {
+      this.jwk = jwk
+      this.pub = jwk.n
+      this.addr = addr
+      this.isWallet = false
+    }
+    let bal = "0"
+    if (amount && isLocalhost(this.host)) bal = await this.mint(addr, amount)
+    return { jwk, addr, pub: jwk.n, bal }
+  }
+
+  async transfer(ar, target, jwk) {
+    let err = null
+    ;({ jwk, err } = await this.checkWallet({ jwk }))
+    if (err) return { err }
+    else {
+      let tx = await this.arweave.createTransaction({
+        target,
+        quantity: this.toWinston(ar),
+      })
+      return await this.postTx(tx, jwk)
+    }
+  }
+
+  async bundle(_items, jwk) {
+    let err = null
+    ;({ jwk, err } = await this.checkWallet({ jwk }))
+    if (err) return { err }
+    else {
+      const signer = new ArweaveSigner(jwk)
+      const items = _items.map(v => {
+        let tags = []
+        for (const k in v[1] && {}) {
+          if (is(Array)(v[1][k])) {
+            for (const v of v[1][k]) tags.push(tag(k, v))
+          } else {
+            tags.push(tag(k, v[1][k]))
+          }
+        }
+        return createData(v[0], signer, { tags, ...(v[2] ?? {}) })
+      })
+      const bundle = await bundleAndSignData(items, signer)
+      const tx = await bundle.toTransaction({}, this.arweave, jwk)
+      await this.postTx(tx, jwk)
+      return { err, items, tx, id: tx.id }
+    }
+  }
+
+  async post({ data = "1984", tags = {}, jwk }) {
+    let err = null
+    ;({ err, jwk } = await this.checkWallet({ jwk }))
+    if (err) return { err }
+    else {
+      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 this.postTx(tx, jwk)
+    }
+  }
+
+  async postTx(tx, jwk) {
+    let [res, err] = [null, null]
+    ;({ err, jwk } = await this.checkWallet({ jwk }))
+    if (!err) {
+      if (this.isArConnect(jwk)) tx = await jwk.sign(tx)
+      else {
+        await this.arweave.transactions.sign(tx, jwk)
+      }
+      res = await this.arweave.transactions.post(tx)
+      if (res.status !== 200) err = res.statusText
+      if (isLocalhost(this.host)) await this.mine()
+    }
+    return { res, err, id: tx.id }
+  }
+
+  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)
+  }
+
+  async data(txid, string = false) {
+    return await this.arweave.transactions.getData(txid, {
+      decode: true,
+      string,
+    })
+  }
+}
+
+export default AR

package/test/dirname.js

@@ -0,0 +1 @@
+export default import.meta.dirname

package/test/helpers.js

@@ -0,0 +1,161 @@
+import { AR, AO } from "./index.js"
+import assert from "assert"
+import { createDataItemSigner, connect } from "@permaweb/aoconnect"
+import { dirname as _dirname, resolve } from "path"
+import { mkdirSync, existsSync, writeFileSync, readFileSync } from "fs"
+import yargs from "yargs"
+
+let {
+  reset = false,
+  cache = false,
+  auth = null,
+} = yargs(process.argv.slice(2)).argv
+
+const dirname = async () =>
+  typeof __dirname != "undefined"
+    ? __dirname
+    : (await import("./dirname.js")).default
+
+export class Src {
+  constructor({ ar, dir } = {}) {
+    this.ar = ar
+    this.dir = dir
+    if (!dir) dirname().then(v => (this.dir = v))
+  }
+  data(file, ext = "lua") {
+    return readFileSync(
+      `${this.dir}/${file}.${ext}`,
+      ext === "wasm" ? null : "utf8",
+    )
+  }
+  async upload(file, ext = "lua") {
+    const res = await this.ar.post({ data: this.data(file, ext) })
+    return res.err ? null : res.id
+  }
+}
+
+export const setup = async ({
+  aoconnect,
+  arweave,
+  cacheDir = ".cache",
+  targets = { profile: false, note: false, asset: false },
+} = {}) => {
+  if (targets.asset || targets.note) targets.profile = true
+  let opt = null
+  console.error = () => {}
+  console.warn = () => {}
+  const dir = resolve(await dirname(), "lua")
+  const _cacheDir = resolve(await dirname(), cacheDir)
+  const optPath = `${_cacheDir}/opt.json`
+  if (cache && !reset) {
+    try {
+      if (existsSync(optPath)) {
+        opt = JSON.parse(readFileSync(optPath, "utf8"))
+      } else {
+        console.log("cache doesn't exist:", optPath)
+      }
+    } catch (e) {
+      console.log(e)
+    }
+  }
+
+  if (opt) {
+    const ar = await new AR(opt.ar).init(opt.jwk)
+    const src = new Src({ ar, readFileSync, dir })
+    const ao = await new AO(opt.ao).init(opt.jwk)
+    const ao2 = await new AO(opt.ao2).init(opt.jwk)
+    console.log("cache:\t", optPath)
+    console.log("addr:\t", ar.addr)
+    return { opt, ar, ao2, ao, src }
+  }
+
+  // ar
+  arweave ??= { port: 4000 }
+  aoconnect ??= {
+    MU_URL: "http://localhost:4002",
+    CU_URL: "http://localhost:4004",
+    GATEWAY_URL: "http://localhost:4000",
+  }
+  const ar = new AR(arweave)
+  await ar.gen("10")
+  const src = new Src({ ar, readFileSync, dir })
+  opt = { ar: { ...arweave }, jwk: ar.jwk }
+  if (!auth && /localhost/.test(aoconnect?.CU_URL ?? "")) {
+    auth = (await fetch(aoconnect.CU_URL).then(r => r.json())).address
+  }
+
+  // ao
+  const wasm = await src.upload("aos-sqlite", "wasm")
+  const wasm2 = await src.upload("aos", "wasm")
+  const wasm_aos2 = await src.upload("aos2_0_1", "wasm")
+
+  const ao = new AO({ aoconnect, ar, authority: auth })
+  const { id: module_aos2 } = await ao.postModule({
+    data: await ar.data(wasm_aos2),
+  })
+
+  const { id: module_sqlite } = await ao.postModule({
+    data: await ar.data(wasm),
+    overwrite: true,
+  })
+
+  const { id: module } = await ao.postModule({
+    data: await ar.data(wasm2),
+    overwrite: true,
+  })
+
+  const { scheduler } = await ao.postScheduler({
+    url: "http://su",
+    overwrite: true,
+  })
+  opt.ao = {
+    module: module_sqlite,
+    scheduler,
+    aoconnect,
+    ar: opt.ar,
+    authority: auth,
+  }
+
+  // ao2
+  const ao2 = await new AO({
+    aoconnect,
+    ar,
+    authority: auth,
+    module: module_aos2,
+    scheduler,
+  }).init(ar.jwk)
+
+  opt.ao2 = {
+    module: module_aos2,
+    scheduler,
+    aoconnect,
+    ar: opt.ar,
+    authority: auth,
+  }
+
+  if (auth) opt.ao.authority = auth
+  opt.authority = auth
+  opt.targets = targets
+  opt.modules = {
+    aos2: module_aos2,
+    aos1: module,
+    sqlite: module_sqlite,
+  }
+  if (cache) {
+    if (!existsSync(_cacheDir)) mkdirSync(_cacheDir)
+    writeFileSync(optPath, JSON.stringify(opt))
+  }
+  return { opt, ao, ar, src, ao2 }
+}
+
+export const ok = obj => {
+  if (obj.err) console.log(obj.err)
+  assert.equal(obj.err, null)
+  return obj
+}
+
+export const fail = obj => {
+  if (!obj.err) console.log(obj.res)
+  assert.notEqual(obj.err, null)
+  return obj
+}