@inodra/sui 0.1.0

package/dist/reflection-FEGYA7DU.js

@@ -0,0 +1,9 @@
+import {
+  EventSchemaReflector
+} from "./chunk-3CBLVI6J.js";
+import "./chunk-D6FZYWG7.js";
+import "./chunk-U6D5LGNF.js";
+export {
+  EventSchemaReflector
+};
+//# sourceMappingURL=reflection-FEGYA7DU.js.map

package/dist/reflection-FEGYA7DU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/runtime-OWKF3LZ7.js

@@ -0,0 +1,37 @@
+import {
+  baseEventType,
+  eventTypeMatches,
+  innerEventType,
+  moveAddress,
+  moveBalance,
+  moveBool,
+  moveBytes,
+  moveSmallUint,
+  moveString,
+  moveTypeName,
+  moveUint,
+  warpAddressPayloadSchema,
+  warpCoinPayloadSchema,
+  warpEventPayloadSchema,
+  warpObjectPayloadSchema,
+  webhookEventBodySchema
+} from "./chunk-D6FZYWG7.js";
+export {
+  baseEventType,
+  eventTypeMatches,
+  innerEventType,
+  moveAddress,
+  moveBalance,
+  moveBool,
+  moveBytes,
+  moveSmallUint,
+  moveString,
+  moveTypeName,
+  moveUint,
+  warpAddressPayloadSchema,
+  warpCoinPayloadSchema,
+  warpEventPayloadSchema,
+  warpObjectPayloadSchema,
+  webhookEventBodySchema
+};
+//# sourceMappingURL=runtime-OWKF3LZ7.js.map

package/dist/runtime-OWKF3LZ7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/warp.cjs

@@ -0,0 +1,633 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/warp/index.ts
+var warp_exports = {};
+__export(warp_exports, {
+  WarpSseStream: () => WarpSseStream,
+  WarpWebSocketStream: () => WarpWebSocketStream,
+  iterateStream: () => iterateStream
+});
+module.exports = __toCommonJS(warp_exports);
+
+// src/warp/iterate.ts
+async function* iterateStream(stream, options = {}) {
+  const queue = [];
+  let notify;
+  let closed = false;
+  let failure;
+  const unsubscribes = [
+    stream.on("message", (event) => {
+      queue.push(event);
+      notify?.();
+    }),
+    stream.on("close", ({ reason }) => {
+      closed = true;
+      if (reason !== "client closed") {
+        failure = new Error(`Warp stream closed: ${reason}`);
+      }
+      notify?.();
+    })
+  ];
+  try {
+    for (; ; ) {
+      while (queue.length > 0) {
+        yield queue.shift();
+      }
+      if (closed) {
+        if (failure) {
+          throw failure;
+        }
+        return;
+      }
+      await new Promise((resolve) => {
+        notify = resolve;
+      });
+      notify = void 0;
+    }
+  } finally {
+    for (const unsubscribe of unsubscribes) {
+      unsubscribe();
+    }
+    if (options.closeOnReturn ?? true) {
+      stream.close();
+    }
+  }
+}
+
+// src/core/auth.ts
+function resolveAuth(auth) {
+  if (typeof auth === "string") {
+    return staticAuth(apiKeyCredentials(auth));
+  }
+  if ("apiKey" in auth) {
+    return staticAuth(apiKeyCredentials(auth.apiKey));
+  }
+  if ("sessionToken" in auth) {
+    return staticAuth({
+      headers: { authorization: `Bearer ${auth.sessionToken}` }
+    });
+  }
+  return {
+    credentials: async () => auth.getCredentials(),
+    staticCredentials: () => void 0
+  };
+}
+function authFromOptions(options, context) {
+  if (options.auth !== void 0) {
+    return resolveAuth(options.auth);
+  }
+  if (options.apiKey) {
+    return resolveAuth(options.apiKey);
+  }
+  throw new Error(`${context} requires auth (or the apiKey shorthand)`);
+}
+function apiKeyCredentials(apiKey) {
+  if (!apiKey) {
+    throw new Error("Inodra auth: apiKey must be a non-empty string");
+  }
+  return {
+    headers: { "x-api-key": apiKey },
+    queryParams: { api_key: apiKey }
+  };
+}
+function staticAuth(credentials) {
+  return {
+    credentials: async () => credentials,
+    staticCredentials: () => credentials
+  };
+}
+
+// src/core/version.ts
+var SDK_VERSION = "0.1.0";
+var SDK_HEADER_NAME = "x-inodra-sdk";
+var SDK_HEADER_VALUE = `inodra-sdk-ts/${SDK_VERSION}`;
+
+// src/core/network.ts
+var INODRA_ENDPOINTS = {
+  mainnet: {
+    rest: "https://mainnet-api.inodra.com/v1",
+    graphql: "https://mainnet-api.inodra.com/v1/graphql",
+    /** host:port for native gRPC transports */
+    grpc: "mainnet-grpc.inodra.com:443",
+    /** base URL for gRPC-Web transports */
+    grpcWeb: "https://mainnet-grpc.inodra.com",
+    warpWs: "wss://mainnet-api.inodra.com/v1"
+  },
+  testnet: {
+    rest: "https://testnet-api.inodra.com/v1",
+    graphql: "https://testnet-api.inodra.com/v1/graphql",
+    grpc: "testnet-grpc.inodra.com:443",
+    grpcWeb: "https://testnet-grpc.inodra.com",
+    warpWs: "wss://testnet-api.inodra.com/v1"
+  }
+};
+function warpStreamUrl(network, subscriptionId) {
+  return `${INODRA_ENDPOINTS[network].rest}/warp/${subscriptionId}/stream`;
+}
+function warpWebSocketUrl(network, subscriptionId) {
+  return `${INODRA_ENDPOINTS[network].warpWs}/warp/${subscriptionId}/ws`;
+}
+
+// src/warp/emitter.ts
+var Emitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => set?.delete(handler);
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  /** Returns false if any handler threw. */
+  emit(event, payload) {
+    let ok = true;
+    for (const handler of this.handlers.get(event) ?? []) {
+      try {
+        handler(payload);
+      } catch {
+        ok = false;
+      }
+    }
+    return ok;
+  }
+};
+
+// src/warp/sse-parser.ts
+var SseParser = class {
+  buffer = "";
+  eventName = "";
+  dataLines = [];
+  id;
+  retryMs;
+  feed(chunk) {
+    this.buffer += chunk;
+    const messages = [];
+    for (; ; ) {
+      const newline = this.buffer.search(/\r\n|\r|\n/);
+      if (newline === -1) {
+        break;
+      }
+      const line = this.buffer.slice(0, newline);
+      const sep = this.buffer.slice(newline, newline + 2);
+      this.buffer = this.buffer.slice(newline + (sep === "\r\n" ? 2 : 1));
+      if (line === "") {
+        const message = this.flush();
+        if (message) {
+          messages.push(message);
+        }
+        continue;
+      }
+      this.parseLine(line);
+    }
+    return messages;
+  }
+  parseLine(line) {
+    if (line.startsWith(":")) {
+      return;
+    }
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) {
+      value = value.slice(1);
+    }
+    switch (field) {
+      case "event":
+        this.eventName = value;
+        break;
+      case "data":
+        this.dataLines.push(value);
+        break;
+      case "id":
+        if (!value.includes("\0")) {
+          this.id = value;
+        }
+        break;
+      case "retry": {
+        const ms = Number(value);
+        if (Number.isInteger(ms) && ms >= 0) {
+          this.retryMs = ms;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  flush() {
+    if (this.dataLines.length === 0 && this.eventName === "") {
+      const retryOnly = this.retryMs;
+      this.retryMs = void 0;
+      return retryOnly === void 0 ? void 0 : { event: "", data: "", retryMs: retryOnly };
+    }
+    const message = {
+      event: this.eventName || "message",
+      data: this.dataLines.join("\n"),
+      id: this.id,
+      retryMs: this.retryMs
+    };
+    this.eventName = "";
+    this.dataLines = [];
+    this.retryMs = void 0;
+    return message;
+  }
+};
+
+// src/warp/types.ts
+var CONTROL_EVENTS = /* @__PURE__ */ new Set(["connected", "error", "quota_exceeded"]);
+function backoffDelayMs(attempt) {
+  return Math.min(1e3 * 2 ** (attempt - 1), 3e4) + Math.random() * 250;
+}
+
+// src/warp/sse.ts
+var WarpSseStream = class extends Emitter {
+  lastEventId;
+  options;
+  auth;
+  url;
+  fetchImpl;
+  abort;
+  reconnectAttempt = 0;
+  serverRetryMs;
+  closed = false;
+  closeEmitted = false;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.auth = authFromOptions(options, "WarpSseStream");
+    const base = options.url ?? warpStreamUrl(options.network ?? "mainnet", options.subscriptionId);
+    if (options.mode !== void 0) {
+      const url = new URL(base);
+      url.searchParams.set("mode", options.mode);
+      this.url = url.toString();
+    } else {
+      this.url = base;
+    }
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.lastEventId = options.lastEventId;
+  }
+  connect() {
+    if (this.abort) {
+      return;
+    }
+    this.closed = false;
+    this.closeEmitted = false;
+    this.abort = new AbortController();
+    void this.run(this.abort.signal);
+  }
+  close() {
+    const wasActive = this.abort !== void 0;
+    this.closed = true;
+    this.abort?.abort();
+    this.abort = void 0;
+    if (wasActive) {
+      this.emitClose("client closed");
+    }
+  }
+  /** Emit "close" exactly once per connection lifecycle. */
+  emitClose(reason) {
+    if (this.closeEmitted) {
+      return;
+    }
+    this.closeEmitted = true;
+    this.emit("close", { reason });
+  }
+  /** Iterate data events; ends when the stream closes (throws unless client-initiated). */
+  [Symbol.asyncIterator]() {
+    return iterateStream(this);
+  }
+  async run(signal) {
+    for (; ; ) {
+      try {
+        await this.consume(signal);
+        if (this.closed || signal.aborted) {
+          return;
+        }
+      } catch (error) {
+        if (this.closed || signal.aborted) {
+          return;
+        }
+        if (error instanceof TerminalStreamError) {
+          this.emit("error", error);
+          this.emitClose(error.message);
+          this.close();
+          return;
+        }
+        this.emit(
+          "error",
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+      if (!(this.options.reconnect ?? true)) {
+        this.emitClose("disconnected");
+        this.close();
+        return;
+      }
+      this.reconnectAttempt += 1;
+      if (this.reconnectAttempt > (this.options.maxReconnectAttempts ?? 10)) {
+        this.emitClose("max reconnect attempts exceeded");
+        this.close();
+        return;
+      }
+      const delayMs = this.serverRetryMs ?? backoffDelayMs(this.reconnectAttempt);
+      this.emit("reconnecting", { attempt: this.reconnectAttempt, delayMs });
+      await sleep(delayMs);
+      if (this.closed || signal.aborted) {
+        return;
+      }
+    }
+  }
+  async consume(signal) {
+    const { headers: authHeaders } = await this.auth.credentials();
+    const headers = {
+      accept: "text/event-stream",
+      ...authHeaders,
+      [SDK_HEADER_NAME]: SDK_HEADER_VALUE
+    };
+    if (this.lastEventId !== void 0) {
+      headers["Last-Event-ID"] = this.lastEventId;
+    }
+    const response = await this.fetchImpl(this.url, { headers, signal });
+    if (!response.ok || !response.body) {
+      const retryable = response.status >= 500;
+      const message = `SSE connection failed with status ${response.status}`;
+      if (retryable) {
+        throw new Error(message);
+      }
+      throw new TerminalStreamError(message);
+    }
+    const parser = new SseParser();
+    const decoder = new TextDecoder();
+    const reader = response.body.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      for (const message of parser.feed(decoder.decode(value, { stream: true }))) {
+        if (message.retryMs !== void 0) {
+          this.serverRetryMs = message.retryMs;
+        }
+        if (message.event === "" && message.data === "") {
+          continue;
+        }
+        this.dispatch(message.event, message.id, message.data);
+      }
+    }
+  }
+  dispatch(event, id, raw) {
+    let data = raw;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+    }
+    if (id !== void 0) {
+      this.lastEventId = id;
+    }
+    switch (event) {
+      case "connected":
+        this.reconnectAttempt = 0;
+        this.emit("connected", data);
+        return;
+      case "quota_exceeded":
+        this.emit("quota_exceeded", data);
+        this.emitClose("quota_exceeded");
+        this.close();
+        return;
+      case "error": {
+        const message = typeof data === "object" && data !== null && "error" in data ? String(data.error) : raw;
+        this.emit("error", new Error(message));
+        return;
+      }
+      default:
+        if (!CONTROL_EVENTS.has(event)) {
+          this.emit("message", { type: event, id, data });
+        }
+    }
+  }
+};
+var TerminalStreamError = class extends Error {
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/warp/ws.ts
+var WarpWebSocketStream = class extends Emitter {
+  lastEventId;
+  options;
+  auth;
+  wsCtor;
+  ws;
+  reconnectAttempt = 0;
+  closed = false;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.auth = authFromOptions(options, "WarpWebSocketStream");
+    const ctor = options.webSocket ?? globalThis.WebSocket;
+    if (!ctor) {
+      throw new Error(
+        "No WebSocket implementation available \u2014 pass one via the webSocket option"
+      );
+    }
+    this.wsCtor = ctor;
+    this.lastEventId = options.lastEventId;
+  }
+  connect() {
+    if (this.ws) {
+      return;
+    }
+    this.closed = false;
+    this.open();
+  }
+  close() {
+    this.closed = true;
+    this.ws?.close(1e3, "client closed");
+    this.ws = void 0;
+  }
+  /** Acknowledge an event by ID (only needed with autoAck: false). */
+  ack(id) {
+    this.ws?.send(JSON.stringify({ type: "ack", id }));
+  }
+  /** Iterate data events; ends when the stream closes (throws unless client-initiated). */
+  [Symbol.asyncIterator]() {
+    return iterateStream(this);
+  }
+  buildUrl(authParams) {
+    const base = this.options.url ?? warpWebSocketUrl(
+      this.options.network ?? "mainnet",
+      this.options.subscriptionId
+    );
+    const url = new URL(base);
+    for (const [key, value] of Object.entries(authParams)) {
+      url.searchParams.set(key, value);
+    }
+    if (this.options.mode !== void 0) {
+      url.searchParams.set("mode", this.options.mode);
+    }
+    if (this.lastEventId !== void 0) {
+      url.searchParams.set("lastEventId", this.lastEventId);
+    }
+    return url.toString();
+  }
+  open() {
+    const credentials = this.auth.staticCredentials();
+    if (credentials) {
+      this.openWith(credentials.queryParams);
+      return;
+    }
+    void this.auth.credentials().then(
+      (resolved) => {
+        if (!this.closed && !this.ws) {
+          this.openWith(resolved.queryParams);
+        }
+      },
+      (error) => {
+        this.failTerminally(
+          error instanceof Error ? error : new Error(String(error)),
+          "credential resolution failed"
+        );
+      }
+    );
+  }
+  failTerminally(error, reason) {
+    this.closed = true;
+    this.emit("error", error);
+    this.emit("close", { reason });
+  }
+  openWith(authParams) {
+    if (!authParams) {
+      this.failTerminally(
+        new Error(
+          "These credentials cannot authenticate a WebSocket (no header support on upgrades) \u2014 use an API key or the SSE stream"
+        ),
+        "unsupported credentials"
+      );
+      return;
+    }
+    const ws = new this.wsCtor(this.buildUrl(authParams));
+    this.ws = ws;
+    ws.addEventListener("message", (event) => {
+      this.handleMessage(event);
+    });
+    ws.addEventListener("error", () => {
+      this.emit("error", new Error("WebSocket transport error"));
+    });
+    ws.addEventListener("close", (event) => {
+      if (this.ws !== ws) {
+        return;
+      }
+      this.ws = void 0;
+      this.handleClose(event.code, event.reason);
+    });
+  }
+  handleMessage(event) {
+    let parsed;
+    try {
+      parsed = JSON.parse(
+        typeof event.data === "string" ? event.data : String(event.data)
+      );
+    } catch {
+      this.emit("error", new Error("Received malformed WebSocket message"));
+      return;
+    }
+    const type = typeof parsed.event === "string" ? parsed.event : "message";
+    const id = typeof parsed.id === "string" ? parsed.id : void 0;
+    switch (type) {
+      case "connected":
+        this.reconnectAttempt = 0;
+        this.emit("connected", parsed.data);
+        return;
+      case "quota_exceeded":
+        this.emit("quota_exceeded", parsed.data);
+        return;
+      // server closes with 1008; handleClose makes it terminal
+      case "error": {
+        const message = typeof parsed.data === "object" && parsed.data !== null && "error" in parsed.data ? String(parsed.data.error) : "Server error";
+        this.emit("error", new Error(message));
+        return;
+      }
+      default: {
+        if (id !== void 0) {
+          this.lastEventId = id;
+        }
+        const handlersSucceeded = this.emit("message", {
+          type,
+          id,
+          data: parsed.data
+        });
+        if ((this.options.autoAck ?? true) && id !== void 0) {
+          if (handlersSucceeded) {
+            this.ack(id);
+          } else {
+            this.emit(
+              "error",
+              new Error(
+                `Message handler threw; event ${id} not acked and will be redelivered`
+              )
+            );
+          }
+        }
+      }
+    }
+  }
+  handleClose(code, reason) {
+    if (this.closed) {
+      this.emit("close", { reason: "client closed" });
+      return;
+    }
+    if (code === 1008) {
+      this.emit("close", { reason: reason || "policy violation" });
+      this.closed = true;
+      return;
+    }
+    if (!(this.options.reconnect ?? true)) {
+      this.emit("close", { reason: reason || "disconnected" });
+      this.closed = true;
+      return;
+    }
+    this.reconnectAttempt += 1;
+    if (this.reconnectAttempt > (this.options.maxReconnectAttempts ?? 10)) {
+      this.emit("close", { reason: "max reconnect attempts exceeded" });
+      this.closed = true;
+      return;
+    }
+    const delayMs = backoffDelayMs(this.reconnectAttempt);
+    this.emit("reconnecting", { attempt: this.reconnectAttempt, delayMs });
+    setTimeout(() => {
+      if (!this.closed && !this.ws) {
+        this.open();
+      }
+    }, delayMs);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WarpSseStream,
+  WarpWebSocketStream,
+  iterateStream
+});
+//# sourceMappingURL=warp.cjs.map