@johannc-dev/zyrk 0.0.0-stage → 0.2.0

package/dist/sandbox-bootstrap.js

@@ -0,0 +1,519 @@
+(function(N) {
+  "use strict";
+  const g = globalThis;
+  const stringify = JSON.stringify.bind(JSON);
+  const parse = JSON.parse.bind(JSON);
+  const freeze = Object.freeze;
+  const keys = Object.keys;
+  const entries = Object.entries;
+  const hasOwn = Object.prototype.hasOwnProperty;
+  const isArray = Array.isArray;
+  const ErrorCtor = Error;
+  const StringCtor = String;
+  const asyncIterator = Symbol.asyncIterator;
+  const fail = N.fail;
+  const typeOf = (v) => v === null ? "null" : typeof v;
+  for (const name of ["WebAssembly", "SharedArrayBuffer", "FinalizationRegistry"])
+    delete g[name];
+  const define = (name, value) => Object.defineProperty(g, name, { value, writable: true, configurable: true, enumerable: false });
+  const jsonSafe = (v) => {
+    if (v instanceof ErrorCtor) return StringCtor(v.stack ?? v);
+    try {
+      const text = stringify(v, (_k, x) => typeof x === "bigint" ? x.toString() : x);
+      return text === void 0 ? StringCtor(v) : parse(text);
+    } catch {
+      return StringCtor(v);
+    }
+  };
+  const print = (...args) => {
+    const value = args.length === 1 ? jsonSafe(args[0]) : args.map(jsonSafe);
+    N.op(stringify({ Log: { value } }), false);
+  };
+  define(
+    "console",
+    freeze({ log: print, info: print, warn: print, error: print, debug: print, trace: print })
+  );
+  class TextEncoder {
+    get encoding() {
+      return "utf-8";
+    }
+    encode(input = "") {
+      return N.encode(StringCtor(input));
+    }
+    encodeInto(input, dest) {
+      if (!(dest instanceof Uint8Array)) throw new TypeError("encodeInto expects a Uint8Array");
+      const text = StringCtor(input);
+      let read = 0;
+      let written = 0;
+      for (const ch of text) {
+        const bytes = N.encode(ch);
+        if (written + bytes.length > dest.length) break;
+        dest.set(bytes, written);
+        written += bytes.length;
+        read += ch.length;
+      }
+      return { read, written };
+    }
+  }
+  class TextDecoder {
+    #fatal;
+    #ignoreBOM;
+    constructor(label = "utf-8", options = {}) {
+      const name = StringCtor(label).trim().toLowerCase();
+      if (name !== "utf-8" && name !== "utf8" && name !== "unicode-1-1-utf-8")
+        throw new RangeError("Only utf-8 is supported");
+      this.#fatal = !!(options && options.fatal);
+      this.#ignoreBOM = !!(options && options.ignoreBOM);
+    }
+    get encoding() {
+      return "utf-8";
+    }
+    get fatal() {
+      return this.#fatal;
+    }
+    get ignoreBOM() {
+      return this.#ignoreBOM;
+    }
+    decode(input = new Uint8Array(0), options = {}) {
+      if (options && options.stream) throw new TypeError("Streaming decode is not supported");
+      let view;
+      if (input instanceof ArrayBuffer) view = new Uint8Array(input);
+      else if (ArrayBuffer.isView(input))
+        view = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+      else throw new TypeError("decode expects an ArrayBuffer or a view");
+      return N.decode(view, this.#fatal, this.#ignoreBOM);
+    }
+  }
+  define("TextEncoder", TextEncoder);
+  define("TextDecoder", TextDecoder);
+  const cloneError = (message) => {
+    const e = new ErrorCtor(message);
+    e.name = "DataCloneError";
+    return e;
+  };
+  const TypedArray = Object.getPrototypeOf(Uint8Array);
+  const structuredClone = (value) => {
+    const seen = /* @__PURE__ */ new Map();
+    const walk = (v) => {
+      const t = typeof v;
+      if (t === "function" || t === "symbol") throw cloneError(t + " cannot be cloned");
+      if (v === null || t !== "object") return v;
+      if (seen.has(v)) return seen.get(v);
+      let out;
+      if (isArray(v)) {
+        out = new Array(v.length);
+        seen.set(v, out);
+        for (const k of keys(v)) out[k] = walk(v[k]);
+        return out;
+      }
+      if (v instanceof Date) out = new Date(v.getTime());
+      else if (v instanceof RegExp) out = new RegExp(v.source, v.flags);
+      else if (v instanceof ArrayBuffer) out = v.slice(0);
+      else if (v instanceof TypedArray) {
+        const buffer = walk(v.buffer);
+        out = new v.constructor(buffer, v.byteOffset, v.length);
+      } else if (v instanceof DataView) out = new DataView(walk(v.buffer), v.byteOffset, v.byteLength);
+      else if (v instanceof Boolean) out = new Boolean(v.valueOf());
+      else if (v instanceof Number) out = new Number(v.valueOf());
+      else if (v instanceof StringCtor) out = new StringCtor(v.valueOf());
+      else if (v instanceof Map) {
+        out = /* @__PURE__ */ new Map();
+        seen.set(v, out);
+        for (const [k, x] of v) out.set(walk(k), walk(x));
+        return out;
+      } else if (v instanceof Set) {
+        out = /* @__PURE__ */ new Set();
+        seen.set(v, out);
+        for (const x of v) out.add(walk(x));
+        return out;
+      } else if (v instanceof ErrorCtor) {
+        out = new ErrorCtor(v.message);
+        out.name = v.name;
+        if (v.stack !== void 0) out.stack = v.stack;
+      } else if (v instanceof Promise || v instanceof WeakMap || v instanceof WeakSet || v instanceof WeakRef)
+        throw cloneError("This object cannot be cloned");
+      else {
+        out = {};
+        seen.set(v, out);
+        for (const k of keys(v)) out[k] = walk(v[k]);
+        return out;
+      }
+      seen.set(v, out);
+      return out;
+    };
+    return walk(value);
+  };
+  define("structuredClone", structuredClone);
+  define(
+    "crypto",
+    freeze({
+      getRandomValues(array) {
+        N.random(array);
+        return array;
+      }
+    })
+  );
+  const PromiseCtor = Promise;
+  const call = (op) => {
+    let text;
+    try {
+      text = stringify(op);
+    } catch (e) {
+      return PromiseCtor.reject(fail("invalid_argument", "Not JSON: " + StringCtor(e && e.message)));
+    }
+    return N.op(text, true);
+  };
+  const checkWindow = (w) => {
+    if (typeOf(w) !== "object") throw fail("invalid_argument", "Expected a window { sinceMs, untilMs }");
+    const since = w.sinceMs;
+    const until = w.untilMs;
+    const rawSide = w.side;
+    const allowPartial = !!w.allowPartial;
+    const withSignatures = !!w.withSignatures;
+    const withMarket = !!w.withMarket;
+    const withEvents = !!w.withEvents;
+    const withOrder = !!w.withOrder;
+    const withTx = !!w.withTx;
+    if (typeof since !== "number" || typeof until !== "number")
+      throw fail("invalid_argument", "sinceMs and untilMs must be numbers (ms since epoch)");
+    const side = rawSide === void 0 ? "any" : rawSide;
+    if (side !== "any" && side !== "buy" && side !== "sell")
+      throw fail("invalid_argument", 'side must be "buy" or "sell"');
+    return { since, until, side, allowPartial, withSignatures, withMarket, withEvents, withOrder, withTx };
+  };
+  const trades = (kind) => (key, w) => {
+    if (typeof key !== "string") throw fail("invalid_argument", "Expected an address string");
+    const { since, until, side, allowPartial, withSignatures, withMarket, withEvents, withOrder, withTx } = checkWindow(w);
+    return freeze({
+      [asyncIterator]() {
+        let after = null;
+        let done = false;
+        return {
+          async next() {
+            if (done) return { done: true, value: void 0 };
+            const batch = N.read(kind, key, since, until, side, allowPartial, withSignatures, after, withMarket, withEvents, withOrder, withTx);
+            if (batch === null) {
+              done = true;
+              return { done: true, value: void 0 };
+            }
+            after = batch.hour;
+            return { done: false, value: batch };
+          },
+          async return(value) {
+            done = true;
+            return { done: true, value };
+          },
+          [asyncIterator]() {
+            return this;
+          }
+        };
+      }
+    });
+  };
+  const flatParams = (params) => {
+    if (typeOf(params) !== "object") throw fail("invalid_argument", "Expected search parameters");
+    const out = [];
+    for (const [k, v] of entries(params)) if (v !== void 0 && v !== null) out.push([k, StringCtor(v)]);
+    return stringify(out);
+  };
+  async function* volumeSearch(params) {
+    let p = { ...params };
+    for (; ; ) {
+      const page = N.volume(flatParams(p));
+      yield page;
+      const next = page === null || typeof page !== "object" ? null : page.nextCursor;
+      if (next === null || next === void 0) return;
+      if (typeof next !== "string" || next === p.cursor)
+        throw fail("history_unavailable", "Invalid next cursor");
+      const w = page.window;
+      if (w && typeof w === "object" && "since" in w) p = { ...p, since: w.since, until: w.until };
+      p = { ...p, cursor: next };
+    }
+  }
+  const program = () => {
+    const app = g.__app;
+    const p = app && app.default;
+    if (!p || typeOf(p.functions) !== "object")
+      throw fail("invalid_program", "Expected the bundle to export defineProgram({ functions })");
+    for (const name of keys(p.functions))
+      if (typeof p.functions[name] !== "function")
+        throw fail("invalid_program", "Invalid function: " + name);
+    return p;
+  };
+  const describe = () => {
+    const p = program();
+    const sdk = p.__zyrkSdk;
+    return stringify({
+      sdk: typeof sdk === "string" ? sdk : "",
+      functions: keys(p.functions),
+      stateVersion: p.stateVersion ?? 0,
+      ...p.migration ? { migration: p.migration } : {},
+      subscriptions: p.subscriptions ?? {}
+    });
+  };
+  const CHUNK = 4 * 1024 * 1024;
+  const U8 = Uint8Array;
+  const bad = (message) => fail("invalid_request", message);
+  const bytesOf = (value) => {
+    if (typeof value === "string") return N.encode(value);
+    if (value instanceof ArrayBuffer) return new U8(value);
+    if (ArrayBuffer.isView(value)) return new U8(value.buffer, value.byteOffset, value.byteLength);
+    throw bad("Expected a Uint8Array, an ArrayBuffer, a view or a string");
+  };
+  const keyOf = (key) => {
+    if (typeof key !== "string") throw bad("A storage key is a string");
+    return key;
+  };
+  const putOptions = (o, body) => {
+    if (o !== void 0 && o !== null && typeOf(o) !== "object") throw bad("Options must be an object");
+    const rawType = o ? o.contentType : void 0;
+    const rawMeta = o ? o.metadata : void 0;
+    const ifAbsent = !!(o && o.ifAbsent);
+    const rawMatch = o ? o.ifMatch : void 0;
+    if (rawMatch !== void 0 && rawMatch !== null && typeof rawMatch !== "string")
+      throw bad("ifMatch must be an etag string");
+    const ifMatch = rawMatch === void 0 ? null : rawMatch;
+    if (rawType !== void 0 && typeof rawType !== "string") throw bad("contentType must be a string");
+    const metadata = {};
+    if (rawMeta !== void 0 && rawMeta !== null) {
+      if (typeOf(rawMeta) !== "object") throw bad("metadata must be an object of strings");
+      for (const name of Object.keys(rawMeta)) {
+        const value = rawMeta[name];
+        if (typeof value !== "string") throw bad("metadata values must be strings");
+        metadata[name] = value;
+      }
+    }
+    const contentType = rawType !== void 0 ? rawType : typeof body === "string" ? "text/plain; charset=utf-8" : null;
+    return { contentType, metadata, ifAbsent, ifMatch };
+  };
+  const head = (r) => freeze({
+    key: r.key,
+    size: r.size,
+    contentType: r.contentType,
+    metadata: freeze({ ...r.metadata }),
+    lastModified: r.lastModified,
+    writtenAt: r.writtenAt,
+    expiresAt: r.expiresAt,
+    etag: r.etag
+  });
+  const summary = (r) => freeze({ key: r.key, size: r.size, contentType: r.contentType, lastModified: r.lastModified, expiresAt: r.expiresAt });
+  const storageArea = (area) => {
+    const read = async (key, offset, length) => {
+      const first = await call({ StorageGet: { area, key, offset, length: length > CHUNK ? CHUNK : length } });
+      if (first === null) return null;
+      const end = Math.min(first.size, offset + length);
+      const total = Math.max(0, end - first.offset);
+      const out = new U8(total);
+      let at = 0;
+      let r = first;
+      for (; ; ) {
+        const n = N.b64decodeInto(r.data, out, at);
+        if (n < 0) throw fail("unavailable", "Corrupt storage chunk");
+        at += n;
+        if (at >= total || n === 0) break;
+        r = await call({
+          StorageGet: { area, key, offset: first.offset + at, length: Math.min(CHUNK, total - at) }
+        });
+        if (r === null || r.etag !== first.etag)
+          throw fail("value_changed", "The object changed while it was read: read it again");
+      }
+      return { first, body: at === total ? out : out.subarray(0, at) };
+    };
+    const get = async (key, range) => {
+      keyOf(key);
+      const offset = range && range.offset !== void 0 ? range.offset : 0;
+      const length = range && range.length !== void 0 ? range.length : Number.MAX_SAFE_INTEGER;
+      if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(length) || length < 0)
+        throw bad("offset and length must be non-negative integers");
+      const r = await read(key, offset, length);
+      if (r === null) return null;
+      return freeze({ ...head(r.first), body: r.body });
+    };
+    const openWriter = async (key, o) => {
+      const upload = await call({ StorageUploadStart: { area, key, options: o } });
+      let done = false;
+      const check = () => {
+        if (done) throw bad("This storage writer is closed");
+      };
+      return freeze({
+        write: async (value) => {
+          check();
+          const bytes = bytesOf(value);
+          for (let at = 0; at < bytes.length; at += CHUNK) {
+            await call({ StorageUploadChunk: { upload, data: N.b64encode(bytes.subarray(at, at + CHUNK)) } });
+          }
+        },
+        close: async () => {
+          check();
+          done = true;
+          return head(await call({ StorageUploadCommit: { upload } }));
+        },
+        abort: async () => {
+          if (done) return;
+          done = true;
+          await call({ StorageUploadAbort: { upload } });
+        }
+      });
+    };
+    const put = async (key, value, options) => {
+      keyOf(key);
+      const o = putOptions(options, value);
+      const bytes = bytesOf(value);
+      if (bytes.length <= CHUNK)
+        return head(await call({ StoragePut: { area, key, data: N.b64encode(bytes), options: o } }));
+      const w = await openWriter(key, o);
+      try {
+        await w.write(bytes);
+      } catch (e) {
+        await w.abort().catch(() => {
+        });
+        throw e;
+      }
+      return w.close();
+    };
+    const writer = async (key, options) => openWriter(keyOf(key), putOptions(options, void 0));
+    const textDecoder = new TextDecoder("utf-8", { fatal: true });
+    const getText = async (key) => {
+      const r = await get(key);
+      return r === null ? null : textDecoder.decode(r.body);
+    };
+    return freeze({
+      put,
+      get,
+      head: async (key) => {
+        const r = await call({ StorageHead: { area, key: keyOf(key) } });
+        return r === null ? null : head(r);
+      },
+      delete: async (key, o) => {
+        const rawMatch = o ? o.ifMatch : void 0;
+        if (rawMatch !== void 0 && rawMatch !== null && typeof rawMatch !== "string")
+          throw bad("ifMatch must be an etag string");
+        await call({ StorageDelete: { area, key: keyOf(key), if_match: rawMatch === void 0 ? null : rawMatch } });
+      },
+      list: async (prefix, o) => {
+        const p = prefix === void 0 || prefix === null ? "" : prefix;
+        if (typeof p !== "string") throw bad("prefix must be a string");
+        const max = o && o.maxObjects !== void 0 ? o.maxObjects : null;
+        const after = o && o.after !== void 0 && o.after !== null ? keyOf(o.after) : null;
+        if (max !== null && (!Number.isSafeInteger(max) || max < 1))
+          throw bad("maxObjects must be a positive integer");
+        const r = await call({ StorageList: { area, prefix: p, after, max_objects: max } });
+        const page = r.objects.map(summary);
+        page.cursor = r.cursor;
+        page.truncated = r.cursor !== null;
+        return freeze(page);
+      },
+      usage: async () => freeze(await call({ StorageUsage: { area } })),
+      getText,
+      getJSON: async (key) => {
+        const text = await getText(key);
+        return text === null ? null : parse(text);
+      },
+      putJSON: async (key, value, options) => {
+        let text;
+        try {
+          text = stringify(value);
+        } catch (e) {
+          throw bad("Not JSON: " + StringCtor(e && e.message));
+        }
+        if (text === void 0) throw bad("Not JSON");
+        return put(key, text, { ...options || {}, contentType: "application/json" });
+      },
+      writer
+    });
+  };
+  const storage = freeze({
+    short: storageArea("short"),
+    long: storageArea("long"),
+    durable: storageArea("durable")
+  });
+  const start = (functionName, argsText, executionText) => {
+    const p = program();
+    let depth = 0;
+    const invoke = async (name, args) => {
+      if (typeof name !== "string" || !hasOwn.call(p.functions, name))
+        throw fail("unknown_function", "Unknown function: " + StringCtor(name));
+      if (++depth > N.maxDepth) throw fail("invocation_depth", "Invocation depth exceeded");
+      try {
+        return await p.functions[name](ctx, args);
+      } finally {
+        depth--;
+      }
+    };
+    const execution = parse(executionText);
+    const ctx = freeze({
+      execution: freeze({
+        id: execution.id,
+        workflow: execution.workflow,
+        program: execution.program,
+        version: execution.version,
+        attempt: execution.attempt
+      }),
+      data: freeze({
+        walletTrades: trades("wallet"),
+        tokenTrades: trades("token"),
+        tokenTotals: async (mint, o) => {
+          if (typeof mint !== "string") throw fail("invalid_argument", "Expected a mint address");
+          const rawQuote = o ? o.quote : void 0;
+          const quote = rawQuote !== void 0 ? StringCtor(rawQuote) : null;
+          return N.totals(mint, quote);
+        },
+        tokenInfo: async (mint) => {
+          if (typeof mint !== "string") throw fail("invalid_argument", "Expected a mint address");
+          return N.info(mint);
+        },
+        volumeSearch
+      }),
+      state: freeze({
+        get: (key) => call({ StateGet: { key } }),
+        set: (key, value) => call({ StateSet: { key, value } }),
+        delete: (key) => call({ StateDelete: { key } })
+      }),
+      jobs: freeze({
+        start: (i) => call({
+          JobStart: {
+            function: i && i.function,
+            args: i && i.args,
+            on_complete: (i && i.onComplete) ?? null
+          }
+        }),
+        wait: (ids, o) => call({
+          JobWait: {
+            ids: isArray(ids) ? ids : [ids],
+            timeout_ms: (o && o.timeoutMs) ?? null
+          }
+        }),
+        result: (id) => call({ JobResult: { id } }),
+        continue: (args) => call({ Continue: { args } })
+      }),
+      storage,
+      subscriptions: freeze({
+        set: (name, subscription) => call({ Subscribe: { name, subscription } }),
+        remove: (name) => call({ Unsubscribe: { name } }),
+        replay: (request) => call({ Replay: { request } })
+      }),
+      invoke,
+      log: (value) => call({ Log: { value: value === void 0 ? null : value } }),
+      emit: (value) => call({ Emit: { value: value === void 0 ? null : value } }),
+      webhook: freeze({
+        send: (payload, o) => call({
+          WebhookSend: {
+            payload: payload === void 0 ? null : payload,
+            drop_if_full: !!o && o.onFull === "drop"
+          }
+        })
+      })
+    });
+    return (async () => {
+      const value = await invoke(functionName, parse(argsText));
+      let text;
+      try {
+        text = stringify(value);
+      } catch (e) {
+        throw fail("invalid_result", "The result is not JSON: " + StringCtor(e && e.message));
+      }
+      return text === void 0 ? "null" : text;
+    })();
+  };
+  return freeze({ start, describe });
+});