@inodra/sui 0.1.0

package/dist/cli.js

@@ -0,0 +1,665 @@
+// src/cli.ts
+import { writeFileSync } from "fs";
+
+// src/events/move-types.ts
+import { z as z2 } from "zod";
+
+// src/events/runtime.ts
+import { z } from "zod";
+var moveSmallUint = z.number();
+var moveUint = z.union([z.string(), z.number()]).transform((value) => String(value));
+var moveBool = z.boolean();
+var moveAddress = z.string();
+var moveString = z.string();
+var moveTypeName = z.union([z.string(), z.looseObject({ name: z.string() })]).transform((value) => typeof value === "string" ? value : value.name);
+var moveBalance = z.union([
+  z.string(),
+  z.number(),
+  z.looseObject({ value: z.union([z.string(), z.number()]) })
+]).transform(
+  (value) => typeof value === "object" ? String(value.value) : String(value)
+);
+var moveBytes = z.union([z.string(), z.array(z.number())]);
+var warpEventPayloadSchema = z.looseObject({
+  activityType: z.literal("package_event"),
+  txDigest: z.string(),
+  eventSequence: z.number(),
+  checkpoint: z.number(),
+  timestamp: z.number(),
+  /** Full concrete Move event type. */
+  type: z.string(),
+  sender: z.string(),
+  /** Decoded Move event payload — type with the generated catalog schemas. */
+  data: z.unknown()
+});
+var warpAddressPayloadSchema = z.looseObject({
+  address: z.string(),
+  activityType: z.string(),
+  txDigest: z.string(),
+  checkpoint: z.number(),
+  timestamp: z.number(),
+  objectId: z.string().optional(),
+  objectType: z.string().optional()
+});
+var warpCoinPayloadSchema = z.looseObject({
+  activityType: z.literal("balance_change"),
+  address: z.string(),
+  coin_type: z.string(),
+  /** Signed amount, string for precision. */
+  amount: z.string(),
+  txDigest: z.string(),
+  checkpoint: z.number(),
+  timestamp: z.number()
+});
+var warpObjectPayloadSchema = z.looseObject({
+  activityType: z.literal("object_change"),
+  object_id: z.string(),
+  transactionDirection: z.string(),
+  writeKind: z.string(),
+  owner: z.string().optional(),
+  previousOwner: z.string().optional(),
+  txDigest: z.string(),
+  checkpoint: z.number(),
+  timestamp: z.number()
+});
+var webhookEventBodySchema = z.looseObject({
+  payloadVersion: z.number(),
+  payload: warpEventPayloadSchema.extend({ webhookId: z.string() })
+});
+function baseEventType(eventType) {
+  const idx = eventType.indexOf("<");
+  return idx === -1 ? eventType : eventType.slice(0, idx);
+}
+
+// src/events/move-types.ts
+var PRIMITIVES = /* @__PURE__ */ new Set([
+  "u8",
+  "u16",
+  "u32",
+  "u64",
+  "u128",
+  "u256",
+  "bool",
+  "address",
+  "signer"
+]);
+function splitArgs(inner) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const char of inner) {
+    if (char === "<") depth++;
+    if (char === ">") depth--;
+    if (char === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+function parseMoveType(input) {
+  const type = input.trim();
+  if (PRIMITIVES.has(type)) {
+    return { kind: "prim", prim: type };
+  }
+  if (type.startsWith("vector<") && type.endsWith(">")) {
+    return { kind: "vector", inner: parseMoveType(type.slice(7, -1)) };
+  }
+  const param = /^\$(\d+)$/.exec(type);
+  if (param) {
+    return { kind: "param", index: Number(param[1]) };
+  }
+  const generic = type.indexOf("<");
+  const base = generic === -1 ? type : type.slice(0, generic);
+  const args = generic === -1 || !type.endsWith(">") ? [] : splitArgs(type.slice(generic + 1, -1)).map(parseMoveType);
+  const [address, module, name, ...rest2] = base.split("::");
+  if (address?.startsWith("0x") && module && name && rest2.length === 0) {
+    return {
+      kind: "struct",
+      address: normalizeAddress(address),
+      module,
+      name,
+      args
+    };
+  }
+  return { kind: "opaque", raw: type };
+}
+function normalizeAddress(address) {
+  return address.replace(/^0x0+(?=[0-9a-fA-F])/, "0x");
+}
+function formatMoveType(node) {
+  switch (node.kind) {
+    case "prim":
+      return node.prim;
+    case "vector":
+      return `vector<${formatMoveType(node.inner)}>`;
+    case "param":
+      return `$${node.index}`;
+    case "opaque":
+      return node.raw;
+    case "struct": {
+      const base = `${node.address}::${node.module}::${node.name}`;
+      return node.args.length === 0 ? base : `${base}<${node.args.map(formatMoveType).join(", ")}>`;
+    }
+  }
+}
+function substituteTypeParams(node, args) {
+  switch (node.kind) {
+    case "param":
+      return args[node.index] ?? node;
+    case "vector":
+      return { kind: "vector", inner: substituteTypeParams(node.inner, args) };
+    case "struct":
+      return {
+        ...node,
+        args: node.args.map((a) => substituteTypeParams(a, args))
+      };
+    default:
+      return node;
+  }
+}
+var MAX_DEPTH = 6;
+async function resolveShape(node, resolveStruct, depth = 0, stack = []) {
+  switch (node.kind) {
+    case "prim":
+      switch (node.prim) {
+        case "u8":
+        case "u16":
+        case "u32":
+          return { kind: "smallUint" };
+        case "u64":
+        case "u128":
+        case "u256":
+          return { kind: "uint" };
+        case "bool":
+          return { kind: "bool" };
+        case "address":
+        case "signer":
+          return { kind: "address" };
+        default:
+          return { kind: "unknown" };
+      }
+    case "vector":
+      if (node.inner.kind === "prim" && node.inner.prim === "u8") {
+        return { kind: "bytes" };
+      }
+      return {
+        kind: "vector",
+        inner: await resolveShape(node.inner, resolveStruct, depth, stack)
+      };
+    case "param":
+    case "opaque":
+      return { kind: "unknown" };
+    case "struct": {
+      const base = `${node.address}::${node.module}::${node.name}`;
+      switch (base) {
+        case "0x1::string::String":
+        case "0x1::ascii::String":
+        case "0x2::url::Url":
+          return { kind: "string" };
+        case "0x1::type_name::TypeName":
+          return { kind: "typeName" };
+        case "0x2::object::ID":
+          return { kind: "address" };
+        case "0x2::balance::Balance":
+          return { kind: "balance" };
+        case "0x1::option::Option": {
+          const inner = node.args[0];
+          if (node.args.length === 1 && inner) {
+            return {
+              kind: "option",
+              inner: await resolveShape(inner, resolveStruct, depth, stack)
+            };
+          }
+          return { kind: "unknown" };
+        }
+      }
+      const key = formatMoveType(node);
+      if (depth >= MAX_DEPTH || stack.includes(key)) {
+        return { kind: "unknown" };
+      }
+      const definition = await resolveStruct(node);
+      if (!definition) {
+        return { kind: "unknown" };
+      }
+      const fields = await Promise.all(
+        definition.map(async (field) => ({
+          name: field.name,
+          value: await resolveShape(
+            substituteTypeParams(field.type, node.args),
+            resolveStruct,
+            depth + 1,
+            [...stack, key]
+          )
+        }))
+      );
+      return { kind: "object", fields };
+    }
+  }
+}
+function shapeToZod(shape) {
+  switch (shape.kind) {
+    case "smallUint":
+      return moveSmallUint;
+    case "uint":
+      return moveUint;
+    case "bool":
+      return moveBool;
+    case "address":
+      return moveAddress;
+    case "string":
+      return moveString;
+    case "typeName":
+      return moveTypeName;
+    case "balance":
+      return moveBalance;
+    case "bytes":
+      return moveBytes;
+    case "option":
+      return shapeToZod(shape.inner).nullable();
+    case "vector":
+      return z2.array(shapeToZod(shape.inner));
+    case "object":
+      return z2.looseObject(
+        Object.fromEntries(
+          shape.fields.map((f) => [f.name, shapeToZod(f.value)])
+        )
+      );
+    case "unknown":
+      return z2.unknown();
+  }
+}
+var PRIMITIVE_EXPRS = {
+  smallUint: "moveSmallUint",
+  uint: "moveUint",
+  bool: "moveBool",
+  address: "moveAddress",
+  string: "moveString",
+  typeName: "moveTypeName",
+  balance: "moveBalance",
+  bytes: "moveBytes"
+};
+function shapeToExpr(shape, used, indent = "") {
+  const primitive = PRIMITIVE_EXPRS[shape.kind];
+  if (primitive) {
+    used.add(primitive);
+    return primitive;
+  }
+  switch (shape.kind) {
+    case "option":
+      return `${shapeToExpr(shape.inner, used, indent)}.nullable()`;
+    case "vector":
+      return `z.array(${shapeToExpr(shape.inner, used, indent)})`;
+    case "object": {
+      const lines = ["z.looseObject({"];
+      for (const field of shape.fields) {
+        lines.push(
+          `${indent}	${JSON.stringify(field.name)}: ${shapeToExpr(field.value, used, `${indent}	`)},`
+        );
+      }
+      lines.push(`${indent}})`);
+      return lines.join("\n");
+    }
+    default:
+      return "z.unknown()";
+  }
+}
+
+// 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/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 graphqlUrl(network) {
+  return INODRA_ENDPOINTS[network].graphql;
+}
+
+// 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/events/reflection.ts
+var STRUCT_QUERY = `query($pkg: SuiAddress!, $module: String!, $struct: String!) {
+	package(address: $pkg) {
+		module(name: $module) { struct(name: $struct) { fields { name type { repr } } } }
+	}
+}`;
+var EventSchemaReflector = class {
+  url;
+  headers;
+  fetchImpl;
+  /** Struct-definition cache, keyed by `address::module::name`. */
+  structs = /* @__PURE__ */ new Map();
+  /** Resolved shape cache, keyed by the canonical concrete type string. */
+  shapes = /* @__PURE__ */ new Map();
+  schemas = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.url = options.url ?? graphqlUrl(options.network ?? "mainnet");
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    const headers = {
+      "content-type": "application/json",
+      [SDK_HEADER_NAME]: SDK_HEADER_VALUE
+    };
+    if (options.auth !== void 0 || options.apiKey) {
+      const credentials = authFromOptions(
+        options,
+        "EventSchemaReflector"
+      ).staticCredentials();
+      if (!credentials) {
+        throw new Error(
+          "EventSchemaReflector does not support dynamic credential providers"
+        );
+      }
+      Object.assign(headers, credentials.headers);
+    }
+    this.headers = headers;
+  }
+  /**
+   * Resolved schema shape for a concrete Move type (cached). Useful for
+   * codegen and introspection; most callers want {@link schemaFor}.
+   */
+  shapeFor(type) {
+    const node = parseMoveType(type);
+    const key = formatMoveType(node);
+    let pending = this.shapes.get(key);
+    if (!pending) {
+      pending = resolveShape(node, (struct) => this.structFields(struct));
+      this.shapes.set(key, pending);
+      pending.catch(() => this.shapes.delete(key));
+    }
+    return pending;
+  }
+  /**
+   * Build (and cache) a loose, normalizing zod schema for any concrete Move
+   * event type. Same encoding rules as the generated catalog schemas.
+   */
+  schemaFor(type) {
+    const key = formatMoveType(parseMoveType(type));
+    let pending = this.schemas.get(key);
+    if (!pending) {
+      pending = this.shapeFor(type).then((shape) => {
+        if (shape.kind !== "object") {
+          throw new Error(
+            `${type} did not resolve to a struct \u2014 is it a Move event type on this network?`
+          );
+        }
+        return shapeToZod(shape);
+      });
+      this.schemas.set(key, pending);
+      pending.catch(() => this.schemas.delete(key));
+    }
+    return pending;
+  }
+  /**
+   * Validate + normalize an event payload against the reflected schema.
+   * Accepts a Warp stream message, a bare `{type, data}` event payload, or
+   * a webhook body. Returns undefined when the message carries a different
+   * event type; throws when the payload doesn't fit the reflected schema.
+   *
+   * Matching: exact when `type` is fully instantiated; base-type when
+   * `type` has no generics (all instantiations match).
+   */
+  async parseEvent(message, type) {
+    const payload = extractEventPayload(message);
+    if (!payload) {
+      return void 0;
+    }
+    const canonical = (t) => formatMoveType(parseMoveType(t));
+    const requested = canonical(type);
+    const matches = type.includes("<") ? canonical(payload.type) === requested : canonical(baseEventType(payload.type)) === requested;
+    if (!matches) {
+      return void 0;
+    }
+    const schema = await this.schemaFor(
+      type.includes("<") ? type : payload.type
+    );
+    return schema.parse(payload.data);
+  }
+  structFields(struct) {
+    const key = `${struct.address}::${struct.module}::${struct.name}`;
+    let pending = this.structs.get(key);
+    if (!pending) {
+      pending = this.fetchStruct(struct);
+      this.structs.set(key, pending);
+      pending.catch(() => this.structs.delete(key));
+    }
+    return pending;
+  }
+  async fetchStruct(struct) {
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        const response = await this.fetchImpl(this.url, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify({
+            query: STRUCT_QUERY,
+            variables: {
+              pkg: struct.address,
+              module: struct.module,
+              struct: struct.name
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`GraphQL reflection failed: HTTP ${response.status}`);
+        }
+        const body = await response.json();
+        if (body.errors) {
+          throw new Error(
+            `GraphQL reflection errors: ${JSON.stringify(body.errors)}`
+          );
+        }
+        const fields = body.data?.package?.module?.struct?.fields;
+        if (!fields) {
+          return void 0;
+        }
+        return fields.map((field) => ({
+          name: field.name,
+          type: parseMoveType(field.type.repr)
+        }));
+      } catch (error) {
+        lastError = error;
+        await new Promise((r) => setTimeout(r, 300 * 2 ** attempt));
+      }
+    }
+    throw lastError;
+  }
+};
+function extractEventPayload(input, depth = 0) {
+  if (depth > 3 || typeof input !== "object" || input === null) {
+    return void 0;
+  }
+  const record = input;
+  if (typeof record.type === "string" && record.type.includes("::") && "data" in record) {
+    return { type: record.type, data: record.data };
+  }
+  return extractEventPayload(record.payload, depth + 1) ?? extractEventPayload(record.data, depth + 1);
+}
+
+// src/cli.ts
+function fail(message) {
+  console.error(`inodra-sui: ${message}`);
+  process.exit(1);
+}
+function pascal(value) {
+  const name = value.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => (part[0]?.toUpperCase() ?? "") + part.slice(1)).join("");
+  return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+function parseArgs(argv) {
+  const args = {
+    types: [],
+    network: "mainnet",
+    importFrom: "@inodra/sui/events"
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    switch (arg) {
+      case "-o":
+      case "--out":
+        args.out = argv[++i];
+        break;
+      case "--network":
+        args.network = argv[++i];
+        break;
+      case "--url":
+        args.url = argv[++i];
+        break;
+      case "--import-from":
+        args.importFrom = argv[++i] ?? args.importFrom;
+        break;
+      default:
+        if (arg.startsWith("-")) {
+          fail(`unknown option ${arg}`);
+        }
+        args.types.push(arg);
+    }
+  }
+  return args;
+}
+async function codegenEvents(args) {
+  if (args.types.length === 0) {
+    fail("pass at least one Move event type");
+  }
+  const apiKey = process.env.INODRA_API_KEY;
+  const url = args.url ?? (apiKey ? void 0 : `https://graphql.${args.network}.sui.io/graphql`);
+  const reflector = new EventSchemaReflector({
+    ...apiKey && !args.url ? { apiKey } : {},
+    network: args.network,
+    url
+  });
+  const used = /* @__PURE__ */ new Set();
+  const blocks = [];
+  const mapEntries = [];
+  const seenNames = /* @__PURE__ */ new Map();
+  for (const rawType of args.types) {
+    const node = parseMoveType(rawType);
+    if (node.kind !== "struct") {
+      fail(`${rawType} is not a struct event type`);
+    }
+    const canonical = formatMoveType(node);
+    let shape;
+    try {
+      shape = await reflector.shapeFor(canonical);
+    } catch (error) {
+      fail(`reflection failed for ${canonical}: ${error.message}`);
+    }
+    if (shape.kind !== "object") {
+      fail(`${canonical} did not resolve to a struct on ${args.network}`);
+    }
+    let name = pascal(`${node.module} ${node.name}`);
+    const clashes = seenNames.get(name) ?? 0;
+    seenNames.set(name, clashes + 1);
+    if (clashes > 0) {
+      name = `${name}${clashes + 1}`;
+    }
+    blocks.push(
+      [
+        `/** ${canonical} */`,
+        `export const ${name}Schema = ${shapeToExpr(shape, used)};`,
+        `export type ${name}Event = z.infer<typeof ${name}Schema>;`
+      ].join("\n")
+    );
+    mapEntries.push(`	${JSON.stringify(canonical)}: ${name}Schema,`);
+  }
+  const primitiveImports = used.size > 0 ? `import {
+	${[...used].sort().join(",\n	")},
+} from ${JSON.stringify(args.importFrom)};
+` : "";
+  const source = `// Generated by inodra-sui v${SDK_VERSION} (codegen-events). DO NOT EDIT.
+// Regenerate: inodra-sui codegen-events ${args.types.map((t) => JSON.stringify(t)).join(" ")}${args.out ? ` -o ${args.out}` : ""}
+import { z } from "zod";
+${primitiveImports}
+${blocks.join("\n\n")}
+
+/** Reflected schemas keyed by canonical Move event type. */
+export const reflectedEventSchemas = {
+${mapEntries.join("\n")}
+} as const;
+`;
+  if (args.out) {
+    writeFileSync(args.out, source);
+    console.error(
+      `inodra-sui: wrote ${args.out} (${args.types.length} event type(s))`
+    );
+  } else {
+    process.stdout.write(source);
+  }
+}
+var [command, ...rest] = process.argv.slice(2);
+switch (command) {
+  case "codegen-events":
+    await codegenEvents(parseArgs(rest));
+    break;
+  case void 0:
+  case "help":
+  case "--help":
+    console.log(
+      "Usage: inodra-sui codegen-events <moveEventType...> [-o out.ts] [--network mainnet|testnet] [--url <graphql>] [--import-from <spec>]"
+    );
+    break;
+  default:
+    fail(`unknown command ${command} \u2014 try: inodra-sui help`);
+}
+//# sourceMappingURL=cli.js.map