@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/vendor/nanocodex/cloud/Dialog.mjs

@@ -0,0 +1,366 @@
+import { DialogBusyError, UserRejectedRequestError } from "./Errors.mjs";
+
+export const DEFAULT_HOST = "https://nanocodex.gakonst.workers.dev/connect-dialog/";
+
+const iframeInstances = new Map();
+const popupInstances = new Map();
+
+export function from(parameters) {
+  if (!parameters || typeof parameters !== "object") {
+    throw new TypeError("Dialog.from requires parameters");
+  }
+  if (typeof parameters.setup !== "function") {
+    throw new TypeError("Dialog.from requires setup");
+  }
+  return Object.freeze({
+    key: requiredString(parameters.key, "dialog key"),
+    name: requiredString(parameters.name, "dialog name"),
+    type: requiredString(parameters.type, "dialog type"),
+    setup: parameters.setup,
+  });
+}
+
+export function iframe(options = {}) {
+  const host = new URL(options.host ?? DEFAULT_HOST).toString();
+  return from({
+    key: options.key ?? "nanocodex-iframe",
+    name: options.name ?? "Nanocodex Connect",
+    type: "iframe",
+    setup({ appId }) {
+      if (typeof document === "undefined" || typeof window === "undefined") {
+        return {
+          host,
+          async open() {
+            throw new Error("The Nanocodex iframe dialog requires a browser");
+          },
+        };
+      }
+      const source = dialogUrl(host, "iframe", appId);
+      let instance = iframeInstances.get(source);
+      if (!instance) {
+        instance = createIframeInstance(source);
+        iframeInstances.set(source, instance);
+      }
+      return instance;
+    },
+  });
+}
+
+export function popup(options = {}) {
+  const host = new URL(options.host ?? DEFAULT_HOST).toString();
+  return from({
+    key: options.key ?? "nanocodex-popup",
+    name: options.name ?? "Nanocodex Connect",
+    type: "popup",
+    setup({ appId }) {
+      if (typeof window === "undefined") {
+        return {
+          host,
+          async open() {
+            throw new Error("The Nanocodex popup dialog requires a browser");
+          },
+        };
+      }
+      const source = dialogUrl(host, "popup", appId);
+      let instance = popupInstances.get(source);
+      if (!instance) {
+        instance = createPopupInstance(source, options);
+        popupInstances.set(source, instance);
+      }
+      return instance;
+    },
+  });
+}
+
+export function memory(options = {}) {
+  return from({
+    key: options.key ?? "nanocodex-memory",
+    name: options.name ?? "Nanocodex Connect playground",
+    type: "memory",
+    setup() {
+      const listeners = new Set();
+      let pending;
+      let snapshot;
+
+      function publish(value) {
+        snapshot = value;
+        for (const listener of [...listeners]) listener();
+      }
+
+      return {
+        host: options.host ?? "https://connect.nanocodex.xyz",
+        open(request) {
+          if (pending) return Promise.reject(new DialogBusyError());
+          return new Promise((resolve, reject) => {
+            pending = { reject, request, resolve };
+            publish(Object.freeze(request));
+          });
+        },
+        getRequest() {
+          return snapshot;
+        },
+        subscribe(listener) {
+          if (typeof listener !== "function") {
+            throw new TypeError("dialog subscription requires a listener");
+          }
+          listeners.add(listener);
+          return () => listeners.delete(listener);
+        },
+        respond(result) {
+          if (!pending) throw new Error("The Nanocodex dialog has no pending request");
+          const current = pending;
+          pending = undefined;
+          publish(undefined);
+          current.resolve(result);
+        },
+        reject(error = new UserRejectedRequestError()) {
+          if (!pending) throw new Error("The Nanocodex dialog has no pending request");
+          const current = pending;
+          pending = undefined;
+          publish(undefined);
+          current.reject(error);
+        },
+      };
+    },
+  });
+}
+
+function createIframeInstance(host) {
+  let active;
+  let frame;
+  let modal;
+  let ready;
+  let walletFrame;
+  let walletHost;
+  let walletModal;
+  let walletReady;
+  let walletStale = false;
+  let walletVisible = false;
+
+  function mount() {
+    if (frame && modal) return;
+    modal = document.createElement("dialog");
+    modal.setAttribute("aria-label", "Nanocodex Connect permissions");
+    modal.style.cssText = "border:0;padding:0;background:transparent;max-width:none;max-height:none";
+    modal.addEventListener("cancel", (event) => {
+      event.preventDefault();
+      rejectActive(new UserRejectedRequestError());
+    });
+    modal.addEventListener("close", () => {
+      if (active) rejectActive(new UserRejectedRequestError());
+    });
+    frame = document.createElement("iframe");
+    frame.dataset.testid = "nanocodex-connect-dialog";
+    frame.title = "Nanocodex Connect permissions";
+    frame.src = host;
+    frame.tabIndex = -1;
+    frame.setAttribute("inert", "");
+    const dialogOrigin = new URL(host).origin;
+    frame.allow = [
+      `publickey-credentials-get ${dialogOrigin}`,
+      `publickey-credentials-create ${dialogOrigin}`,
+      "payment",
+    ].join("; ");
+    frame.style.cssText = "border:0;width:min(440px,calc(100vw - 24px));height:min(720px,calc(100vh - 24px));background:#161616";
+    frame.style.display = "none";
+    modal.append(frame);
+    document.body.append(modal);
+    ready = new Promise((resolve) => frame.addEventListener("load", resolve, { once: true }));
+  }
+
+  function rejectActive(error) {
+    if (!active) return;
+    const current = active;
+    active = undefined;
+    if (modal?.open) modal.close();
+    frame.tabIndex = -1;
+    frame.setAttribute("inert", "");
+    frame.style.display = "none";
+    current.reject(error);
+  }
+
+  function onMessage(event) {
+    if (!active || event.origin !== new URL(host).origin || event.source !== frame?.contentWindow) return;
+    const message = event.data;
+    if (!message || message.type !== "nanocodex:response" || message.id !== active.request.id) return;
+    const current = active;
+    active = undefined;
+    modal?.close();
+    frame.tabIndex = -1;
+    frame.setAttribute("inert", "");
+    frame.style.display = "none";
+    if (message.error) {
+      current.reject(new UserRejectedRequestError(message.error.message));
+      return;
+    }
+    current.resolve(message.result);
+  }
+
+  window.addEventListener("message", onMessage);
+
+  function mountWallet(nextHost) {
+    const url = new URL(nextHost ?? host);
+    if (!url.searchParams.has("origin")) url.searchParams.set("origin", window.location.origin);
+    url.searchParams.set("mode", "iframe");
+    const source = url.toString();
+    if (walletFrame && walletModal && walletHost === source) return;
+    walletModal?.remove();
+    walletModal = document.createElement("dialog");
+    walletModal.dataset.nanocodexConnectWallet = "";
+    walletModal.setAttribute("aria-label", "Nanocodex Connect");
+    walletModal.style.cssText = "border:0;outline:0;padding:0;background:transparent;max-width:none;max-height:none;width:100vw;height:100vh";
+    walletModal.addEventListener("cancel", (event) => event.preventDefault());
+    const style = document.createElement("style");
+    style.textContent = "dialog[data-nanocodex-connect-wallet]::backdrop{background:transparent}";
+    walletFrame = document.createElement("iframe");
+    walletFrame.dataset.testid = "nanocodex-connect-wallet";
+    walletFrame.title = "Nanocodex Connect";
+    walletReady = new Promise((resolve) => {
+      walletFrame.addEventListener("load", resolve, { once: true });
+    });
+    walletFrame.src = source;
+    const dialogOrigin = url.origin;
+    walletFrame.allow = [
+      `publickey-credentials-get ${dialogOrigin}`,
+      `publickey-credentials-create ${dialogOrigin}`,
+      "clipboard-write",
+      "payment",
+    ].join("; ");
+    walletFrame.style.cssText = "border:0;position:fixed;inset:0;width:100%;height:100%;background:transparent;color-scheme:light dark";
+    setWalletInteractive(walletVisible);
+    walletModal.append(style, walletFrame);
+    document.body.append(walletModal);
+    walletHost = source;
+    walletStale = false;
+    if (walletVisible) walletModal.showModal();
+  }
+
+  async function refreshStaleWallet() {
+    if (!walletStale) return;
+    walletModal?.remove();
+    walletFrame = undefined;
+    walletHost = undefined;
+    walletModal = undefined;
+    walletReady = undefined;
+    mountWallet(host);
+    await walletReady;
+  }
+
+  function showWallet() {
+    walletVisible = true;
+    setWalletInteractive(true);
+    if (walletModal && !walletModal.open) walletModal.showModal();
+    walletFrame?.focus();
+  }
+
+  function hideWallet() {
+    walletVisible = false;
+    if (walletModal?.open) walletModal.close();
+    setWalletInteractive(false);
+  }
+
+  async function resetWallet() {
+    walletVisible = false;
+    if (walletModal?.open) walletModal.close();
+    setWalletInteractive(false);
+    // The hosted account is still finishing its own logout when the Wata
+    // response reaches the parent. Keep that document alive until the next
+    // connect, then replace it before creating the next Provider session.
+    walletStale = true;
+  }
+
+  function setWalletInteractive(visible) {
+    if (!walletFrame) return;
+    walletFrame.tabIndex = visible ? 0 : -1;
+    walletFrame.style.display = visible ? "block" : "none";
+    if (visible) walletFrame.removeAttribute("inert");
+    else walletFrame.setAttribute("inert", "");
+  }
+
+  // Keep the hosted wallet warm from client creation. The iframe remains
+  // hidden and inert until a request is made, but its Accounts/WebAuthn
+  // runtime can load while the embedding app is already useful.
+  mountWallet(host);
+
+  return {
+    host,
+    hideWallet,
+    resetWallet,
+    async open(request) {
+      if (active) throw new DialogBusyError();
+      mount();
+      await ready;
+      return new Promise((resolve, reject) => {
+        active = { reject, request, resolve };
+        frame.removeAttribute("inert");
+        frame.tabIndex = 0;
+        frame.style.display = "block";
+        modal.showModal();
+        frame.contentWindow.postMessage({
+          type: "nanocodex:request",
+          id: request.id,
+          request,
+        }, new URL(host).origin);
+      });
+    },
+    showWallet,
+    async waitForWallet() {
+      await refreshStaleWallet();
+      await walletReady;
+    },
+    walletTarget(options = {}) {
+      mountWallet(options.host);
+      if (walletVisible && walletModal && !walletModal.open) walletModal.showModal();
+      return walletFrame?.contentWindow;
+    },
+  };
+}
+
+function createPopupInstance(host, options) {
+  const source = host;
+  const targetName = options.target ?? "nanocodex-connect";
+  const features = options.features ?? "popup=yes,width=440,height=720,resizable=yes,scrollbars=yes";
+  let walletWindow;
+
+  function showWallet() {
+    if (!walletWindow || walletWindow.closed) {
+      walletWindow = window.open(source, targetName, features);
+    }
+    if (!walletWindow) {
+      throw new Error("Nanocodex Connect was blocked. Allow the popup and try again.");
+    }
+    walletWindow.focus?.();
+  }
+
+  function hideWallet() {
+    if (walletWindow && !walletWindow.closed) walletWindow.close();
+    walletWindow = undefined;
+  }
+
+  return {
+    host: source,
+    async open() {
+      throw new Error("The Nanocodex popup supports account authorization only");
+    },
+    showWallet,
+    hideWallet,
+    walletTarget() {
+      return walletWindow && !walletWindow.closed ? walletWindow : undefined;
+    },
+  };
+}
+
+function dialogUrl(host, mode, appId) {
+  const url = new URL(host);
+  url.searchParams.set("app_id", appId);
+  url.searchParams.set("origin", window.location.origin);
+  url.searchParams.set("mode", mode);
+  return url.toString();
+}
+
+function requiredString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value;
+}

package/vendor/nanocodex/cloud/Errors.d.mts

@@ -0,0 +1,22 @@
+export declare class BaseError extends Error {
+  readonly code: string;
+  readonly status: number | undefined;
+  readonly metaMessages: readonly string[];
+  constructor(message: string, options?: Readonly<{
+    cause?: unknown;
+    code?: string | undefined;
+    status?: number | undefined;
+    metaMessages?: readonly string[] | undefined;
+  }>);
+}
+
+export declare class HttpError extends BaseError {
+  constructor(status: number, message: string, options?: Readonly<{
+    cause?: unknown;
+    code?: string | undefined;
+  }>);
+}
+
+export declare class InvalidResponseError extends BaseError {}
+export declare class UserRejectedRequestError extends BaseError {}
+export declare class DialogBusyError extends BaseError {}

package/vendor/nanocodex/cloud/Errors.mjs

@@ -0,0 +1,39 @@
+export class BaseError extends Error {
+  constructor(message, options = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "Connect.BaseError";
+    this.code = options.code ?? "connect_error";
+    this.status = options.status;
+    this.metaMessages = Object.freeze([...(options.metaMessages ?? [])]);
+  }
+}
+
+export class HttpError extends BaseError {
+  constructor(status, message, options = {}) {
+    super(message, { ...options, code: options.code ?? "http_error", status });
+    this.name = "Connect.HttpError";
+  }
+}
+
+export class InvalidResponseError extends BaseError {
+  constructor(message, options = {}) {
+    super(message, { ...options, code: "invalid_response" });
+    this.name = "Connect.InvalidResponseError";
+  }
+}
+
+export class UserRejectedRequestError extends BaseError {
+  constructor(message = "The Nanocodex request was rejected.", options = {}) {
+    super(message, { ...options, code: "user_rejected_request" });
+    this.name = "Connect.UserRejectedRequestError";
+  }
+}
+
+export class DialogBusyError extends BaseError {
+  constructor() {
+    super("The Nanocodex dialog is already handling a request.", {
+      code: "dialog_busy",
+    });
+    this.name = "Connect.DialogBusyError";
+  }
+}

package/vendor/nanocodex/cloud/Principal.d.mts

@@ -0,0 +1,26 @@
+export type Exchange = Readonly<{ token: string; expiresAt: number }>;
+
+export type Instance = Readonly<{
+  create(options: Readonly<{
+    resources: readonly string[];
+    signal?: AbortSignal | undefined;
+  }>): Promise<Exchange>;
+}>;
+
+export type Principal<type extends string = string> = Readonly<{
+  key: string;
+  name: string;
+  type: type;
+  setup(context: Readonly<{
+    appId: string;
+    appOrigin: string | undefined;
+  }>): Instance;
+}>;
+
+export function host(options?: Readonly<{
+  /** Same-origin application route that verifies the current host login. */
+  url?: string | URL | undefined;
+  fetch?: typeof globalThis.fetch | undefined;
+  key?: string | undefined;
+  name?: string | undefined;
+}>): Principal<"host">;

package/vendor/nanocodex/cloud/Principal.mjs

@@ -0,0 +1,88 @@
+const EXCHANGE_TOKEN = /^[A-Za-z0-9_-]{43}$/;
+const MAX_EXCHANGE_TTL_SECONDS = 300;
+
+/** Reads a one-time host-principal exchange from an application-owned route. */
+export function host(options = {}) {
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== "function") throw new TypeError("host principal requires fetch");
+  return Object.freeze({
+    key: requiredString(options.key ?? "host-principal", "principal key"),
+    name: requiredString(options.name ?? "Host application principal", "principal name"),
+    type: "host",
+    setup({ appId, appOrigin }) {
+      const endpoint = principalEndpoint(
+        options.url ?? "/api/nanocodex/host-principal",
+        appOrigin,
+      );
+      return Object.freeze({
+        async create({ resources, signal } = {}) {
+          const exactResources = principalResources(resources);
+          const response = await fetchFn(endpoint, {
+            method: "POST",
+            credentials: "include",
+            headers: {
+              accept: "application/json",
+              "content-type": "application/json",
+              "x-nanocodex-app-id": appId,
+            },
+            body: JSON.stringify({ resources: exactResources }),
+            signal,
+          });
+          const body = await response.json().catch(() => undefined);
+          if (!response.ok) {
+            const error = new Error(
+              body?.error?.message ?? `The host principal exchange failed with ${response.status}.`,
+            );
+            error.status = response.status;
+            throw error;
+          }
+          return principalExchange(body);
+        },
+      });
+    },
+  });
+}
+
+function principalEndpoint(value, appOrigin) {
+  let endpoint;
+  try {
+    endpoint = new URL(String(value), appOrigin);
+  } catch {
+    throw new TypeError("host principal url requires an absolute application origin");
+  }
+  if (!appOrigin || endpoint.origin !== appOrigin) {
+    throw new TypeError("host principal url must stay on the embedding application's origin");
+  }
+  if (endpoint.username || endpoint.password || endpoint.hash) {
+    throw new TypeError("host principal url cannot contain credentials or a fragment");
+  }
+  return endpoint;
+}
+
+function principalExchange(value) {
+  const now = Math.floor(Date.now() / 1_000);
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || !EXCHANGE_TOKEN.test(value.token)
+    || !Number.isSafeInteger(value.expires_at)
+    || value.expires_at <= now
+    || value.expires_at > now + MAX_EXCHANGE_TTL_SECONDS) {
+    throw new TypeError("host principal returned an invalid exchange");
+  }
+  return Object.freeze({ token: value.token, expiresAt: value.expires_at });
+}
+
+function principalResources(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 64
+    || value.some((resource) => typeof resource !== "string"
+      || resource.length === 0 || resource.length > 512)) {
+    throw new TypeError("host principal resources must be 1 through 64 bounded strings");
+  }
+  return Object.freeze([...value]);
+}
+
+function requiredString(value, label) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new TypeError(`${label} must be a non-empty string`);
+  }
+  return value;
+}

package/vendor/nanocodex/cloud/RemoteProvider.mjs

@@ -0,0 +1,88 @@
+import { Wata, postMessage } from "wata";
+
+import { UserRejectedRequestError } from "./Errors.mjs";
+
+export function create(parameters) {
+  const host = walletHost(parameters.host);
+  let session;
+  let queue = Promise.resolve();
+  let state = Object.freeze({ accounts: Object.freeze([]), activeAccount: 0, accessKeys: Object.freeze([]) });
+
+  function ensureSession() {
+    if (session) return session;
+    const next = Wata.create({
+      transports: [postMessage({
+        connect: "eager",
+        host,
+        target: ({ host: targetHost }) => {
+          const target = parameters.target({ host: targetHost });
+          if (!target) throw new Error("The Nanocodex Connect wallet host is unavailable.");
+          return target;
+        },
+      })],
+    }).start();
+    session = next;
+    void next.ready.catch(() => {
+      if (session === next) session = undefined;
+    });
+    next.onClose(() => {
+      if (session === next) session = undefined;
+    });
+    next.onNotification((event) => {
+      if (event.method !== "accountsChanged" || !Array.isArray(event.params)) return;
+      state = Object.freeze({
+        accounts: Object.freeze(event.params
+          .filter((address) => typeof address === "string")
+          .map((address) => Object.freeze({ address }))),
+        activeAccount: 0,
+        accessKeys: Object.freeze([]),
+      });
+    });
+    return next;
+  }
+
+  function request(request) {
+    const result = queue.then(async () => {
+      try {
+        const sent = await ensureSession().send({
+          method: request.method,
+          params: request.params ?? [],
+          ...(request.context ? { context: request.context } : {}),
+        });
+        if (request.method === "wallet_disconnect") {
+          state = Object.freeze({ accounts: Object.freeze([]), activeAccount: 0, accessKeys: Object.freeze([]) });
+        }
+        return sent.result;
+      } catch (error) {
+        if (error?.code === 4001) {
+          throw new UserRejectedRequestError(error.message, { cause: error });
+        }
+        throw error;
+      }
+    });
+    queue = result.catch(() => undefined);
+    return result;
+  }
+
+  return Object.freeze({
+    prepare() {
+      return ensureSession().ready;
+    },
+    async reset() {
+      const current = session;
+      session = undefined;
+      state = Object.freeze({ accounts: Object.freeze([]), activeAccount: 0, accessKeys: Object.freeze([]) });
+      await current?.close();
+    },
+    request,
+    store: Object.freeze({ getState: () => state }),
+  });
+}
+
+function walletHost(host) {
+  if (typeof window === "undefined") return host;
+  const url = new URL(host);
+  url.searchParams.set("origin", window.location.origin);
+  if (!url.searchParams.has("mode")) url.searchParams.set("mode", "iframe");
+  return url.toString();
+}

package/vendor/nanocodex/cloud/Transport.d.mts

@@ -0,0 +1,47 @@
+export const DEFAULT_API_URL: "https://api.nanocodex.xyz";
+export const MOCK_ACCOUNT_ADDRESS: `0x${string}`;
+export const MOCK_MACHINE_USD_ADDRESS: `0x${string}`;
+
+export type Request = Readonly<{
+  path: string;
+  method?: "GET" | "POST" | "DELETE" | undefined;
+  headers?: HeadersInit | undefined;
+  body?: unknown;
+  signal?: AbortSignal | undefined;
+}>;
+
+export type Instance = Readonly<{
+  baseUrl: string;
+  fetch?(input: RequestInfo | URL, init?: RequestInit | undefined): Promise<Response>;
+  request(request: Request): Promise<unknown>;
+}>;
+
+export type Transport<type extends string = string> = Readonly<{
+  key: string;
+  name: string;
+  type: type;
+  setup(options: Readonly<{ appId: string }>): Instance;
+}>;
+
+export function from<const type extends string>(parameters: Readonly<{
+  key: string;
+  name: string;
+  type: type;
+  setup(options: Readonly<{ appId: string }>): Instance;
+}>): Transport<type>;
+
+export function http(url?: string | undefined, options?: Readonly<{
+  credentials?: RequestCredentials | undefined;
+  fetch?: typeof globalThis.fetch | undefined;
+  key?: string | undefined;
+  name?: string | undefined;
+}>): Transport<"http">;
+
+export function mock(options?: Readonly<{
+  accountAddress?: `0x${string}` | undefined;
+  appName?: string | undefined;
+  appOrigin?: string | undefined;
+  key?: string | undefined;
+  machineUsdAddress?: `0x${string}` | undefined;
+  name?: string | undefined;
+}>): Transport<"mock">;