@inodra/sui 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4723 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/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 staticAuthHeaders(options, context) {
+  const credentials = authFromOptions(options, context).staticCredentials();
+  if (!credentials) {
+    throw new Error(
+      `${context} does not support dynamic credential providers \u2014 pass an apiKey or sessionToken`
+    );
+  }
+  return credentials.headers;
+}
+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
+  };
+}
+var init_auth = __esm({
+  "src/core/auth.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/network.ts
+function restBaseUrl(network) {
+  return INODRA_ENDPOINTS[network].rest;
+}
+function graphqlUrl(network) {
+  return INODRA_ENDPOINTS[network].graphql;
+}
+function grpcBaseUrl(network) {
+  return INODRA_ENDPOINTS[network].grpcWeb;
+}
+function warpStreamUrl(network, subscriptionId) {
+  return `${INODRA_ENDPOINTS[network].rest}/warp/${subscriptionId}/stream`;
+}
+function warpWebSocketUrl(network, subscriptionId) {
+  return `${INODRA_ENDPOINTS[network].warpWs}/warp/${subscriptionId}/ws`;
+}
+var INODRA_ENDPOINTS;
+var init_network = __esm({
+  "src/core/network.ts"() {
+    "use strict";
+    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"
+      }
+    };
+  }
+});
+
+// src/core/version.ts
+var SDK_VERSION, SDK_HEADER_NAME, SDK_HEADER_VALUE;
+var init_version = __esm({
+  "src/core/version.ts"() {
+    "use strict";
+    SDK_VERSION = "0.1.0";
+    SDK_HEADER_NAME = "x-inodra-sdk";
+    SDK_HEADER_VALUE = `inodra-sdk-ts/${SDK_VERSION}`;
+  }
+});
+
+// src/events/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  baseEventType: () => baseEventType,
+  eventTypeMatches: () => eventTypeMatches,
+  innerEventType: () => innerEventType,
+  moveAddress: () => moveAddress,
+  moveBalance: () => moveBalance,
+  moveBool: () => moveBool,
+  moveBytes: () => moveBytes,
+  moveSmallUint: () => moveSmallUint,
+  moveString: () => moveString,
+  moveTypeName: () => moveTypeName,
+  moveUint: () => moveUint,
+  warpAddressPayloadSchema: () => warpAddressPayloadSchema,
+  warpCoinPayloadSchema: () => warpCoinPayloadSchema,
+  warpEventPayloadSchema: () => warpEventPayloadSchema,
+  warpObjectPayloadSchema: () => warpObjectPayloadSchema,
+  webhookEventBodySchema: () => webhookEventBodySchema
+});
+function baseEventType(eventType) {
+  const idx = eventType.indexOf("<");
+  return idx === -1 ? eventType : eventType.slice(0, idx);
+}
+function innerEventType(eventType) {
+  const start = eventType.indexOf("<");
+  if (start === -1 || !eventType.endsWith(">")) {
+    return void 0;
+  }
+  return eventType.slice(start + 1, -1);
+}
+function eventTypeMatches(rawEventType, deployment, generic) {
+  if (generic) {
+    return baseEventType(rawEventType) === deployment.eventType;
+  }
+  return rawEventType === deployment.eventType;
+}
+var import_zod, moveSmallUint, moveUint, moveBool, moveAddress, moveString, moveTypeName, moveBalance, moveBytes, warpEventPayloadSchema, warpAddressPayloadSchema, warpCoinPayloadSchema, warpObjectPayloadSchema, webhookEventBodySchema;
+var init_runtime = __esm({
+  "src/events/runtime.ts"() {
+    "use strict";
+    import_zod = require("zod");
+    moveSmallUint = import_zod.z.number();
+    moveUint = import_zod.z.union([import_zod.z.string(), import_zod.z.number()]).transform((value) => String(value));
+    moveBool = import_zod.z.boolean();
+    moveAddress = import_zod.z.string();
+    moveString = import_zod.z.string();
+    moveTypeName = import_zod.z.union([import_zod.z.string(), import_zod.z.looseObject({ name: import_zod.z.string() })]).transform((value) => typeof value === "string" ? value : value.name);
+    moveBalance = import_zod.z.union([
+      import_zod.z.string(),
+      import_zod.z.number(),
+      import_zod.z.looseObject({ value: import_zod.z.union([import_zod.z.string(), import_zod.z.number()]) })
+    ]).transform(
+      (value) => typeof value === "object" ? String(value.value) : String(value)
+    );
+    moveBytes = import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.number())]);
+    warpEventPayloadSchema = import_zod.z.looseObject({
+      activityType: import_zod.z.literal("package_event"),
+      txDigest: import_zod.z.string(),
+      eventSequence: import_zod.z.number(),
+      checkpoint: import_zod.z.number(),
+      timestamp: import_zod.z.number(),
+      /** Full concrete Move event type. */
+      type: import_zod.z.string(),
+      sender: import_zod.z.string(),
+      /** Decoded Move event payload — type with the generated catalog schemas. */
+      data: import_zod.z.unknown()
+    });
+    warpAddressPayloadSchema = import_zod.z.looseObject({
+      address: import_zod.z.string(),
+      activityType: import_zod.z.string(),
+      txDigest: import_zod.z.string(),
+      checkpoint: import_zod.z.number(),
+      timestamp: import_zod.z.number(),
+      objectId: import_zod.z.string().optional(),
+      objectType: import_zod.z.string().optional()
+    });
+    warpCoinPayloadSchema = import_zod.z.looseObject({
+      activityType: import_zod.z.literal("balance_change"),
+      address: import_zod.z.string(),
+      coin_type: import_zod.z.string(),
+      /** Signed amount, string for precision. */
+      amount: import_zod.z.string(),
+      txDigest: import_zod.z.string(),
+      checkpoint: import_zod.z.number(),
+      timestamp: import_zod.z.number()
+    });
+    warpObjectPayloadSchema = import_zod.z.looseObject({
+      activityType: import_zod.z.literal("object_change"),
+      object_id: import_zod.z.string(),
+      transactionDirection: import_zod.z.string(),
+      writeKind: import_zod.z.string(),
+      owner: import_zod.z.string().optional(),
+      previousOwner: import_zod.z.string().optional(),
+      txDigest: import_zod.z.string(),
+      checkpoint: import_zod.z.number(),
+      timestamp: import_zod.z.number()
+    });
+    webhookEventBodySchema = import_zod.z.looseObject({
+      payloadVersion: import_zod.z.number(),
+      payload: warpEventPayloadSchema.extend({ webhookId: import_zod.z.string() })
+    });
+  }
+});
+
+// src/events/move-types.ts
+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, module2, name, ...rest] = base.split("::");
+  if (address?.startsWith("0x") && module2 && name && rest.length === 0) {
+    return {
+      kind: "struct",
+      address: normalizeAddress(address),
+      module: module2,
+      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;
+  }
+}
+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 import_zod2.z.array(shapeToZod(shape.inner));
+    case "object":
+      return import_zod2.z.looseObject(
+        Object.fromEntries(
+          shape.fields.map((f) => [f.name, shapeToZod(f.value)])
+        )
+      );
+    case "unknown":
+      return import_zod2.z.unknown();
+  }
+}
+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()";
+  }
+}
+var import_zod2, PRIMITIVES, MAX_DEPTH, PRIMITIVE_EXPRS;
+var init_move_types = __esm({
+  "src/events/move-types.ts"() {
+    "use strict";
+    import_zod2 = require("zod");
+    init_runtime();
+    PRIMITIVES = /* @__PURE__ */ new Set([
+      "u8",
+      "u16",
+      "u32",
+      "u64",
+      "u128",
+      "u256",
+      "bool",
+      "address",
+      "signer"
+    ]);
+    MAX_DEPTH = 6;
+    PRIMITIVE_EXPRS = {
+      smallUint: "moveSmallUint",
+      uint: "moveUint",
+      bool: "moveBool",
+      address: "moveAddress",
+      string: "moveString",
+      typeName: "moveTypeName",
+      balance: "moveBalance",
+      bytes: "moveBytes"
+    };
+  }
+});
+
+// src/events/reflection.ts
+var reflection_exports = {};
+__export(reflection_exports, {
+  EventSchemaReflector: () => EventSchemaReflector
+});
+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);
+}
+var STRUCT_QUERY, EventSchemaReflector;
+var init_reflection = __esm({
+  "src/events/reflection.ts"() {
+    "use strict";
+    init_auth();
+    init_network();
+    init_version();
+    init_move_types();
+    init_runtime();
+    STRUCT_QUERY = `query($pkg: SuiAddress!, $module: String!, $struct: String!) {
+	package(address: $pkg) {
+		module(name: $module) { struct(name: $struct) { fields { name type { repr } } } }
+	}
+}`;
+    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 matches2 = type.includes("<") ? canonical(payload.type) === requested : canonical(baseEventType(payload.type)) === requested;
+        if (!matches2) {
+          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;
+      }
+    };
+  }
+});
+
+// src/generated/events.ts
+var import_zod3, _7kConfirmSwapSchema, _7kSwapSchema, AftermathDepositSchema, AftermathPerpFundingSchema, AftermathPerpLiquidatedSchema, AftermathSwapSchema, AlphafiLiquidityChangeSchema, AlphafiRewardSchema, BluefinFeeCollectedSchema, BluefinLiquidityProvidedSchema, BluefinLiquidityRemovedSchema, BluefinPoolCreatedSchema, BluefinPositionClosedSchema, BluefinPositionOpenedSchema, BluefinRewardCollectedSchema, BluefinSwapSchema, BucketBorrowSchema, BucketDepositCollateralSchema, BucketPositionUpdatedSchema, BucketRedeemSchema, BucketRepaySchema, BucketSbuckDepositSchema, BucketSbuckRewardsSchema, BucketWithdrawCollateralSchema, CetusAddLiquiditySchema, CetusClosePositionSchema, CetusCollectFeeSchema, CetusCreatePoolSchema, CetusOpenPositionSchema, CetusRemoveLiquiditySchema, CetusSwapSchema, CurrentBorrowSchema, CurrentDepositSchema, CurrentLiquidateSchema, CurrentRepaySchema, CurrentWithdrawSchema, DeepbookBalanceSchema, DeepbookFlashLoanSchema, DeepbookOrderCanceledSchema, DeepbookOrderFilledSchema, DeepbookOrderInfoSchema, DeepbookOrderPlacedSchema, EmberDepositSchema, EmberRateUpdatedSchema, EmberRedeemProcessedSchema, EmberRedeemRequestSchema, FlowxAmmPairCreatedSchema, FlowxAmmSwapSchema, FlowxClmmPoolCreatedSchema, FlowxClmmSwapSchema, HaedalInstantUnstakedSchema, HaedalStakedSchema, HaedalUnstakedSchema, KaiAddLiquiditySchema, KaiDeleverageSchema, KaiLiquidationSchema, KaiPositionOpenSchema, KaiReduceSchema, KaiSupplySchema, KaiSupplyWithdrawSchema, KriyaAddLiquiditySchema, KriyaSwapSchema, MagmaAddLiquiditySchema, MagmaCollectFeeSchema, MagmaCollectRewardSchema, MagmaCreatePoolSchema, MagmaRemoveLiquiditySchema, MagmaSwapSchema, MoleAddDebtSchema, MoleDepositSchema, MoleHarvestSchema, MoleKillSchema, MoleWithdrawSchema, MoleWorkSchema, MomentumAddLiquiditySchema, MomentumCollectFeeSchema, MomentumCollectRewardSchema, MomentumPoolCreatedSchema, MomentumRemoveLiquiditySchema, MomentumRepayFlashSwapSchema, MomentumSwapSchema, NaviBorrowSchema, NaviDepositSchema, NaviLiquidationSchema, NaviRepaySchema, NaviWithdrawSchema, PythPriceFeedUpdateSchema, ScallopBorrowSchema, ScallopCollateralDepositSchema, ScallopCollateralWithdrawSchema, ScallopLiquidationSchema, ScallopRepaySchema, SpringsuiEpochChangedSchema, SpringsuiStakeSchema, SpringsuiUnstakeSchema, SteammBankDepositSchema, SteammBankWithdrawSchema, SuilendBorrowSchema, SuilendClaimRewardSchema, SuilendDepositSchema, SuilendLiquidateSchema, SuilendRepaySchema, SuilendWithdrawSchema, SupraPriceUpdateSchema, TurbosAddLiquiditySchema, TurbosPoolCreatedSchema, TurbosRemoveLiquiditySchema, TurbosSwapSchema, TypusDovAuctionSchema, TypusDovBidSchema, TypusDovSettleSchema, TypusPerpFundingSchema, TypusPerpLiquidateSchema, TypusPerpLpBurnSchema, TypusPerpLpMintSchema, TypusPerpOrderSchema, VoloStakedSchema, VoloUnstakedSchema, WalrusBlobCertifiedSchema, WalrusBlobDeletedSchema, WalrusBlobRegisteredSchema, catalogEvents;
+var init_events = __esm({
+  "src/generated/events.ts"() {
+    "use strict";
+    import_zod3 = require("zod");
+    init_runtime();
+    _7kConfirmSwapSchema = import_zod3.z.looseObject({
+      "quote_id": moveString,
+      "from": moveTypeName,
+      "target": moveTypeName,
+      "amount_in": moveUint,
+      "amount_out": moveUint,
+      "fee_amount": moveUint,
+      "fee_rate": moveSmallUint,
+      "fee_recipient": moveAddress,
+      "expect_amount_out": moveUint,
+      "amount_out_limit": moveUint
+    });
+    _7kSwapSchema = import_zod3.z.looseObject({
+      "quote_id": moveString,
+      "pool_id": moveAddress,
+      "dex": moveString,
+      "from": moveTypeName,
+      "target": moveTypeName,
+      "amount_in": moveUint,
+      "amount_out": moveUint,
+      "amount_in_remaining": moveUint
+    });
+    AftermathDepositSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "issuer": moveAddress,
+      "referrer": moveAddress.nullable(),
+      "types": import_zod3.z.array(moveString),
+      "deposits": import_zod3.z.array(moveUint),
+      "reserves": import_zod3.z.array(moveUint),
+      "lp_coins_minted": moveUint
+    });
+    AftermathPerpFundingSchema = import_zod3.z.looseObject({
+      "ch_id": moveAddress,
+      "account_id": moveUint,
+      "collateral_change_usd": moveUint,
+      "collateral_after": moveUint
+    });
+    AftermathPerpLiquidatedSchema = import_zod3.z.looseObject({
+      "ch_id": moveAddress,
+      "liqee_account_id": moveUint,
+      "liqor_account_id": moveUint,
+      "is_liqee_long": moveBool,
+      "base_liquidated": moveUint,
+      "quote_liquidated": moveUint,
+      "bad_debt": moveUint
+    });
+    AftermathSwapSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "issuer": moveAddress,
+      "referrer": moveAddress.nullable(),
+      "types_in": import_zod3.z.array(moveString),
+      "amounts_in": import_zod3.z.array(moveUint),
+      "types_out": import_zod3.z.array(moveString),
+      "amounts_out": import_zod3.z.array(moveUint),
+      "reserves": import_zod3.z.array(moveUint)
+    });
+    AlphafiLiquidityChangeSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "event_type": moveSmallUint,
+      "amount_a": moveUint,
+      "amount_b": moveUint,
+      "total_amount_a": moveUint,
+      "total_amount_b": moveUint,
+      "fee_collected_a": moveUint,
+      "fee_collected_b": moveUint,
+      "tokens_invested": moveUint,
+      "sender": moveAddress
+    });
+    AlphafiRewardSchema = import_zod3.z.looseObject({
+      "coin_type": moveTypeName,
+      "amount": moveUint,
+      "investor_id": moveAddress,
+      "fee_collected": moveUint,
+      "total_amount_a": moveUint,
+      "total_amount_b": moveUint,
+      "sender": moveAddress
+    });
+    BluefinFeeCollectedSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "coin_a_amount": moveUint,
+      "coin_b_amount": moveUint
+    });
+    BluefinLiquidityProvidedSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "coin_a_amount": moveUint,
+      "coin_b_amount": moveUint,
+      "liquidity": moveUint
+    });
+    BluefinLiquidityRemovedSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "coin_a_amount": moveUint,
+      "coin_b_amount": moveUint,
+      "liquidity": moveUint
+    });
+    BluefinPoolCreatedSchema = import_zod3.z.looseObject({
+      "id": moveAddress,
+      "coin_a": moveString,
+      "coin_b": moveString,
+      "fee_rate": moveUint,
+      "tick_spacing": moveSmallUint
+    });
+    BluefinPositionClosedSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "position_id": moveAddress
+    });
+    BluefinPositionOpenedSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "position_id": moveAddress
+    });
+    BluefinRewardCollectedSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "reward_type": moveString,
+      "reward_symbol": moveString,
+      "reward_amount": moveUint
+    });
+    BluefinSwapSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "a2b": moveBool,
+      "amount_in": moveUint,
+      "amount_out": moveUint,
+      "fee": moveUint,
+      "after_sqrt_price": moveUint,
+      "sequence_number": moveUint
+    });
+    BucketBorrowSchema = import_zod3.z.looseObject({
+      "collateral_type": moveString,
+      "buck_amount": moveUint
+    });
+    BucketDepositCollateralSchema = import_zod3.z.looseObject({
+      "collateral_type": moveString,
+      "collateral_amount": moveUint
+    });
+    BucketPositionUpdatedSchema = import_zod3.z.looseObject({
+      "collateral_type": moveString,
+      "debtor": moveAddress,
+      "bottle_id": moveAddress,
+      "collateral_amount": moveUint,
+      "buck_amount": moveUint
+    });
+    BucketRedeemSchema = import_zod3.z.looseObject({
+      "collateral_type": moveString,
+      "input_buck_amount": moveUint,
+      "output_collateral_amount": moveUint
+    });
+    BucketRepaySchema = import_zod3.z.looseObject({
+      "collateral_type": moveString,
+      "buck_amount": moveUint
+    });
+    BucketSbuckDepositSchema = import_zod3.z.looseObject({
+      "buck_amount": moveUint,
+      "sbuck_share": moveUint
+    });
+    BucketSbuckRewardsSchema = import_zod3.z.looseObject({
+      "buck_amount": moveUint
+    });
+    BucketWithdrawCollateralSchema = import_zod3.z.looseObject({
+      "collateral_type": moveString,
+      "collateral_amount": moveUint
+    });
+    CetusAddLiquiditySchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "position": moveAddress,
+      "liquidity": moveUint,
+      "after_liquidity": moveUint,
+      "amount_a": moveUint,
+      "amount_b": moveUint
+    });
+    CetusClosePositionSchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "position": moveAddress
+    });
+    CetusCollectFeeSchema = import_zod3.z.looseObject({
+      "position": moveAddress,
+      "pool": moveAddress,
+      "amount_a": moveUint,
+      "amount_b": moveUint
+    });
+    CetusCreatePoolSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "coin_type_a": moveString,
+      "coin_type_b": moveString,
+      "tick_spacing": moveSmallUint
+    });
+    CetusOpenPositionSchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "position": moveAddress
+    });
+    CetusRemoveLiquiditySchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "position": moveAddress,
+      "liquidity": moveUint,
+      "after_liquidity": moveUint,
+      "amount_a": moveUint,
+      "amount_b": moveUint
+    });
+    CetusSwapSchema = import_zod3.z.looseObject({
+      "atob": moveBool,
+      "pool": moveAddress,
+      "partner": moveAddress,
+      "amount_in": moveUint,
+      "amount_out": moveUint,
+      "fee_amount": moveUint,
+      "before_sqrt_price": moveUint,
+      "after_sqrt_price": moveUint,
+      "steps": moveUint
+    });
+    CurrentBorrowSchema = import_zod3.z.looseObject({
+      "borrower": moveAddress,
+      "market": moveTypeName,
+      "obligation": moveAddress,
+      "asset": moveTypeName,
+      "amount": moveUint,
+      "time": moveUint
+    });
+    CurrentDepositSchema = import_zod3.z.looseObject({
+      "minter": moveAddress,
+      "market": moveTypeName,
+      "obligation": moveAddress,
+      "deposit_asset": moveTypeName,
+      "deposit_amount": moveUint,
+      "ctoken_amount": moveUint,
+      "time": moveUint
+    });
+    CurrentLiquidateSchema = import_zod3.z.looseObject({
+      "liquidator": moveAddress,
+      "market": moveTypeName,
+      "obligation": moveAddress,
+      "collateral_type": moveTypeName,
+      "debt_type": moveTypeName,
+      "seized_collateral_amount": moveUint,
+      "repay_amount": moveUint,
+      "refund_amount": moveUint,
+      "timestamp": moveUint
+    });
+    CurrentRepaySchema = import_zod3.z.looseObject({
+      "repayer": moveAddress,
+      "market": moveTypeName,
+      "obligation": moveAddress,
+      "asset": moveTypeName,
+      "amount": moveUint,
+      "refund": moveUint,
+      "time": moveUint
+    });
+    CurrentWithdrawSchema = import_zod3.z.looseObject({
+      "redeemer": moveAddress,
+      "market": moveTypeName,
+      "obligation": moveAddress,
+      "withdraw_asset": moveTypeName,
+      "withdraw_amount": moveUint,
+      "time": moveUint
+    });
+    DeepbookBalanceSchema = import_zod3.z.looseObject({
+      "balance_manager_id": moveAddress,
+      "asset": moveTypeName,
+      "amount": moveUint,
+      "deposit": moveBool
+    });
+    DeepbookFlashLoanSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "borrow_quantity": moveUint,
+      "type_name": moveTypeName
+    });
+    DeepbookOrderCanceledSchema = import_zod3.z.looseObject({
+      "balance_manager_id": moveAddress,
+      "pool_id": moveAddress,
+      "order_id": moveUint,
+      "trader": moveAddress,
+      "price": moveUint,
+      "is_bid": moveBool,
+      "original_quantity": moveUint,
+      "base_asset_quantity_canceled": moveUint,
+      "timestamp": moveUint
+    });
+    DeepbookOrderFilledSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "maker_order_id": moveUint,
+      "taker_order_id": moveUint,
+      "price": moveUint,
+      "taker_is_bid": moveBool,
+      "base_quantity": moveUint,
+      "quote_quantity": moveUint,
+      "taker_fee": moveUint,
+      "maker_fee": moveUint,
+      "timestamp": moveUint
+    });
+    DeepbookOrderInfoSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "order_id": moveUint,
+      "balance_manager_id": moveAddress,
+      "client_order_id": moveUint,
+      "trader": moveAddress,
+      "order_type": moveSmallUint,
+      "price": moveUint,
+      "is_bid": moveBool,
+      "original_quantity": moveUint,
+      "executed_quantity": moveUint,
+      "status": moveSmallUint,
+      "timestamp": moveUint
+    });
+    DeepbookOrderPlacedSchema = import_zod3.z.looseObject({
+      "balance_manager_id": moveAddress,
+      "pool_id": moveAddress,
+      "order_id": moveUint,
+      "client_order_id": moveUint,
+      "trader": moveAddress,
+      "price": moveUint,
+      "is_bid": moveBool,
+      "placed_quantity": moveUint,
+      "expire_timestamp": moveUint,
+      "timestamp": moveUint
+    });
+    EmberDepositSchema = import_zod3.z.looseObject({
+      "vault_id": moveAddress,
+      "owner": moveAddress,
+      "total_amount": moveUint,
+      "shares_minted": moveUint,
+      "current_balance": moveUint,
+      "total_shares": moveUint,
+      "sequence_number": moveUint
+    });
+    EmberRateUpdatedSchema = import_zod3.z.looseObject({
+      "vault_id": moveAddress,
+      "previous_rate": moveUint,
+      "new_rate": moveUint,
+      "sequence_number": moveUint
+    });
+    EmberRedeemProcessedSchema = import_zod3.z.looseObject({
+      "vault_id": moveAddress,
+      "owner": moveAddress,
+      "receiver": moveAddress,
+      "shares": moveUint,
+      "withdraw_amount": moveUint,
+      "skipped": moveBool,
+      "cancelled": moveBool,
+      "sequence_number": moveUint
+    });
+    EmberRedeemRequestSchema = import_zod3.z.looseObject({
+      "vault_id": moveAddress,
+      "owner": moveAddress,
+      "receiver": moveAddress,
+      "shares": moveUint,
+      "total_shares": moveUint,
+      "sequence_number": moveUint
+    });
+    FlowxAmmPairCreatedSchema = import_zod3.z.looseObject({
+      "user": moveAddress,
+      "coin_x": moveString,
+      "coin_y": moveString
+    });
+    FlowxAmmSwapSchema = import_zod3.z.looseObject({
+      "user": moveAddress,
+      "coin_x": moveString,
+      "coin_y": moveString,
+      "amount_x_in": moveUint,
+      "amount_y_in": moveUint,
+      "amount_x_out": moveUint,
+      "amount_y_out": moveUint
+    });
+    FlowxClmmPoolCreatedSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "coin_type_x": moveTypeName,
+      "coin_type_y": moveTypeName,
+      "fee_rate": moveUint,
+      "tick_spacing": moveSmallUint
+    });
+    FlowxClmmSwapSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "x_for_y": moveBool,
+      "amount_x": moveUint,
+      "amount_y": moveUint,
+      "liquidity": moveUint,
+      "fee_amount": moveUint
+    });
+    HaedalInstantUnstakedSchema = import_zod3.z.looseObject({
+      "owner": moveAddress,
+      "sui_amount": moveUint,
+      "st_amount": moveUint
+    });
+    HaedalStakedSchema = import_zod3.z.looseObject({
+      "owner": moveAddress,
+      "sui_amount": moveUint,
+      "st_amount": moveUint,
+      "validator": moveAddress
+    });
+    HaedalUnstakedSchema = import_zod3.z.looseObject({
+      "owner": moveAddress,
+      "epoch": moveUint,
+      "sui_amount": moveUint,
+      "st_amount": moveUint
+    });
+    KaiAddLiquiditySchema = import_zod3.z.looseObject({
+      "position_id": moveAddress,
+      "sqrt_pool_price_x64": moveUint,
+      "delta_l": moveUint,
+      "delta_x": moveUint,
+      "delta_y": moveUint
+    });
+    KaiDeleverageSchema = import_zod3.z.looseObject({
+      "position_id": moveAddress,
+      "delta_l": moveUint,
+      "delta_x": moveUint,
+      "delta_y": moveUint,
+      "x_repaid": moveUint,
+      "y_repaid": moveUint
+    });
+    KaiLiquidationSchema = import_zod3.z.looseObject({
+      "position_id": moveAddress,
+      "x_repaid": moveUint,
+      "y_repaid": moveUint,
+      "liquidator_reward_x": moveUint,
+      "liquidator_reward_y": moveUint,
+      "liquidation_fee_x": moveUint,
+      "liquidation_fee_y": moveUint
+    });
+    KaiPositionOpenSchema = import_zod3.z.looseObject({
+      "position_id": moveAddress,
+      "config_id": moveAddress,
+      "x0": moveUint,
+      "y0": moveUint,
+      "cx": moveUint,
+      "cy": moveUint,
+      "dx": moveUint,
+      "dy": moveUint,
+      "l": moveUint,
+      "creation_fee_amt_sui": moveUint
+    });
+    KaiReduceSchema = import_zod3.z.looseObject({
+      "position_id": moveAddress,
+      "delta_l": moveUint,
+      "delta_x": moveUint,
+      "delta_y": moveUint,
+      "withdrawn_x": moveUint,
+      "withdrawn_y": moveUint,
+      "x_repaid": moveUint,
+      "y_repaid": moveUint
+    });
+    KaiSupplySchema = import_zod3.z.looseObject({
+      "supply_pool_id": moveAddress,
+      "deposited": moveUint,
+      "share_balance": moveUint
+    });
+    KaiSupplyWithdrawSchema = import_zod3.z.looseObject({
+      "supply_pool_id": moveAddress,
+      "share_balance": moveUint,
+      "withdrawn": moveUint
+    });
+    KriyaAddLiquiditySchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "liquidity_provider": moveAddress,
+      "amount_x": moveUint,
+      "amount_y": moveUint,
+      "lsp_minted": moveUint
+    });
+    KriyaSwapSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "user": moveAddress,
+      "reserve_x": moveUint,
+      "reserve_y": moveUint,
+      "amount_in": moveUint,
+      "amount_out": moveUint
+    });
+    MagmaAddLiquiditySchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "position": moveAddress,
+      "liquidity": moveUint,
+      "after_liquidity": moveUint,
+      "amount_a": moveUint,
+      "amount_b": moveUint
+    });
+    MagmaCollectFeeSchema = import_zod3.z.looseObject({
+      "position": moveAddress,
+      "pool": moveAddress,
+      "amount_a": moveUint,
+      "amount_b": moveUint
+    });
+    MagmaCollectRewardSchema = import_zod3.z.looseObject({
+      "position": moveAddress,
+      "pool": moveAddress,
+      "amount": moveUint
+    });
+    MagmaCreatePoolSchema = import_zod3.z.looseObject({
+      "pool_id": moveAddress,
+      "coin_type_a": moveString,
+      "coin_type_b": moveString,
+      "tick_spacing": moveSmallUint
+    });
+    MagmaRemoveLiquiditySchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "position": moveAddress,
+      "liquidity": moveUint,
+      "after_liquidity": moveUint,
+      "amount_a": moveUint,
+      "amount_b": moveUint
+    });
+    MagmaSwapSchema = import_zod3.z.looseObject({
+      "atob": moveBool,
+      "pool": moveAddress,
+      "partner": moveAddress,
+      "amount_in": moveUint,
+      "amount_out": moveUint,
+      "fee_amount": moveUint,
+      "before_sqrt_price": moveUint,
+      "after_sqrt_price": moveUint,
+      "steps": moveUint
+    });
+    MoleAddDebtSchema = import_zod3.z.looseObject({
+      "id": moveUint,
+      "debt_share": moveUint
+    });
+    MoleDepositSchema = import_zod3.z.looseObject({
+      "account": moveAddress,
+      "amount": moveUint,
+      "share": moveUint
+    });
+    MoleHarvestSchema = import_zod3.z.looseObject({
+      "user": moveAddress,
+      "pid": moveUint,
+      "amount": moveUint,
+      "action_type": moveUint
+    });
+    MoleKillSchema = import_zod3.z.looseObject({
+      "id": moveUint,
+      "killer": moveAddress,
+      "owner": moveAddress,
+      "posVal": moveUint,
+      "debt": moveUint,
+      "prize": moveUint,
+      "left": moveUint
+    });
+    MoleWithdrawSchema = import_zod3.z.looseObject({
+      "account": moveAddress,
+      "share": moveUint,
+      "amount": moveUint
+    });
+    MoleWorkSchema = import_zod3.z.looseObject({
+      "id": moveUint,
+      "loan": moveUint
+    });
+    MomentumAddLiquiditySchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "liquidity": moveUint,
+      "amount_x": moveUint,
+      "amount_y": moveUint
+    });
+    MomentumCollectFeeSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "amount_x": moveUint,
+      "amount_y": moveUint
+    });
+    MomentumCollectRewardSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "reward_coin_type": moveTypeName,
+      "amount": moveUint
+    });
+    MomentumPoolCreatedSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "type_x": moveTypeName,
+      "type_y": moveTypeName,
+      "fee_rate": moveUint,
+      "tick_spacing": moveSmallUint
+    });
+    MomentumRemoveLiquiditySchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "position_id": moveAddress,
+      "liquidity": moveUint,
+      "amount_x": moveUint,
+      "amount_y": moveUint
+    });
+    MomentumRepayFlashSwapSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "amount_x_debt": moveUint,
+      "amount_y_debt": moveUint,
+      "paid_x": moveUint,
+      "paid_y": moveUint,
+      "reserve_x": moveUint,
+      "reserve_y": moveUint
+    });
+    MomentumSwapSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "pool_id": moveAddress,
+      "x_for_y": moveBool,
+      "amount_x": moveUint,
+      "amount_y": moveUint,
+      "fee_amount": moveUint,
+      "liquidity": moveUint
+    });
+    NaviBorrowSchema = import_zod3.z.looseObject({
+      "reserve": moveSmallUint,
+      "sender": moveAddress,
+      "amount": moveUint,
+      "market_id": moveUint
+    });
+    NaviDepositSchema = import_zod3.z.looseObject({
+      "reserve": moveSmallUint,
+      "sender": moveAddress,
+      "amount": moveUint,
+      "market_id": moveUint
+    });
+    NaviLiquidationSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "user": moveAddress,
+      "collateral_asset": moveSmallUint,
+      "collateral_amount": moveUint,
+      "debt_asset": moveSmallUint,
+      "debt_amount": moveUint,
+      "market_id": moveUint
+    });
+    NaviRepaySchema = import_zod3.z.looseObject({
+      "reserve": moveSmallUint,
+      "sender": moveAddress,
+      "amount": moveUint,
+      "market_id": moveUint
+    });
+    NaviWithdrawSchema = import_zod3.z.looseObject({
+      "reserve": moveSmallUint,
+      "sender": moveAddress,
+      "to": moveAddress,
+      "amount": moveUint,
+      "market_id": moveUint
+    });
+    PythPriceFeedUpdateSchema = import_zod3.z.looseObject({
+      "price_feed": import_zod3.z.unknown(),
+      "timestamp": moveUint
+    });
+    ScallopBorrowSchema = import_zod3.z.looseObject({
+      "borrower": moveAddress,
+      "obligation": moveAddress,
+      "asset": moveTypeName,
+      "amount": moveUint,
+      "borrow_fee": moveUint,
+      "time": moveUint
+    });
+    ScallopCollateralDepositSchema = import_zod3.z.looseObject({
+      "provider": moveAddress,
+      "obligation": moveAddress,
+      "deposit_asset": moveTypeName,
+      "deposit_amount": moveUint
+    });
+    ScallopCollateralWithdrawSchema = import_zod3.z.looseObject({
+      "taker": moveAddress,
+      "obligation": moveAddress,
+      "withdraw_asset": moveTypeName,
+      "withdraw_amount": moveUint
+    });
+    ScallopLiquidationSchema = import_zod3.z.looseObject({
+      "liquidator": moveAddress,
+      "obligation": moveAddress,
+      "debt_type": moveTypeName,
+      "collateral_type": moveTypeName,
+      "repay_on_behalf": moveUint,
+      "liq_amount": moveUint,
+      "timestamp": moveUint
+    });
+    ScallopRepaySchema = import_zod3.z.looseObject({
+      "repayer": moveAddress,
+      "obligation": moveAddress,
+      "asset": moveTypeName,
+      "amount": moveUint,
+      "time": moveUint
+    });
+    SpringsuiEpochChangedSchema = import_zod3.z.looseObject({
+      "event": import_zod3.z.looseObject({
+        "typename": moveTypeName,
+        "old_sui_supply": moveUint,
+        "new_sui_supply": moveUint,
+        "lst_supply": moveUint,
+        "spread_fee": moveUint
+      })
+    });
+    SpringsuiStakeSchema = import_zod3.z.looseObject({
+      "event": import_zod3.z.looseObject({
+        "typename": moveTypeName,
+        "sui_amount_in": moveUint,
+        "lst_amount_out": moveUint,
+        "fee_amount": moveUint
+      })
+    });
+    SpringsuiUnstakeSchema = import_zod3.z.looseObject({
+      "event": import_zod3.z.looseObject({
+        "typename": moveTypeName,
+        "lst_amount_in": moveUint,
+        "sui_amount_out": moveUint,
+        "fee_amount": moveUint
+      })
+    });
+    SteammBankDepositSchema = import_zod3.z.looseObject({
+      "event": import_zod3.z.looseObject({
+        "user": moveAddress,
+        "bank_id": moveAddress,
+        "lending_market_id": moveAddress,
+        "deposited_amount": moveUint,
+        "minted_amount": moveUint
+      })
+    });
+    SteammBankWithdrawSchema = import_zod3.z.looseObject({
+      "event": import_zod3.z.looseObject({
+        "user": moveAddress,
+        "bank_id": moveAddress,
+        "lending_market_id": moveAddress,
+        "withdrawn_amount": moveUint,
+        "burned_amount": moveUint
+      })
+    });
+    SuilendBorrowSchema = import_zod3.z.looseObject({
+      "lending_market_id": moveAddress,
+      "coin_type": moveTypeName,
+      "reserve_id": moveAddress,
+      "obligation_id": moveAddress,
+      "liquidity_amount": moveUint,
+      "origination_fee_amount": moveUint
+    });
+    SuilendClaimRewardSchema = import_zod3.z.looseObject({
+      "lending_market_id": moveAddress,
+      "reserve_id": moveAddress,
+      "obligation_id": moveAddress,
+      "is_deposit_reward": moveBool,
+      "coin_type": moveTypeName,
+      "liquidity_amount": moveUint
+    });
+    SuilendDepositSchema = import_zod3.z.looseObject({
+      "lending_market_id": moveAddress,
+      "coin_type": moveTypeName,
+      "reserve_id": moveAddress,
+      "obligation_id": moveAddress,
+      "ctoken_amount": moveUint
+    });
+    SuilendLiquidateSchema = import_zod3.z.looseObject({
+      "lending_market_id": moveAddress,
+      "obligation_id": moveAddress,
+      "repay_amount": moveUint,
+      "withdraw_amount": moveUint,
+      "protocol_fee_amount": moveUint,
+      "liquidator_bonus_amount": moveUint
+    });
+    SuilendRepaySchema = import_zod3.z.looseObject({
+      "lending_market_id": moveAddress,
+      "coin_type": moveTypeName,
+      "reserve_id": moveAddress,
+      "obligation_id": moveAddress,
+      "liquidity_amount": moveUint
+    });
+    SuilendWithdrawSchema = import_zod3.z.looseObject({
+      "lending_market_id": moveAddress,
+      "coin_type": moveTypeName,
+      "reserve_id": moveAddress,
+      "obligation_id": moveAddress,
+      "ctoken_amount": moveUint
+    });
+    SupraPriceUpdateSchema = import_zod3.z.looseObject({
+      "pair": moveSmallUint,
+      "value": moveUint,
+      "decimal": moveSmallUint,
+      "timestamp": moveUint,
+      "round": moveUint
+    });
+    TurbosAddLiquiditySchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "owner": moveAddress,
+      "amount_a": moveUint,
+      "amount_b": moveUint,
+      "liquidity_delta": moveUint
+    });
+    TurbosPoolCreatedSchema = import_zod3.z.looseObject({
+      "account": moveAddress,
+      "pool": moveAddress,
+      "fee": moveSmallUint,
+      "tick_spacing": moveSmallUint,
+      "sqrt_price": moveUint
+    });
+    TurbosRemoveLiquiditySchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "owner": moveAddress,
+      "amount_a": moveUint,
+      "amount_b": moveUint,
+      "liquidity_delta": moveUint
+    });
+    TurbosSwapSchema = import_zod3.z.looseObject({
+      "pool": moveAddress,
+      "recipient": moveAddress,
+      "amount_a": moveUint,
+      "amount_b": moveUint,
+      "liquidity": moveUint,
+      "sqrt_price": moveUint,
+      "fee_amount": moveUint,
+      "a_to_b": moveBool
+    });
+    TypusDovAuctionSchema = import_zod3.z.looseObject({
+      "signer": moveAddress,
+      "index": moveUint,
+      "round": moveUint,
+      "start_ts_ms": moveUint,
+      "end_ts_ms": moveUint,
+      "size": moveUint
+    });
+    TypusDovBidSchema = import_zod3.z.looseObject({
+      "signer": moveAddress,
+      "index": moveUint,
+      "bid_index": moveUint,
+      "price": moveUint,
+      "size": moveUint,
+      "ts_ms": moveUint
+    });
+    TypusDovSettleSchema = import_zod3.z.looseObject({
+      "signer": moveAddress,
+      "index": moveUint,
+      "round": moveUint,
+      "oracle_price": moveUint,
+      "settle_balance": moveUint,
+      "settled_balance": moveUint
+    });
+    TypusPerpFundingSchema = import_zod3.z.looseObject({
+      "base_token": moveTypeName,
+      "new_funding_ts_ms": moveUint,
+      "cumulative_funding_rate_index": moveUint
+    });
+    TypusPerpLiquidateSchema = import_zod3.z.looseObject({
+      "user": moveAddress,
+      "position_id": moveUint,
+      "collateral_price": moveUint,
+      "trading_price": moveUint,
+      "realized_liquidator_fee": moveUint
+    });
+    TypusPerpLpBurnSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "index": moveUint,
+      "burn_lp_amount": moveUint,
+      "withdraw_token_amount": moveUint
+    });
+    TypusPerpLpMintSchema = import_zod3.z.looseObject({
+      "sender": moveAddress,
+      "index": moveUint,
+      "deposit_amount": moveUint,
+      "minted_lp_amount": moveUint
+    });
+    TypusPerpOrderSchema = import_zod3.z.looseObject({
+      "user": moveAddress,
+      "market_index": moveUint,
+      "pool_index": moveUint,
+      "order_id": moveUint,
+      "collateral_amount": moveUint,
+      "leverage_mbp": moveUint,
+      "is_long": moveBool,
+      "size": moveUint,
+      "trigger_price": moveUint
+    });
+    VoloStakedSchema = import_zod3.z.looseObject({
+      "staker": moveAddress,
+      "sui_amount": moveUint,
+      "cert_amount": moveUint
+    });
+    VoloUnstakedSchema = import_zod3.z.looseObject({
+      "staker": moveAddress,
+      "cert_amount": moveUint,
+      "sui_amount": moveUint
+    });
+    WalrusBlobCertifiedSchema = import_zod3.z.looseObject({
+      "epoch": moveSmallUint,
+      "blob_id": moveUint,
+      "end_epoch": moveSmallUint,
+      "deletable": moveBool,
+      "object_id": moveAddress
+    });
+    WalrusBlobDeletedSchema = import_zod3.z.looseObject({
+      "epoch": moveSmallUint,
+      "blob_id": moveUint,
+      "end_epoch": moveSmallUint,
+      "object_id": moveAddress,
+      "was_certified": moveBool
+    });
+    WalrusBlobRegisteredSchema = import_zod3.z.looseObject({
+      "epoch": moveSmallUint,
+      "blob_id": moveUint,
+      "size": moveUint,
+      "end_epoch": moveSmallUint,
+      "deletable": moveBool,
+      "object_id": moveAddress
+    });
+    catalogEvents = {
+      "7k.confirm-swap": {
+        id: "7k.confirm-swap",
+        protocolId: "7k",
+        label: "7K \u2014 Swap confirmed",
+        category: "swap",
+        description: "A completed 7K aggregator trade (per-trade settlement summary).",
+        generic: false,
+        schema: _7kConfirmSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x33ec64e9bb369bf045ddc198c81adbf2acab424da37465d95296ee02045d2b17::router::ConfirmSwapEvent", primary: true }
+        ]
+      },
+      "7k.swap": {
+        id: "7k.swap",
+        protocolId: "7k",
+        label: "7K \u2014 Swap (route leg)",
+        category: "swap",
+        description: "A single routing-leg swap on the 7K aggregator (per pool/DEX).",
+        generic: false,
+        schema: _7kSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x33ec64e9bb369bf045ddc198c81adbf2acab424da37465d95296ee02045d2b17::router::SwapEvent", primary: true }
+        ]
+      },
+      "aftermath.deposit": {
+        id: "aftermath.deposit",
+        protocolId: "aftermath",
+        label: "Aftermath \u2014 Add liquidity",
+        category: "liquidity",
+        description: "Liquidity was deposited into an Aftermath AMM pool.",
+        generic: false,
+        schema: AftermathDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xc4049b2d1cc0f6e017fda8260e4377cecd236bd7f56a54fee120816e72e2e0dd::events::DepositEventV2", primary: true }
+        ]
+      },
+      "aftermath.perp-funding": {
+        id: "aftermath.perp-funding",
+        protocolId: "aftermath",
+        label: "Aftermath \u2014 Funding settled (Perps)",
+        category: "funding",
+        description: "Funding was settled for an Aftermath perpetuals account.",
+        generic: false,
+        schema: AftermathPerpFundingSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x21d001e8b07da2e3facb3e2d636bbaef43ba3c978bd84810368840b7d57c5068::events::SettledFunding", primary: true }
+        ]
+      },
+      "aftermath.perp-liquidated": {
+        id: "aftermath.perp-liquidated",
+        protocolId: "aftermath",
+        label: "Aftermath \u2014 Position liquidated (Perps)",
+        category: "liquidation",
+        description: "A perpetuals position was liquidated on Aftermath.",
+        generic: false,
+        schema: AftermathPerpLiquidatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x21d001e8b07da2e3facb3e2d636bbaef43ba3c978bd84810368840b7d57c5068::events::LiquidatedPosition", primary: true }
+        ]
+      },
+      "aftermath.swap": {
+        id: "aftermath.swap",
+        protocolId: "aftermath",
+        label: "Aftermath \u2014 Swap",
+        category: "swap",
+        description: "A swap was executed on an Aftermath AMM pool.",
+        generic: false,
+        schema: AftermathSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xc4049b2d1cc0f6e017fda8260e4377cecd236bd7f56a54fee120816e72e2e0dd::events::SwapEventV2", primary: true }
+        ]
+      },
+      "alphafi.liquidity-change": {
+        id: "alphafi.liquidity-change",
+        protocolId: "alphafi",
+        label: "AlphaFi \u2014 Vault deposit/withdraw",
+        category: "vault",
+        description: "A deposit or withdrawal on an AlphaFi vault (event_type: 1 = deposit, 0 = withdraw).",
+        generic: false,
+        schema: AlphafiLiquidityChangeSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x754afbce8c72c8e491e3b9d536aa9d9766fdbc68650224ce01072189b235eee3::alphafi_bluefin_type_1_pool::LiquidityChangeEvent", primary: true }
+        ]
+      },
+      "alphafi.reward": {
+        id: "alphafi.reward",
+        protocolId: "alphafi",
+        label: "AlphaFi \u2014 Reward harvest",
+        category: "reward",
+        description: "An AlphaFi vault auto-compounded its rewards.",
+        generic: false,
+        schema: AlphafiRewardSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x830ce657bd8547460bdb1a5e5a7607d4641a73593a23165c8630c0d310a3f306::alphafi_bluefin_type_1_pool::RewardEvent", primary: true }
+        ]
+      },
+      "bluefin.fee-collected": {
+        id: "bluefin.fee-collected",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Fee collected",
+        category: "fee",
+        description: "Trading fees were collected from a Bluefin position.",
+        generic: false,
+        schema: BluefinFeeCollectedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::UserFeeCollected", primary: true }
+        ]
+      },
+      "bluefin.liquidity-provided": {
+        id: "bluefin.liquidity-provided",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Liquidity provided",
+        category: "liquidity",
+        description: "Liquidity was provided to a Bluefin position.",
+        generic: false,
+        schema: BluefinLiquidityProvidedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::LiquidityProvided", primary: true }
+        ]
+      },
+      "bluefin.liquidity-removed": {
+        id: "bluefin.liquidity-removed",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Liquidity removed",
+        category: "liquidity",
+        description: "Liquidity was removed from a Bluefin position.",
+        generic: false,
+        schema: BluefinLiquidityRemovedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::LiquidityRemoved", primary: true }
+        ]
+      },
+      "bluefin.pool-created": {
+        id: "bluefin.pool-created",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Pool created",
+        category: "pool",
+        description: "A new Bluefin spot pool was created.",
+        generic: false,
+        schema: BluefinPoolCreatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::PoolCreated", primary: true }
+        ]
+      },
+      "bluefin.position-closed": {
+        id: "bluefin.position-closed",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Position closed",
+        category: "position",
+        description: "A Bluefin liquidity position was closed.",
+        generic: false,
+        schema: BluefinPositionClosedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::PositionClosed", primary: true }
+        ]
+      },
+      "bluefin.position-opened": {
+        id: "bluefin.position-opened",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Position opened",
+        category: "position",
+        description: "A new Bluefin liquidity position was opened.",
+        generic: false,
+        schema: BluefinPositionOpenedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::PositionOpened", primary: true }
+        ]
+      },
+      "bluefin.reward-collected": {
+        id: "bluefin.reward-collected",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Reward collected",
+        category: "reward",
+        description: "Incentive rewards were collected from a Bluefin position.",
+        generic: false,
+        schema: BluefinRewardCollectedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::UserRewardCollected", primary: true }
+        ]
+      },
+      "bluefin.swap": {
+        id: "bluefin.swap",
+        protocolId: "bluefin",
+        label: "Bluefin \u2014 Swap",
+        category: "swap",
+        description: "An asset swap was executed on a Bluefin spot pool.",
+        generic: false,
+        schema: BluefinSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x3492c874c1e3b3e2984e8c41b589e642d4d0a5d6459e5a9cfc2d52fd7c89c267::events::AssetSwap", primary: true }
+        ]
+      },
+      "bucket.borrow": {
+        id: "bucket.borrow",
+        protocolId: "bucket",
+        label: "Bucket \u2014 Borrow (mint BUCK)",
+        category: "borrow",
+        description: "BUCK was minted against collateral in a Bucket CDP.",
+        generic: false,
+        schema: BucketBorrowSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck_events::BuckMinted", primary: true }
+        ]
+      },
+      "bucket.deposit-collateral": {
+        id: "bucket.deposit-collateral",
+        protocolId: "bucket",
+        label: "Bucket \u2014 Deposit collateral",
+        category: "supply",
+        description: "Collateral was added to a Bucket CDP.",
+        generic: false,
+        schema: BucketDepositCollateralSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck_events::CollateralIncreased", primary: true }
+        ]
+      },
+      "bucket.position-updated": {
+        id: "bucket.position-updated",
+        protocolId: "bucket",
+        label: "Bucket \u2014 Position updated",
+        category: "position",
+        description: "A Bucket CDP position (bottle) changed state.",
+        generic: false,
+        schema: BucketPositionUpdatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::bucket_events::BottleUpdated", primary: true }
+        ]
+      },
+      "bucket.redeem": {
+        id: "bucket.redeem",
+        protocolId: "bucket",
+        label: "Bucket \u2014 Redeem",
+        category: "liquidation",
+        description: "BUCK was redeemed for collateral on a Bucket CDP.",
+        generic: false,
+        schema: BucketRedeemSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::bucket_events::Redeem", primary: true }
+        ]
+      },
+      "bucket.repay": {
+        id: "bucket.repay",
+        protocolId: "bucket",
+        label: "Bucket \u2014 Repay (burn BUCK)",
+        category: "repay",
+        description: "BUCK was burned to repay debt in a Bucket CDP.",
+        generic: false,
+        schema: BucketRepaySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck_events::BuckBurnt", primary: true }
+        ]
+      },
+      "bucket.sbuck-deposit": {
+        id: "bucket.sbuck-deposit",
+        protocolId: "bucket",
+        label: "Bucket \u2014 sBUCK deposit",
+        category: "supply",
+        description: "BUCK was deposited into the sBUCK savings vault.",
+        generic: false,
+        schema: BucketSbuckDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1798f84ee72176114ddbf5525a6d964c5f8ea1b3738d08d50d0d3de4cf584884::event::Deposit", primary: true }
+        ]
+      },
+      "bucket.sbuck-rewards": {
+        id: "bucket.sbuck-rewards",
+        protocolId: "bucket",
+        label: "Bucket \u2014 sBUCK rewards collected",
+        category: "reward",
+        description: "Rewards were collected from the sBUCK savings vault.",
+        generic: false,
+        schema: BucketSbuckRewardsSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1798f84ee72176114ddbf5525a6d964c5f8ea1b3738d08d50d0d3de4cf584884::event::CollectRewards", primary: true }
+        ]
+      },
+      "bucket.withdraw-collateral": {
+        id: "bucket.withdraw-collateral",
+        protocolId: "bucket",
+        label: "Bucket \u2014 Withdraw collateral",
+        category: "withdraw",
+        description: "Collateral was removed from a Bucket CDP.",
+        generic: false,
+        schema: BucketWithdrawCollateralSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xce7ff77a83ea0cb6fd39bd8748e2ec89a3f41e8efdc3f4eb123e0ca37b184db2::buck_events::CollateralDecreased", primary: true }
+        ]
+      },
+      "cetus.add-liquidity": {
+        id: "cetus.add-liquidity",
+        protocolId: "cetus",
+        label: "Cetus \u2014 Add liquidity",
+        category: "liquidity",
+        description: "Liquidity was added to a Cetus position.",
+        generic: false,
+        schema: CetusAddLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool::AddLiquidityEvent", primary: true }
+        ]
+      },
+      "cetus.close-position": {
+        id: "cetus.close-position",
+        protocolId: "cetus",
+        label: "Cetus \u2014 Close position",
+        category: "position",
+        description: "A Cetus liquidity position was closed.",
+        generic: false,
+        schema: CetusClosePositionSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool::ClosePositionEvent", primary: true }
+        ]
+      },
+      "cetus.collect-fee": {
+        id: "cetus.collect-fee",
+        protocolId: "cetus",
+        label: "Cetus \u2014 Collect fee",
+        category: "fee",
+        description: "Accrued swap fees were collected from a Cetus position.",
+        generic: false,
+        schema: CetusCollectFeeSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool::CollectFeeEvent", primary: true }
+        ]
+      },
+      "cetus.create-pool": {
+        id: "cetus.create-pool",
+        protocolId: "cetus",
+        label: "Cetus \u2014 Create pool",
+        category: "pool",
+        description: "A new Cetus CLMM pool was created via the factory.",
+        generic: false,
+        schema: CetusCreatePoolSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::factory::CreatePoolEvent", primary: true }
+        ]
+      },
+      "cetus.open-position": {
+        id: "cetus.open-position",
+        protocolId: "cetus",
+        label: "Cetus \u2014 Open position",
+        category: "position",
+        description: "A new Cetus liquidity position was opened.",
+        generic: false,
+        schema: CetusOpenPositionSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool::OpenPositionEvent", primary: true }
+        ]
+      },
+      "cetus.remove-liquidity": {
+        id: "cetus.remove-liquidity",
+        protocolId: "cetus",
+        label: "Cetus \u2014 Remove liquidity",
+        category: "liquidity",
+        description: "Liquidity was removed from a Cetus position.",
+        generic: false,
+        schema: CetusRemoveLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool::RemoveLiquidityEvent", primary: true }
+        ]
+      },
+      "cetus.swap": {
+        id: "cetus.swap",
+        protocolId: "cetus",
+        label: "Cetus \u2014 Swap",
+        category: "swap",
+        description: "A token swap was executed on a Cetus CLMM pool.",
+        generic: false,
+        schema: CetusSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1eabed72c53feb3805120a081dc15963c204dc8d091542592abaf7a35689b2fb::pool::SwapEvent", primary: true }
+        ]
+      },
+      "current.borrow": {
+        id: "current.borrow",
+        protocolId: "current",
+        label: "Current \u2014 Borrow",
+        category: "borrow",
+        description: "Assets were borrowed from a Current lending market.",
+        generic: false,
+        schema: CurrentBorrowSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::borrow::BorrowEvent", primary: true }
+        ]
+      },
+      "current.deposit": {
+        id: "current.deposit",
+        protocolId: "current",
+        label: "Current \u2014 Deposit",
+        category: "supply",
+        description: "Assets were deposited (supplied) to a Current lending market.",
+        generic: false,
+        schema: CurrentDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::deposit::DepositEvent", primary: true }
+        ]
+      },
+      "current.liquidate": {
+        id: "current.liquidate",
+        protocolId: "current",
+        label: "Current \u2014 Liquidation",
+        category: "liquidation",
+        description: "A Current obligation was liquidated.",
+        generic: false,
+        schema: CurrentLiquidateSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::liquidate::LiquidateEvent", primary: true }
+        ]
+      },
+      "current.repay": {
+        id: "current.repay",
+        protocolId: "current",
+        label: "Current \u2014 Repay",
+        category: "repay",
+        description: "A Current loan was repaid.",
+        generic: false,
+        schema: CurrentRepaySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::repay::RepayEvent", primary: true }
+        ]
+      },
+      "current.withdraw": {
+        id: "current.withdraw",
+        protocolId: "current",
+        label: "Current \u2014 Withdraw",
+        category: "withdraw",
+        description: "Assets were withdrawn from a Current lending market.",
+        generic: false,
+        schema: CurrentWithdrawSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfe1d8929d13b00aaecd7642dec1c6d41cab82882a1b139efa46bf61dfd6380bf::withdraw::WithdrawEvent", primary: true }
+        ]
+      },
+      "deepbook.balance": {
+        id: "deepbook.balance",
+        protocolId: "deepbook",
+        label: "DeepBook \u2014 Balance change",
+        category: "fee",
+        description: "A deposit or withdrawal on a DeepBook balance manager.",
+        generic: false,
+        schema: DeepbookBalanceSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::balance_manager::BalanceEvent", primary: true }
+        ]
+      },
+      "deepbook.flash-loan": {
+        id: "deepbook.flash-loan",
+        protocolId: "deepbook",
+        label: "DeepBook \u2014 Flash loan borrowed",
+        category: "fee",
+        description: "A flash loan was borrowed from a DeepBook pool.",
+        generic: false,
+        schema: DeepbookFlashLoanSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::vault::FlashLoanBorrowed", primary: true }
+        ]
+      },
+      "deepbook.order-canceled": {
+        id: "deepbook.order-canceled",
+        protocolId: "deepbook",
+        label: "DeepBook \u2014 Order canceled",
+        category: "order",
+        description: "A DeepBook maker order was canceled.",
+        generic: false,
+        schema: DeepbookOrderCanceledSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order::OrderCanceled", primary: true }
+        ]
+      },
+      "deepbook.order-filled": {
+        id: "deepbook.order-filled",
+        protocolId: "deepbook",
+        label: "DeepBook \u2014 Order filled",
+        category: "order",
+        description: "A DeepBook order was filled (partially or fully).",
+        generic: false,
+        schema: DeepbookOrderFilledSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order_info::OrderFilled", primary: true }
+        ]
+      },
+      "deepbook.order-info": {
+        id: "deepbook.order-info",
+        protocolId: "deepbook",
+        label: "DeepBook \u2014 Order update",
+        category: "order",
+        description: "An order's lifecycle update on a DeepBook pool (placed/filled/status).",
+        generic: false,
+        schema: DeepbookOrderInfoSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order_info::OrderInfo", primary: true }
+        ]
+      },
+      "deepbook.order-placed": {
+        id: "deepbook.order-placed",
+        protocolId: "deepbook",
+        label: "DeepBook \u2014 Order placed",
+        category: "order",
+        description: "A maker limit order was placed on a DeepBook pool.",
+        generic: false,
+        schema: DeepbookOrderPlacedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x2c8d603bc51326b8c13cef9dd07031a408a48dddb541963357661df5d3204809::order_info::OrderPlaced", primary: true }
+        ]
+      },
+      "ember.deposit": {
+        id: "ember.deposit",
+        protocolId: "ember",
+        label: "Ember \u2014 Vault deposit",
+        category: "vault",
+        description: "A deposit into an Ember vault (matches all deposit coin types).",
+        generic: true,
+        schema: EmberDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xc83d5406fd355f34d3ce87b35ab2c0b099af9d309ba96c17e40309502a49976f::events::VaultDepositEvent", primary: true }
+        ]
+      },
+      "ember.rate-updated": {
+        id: "ember.rate-updated",
+        protocolId: "ember",
+        label: "Ember \u2014 Vault rate updated",
+        category: "reward",
+        description: "An Ember vault's share rate (price) was updated.",
+        generic: false,
+        schema: EmberRateUpdatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xc83d5406fd355f34d3ce87b35ab2c0b099af9d309ba96c17e40309502a49976f::events::VaultRateUpdatedEvent", primary: true }
+        ]
+      },
+      "ember.redeem-processed": {
+        id: "ember.redeem-processed",
+        protocolId: "ember",
+        label: "Ember \u2014 Redeem processed",
+        category: "withdraw",
+        description: "A queued Ember redeem request was processed.",
+        generic: true,
+        schema: EmberRedeemProcessedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xc83d5406fd355f34d3ce87b35ab2c0b099af9d309ba96c17e40309502a49976f::events::RequestProcessedEvent", primary: true }
+        ]
+      },
+      "ember.redeem-request": {
+        id: "ember.redeem-request",
+        protocolId: "ember",
+        label: "Ember \u2014 Redeem requested",
+        category: "withdraw",
+        description: "A redeem (withdrawal) was requested from an Ember vault.",
+        generic: true,
+        schema: EmberRedeemRequestSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xc83d5406fd355f34d3ce87b35ab2c0b099af9d309ba96c17e40309502a49976f::events::RequestRedeemedEvent", primary: true }
+        ]
+      },
+      "flowx.amm-pair-created": {
+        id: "flowx.amm-pair-created",
+        protocolId: "flowx",
+        label: "FlowX \u2014 Pair created (AMM)",
+        category: "pool",
+        description: "A new FlowX AMM trading pair was created.",
+        generic: false,
+        schema: FlowxAmmPairCreatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xba153169476e8c3114962261d1edc70de5ad9781b83cc617ecc8c1923191cae0::factory::PairCreated", primary: true }
+        ]
+      },
+      "flowx.amm-swap": {
+        id: "flowx.amm-swap",
+        protocolId: "flowx",
+        label: "FlowX \u2014 Swap (AMM)",
+        category: "swap",
+        description: "A swap was executed on a FlowX AMM pair.",
+        generic: false,
+        schema: FlowxAmmSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xba153169476e8c3114962261d1edc70de5ad9781b83cc617ecc8c1923191cae0::pair::Swapped", primary: true }
+        ]
+      },
+      "flowx.clmm-pool-created": {
+        id: "flowx.clmm-pool-created",
+        protocolId: "flowx",
+        label: "FlowX \u2014 Pool created (CLMM)",
+        category: "pool",
+        description: "A new FlowX CLMM pool was created.",
+        generic: false,
+        schema: FlowxClmmPoolCreatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::pool_manager::PoolCreated", primary: true }
+        ]
+      },
+      "flowx.clmm-swap": {
+        id: "flowx.clmm-swap",
+        protocolId: "flowx",
+        label: "FlowX \u2014 Swap (CLMM)",
+        category: "swap",
+        description: "A swap was executed on a FlowX CLMM pool.",
+        generic: false,
+        schema: FlowxClmmSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x25929e7f29e0a30eb4e692952ba1b5b65a3a4d65ab5f2a32e1ba3edcb587f26d::pool::Swap", primary: true }
+        ]
+      },
+      "haedal.instant-unstaked": {
+        id: "haedal.instant-unstaked",
+        protocolId: "haedal",
+        label: "Haedal \u2014 Instant unstaked",
+        category: "unstake",
+        description: "An instant unstake was performed on Haedal.",
+        generic: false,
+        schema: HaedalInstantUnstakedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::staking::UserInstantUnstaked", primary: true }
+        ]
+      },
+      "haedal.staked": {
+        id: "haedal.staked",
+        protocolId: "haedal",
+        label: "Haedal \u2014 Staked",
+        category: "stake",
+        description: "SUI was staked with Haedal in exchange for haSUI.",
+        generic: false,
+        schema: HaedalStakedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::staking::UserStaked", primary: true }
+        ]
+      },
+      "haedal.unstaked": {
+        id: "haedal.unstaked",
+        protocolId: "haedal",
+        label: "Haedal \u2014 Unstaked",
+        category: "unstake",
+        description: "A delayed unstake was initiated on Haedal.",
+        generic: false,
+        schema: HaedalUnstakedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xbde4ba4c2e274a60ce15c1cfff9e5c42e41654ac8b6d906a57efa4bd3c29f47d::staking::UserNormalUnstaked", primary: true }
+        ]
+      },
+      "kai.add-liquidity": {
+        id: "kai.add-liquidity",
+        protocolId: "kai",
+        label: "Kai \u2014 Increase position",
+        category: "liquidity",
+        description: "Liquidity was added to a Kai leveraged position.",
+        generic: false,
+        schema: KaiAddLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x51e0ccce48f0763f98f1cb4856847c2e1531adacada99cdd7626ab999db57523::position_core_clmm::AddLiquidityInfo", primary: true }
+        ]
+      },
+      "kai.deleverage": {
+        id: "kai.deleverage",
+        protocolId: "kai",
+        label: "Kai \u2014 Deleverage",
+        category: "repay",
+        description: "A Kai leveraged position was deleveraged (debt repaid).",
+        generic: false,
+        schema: KaiDeleverageSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x51e0ccce48f0763f98f1cb4856847c2e1531adacada99cdd7626ab999db57523::position_core_clmm::DeleverageInfo", primary: true }
+        ]
+      },
+      "kai.liquidation": {
+        id: "kai.liquidation",
+        protocolId: "kai",
+        label: "Kai \u2014 Liquidation",
+        category: "liquidation",
+        description: "A Kai leveraged position was liquidated.",
+        generic: false,
+        schema: KaiLiquidationSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x51e0ccce48f0763f98f1cb4856847c2e1531adacada99cdd7626ab999db57523::position_core_clmm::LiquidationInfo", primary: true }
+        ]
+      },
+      "kai.position-open": {
+        id: "kai.position-open",
+        protocolId: "kai",
+        label: "Kai \u2014 Open leveraged position",
+        category: "borrow",
+        description: "A new Kai leveraged CLMM position was opened.",
+        generic: false,
+        schema: KaiPositionOpenSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x51e0ccce48f0763f98f1cb4856847c2e1531adacada99cdd7626ab999db57523::position_core_clmm::PositionCreationInfo", primary: true }
+        ]
+      },
+      "kai.reduce": {
+        id: "kai.reduce",
+        protocolId: "kai",
+        label: "Kai \u2014 Reduce position",
+        category: "withdraw",
+        description: "A Kai leveraged position was reduced / partially withdrawn.",
+        generic: false,
+        schema: KaiReduceSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x51e0ccce48f0763f98f1cb4856847c2e1531adacada99cdd7626ab999db57523::position_core_clmm::ReductionInfo", primary: true }
+        ]
+      },
+      "kai.supply": {
+        id: "kai.supply",
+        protocolId: "kai",
+        label: "Kai \u2014 Supply to pool",
+        category: "lend",
+        description: "Liquidity was supplied to a Kai lending pool.",
+        generic: false,
+        schema: KaiSupplySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x51e0ccce48f0763f98f1cb4856847c2e1531adacada99cdd7626ab999db57523::supply_pool::SupplyInfo", primary: true }
+        ]
+      },
+      "kai.supply-withdraw": {
+        id: "kai.supply-withdraw",
+        protocolId: "kai",
+        label: "Kai \u2014 Withdraw from pool",
+        category: "withdraw",
+        description: "Supplied liquidity was withdrawn from a Kai lending pool.",
+        generic: false,
+        schema: KaiSupplyWithdrawSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x51e0ccce48f0763f98f1cb4856847c2e1531adacada99cdd7626ab999db57523::supply_pool::WithdrawInfo", primary: true }
+        ]
+      },
+      "kriya.add-liquidity": {
+        id: "kriya.add-liquidity",
+        protocolId: "kriya",
+        label: "Kriya \u2014 Add liquidity",
+        category: "liquidity",
+        description: "Liquidity was provided to a Kriya pool.",
+        generic: false,
+        schema: KriyaAddLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xa0eba10b173538c8fecca1dff298e488402cc9ff374f8a12ca7758eebe830b66::spot_dex::LiquidityAddedEvent", primary: true }
+        ]
+      },
+      "kriya.swap": {
+        id: "kriya.swap",
+        protocolId: "kriya",
+        label: "Kriya \u2014 Swap",
+        category: "swap",
+        description: "A token swap was executed on a Kriya spot pool (matches all token types).",
+        generic: true,
+        schema: KriyaSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xa0eba10b173538c8fecca1dff298e488402cc9ff374f8a12ca7758eebe830b66::spot_dex::SwapEvent", primary: true }
+        ]
+      },
+      "magma.add-liquidity": {
+        id: "magma.add-liquidity",
+        protocolId: "magma",
+        label: "Magma \u2014 Add liquidity",
+        category: "liquidity",
+        description: "Liquidity was added to a Magma CLMM pool.",
+        generic: false,
+        schema: MagmaAddLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4a35d3dfef55ed3631b7158544c6322a23bc434fe4fca1234cb680ce0505f82d::pool::AddLiquidityEvent", primary: true }
+        ]
+      },
+      "magma.collect-fee": {
+        id: "magma.collect-fee",
+        protocolId: "magma",
+        label: "Magma \u2014 Collect fee",
+        category: "fee",
+        description: "Trading fees were collected from a Magma position.",
+        generic: false,
+        schema: MagmaCollectFeeSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4a35d3dfef55ed3631b7158544c6322a23bc434fe4fca1234cb680ce0505f82d::pool::CollectFeeEvent", primary: true }
+        ]
+      },
+      "magma.collect-reward": {
+        id: "magma.collect-reward",
+        protocolId: "magma",
+        label: "Magma \u2014 Collect reward",
+        category: "reward",
+        description: "Incentive rewards were collected from a Magma position.",
+        generic: false,
+        schema: MagmaCollectRewardSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4a35d3dfef55ed3631b7158544c6322a23bc434fe4fca1234cb680ce0505f82d::pool::CollectRewardEvent", primary: true }
+        ]
+      },
+      "magma.create-pool": {
+        id: "magma.create-pool",
+        protocolId: "magma",
+        label: "Magma \u2014 Create pool",
+        category: "pool",
+        description: "A new Magma CLMM pool was created.",
+        generic: false,
+        schema: MagmaCreatePoolSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4a35d3dfef55ed3631b7158544c6322a23bc434fe4fca1234cb680ce0505f82d::factory::CreatePoolEvent", primary: true }
+        ]
+      },
+      "magma.remove-liquidity": {
+        id: "magma.remove-liquidity",
+        protocolId: "magma",
+        label: "Magma \u2014 Remove liquidity",
+        category: "liquidity",
+        description: "Liquidity was removed from a Magma CLMM pool.",
+        generic: false,
+        schema: MagmaRemoveLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4a35d3dfef55ed3631b7158544c6322a23bc434fe4fca1234cb680ce0505f82d::pool::RemoveLiquidityEvent", primary: true }
+        ]
+      },
+      "magma.swap": {
+        id: "magma.swap",
+        protocolId: "magma",
+        label: "Magma \u2014 Swap",
+        category: "swap",
+        description: "A token swap was executed on a Magma CLMM pool.",
+        generic: false,
+        schema: MagmaSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4a35d3dfef55ed3631b7158544c6322a23bc434fe4fca1234cb680ce0505f82d::pool::SwapEvent", primary: true }
+        ]
+      },
+      "mole.add-debt": {
+        id: "mole.add-debt",
+        protocolId: "mole",
+        label: "Mole \u2014 Add debt (leverage)",
+        category: "borrow",
+        description: "Debt was added to a Mole leveraged-farm position.",
+        generic: true,
+        schema: MoleAddDebtSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x5ffa69ee4ee14d899dcc750df92de12bad4bacf81efa1ae12ee76406804dda7f::vault::AddDebtEvent", primary: true }
+        ]
+      },
+      "mole.deposit": {
+        id: "mole.deposit",
+        protocolId: "mole",
+        label: "Mole \u2014 Vault deposit",
+        category: "vault",
+        description: "A deposit into a Mole savings vault (matches all coin types).",
+        generic: true,
+        schema: MoleDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x5ffa69ee4ee14d899dcc750df92de12bad4bacf81efa1ae12ee76406804dda7f::vault::DepositEvent", primary: true }
+        ]
+      },
+      "mole.harvest": {
+        id: "mole.harvest",
+        protocolId: "mole",
+        label: "Mole \u2014 Harvest rewards",
+        category: "reward",
+        description: "Rewards were harvested from a Mole vault/farm.",
+        generic: true,
+        schema: MoleHarvestSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xc4dc6948a7d0a58f32fadd44e45efb201f44383bfab1cb6c48b9c186a92cc762::sui_incentive::HarvestEvent", primary: true }
+        ]
+      },
+      "mole.kill": {
+        id: "mole.kill",
+        protocolId: "mole",
+        label: "Mole \u2014 Position liquidation (kill)",
+        category: "liquidation",
+        description: "A Mole leveraged-farm position was liquidated.",
+        generic: true,
+        schema: MoleKillSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x5ffa69ee4ee14d899dcc750df92de12bad4bacf81efa1ae12ee76406804dda7f::vault::KillEvent", primary: true }
+        ]
+      },
+      "mole.withdraw": {
+        id: "mole.withdraw",
+        protocolId: "mole",
+        label: "Mole \u2014 Vault withdraw",
+        category: "withdraw",
+        description: "A withdrawal from a Mole savings vault (matches all coin types).",
+        generic: true,
+        schema: MoleWithdrawSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x5ffa69ee4ee14d899dcc750df92de12bad4bacf81efa1ae12ee76406804dda7f::vault::WithdrawEvent", primary: true }
+        ]
+      },
+      "mole.work": {
+        id: "mole.work",
+        protocolId: "mole",
+        label: "Mole \u2014 Open/adjust farm position",
+        category: "liquidity",
+        description: "A Mole leveraged-farm position was opened or adjusted.",
+        generic: true,
+        schema: MoleWorkSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x5ffa69ee4ee14d899dcc750df92de12bad4bacf81efa1ae12ee76406804dda7f::vault::WorkEvent", primary: true }
+        ]
+      },
+      "momentum.add-liquidity": {
+        id: "momentum.add-liquidity",
+        protocolId: "momentum",
+        label: "Momentum \u2014 Add liquidity",
+        category: "liquidity",
+        description: "Liquidity was added to a Momentum position.",
+        generic: false,
+        schema: MomentumAddLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::liquidity::AddLiquidityEvent", primary: true }
+        ]
+      },
+      "momentum.collect-fee": {
+        id: "momentum.collect-fee",
+        protocolId: "momentum",
+        label: "Momentum \u2014 Collect fee",
+        category: "fee",
+        description: "Trading fees were collected from a Momentum position.",
+        generic: false,
+        schema: MomentumCollectFeeSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::collect::FeeCollectedEvent", primary: true }
+        ]
+      },
+      "momentum.collect-reward": {
+        id: "momentum.collect-reward",
+        protocolId: "momentum",
+        label: "Momentum \u2014 Collect reward",
+        category: "reward",
+        description: "Incentive rewards were collected from a Momentum position.",
+        generic: false,
+        schema: MomentumCollectRewardSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::collect::CollectPoolRewardEvent", primary: true }
+        ]
+      },
+      "momentum.pool-created": {
+        id: "momentum.pool-created",
+        protocolId: "momentum",
+        label: "Momentum \u2014 Pool created",
+        category: "pool",
+        description: "A new Momentum pool was created.",
+        generic: false,
+        schema: MomentumPoolCreatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::create_pool::PoolCreatedEvent", primary: true }
+        ]
+      },
+      "momentum.remove-liquidity": {
+        id: "momentum.remove-liquidity",
+        protocolId: "momentum",
+        label: "Momentum \u2014 Remove liquidity",
+        category: "liquidity",
+        description: "Liquidity was removed from a Momentum position.",
+        generic: false,
+        schema: MomentumRemoveLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::liquidity::RemoveLiquidityEvent", primary: true }
+        ]
+      },
+      "momentum.repay-flash-swap": {
+        id: "momentum.repay-flash-swap",
+        protocolId: "momentum",
+        label: "Momentum \u2014 Repay flash swap",
+        category: "fee",
+        description: "A Momentum flash swap was repaid.",
+        generic: false,
+        schema: MomentumRepayFlashSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::trade::RepayFlashSwapEvent", primary: true }
+        ]
+      },
+      "momentum.swap": {
+        id: "momentum.swap",
+        protocolId: "momentum",
+        label: "Momentum \u2014 Swap",
+        category: "swap",
+        description: "A swap was executed on a Momentum CLMM pool.",
+        generic: false,
+        schema: MomentumSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x70285592c97965e811e0c6f98dccc3a9c2b4ad854b3594faab9597ada267b860::trade::SwapEvent", primary: true }
+        ]
+      },
+      "navi.borrow": {
+        id: "navi.borrow",
+        protocolId: "navi",
+        label: "NAVI \u2014 Borrow",
+        category: "borrow",
+        description: "Assets were borrowed from a NAVI pool.",
+        generic: false,
+        schema: NaviBorrowSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1e4a13a0494d5facdbe8473e74127b838c2d446ecec0ce262e2eddafa77259cb::event::BorrowEvent", primary: true }
+        ]
+      },
+      "navi.deposit": {
+        id: "navi.deposit",
+        protocolId: "navi",
+        label: "NAVI \u2014 Deposit",
+        category: "supply",
+        description: "Assets were supplied to a NAVI lending pool.",
+        generic: false,
+        schema: NaviDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1e4a13a0494d5facdbe8473e74127b838c2d446ecec0ce262e2eddafa77259cb::event::DepositEvent", primary: true }
+        ]
+      },
+      "navi.liquidation": {
+        id: "navi.liquidation",
+        protocolId: "navi",
+        label: "NAVI \u2014 Liquidation",
+        category: "liquidation",
+        description: "An undercollateralized NAVI position was liquidated.",
+        generic: false,
+        schema: NaviLiquidationSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1e4a13a0494d5facdbe8473e74127b838c2d446ecec0ce262e2eddafa77259cb::event::LiquidationEvent", primary: true }
+        ]
+      },
+      "navi.repay": {
+        id: "navi.repay",
+        protocolId: "navi",
+        label: "NAVI \u2014 Repay",
+        category: "repay",
+        description: "Borrowed assets were repaid to a NAVI pool.",
+        generic: false,
+        schema: NaviRepaySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1e4a13a0494d5facdbe8473e74127b838c2d446ecec0ce262e2eddafa77259cb::event::RepayEvent", primary: true }
+        ]
+      },
+      "navi.withdraw": {
+        id: "navi.withdraw",
+        protocolId: "navi",
+        label: "NAVI \u2014 Withdraw",
+        category: "withdraw",
+        description: "Supplied assets were withdrawn from a NAVI pool.",
+        generic: false,
+        schema: NaviWithdrawSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x1e4a13a0494d5facdbe8473e74127b838c2d446ecec0ce262e2eddafa77259cb::event::WithdrawEvent", primary: true }
+        ]
+      },
+      "pyth.price-feed-update": {
+        id: "pyth.price-feed-update",
+        protocolId: "pyth",
+        label: "Pyth \u2014 Price feed update",
+        category: "oracle",
+        description: "A Pyth price feed was updated with new price data.",
+        generic: false,
+        schema: PythPriceFeedUpdateSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x8d97f1cd6ac663735be08d1d2b6d02a159e711586461306ce60a2b7a6a565a9e::event::PriceFeedUpdateEvent", primary: true },
+          { network: "testnet", eventType: "0xabf837e98c26087cba0883c0a7a28326b1fa3c5e1e2c5abdb486f9e8f594c837::event::PriceFeedUpdateEvent", primary: true }
+        ]
+      },
+      "scallop.borrow": {
+        id: "scallop.borrow",
+        protocolId: "scallop",
+        label: "Scallop \u2014 Borrow",
+        category: "borrow",
+        description: "Assets were borrowed from a Scallop lending market.",
+        generic: false,
+        schema: ScallopBorrowSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::borrow::BorrowEventV3", primary: true }
+        ]
+      },
+      "scallop.collateral-deposit": {
+        id: "scallop.collateral-deposit",
+        protocolId: "scallop",
+        label: "Scallop \u2014 Deposit collateral",
+        category: "supply",
+        description: "Collateral was deposited into a Scallop obligation.",
+        generic: false,
+        schema: ScallopCollateralDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::deposit_collateral::CollateralDepositEvent", primary: true }
+        ]
+      },
+      "scallop.collateral-withdraw": {
+        id: "scallop.collateral-withdraw",
+        protocolId: "scallop",
+        label: "Scallop \u2014 Withdraw collateral",
+        category: "withdraw",
+        description: "Collateral was withdrawn from a Scallop obligation.",
+        generic: false,
+        schema: ScallopCollateralWithdrawSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::withdraw_collateral::CollateralWithdrawEvent", primary: true }
+        ]
+      },
+      "scallop.liquidation": {
+        id: "scallop.liquidation",
+        protocolId: "scallop",
+        label: "Scallop \u2014 Liquidation",
+        category: "liquidation",
+        description: "A Scallop obligation was liquidated.",
+        generic: false,
+        schema: ScallopLiquidationSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x6e641f0dca8aedab3101d047e96439178f16301bf0b57fe8745086ff1195eb3e::liquidate::LiquidateEventV2", primary: true }
+        ]
+      },
+      "scallop.repay": {
+        id: "scallop.repay",
+        protocolId: "scallop",
+        label: "Scallop \u2014 Repay",
+        category: "repay",
+        description: "Borrowed assets were repaid to a Scallop market.",
+        generic: false,
+        schema: ScallopRepaySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xefe8b36d5b2e43728cc323298626b83177803521d195cfb11e15b910e892fddf::repay::RepayEvent", primary: true }
+        ]
+      },
+      "springsui.epoch-changed": {
+        id: "springsui.epoch-changed",
+        protocolId: "springsui",
+        label: "SpringSui \u2014 Epoch changed (rewards)",
+        category: "reward",
+        description: "SpringSui accrued staking rewards at an epoch change.",
+        generic: false,
+        schema: SpringsuiEpochChangedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xb0575765166030556a6eafd3b1b970eba8183ff748860680245b9edd41c716e7::events::Event<0xb0575765166030556a6eafd3b1b970eba8183ff748860680245b9edd41c716e7::liquid_staking::EpochChangedEvent>", primary: true }
+        ]
+      },
+      "springsui.stake": {
+        id: "springsui.stake",
+        protocolId: "springsui",
+        label: "SpringSui \u2014 Stake (mint LST)",
+        category: "stake",
+        description: "SUI was staked to mint a SpringSui liquid-staking token.",
+        generic: false,
+        schema: SpringsuiStakeSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xb0575765166030556a6eafd3b1b970eba8183ff748860680245b9edd41c716e7::events::Event<0xb0575765166030556a6eafd3b1b970eba8183ff748860680245b9edd41c716e7::liquid_staking::MintEvent>", primary: true }
+        ]
+      },
+      "springsui.unstake": {
+        id: "springsui.unstake",
+        protocolId: "springsui",
+        label: "SpringSui \u2014 Unstake (redeem LST)",
+        category: "unstake",
+        description: "A SpringSui liquid-staking token was redeemed for SUI.",
+        generic: false,
+        schema: SpringsuiUnstakeSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xb0575765166030556a6eafd3b1b970eba8183ff748860680245b9edd41c716e7::events::Event<0xb0575765166030556a6eafd3b1b970eba8183ff748860680245b9edd41c716e7::liquid_staking::RedeemEvent>", primary: true }
+        ]
+      },
+      "steamm.bank-deposit": {
+        id: "steamm.bank-deposit",
+        protocolId: "steamm",
+        label: "Steamm \u2014 Bank deposit (mint bToken)",
+        category: "supply",
+        description: "Funds were deposited into a Steamm bank, minting bTokens.",
+        generic: false,
+        schema: SteammBankDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4fb1cf45dffd6230305f1d269dd1816678cc8e3ba0b747a813a556921219f261::events::Event<0x4fb1cf45dffd6230305f1d269dd1816678cc8e3ba0b747a813a556921219f261::bank::MintBTokenEvent>", primary: true }
+        ]
+      },
+      "steamm.bank-withdraw": {
+        id: "steamm.bank-withdraw",
+        protocolId: "steamm",
+        label: "Steamm \u2014 Bank withdraw (burn bToken)",
+        category: "withdraw",
+        description: "bTokens were burned to withdraw funds from a Steamm bank.",
+        generic: false,
+        schema: SteammBankWithdrawSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4fb1cf45dffd6230305f1d269dd1816678cc8e3ba0b747a813a556921219f261::events::Event<0x4fb1cf45dffd6230305f1d269dd1816678cc8e3ba0b747a813a556921219f261::bank::BurnBTokenEvent>", primary: true }
+        ]
+      },
+      "suilend.borrow": {
+        id: "suilend.borrow",
+        protocolId: "suilend",
+        label: "Suilend \u2014 Borrow",
+        category: "borrow",
+        description: "Assets were borrowed from a Suilend market.",
+        generic: false,
+        schema: SuilendBorrowSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::lending_market::BorrowEvent", primary: true }
+        ]
+      },
+      "suilend.claim-reward": {
+        id: "suilend.claim-reward",
+        protocolId: "suilend",
+        label: "Suilend \u2014 Claim reward",
+        category: "reward",
+        description: "Rewards were claimed from a Suilend market.",
+        generic: false,
+        schema: SuilendClaimRewardSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::lending_market::ClaimRewardEvent", primary: true }
+        ]
+      },
+      "suilend.deposit": {
+        id: "suilend.deposit",
+        protocolId: "suilend",
+        label: "Suilend \u2014 Deposit",
+        category: "supply",
+        description: "Assets were deposited into a Suilend reserve.",
+        generic: false,
+        schema: SuilendDepositSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::lending_market::DepositEvent", primary: true }
+        ]
+      },
+      "suilend.liquidate": {
+        id: "suilend.liquidate",
+        protocolId: "suilend",
+        label: "Suilend \u2014 Liquidation",
+        category: "liquidation",
+        description: "A Suilend obligation was liquidated.",
+        generic: false,
+        schema: SuilendLiquidateSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::lending_market::LiquidateEvent", primary: true }
+        ]
+      },
+      "suilend.repay": {
+        id: "suilend.repay",
+        protocolId: "suilend",
+        label: "Suilend \u2014 Repay",
+        category: "repay",
+        description: "Borrowed assets were repaid to a Suilend market.",
+        generic: false,
+        schema: SuilendRepaySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::lending_market::RepayEvent", primary: true }
+        ]
+      },
+      "suilend.withdraw": {
+        id: "suilend.withdraw",
+        protocolId: "suilend",
+        label: "Suilend \u2014 Withdraw",
+        category: "withdraw",
+        description: "Assets were withdrawn from a Suilend reserve.",
+        generic: false,
+        schema: SuilendWithdrawSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf::lending_market::WithdrawEvent", primary: true }
+        ]
+      },
+      "supra.price-update": {
+        id: "supra.price-update",
+        protocolId: "supra",
+        label: "Supra \u2014 Price update",
+        category: "oracle",
+        description: "A Supra oracle price feed (pair) was updated.",
+        generic: false,
+        schema: SupraPriceUpdateSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x4979543452f609ff272d504755966ff5e70122256101c17adbe8bd27d35116c3::SupraSValueFeed::PairDataUpdateEvent", primary: true }
+        ]
+      },
+      "turbos.add-liquidity": {
+        id: "turbos.add-liquidity",
+        protocolId: "turbos",
+        label: "Turbos \u2014 Add liquidity",
+        category: "liquidity",
+        description: "Liquidity was minted into a Turbos position.",
+        generic: false,
+        schema: TurbosAddLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool::MintEvent", primary: true }
+        ]
+      },
+      "turbos.pool-created": {
+        id: "turbos.pool-created",
+        protocolId: "turbos",
+        label: "Turbos \u2014 Pool created",
+        category: "pool",
+        description: "A new Turbos CLMM pool was created.",
+        generic: false,
+        schema: TurbosPoolCreatedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool_factory::PoolCreatedEvent", primary: true }
+        ]
+      },
+      "turbos.remove-liquidity": {
+        id: "turbos.remove-liquidity",
+        protocolId: "turbos",
+        label: "Turbos \u2014 Remove liquidity",
+        category: "liquidity",
+        description: "Liquidity was burned from a Turbos position.",
+        generic: false,
+        schema: TurbosRemoveLiquiditySchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool::BurnEvent", primary: true }
+        ]
+      },
+      "turbos.swap": {
+        id: "turbos.swap",
+        protocolId: "turbos",
+        label: "Turbos \u2014 Swap",
+        category: "swap",
+        description: "A swap was executed on a Turbos CLMM pool.",
+        generic: false,
+        schema: TurbosSwapSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x91bfbc386a41afcfd9b2533058d7e915a1d3829089cc268ff4333d54d6339ca1::pool::SwapEvent", primary: true }
+        ]
+      },
+      "typus.dov-auction": {
+        id: "typus.dov-auction",
+        protocolId: "typus",
+        label: "Typus \u2014 DOV auction started",
+        category: "option",
+        description: "A new Typus options-vault (DOV) auction round started.",
+        generic: false,
+        schema: TypusDovAuctionSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x321848bf1ae327a9e022ccb3701940191e02fa193ab160d9c0e49cd3c003de3a::typus_dov_single::NewAuctionEvent", primary: true }
+        ]
+      },
+      "typus.dov-bid": {
+        id: "typus.dov-bid",
+        protocolId: "typus",
+        label: "Typus \u2014 DOV bid",
+        category: "option",
+        description: "A bid was placed in a Typus options-vault auction.",
+        generic: false,
+        schema: TypusDovBidSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x321848bf1ae327a9e022ccb3701940191e02fa193ab160d9c0e49cd3c003de3a::typus_dov_single::NewBidEvent", primary: true }
+        ]
+      },
+      "typus.dov-settle": {
+        id: "typus.dov-settle",
+        protocolId: "typus",
+        label: "Typus \u2014 DOV settled",
+        category: "option",
+        description: "A Typus options-vault round was settled.",
+        generic: false,
+        schema: TypusDovSettleSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x321848bf1ae327a9e022ccb3701940191e02fa193ab160d9c0e49cd3c003de3a::typus_dov_single::SettleEvent", primary: true }
+        ]
+      },
+      "typus.perp-funding": {
+        id: "typus.perp-funding",
+        protocolId: "typus",
+        label: "Typus \u2014 Perp funding update",
+        category: "funding",
+        description: "A Typus perps market funding rate was updated.",
+        generic: false,
+        schema: TypusPerpFundingSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x9003219180252ae6b81d2893b41d430488669027219537236675c0c2924c94d9::trading::UpdateFundingRateEvent", primary: true }
+        ]
+      },
+      "typus.perp-liquidate": {
+        id: "typus.perp-liquidate",
+        protocolId: "typus",
+        label: "Typus \u2014 Perp liquidation",
+        category: "liquidation",
+        description: "A Typus perps position was liquidated.",
+        generic: false,
+        schema: TypusPerpLiquidateSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x9003219180252ae6b81d2893b41d430488669027219537236675c0c2924c94d9::trading::LiquidateEvent", primary: true }
+        ]
+      },
+      "typus.perp-lp-burn": {
+        id: "typus.perp-lp-burn",
+        protocolId: "typus",
+        label: "Typus \u2014 TLP burn",
+        category: "liquidity",
+        description: "Liquidity was removed from the Typus perps LP (TLP).",
+        generic: false,
+        schema: TypusPerpLpBurnSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x9003219180252ae6b81d2893b41d430488669027219537236675c0c2924c94d9::lp_pool::BurnLpEvent", primary: true }
+        ]
+      },
+      "typus.perp-lp-mint": {
+        id: "typus.perp-lp-mint",
+        protocolId: "typus",
+        label: "Typus \u2014 TLP mint",
+        category: "liquidity",
+        description: "Liquidity was added to the Typus perps LP (TLP).",
+        generic: false,
+        schema: TypusPerpLpMintSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x9003219180252ae6b81d2893b41d430488669027219537236675c0c2924c94d9::lp_pool::MintLpEvent", primary: true }
+        ]
+      },
+      "typus.perp-order": {
+        id: "typus.perp-order",
+        protocolId: "typus",
+        label: "Typus \u2014 Perp order created",
+        category: "perp",
+        description: "A trading order was created on Typus perps.",
+        generic: false,
+        schema: TypusPerpOrderSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x9003219180252ae6b81d2893b41d430488669027219537236675c0c2924c94d9::trading::CreateTradingOrderEvent", primary: true }
+        ]
+      },
+      "volo.staked": {
+        id: "volo.staked",
+        protocolId: "volo",
+        label: "Volo \u2014 Staked",
+        category: "stake",
+        description: "SUI was staked with Volo in exchange for vSUI.",
+        generic: false,
+        schema: VoloStakedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::native_pool::StakedEvent", primary: true }
+        ]
+      },
+      "volo.unstaked": {
+        id: "volo.unstaked",
+        protocolId: "volo",
+        label: "Volo \u2014 Unstaked",
+        category: "unstake",
+        description: "vSUI was burned to unstake SUI on Volo.",
+        generic: false,
+        schema: VoloUnstakedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0x549e8b69270defbfafd4f94e17ec44cdbdd99820b33bda2278dea3b9a32d3f55::native_pool::UnstakedEvent", primary: true }
+        ]
+      },
+      "walrus.blob-certified": {
+        id: "walrus.blob-certified",
+        protocolId: "walrus",
+        label: "Walrus \u2014 Blob certified",
+        category: "storage",
+        description: "A Walrus blob was certified available.",
+        generic: false,
+        schema: WalrusBlobCertifiedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events::BlobCertified", primary: true }
+        ]
+      },
+      "walrus.blob-deleted": {
+        id: "walrus.blob-deleted",
+        protocolId: "walrus",
+        label: "Walrus \u2014 Blob deleted",
+        category: "storage",
+        description: "A Walrus blob was deleted.",
+        generic: false,
+        schema: WalrusBlobDeletedSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events::BlobDeleted", primary: true }
+        ]
+      },
+      "walrus.blob-registered": {
+        id: "walrus.blob-registered",
+        protocolId: "walrus",
+        label: "Walrus \u2014 Blob registered",
+        category: "storage",
+        description: "A new blob was registered for storage on Walrus.",
+        generic: false,
+        schema: WalrusBlobRegisteredSchema,
+        deployments: [
+          { network: "mainnet", eventType: "0xfdc88f7d7cf30afab2f82e8380d11ee8f70efb90e863d1de8616fae1bb09ea77::events::BlobRegistered", primary: true }
+        ]
+      }
+    };
+  }
+});
+
+// src/events/index.ts
+var events_exports = {};
+__export(events_exports, {
+  AftermathDepositSchema: () => AftermathDepositSchema,
+  AftermathPerpFundingSchema: () => AftermathPerpFundingSchema,
+  AftermathPerpLiquidatedSchema: () => AftermathPerpLiquidatedSchema,
+  AftermathSwapSchema: () => AftermathSwapSchema,
+  AlphafiLiquidityChangeSchema: () => AlphafiLiquidityChangeSchema,
+  AlphafiRewardSchema: () => AlphafiRewardSchema,
+  BluefinFeeCollectedSchema: () => BluefinFeeCollectedSchema,
+  BluefinLiquidityProvidedSchema: () => BluefinLiquidityProvidedSchema,
+  BluefinLiquidityRemovedSchema: () => BluefinLiquidityRemovedSchema,
+  BluefinPoolCreatedSchema: () => BluefinPoolCreatedSchema,
+  BluefinPositionClosedSchema: () => BluefinPositionClosedSchema,
+  BluefinPositionOpenedSchema: () => BluefinPositionOpenedSchema,
+  BluefinRewardCollectedSchema: () => BluefinRewardCollectedSchema,
+  BluefinSwapSchema: () => BluefinSwapSchema,
+  BucketBorrowSchema: () => BucketBorrowSchema,
+  BucketDepositCollateralSchema: () => BucketDepositCollateralSchema,
+  BucketPositionUpdatedSchema: () => BucketPositionUpdatedSchema,
+  BucketRedeemSchema: () => BucketRedeemSchema,
+  BucketRepaySchema: () => BucketRepaySchema,
+  BucketSbuckDepositSchema: () => BucketSbuckDepositSchema,
+  BucketSbuckRewardsSchema: () => BucketSbuckRewardsSchema,
+  BucketWithdrawCollateralSchema: () => BucketWithdrawCollateralSchema,
+  CetusAddLiquiditySchema: () => CetusAddLiquiditySchema,
+  CetusClosePositionSchema: () => CetusClosePositionSchema,
+  CetusCollectFeeSchema: () => CetusCollectFeeSchema,
+  CetusCreatePoolSchema: () => CetusCreatePoolSchema,
+  CetusOpenPositionSchema: () => CetusOpenPositionSchema,
+  CetusRemoveLiquiditySchema: () => CetusRemoveLiquiditySchema,
+  CetusSwapSchema: () => CetusSwapSchema,
+  CurrentBorrowSchema: () => CurrentBorrowSchema,
+  CurrentDepositSchema: () => CurrentDepositSchema,
+  CurrentLiquidateSchema: () => CurrentLiquidateSchema,
+  CurrentRepaySchema: () => CurrentRepaySchema,
+  CurrentWithdrawSchema: () => CurrentWithdrawSchema,
+  DeepbookBalanceSchema: () => DeepbookBalanceSchema,
+  DeepbookFlashLoanSchema: () => DeepbookFlashLoanSchema,
+  DeepbookOrderCanceledSchema: () => DeepbookOrderCanceledSchema,
+  DeepbookOrderFilledSchema: () => DeepbookOrderFilledSchema,
+  DeepbookOrderInfoSchema: () => DeepbookOrderInfoSchema,
+  DeepbookOrderPlacedSchema: () => DeepbookOrderPlacedSchema,
+  EmberDepositSchema: () => EmberDepositSchema,
+  EmberRateUpdatedSchema: () => EmberRateUpdatedSchema,
+  EmberRedeemProcessedSchema: () => EmberRedeemProcessedSchema,
+  EmberRedeemRequestSchema: () => EmberRedeemRequestSchema,
+  EventSchemaReflector: () => EventSchemaReflector,
+  FlowxAmmPairCreatedSchema: () => FlowxAmmPairCreatedSchema,
+  FlowxAmmSwapSchema: () => FlowxAmmSwapSchema,
+  FlowxClmmPoolCreatedSchema: () => FlowxClmmPoolCreatedSchema,
+  FlowxClmmSwapSchema: () => FlowxClmmSwapSchema,
+  HaedalInstantUnstakedSchema: () => HaedalInstantUnstakedSchema,
+  HaedalStakedSchema: () => HaedalStakedSchema,
+  HaedalUnstakedSchema: () => HaedalUnstakedSchema,
+  KaiAddLiquiditySchema: () => KaiAddLiquiditySchema,
+  KaiDeleverageSchema: () => KaiDeleverageSchema,
+  KaiLiquidationSchema: () => KaiLiquidationSchema,
+  KaiPositionOpenSchema: () => KaiPositionOpenSchema,
+  KaiReduceSchema: () => KaiReduceSchema,
+  KaiSupplySchema: () => KaiSupplySchema,
+  KaiSupplyWithdrawSchema: () => KaiSupplyWithdrawSchema,
+  KriyaAddLiquiditySchema: () => KriyaAddLiquiditySchema,
+  KriyaSwapSchema: () => KriyaSwapSchema,
+  MagmaAddLiquiditySchema: () => MagmaAddLiquiditySchema,
+  MagmaCollectFeeSchema: () => MagmaCollectFeeSchema,
+  MagmaCollectRewardSchema: () => MagmaCollectRewardSchema,
+  MagmaCreatePoolSchema: () => MagmaCreatePoolSchema,
+  MagmaRemoveLiquiditySchema: () => MagmaRemoveLiquiditySchema,
+  MagmaSwapSchema: () => MagmaSwapSchema,
+  MoleAddDebtSchema: () => MoleAddDebtSchema,
+  MoleDepositSchema: () => MoleDepositSchema,
+  MoleHarvestSchema: () => MoleHarvestSchema,
+  MoleKillSchema: () => MoleKillSchema,
+  MoleWithdrawSchema: () => MoleWithdrawSchema,
+  MoleWorkSchema: () => MoleWorkSchema,
+  MomentumAddLiquiditySchema: () => MomentumAddLiquiditySchema,
+  MomentumCollectFeeSchema: () => MomentumCollectFeeSchema,
+  MomentumCollectRewardSchema: () => MomentumCollectRewardSchema,
+  MomentumPoolCreatedSchema: () => MomentumPoolCreatedSchema,
+  MomentumRemoveLiquiditySchema: () => MomentumRemoveLiquiditySchema,
+  MomentumRepayFlashSwapSchema: () => MomentumRepayFlashSwapSchema,
+  MomentumSwapSchema: () => MomentumSwapSchema,
+  NaviBorrowSchema: () => NaviBorrowSchema,
+  NaviDepositSchema: () => NaviDepositSchema,
+  NaviLiquidationSchema: () => NaviLiquidationSchema,
+  NaviRepaySchema: () => NaviRepaySchema,
+  NaviWithdrawSchema: () => NaviWithdrawSchema,
+  PythPriceFeedUpdateSchema: () => PythPriceFeedUpdateSchema,
+  ScallopBorrowSchema: () => ScallopBorrowSchema,
+  ScallopCollateralDepositSchema: () => ScallopCollateralDepositSchema,
+  ScallopCollateralWithdrawSchema: () => ScallopCollateralWithdrawSchema,
+  ScallopLiquidationSchema: () => ScallopLiquidationSchema,
+  ScallopRepaySchema: () => ScallopRepaySchema,
+  SpringsuiEpochChangedSchema: () => SpringsuiEpochChangedSchema,
+  SpringsuiStakeSchema: () => SpringsuiStakeSchema,
+  SpringsuiUnstakeSchema: () => SpringsuiUnstakeSchema,
+  SteammBankDepositSchema: () => SteammBankDepositSchema,
+  SteammBankWithdrawSchema: () => SteammBankWithdrawSchema,
+  SuilendBorrowSchema: () => SuilendBorrowSchema,
+  SuilendClaimRewardSchema: () => SuilendClaimRewardSchema,
+  SuilendDepositSchema: () => SuilendDepositSchema,
+  SuilendLiquidateSchema: () => SuilendLiquidateSchema,
+  SuilendRepaySchema: () => SuilendRepaySchema,
+  SuilendWithdrawSchema: () => SuilendWithdrawSchema,
+  SupraPriceUpdateSchema: () => SupraPriceUpdateSchema,
+  TurbosAddLiquiditySchema: () => TurbosAddLiquiditySchema,
+  TurbosPoolCreatedSchema: () => TurbosPoolCreatedSchema,
+  TurbosRemoveLiquiditySchema: () => TurbosRemoveLiquiditySchema,
+  TurbosSwapSchema: () => TurbosSwapSchema,
+  TypusDovAuctionSchema: () => TypusDovAuctionSchema,
+  TypusDovBidSchema: () => TypusDovBidSchema,
+  TypusDovSettleSchema: () => TypusDovSettleSchema,
+  TypusPerpFundingSchema: () => TypusPerpFundingSchema,
+  TypusPerpLiquidateSchema: () => TypusPerpLiquidateSchema,
+  TypusPerpLpBurnSchema: () => TypusPerpLpBurnSchema,
+  TypusPerpLpMintSchema: () => TypusPerpLpMintSchema,
+  TypusPerpOrderSchema: () => TypusPerpOrderSchema,
+  VoloStakedSchema: () => VoloStakedSchema,
+  VoloUnstakedSchema: () => VoloUnstakedSchema,
+  WalrusBlobCertifiedSchema: () => WalrusBlobCertifiedSchema,
+  WalrusBlobDeletedSchema: () => WalrusBlobDeletedSchema,
+  WalrusBlobRegisteredSchema: () => WalrusBlobRegisteredSchema,
+  _7kConfirmSwapSchema: () => _7kConfirmSwapSchema,
+  _7kSwapSchema: () => _7kSwapSchema,
+  baseEventType: () => baseEventType,
+  catalogEvents: () => catalogEvents,
+  eventTypeMatches: () => eventTypeMatches,
+  formatMoveType: () => formatMoveType,
+  innerEventType: () => innerEventType,
+  matchCatalogEvent: () => matchCatalogEvent,
+  moveAddress: () => moveAddress,
+  moveBalance: () => moveBalance,
+  moveBool: () => moveBool,
+  moveBytes: () => moveBytes,
+  moveSmallUint: () => moveSmallUint,
+  moveString: () => moveString,
+  moveTypeName: () => moveTypeName,
+  moveUint: () => moveUint,
+  normalizeAddress: () => normalizeAddress,
+  parseCatalogEvent: () => parseCatalogEvent,
+  parseMoveType: () => parseMoveType,
+  resolveCatalogEvent: () => resolveCatalogEvent,
+  resolveShape: () => resolveShape,
+  shapeToExpr: () => shapeToExpr,
+  shapeToZod: () => shapeToZod,
+  substituteTypeParams: () => substituteTypeParams,
+  warpAddressPayloadSchema: () => warpAddressPayloadSchema,
+  warpCoinPayloadSchema: () => warpCoinPayloadSchema,
+  warpEventPayloadSchema: () => warpEventPayloadSchema,
+  warpObjectPayloadSchema: () => warpObjectPayloadSchema,
+  webhookEventBodySchema: () => webhookEventBodySchema
+});
+function resolveCatalogEvent(rawEventType, options = {}) {
+  for (const event of Object.values(catalogEvents)) {
+    for (const deployment of event.deployments) {
+      if (options.network && deployment.network !== options.network) {
+        continue;
+      }
+      if (eventTypeMatches(rawEventType, deployment, event.generic)) {
+        return event;
+      }
+    }
+  }
+  return void 0;
+}
+function extractEventPayload2(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 extractEventPayload2(record.payload, depth + 1) ?? extractEventPayload2(record.data, depth + 1);
+}
+function matches(rawEventType, id, options) {
+  const event = catalogEvents[id];
+  return event.deployments.some(
+    (deployment) => (!options.network || deployment.network === options.network) && eventTypeMatches(rawEventType, deployment, event.generic)
+  );
+}
+function matchCatalogEvent(message, id, options = {}) {
+  const payload = extractEventPayload2(message);
+  if (!payload || !matches(payload.type, id, options)) {
+    return void 0;
+  }
+  return payload.data;
+}
+function parseCatalogEvent(message, id, options = {}) {
+  const payload = extractEventPayload2(message);
+  if (!payload || !matches(payload.type, id, options)) {
+    return void 0;
+  }
+  return catalogEvents[id].schema.parse(
+    payload.data
+  );
+}
+var init_events2 = __esm({
+  "src/events/index.ts"() {
+    "use strict";
+    init_events();
+    init_runtime();
+    init_runtime();
+    init_events();
+    init_move_types();
+    init_reflection();
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccountNamespace: () => AccountNamespace,
+  CatalogNamespace: () => CatalogNamespace,
+  DataNamespace: () => DataNamespace,
+  EventsNamespace: () => EventsNamespace,
+  INODRA_ENDPOINTS: () => INODRA_ENDPOINTS,
+  Inodra: () => Inodra,
+  InodraAuthenticationError: () => InodraAuthenticationError,
+  InodraError: () => InodraError,
+  InodraHttpClient: () => InodraHttpClient,
+  InodraManagementClient: () => InodraManagementClient,
+  InodraRateLimitError: () => InodraRateLimitError,
+  InodraTimeoutError: () => InodraTimeoutError,
+  InodraWebhookSignatureError: () => InodraWebhookSignatureError,
+  SDK_VERSION: () => SDK_VERSION,
+  WarpNamespace: () => WarpNamespace,
+  WarpSseStream: () => WarpSseStream,
+  WarpWebSocketStream: () => WarpWebSocketStream,
+  WebhooksNamespace: () => WebhooksNamespace,
+  iterateStream: () => iterateStream,
+  paginate: () => paginate,
+  resolveAuth: () => resolveAuth,
+  verifyWebhookSignature: () => verifyWebhookSignature
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client.ts
+init_auth();
+
+// src/core/http.ts
+init_auth();
+
+// src/core/errors.ts
+var InodraError = class extends Error {
+  status;
+  requestId;
+  body;
+  /** Stable machine-readable error code from the API (e.g. "QUOTA_EXCEEDED"). */
+  code;
+  constructor(message, options) {
+    super(message);
+    this.name = "InodraError";
+    this.status = options.status;
+    this.requestId = options.requestId;
+    this.body = options.body;
+    this.code = options.code;
+  }
+};
+var InodraAuthenticationError = class extends InodraError {
+  constructor(options) {
+    super(
+      options.message ?? (options.status === 403 ? "Forbidden \u2014 the API key is valid but not allowed to do this" : "Invalid or missing API key"),
+      options
+    );
+    this.name = "InodraAuthenticationError";
+  }
+};
+var InodraRateLimitError = class extends InodraError {
+  retryAfterSeconds;
+  constructor(options) {
+    super(options.message ?? "Rate limit exceeded", options);
+    this.name = "InodraRateLimitError";
+    this.retryAfterSeconds = options.retryAfterSeconds;
+  }
+};
+var InodraTimeoutError = class extends Error {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "InodraTimeoutError";
+  }
+};
+var InodraWebhookSignatureError = class extends Error {
+  constructor() {
+    super("Webhook signature verification failed (bad, missing, or expired)");
+    this.name = "InodraWebhookSignatureError";
+  }
+};
+
+// src/core/http.ts
+init_network();
+init_version();
+var InodraHttpClient = class {
+  baseUrl;
+  /** Rate-limit/credit info from the most recent response, if any. */
+  lastResponseMeta;
+  auth;
+  maxRetries;
+  timeoutMs;
+  fetchImpl;
+  onResponseMeta;
+  constructor(options) {
+    this.auth = authFromOptions(options, "InodraHttpClient");
+    this.baseUrl = (options.baseUrl ?? restBaseUrl(options.network ?? "mainnet")).replace(/\/$/, "");
+    this.maxRetries = options.maxRetries ?? 2;
+    this.timeoutMs = options.timeoutMs ?? 3e4;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.onResponseMeta = options.onResponseMeta;
+  }
+  async request(method, path, options = {}) {
+    const url = new URL(this.baseUrl + path);
+    for (const [key, value] of Object.entries(options.query ?? {})) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    const retryOn5xx = options.idempotent ?? !(method === "POST" || method === "PATCH");
+    let attempt = 0;
+    for (; ; ) {
+      const response = await this.send(url, method, options);
+      this.captureMeta(response);
+      if (response.ok) {
+        if (response.status === 204) {
+          return void 0;
+        }
+        return await response.json();
+      }
+      const retryable = response.status === 429 || retryOn5xx && response.status >= 500;
+      if (retryable && attempt < this.maxRetries) {
+        attempt += 1;
+        await sleep(retryDelayMs(response, attempt));
+        continue;
+      }
+      throw await toError(response);
+    }
+  }
+  async send(url, method, options) {
+    const timeoutSignal = AbortSignal.timeout(this.timeoutMs);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+    const { headers: authHeaders } = await this.auth.credentials();
+    try {
+      return await this.fetchImpl(url, {
+        method,
+        headers: {
+          ...authHeaders,
+          [SDK_HEADER_NAME]: SDK_HEADER_VALUE,
+          "content-type": "application/json",
+          accept: "application/json"
+        },
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+        signal
+      });
+    } catch (error) {
+      if (timeoutSignal.aborted && !options.signal?.aborted) {
+        throw new InodraTimeoutError(this.timeoutMs);
+      }
+      throw error;
+    }
+  }
+  captureMeta(response) {
+    const meta = parseResponseMeta(response);
+    if (meta) {
+      this.lastResponseMeta = meta;
+      this.onResponseMeta?.(meta);
+    }
+  }
+};
+function parseResponseMeta(response) {
+  const meta = {};
+  const limit = header(response, "x-ratelimit-limit");
+  const remaining = header(response, "x-ratelimit-remaining");
+  const reset = header(response, "x-ratelimit-reset");
+  if (limit !== void 0 && remaining !== void 0) {
+    meta.rateLimit = {
+      limit,
+      remaining,
+      reset: reset ?? 0,
+      throttled: response.headers.get("x-ratelimit-throttle") !== null
+    };
+  }
+  const creditRemaining = header(response, "x-inodra-credit-remaining");
+  const creditLimit = header(response, "x-inodra-credit-limit");
+  if (creditRemaining !== void 0 && creditLimit !== void 0) {
+    meta.credits = {
+      remaining: creditRemaining,
+      limit: creditLimit,
+      replenishDate: response.headers.get("x-inodra-credit-replenish-date") ?? void 0,
+      degraded: response.headers.get("x-inodra-credit-degraded") === "true"
+    };
+  }
+  const requestId = response.headers.get("x-request-id");
+  if (requestId) {
+    meta.requestId = requestId;
+  }
+  if (!meta.rateLimit && !meta.credits && !meta.requestId) {
+    return void 0;
+  }
+  return meta;
+}
+function header(response, name) {
+  const raw = response.headers.get(name);
+  if (raw === null) {
+    return void 0;
+  }
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : void 0;
+}
+async function toError(response) {
+  const requestId = response.headers.get("x-request-id") ?? void 0;
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = void 0;
+  }
+  const serverMessage = extractField(body, ["message", "error"]);
+  const code = extractField(body, ["code"]);
+  if (response.status === 401 || response.status === 403) {
+    return new InodraAuthenticationError({
+      status: response.status,
+      requestId,
+      body,
+      code,
+      message: serverMessage
+    });
+  }
+  if (response.status === 429) {
+    const retryAfter = response.headers.get("retry-after");
+    return new InodraRateLimitError({
+      status: response.status,
+      requestId,
+      body,
+      code,
+      retryAfterSeconds: retryAfter ? Number(retryAfter) : void 0,
+      message: serverMessage
+    });
+  }
+  return new InodraError(
+    serverMessage ?? `Request failed with status ${response.status}`,
+    { status: response.status, requestId, body, code }
+  );
+}
+function extractField(body, keys) {
+  if (typeof body !== "object" || body === null) {
+    return void 0;
+  }
+  for (const key of keys) {
+    const value = body[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function retryDelayMs(response, attempt) {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds)) {
+      return seconds * 1e3;
+    }
+  }
+  return 250 * 2 ** (attempt - 1) + Math.random() * 100;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/client.ts
+init_network();
+
+// src/graphql/index.ts
+var import_graphql = require("@mysten/sui/graphql");
+init_auth();
+init_network();
+init_version();
+var import_graphql2 = require("@mysten/sui/graphql");
+function createInodraGraphQLClient(options) {
+  const network = options.network ?? "mainnet";
+  return new import_graphql.SuiGraphQLClient({
+    network,
+    url: options.url ?? graphqlUrl(network),
+    headers: {
+      ...staticAuthHeaders(options, "createInodraGraphQLClient"),
+      [SDK_HEADER_NAME]: SDK_HEADER_VALUE,
+      ...options.headers
+    },
+    queries: options.queries
+  });
+}
+
+// src/grpc-web/index.ts
+var import_grpc = require("@mysten/sui/grpc");
+var import_grpcweb_transport = require("@protobuf-ts/grpcweb-transport");
+init_auth();
+init_network();
+init_version();
+var import_grpc2 = require("@mysten/sui/grpc");
+function createInodraGrpcWebClient(options) {
+  const network = options.network ?? "mainnet";
+  const transport = new import_grpcweb_transport.GrpcWebFetchTransport({
+    baseUrl: options.baseUrl ?? grpcBaseUrl(network),
+    meta: {
+      ...staticAuthHeaders(options, "createInodraGrpcWebClient"),
+      [SDK_HEADER_NAME]: SDK_HEADER_VALUE,
+      ...options.metadata
+    }
+  });
+  return new import_grpc.SuiGrpcClient({ network, transport });
+}
+
+// src/namespaces/account.ts
+var AccountNamespace = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  /** Who am I — key, organization, project, network, tier, subscription. */
+  me() {
+    return this.http.request("GET", "/auth/me");
+  }
+  /** Usage stats for the current billing period (CU, requests, latency). */
+  usage() {
+    return this.http.request("GET", "/usage/stats");
+  }
+};
+
+// src/namespaces/catalog.ts
+var CatalogNamespace = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  protocols(query) {
+    return this.http.request("GET", "/catalog/protocols", { query });
+  }
+  events(query) {
+    return this.http.request("GET", "/catalog/events", { query });
+  }
+};
+
+// src/core/openapi.ts
+async function* paginate(fetchPage) {
+  let cursor;
+  for (; ; ) {
+    const page = await fetchPage(cursor);
+    yield* page.data;
+    if (!page.pagination.hasNext || !page.pagination.cursor) {
+      return;
+    }
+    cursor = page.pagination.cursor;
+  }
+}
+
+// src/namespaces/data.ts
+var DataNamespace = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  accounts = {
+    get: (address) => this.http.request("GET", `/accounts/${encodeURIComponent(address)}`),
+    balance: (address) => this.http.request(
+      "GET",
+      `/accounts/${encodeURIComponent(address)}/balance`
+    ),
+    objects: (address, query) => this.http.request(
+      "GET",
+      `/accounts/${encodeURIComponent(address)}/objects`,
+      { query }
+    ),
+    /** Every owned object, walking all pages lazily. */
+    iterateObjects: (address, query) => paginate(
+      (cursor) => this.accounts.objects(address, { ...query, cursor })
+    ),
+    transactions: (address, query) => this.http.request(
+      "GET",
+      `/accounts/${encodeURIComponent(address)}/transactions`,
+      { query }
+    ),
+    /** Every transaction, walking all pages lazily. */
+    iterateTransactions: (address, query) => paginate(
+      (cursor) => this.accounts.transactions(address, { ...query, cursor })
+    ),
+    delegations: (address) => this.http.request(
+      "GET",
+      `/accounts/${encodeURIComponent(address)}/delegations`
+    )
+  };
+  coins = {
+    /** Coin denomination (supply, holders, decimals, …). */
+    get: (coinType) => this.http.request("GET", `/coins/${encodeURIComponent(coinType)}`),
+    /** Display metadata: name, symbol, icon, description, links. */
+    metadata: (coinType) => this.http.request("GET", `/coins/type/${encodeURIComponent(coinType)}`)
+  };
+  objects = {
+    /** Metadata (type, name, image, project) for one object id. */
+    metadata: (input) => this.http.request("POST", "/objects/metadata", {
+      body: input,
+      idempotent: true
+    }),
+    transactions: (objectId, query) => this.http.request(
+      "GET",
+      `/objects/${encodeURIComponent(objectId)}/transactions`,
+      { query }
+    ),
+    /** Every transaction touching the object, walking all pages lazily. */
+    iterateTransactions: (objectId, query) => paginate(
+      (cursor) => this.objects.transactions(objectId, { ...query, cursor })
+    )
+  };
+  packages = {
+    get: (packageId) => this.http.request("GET", `/packages/${encodeURIComponent(packageId)}`)
+  };
+  chain = {
+    info: () => this.http.request("GET", "/chain/info"),
+    staking: () => this.http.request("GET", "/chain/staking"),
+    stats: () => this.http.request("GET", "/chain/stats")
+  };
+  validators = {
+    list: (query) => this.http.request("GET", "/validators", { query }),
+    apy: () => this.http.request("GET", "/validators/apy"),
+    commission: () => this.http.request("GET", "/validators/commission"),
+    get: (validatorAddress) => this.http.request(
+      "GET",
+      `/validators/${encodeURIComponent(validatorAddress)}`
+    )
+  };
+  suins = {
+    /** SuiNS name → address. */
+    resolve: (name) => this.http.request("GET", `/suins/resolve/${encodeURIComponent(name)}`),
+    /** Address → primary SuiNS name. */
+    reverse: (address) => this.http.request(
+      "GET",
+      `/suins/reverse/${encodeURIComponent(address)}`
+    ),
+    resolveBatch: (input) => this.http.request("POST", "/suins/resolve/batch", {
+      body: input,
+      idempotent: true
+    }),
+    availability: (name) => this.http.request(
+      "GET",
+      `/suins/availability/${encodeURIComponent(name)}`
+    )
+  };
+};
+
+// src/namespaces/events.ts
+var EventsNamespace = class {
+  ctx;
+  reflectorPromise;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  /** The underlying reflector (shared cache across calls). */
+  reflector() {
+    this.reflectorPromise ??= Promise.resolve().then(() => (init_reflection(), reflection_exports)).then(
+      (module2) => new module2.EventSchemaReflector({
+        auth: this.ctx.auth,
+        network: this.ctx.network,
+        url: this.ctx.graphqlUrl,
+        fetch: this.ctx.fetch
+      })
+    );
+    return this.reflectorPromise;
+  }
+  /**
+   * Build (and cache) a loose, normalizing zod schema for any concrete
+   * Move event type, by reflecting its struct layout on-chain. Generic
+   * types are typed concretely from their instantiation.
+   */
+  async schemaFor(type) {
+    return (await this.reflector()).schemaFor(type);
+  }
+  /**
+   * Validate + normalize an event payload against the reflected schema.
+   * Accepts a Warp stream message, a bare event payload, or a webhook
+   * body. Returns undefined for other event types; throws on schema
+   * mismatch. Pass a base type (no `<…>`) to match every instantiation —
+   * each is reflected and typed concretely.
+   */
+  async parseEvent(message, type) {
+    return (await this.reflector()).parseEvent(message, type);
+  }
+};
+
+// 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/warp/sse.ts
+init_auth();
+init_version();
+init_network();
+
+// 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 sleep2(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 sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/warp/ws.ts
+init_auth();
+init_network();
+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);
+  }
+};
+
+// src/namespaces/warp.ts
+var WarpNamespace = class {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  createEventStream(input) {
+    return this.ctx.http.request("POST", "/warp/events", { body: input });
+  }
+  createAddressStream(input) {
+    return this.ctx.http.request("POST", "/warp/addresses", { body: input });
+  }
+  createCoinStream(input) {
+    return this.ctx.http.request("POST", "/warp/coins", { body: input });
+  }
+  createObjectStream(input) {
+    return this.ctx.http.request("POST", "/warp/objects", { body: input });
+  }
+  list() {
+    return this.ctx.http.request("GET", "/warp");
+  }
+  get(id) {
+    return this.ctx.http.request("GET", `/warp/${encodeURIComponent(id)}`);
+  }
+  update(id, input) {
+    return this.ctx.http.request("PUT", `/warp/${encodeURIComponent(id)}`, {
+      body: input
+    });
+  }
+  delete(id) {
+    return this.ctx.http.request("DELETE", `/warp/${encodeURIComponent(id)}`);
+  }
+  /**
+   * Open an SSE connection to a Warp subscription and start it.
+   * At-least-once delivery; reconnects resume from the last event ID.
+   */
+  connect(subscriptionId, options = {}) {
+    const stream = new WarpSseStream({
+      ...options,
+      auth: this.ctx.auth,
+      subscriptionId,
+      network: this.ctx.network,
+      url: options.url ?? this.sseUrl(subscriptionId),
+      fetch: options.fetch ?? this.ctx.fetch
+    });
+    stream.connect();
+    return stream;
+  }
+  /**
+   * Open a WebSocket connection to a Warp subscription and start it.
+   * Exactly-once delivery via acks (automatic by default).
+   */
+  connectWebSocket(subscriptionId, options = {}) {
+    const stream = new WarpWebSocketStream({
+      ...options,
+      auth: this.ctx.auth,
+      subscriptionId,
+      network: this.ctx.network,
+      url: options.url ?? this.wsUrl(subscriptionId)
+    });
+    stream.connect();
+    return stream;
+  }
+  /**
+   * One call from catalog id to typed live events: resolves the event's
+   * canonical type for this network, creates the subscription, connects,
+   * and yields validated payloads.
+   *
+   * ```ts
+   * const swaps = await inodra.warp.streamCatalogEvent("cetus.swap", {
+   *   ephemeral: true,
+   * });
+   * for await (const { payload, envelope } of swaps) {
+   *   console.log(envelope.txDigest, payload.amount_in);
+   * }
+   * ```
+   */
+  async streamCatalogEvent(id, options = {}) {
+    const events = await Promise.resolve().then(() => (init_events2(), events_exports));
+    const event = events.catalogEvents[id];
+    if (!event) {
+      throw new Error(`Unknown catalog event id: ${String(id)}`);
+    }
+    const deployments = event.deployments;
+    const deployment = deployments.find(
+      (d) => d.network === this.ctx.network && d.primary
+    ) ?? deployments.find((d) => d.network === this.ctx.network);
+    if (!deployment) {
+      throw new Error(
+        `Catalog event ${String(id)} has no verified deployment on ${this.ctx.network}`
+      );
+    }
+    const { sender, eventFieldFilters, transport, ephemeral, ...connectOptions } = options;
+    const created = await this.createEventStream({
+      eventType: deployment.eventType,
+      sender,
+      eventFieldFilters
+    });
+    const subscription = created.data;
+    let stream;
+    try {
+      stream = transport === "ws" ? this.connectWebSocket(subscription.id, connectOptions) : this.connect(subscription.id, connectOptions);
+    } catch (error) {
+      if (ephemeral) {
+        await this.delete(subscription.id).catch(() => {
+        });
+      }
+      throw error;
+    }
+    let cleaned = false;
+    const close = async () => {
+      stream.close();
+      if (ephemeral && !cleaned) {
+        cleaned = true;
+        await this.delete(subscription.id);
+      }
+    };
+    const network = this.ctx.network;
+    return {
+      subscription,
+      stream,
+      close,
+      async *[Symbol.asyncIterator]() {
+        try {
+          for await (const raw of iterateStream(stream, {
+            closeOnReturn: false
+          })) {
+            const payload = events.parseCatalogEvent(raw, id, { network });
+            if (payload === void 0) {
+              continue;
+            }
+            const envelope = events.warpEventPayloadSchema.parse(raw.data);
+            yield { payload, envelope };
+          }
+        } finally {
+          await close();
+        }
+      }
+    };
+  }
+  sseUrl(subscriptionId) {
+    if (!this.ctx.restBaseUrl) {
+      return void 0;
+    }
+    return `${this.ctx.restBaseUrl}/warp/${encodeURIComponent(subscriptionId)}/stream`;
+  }
+  wsUrl(subscriptionId) {
+    if (!this.ctx.warpWsBaseUrl) {
+      return void 0;
+    }
+    return `${this.ctx.warpWsBaseUrl}/warp/${encodeURIComponent(subscriptionId)}/ws`;
+  }
+};
+
+// src/webhooks/index.ts
+async function verifyWebhookSignature(options) {
+  const parsed = parseSignatureHeader(options.signature);
+  if (!parsed) {
+    return false;
+  }
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (Math.abs(now - parsed.timestamp) > tolerance) {
+    return false;
+  }
+  const expected = await hmacSha256Hex(
+    options.secret,
+    `${parsed.timestamp}.${options.payload}`
+  );
+  return parsed.signatures.some(
+    (candidate) => timingSafeEqualHex(candidate, expected)
+  );
+}
+function parseSignatureHeader(header2) {
+  if (typeof header2 !== "string" || header2.length === 0) {
+    return void 0;
+  }
+  let timestamp;
+  const signatures = [];
+  for (const part of header2.split(",")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) {
+      continue;
+    }
+    const key = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (key === "t") {
+      const ts = Number(value);
+      if (Number.isInteger(ts)) {
+        timestamp = ts;
+      }
+    } else if (key === "v1" && /^[0-9a-f]+$/i.test(value)) {
+      signatures.push(value.toLowerCase());
+    }
+  }
+  if (timestamp === void 0 || signatures.length === 0) {
+    return void 0;
+  }
+  return { timestamp, signatures };
+}
+async function hmacSha256Hex(secret, message) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    encoder.encode(message)
+  );
+  return Array.from(
+    new Uint8Array(signature),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+function timingSafeEqualHex(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+// src/namespaces/webhooks.ts
+var WebhooksNamespace = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  createEvent(input) {
+    return this.http.request("POST", "/webhooks/events", { body: input });
+  }
+  createAddress(input) {
+    return this.http.request("POST", "/webhooks/addresses", { body: input });
+  }
+  createCoin(input) {
+    return this.http.request("POST", "/webhooks/coins", { body: input });
+  }
+  createObject(input) {
+    return this.http.request("POST", "/webhooks/objects", { body: input });
+  }
+  list() {
+    return this.http.request("GET", "/webhooks");
+  }
+  get(id) {
+    return this.http.request("GET", `/webhooks/${encodeURIComponent(id)}`);
+  }
+  update(id, input) {
+    return this.http.request("PUT", `/webhooks/${encodeURIComponent(id)}`, {
+      body: input
+    });
+  }
+  delete(id) {
+    return this.http.request("DELETE", `/webhooks/${encodeURIComponent(id)}`);
+  }
+  /** Verify an incoming webhook delivery's X-Inodra-Signature header. */
+  verifySignature(options) {
+    return verifyWebhookSignature(options);
+  }
+  /**
+   * Verify and parse an incoming event-webhook delivery in one step
+   * (Stripe's constructEvent pattern). Throws InodraWebhookSignatureError
+   * on a bad or expired signature, and a zod error if the body doesn't
+   * look like an Inodra delivery.
+   *
+   * Pair with `matchCatalogEvent`/`parseCatalogEvent` from
+   * `@inodra/sui/events` to narrow the payload to a catalog event type.
+   *
+   * ```ts
+   * const body = await inodra.webhooks.constructEvent({
+   *   payload: rawBody, // exact raw string — do not JSON.parse first
+   *   signature: req.headers["x-inodra-signature"],
+   *   secret: process.env.INODRA_WEBHOOK_SECRET,
+   * });
+   * const swap = parseCatalogEvent(body, "cetus.swap");
+   * ```
+   */
+  async constructEvent(options) {
+    const valid = await verifyWebhookSignature(options);
+    if (!valid) {
+      throw new InodraWebhookSignatureError();
+    }
+    const { webhookEventBodySchema: webhookEventBodySchema2 } = await Promise.resolve().then(() => (init_runtime(), runtime_exports));
+    return webhookEventBodySchema2.parse(JSON.parse(options.payload));
+  }
+};
+
+// src/client.ts
+var Inodra = class {
+  network;
+  /** The underlying REST transport (shared by all REST namespaces). */
+  http;
+  options;
+  auth;
+  memo = /* @__PURE__ */ new Map();
+  constructor(options) {
+    authFromOptions(options, "Inodra");
+    this.options = options;
+    this.auth = options.auth ?? { apiKey: options.apiKey };
+    this.network = options.network ?? "mainnet";
+    this.http = new InodraHttpClient({
+      auth: this.auth,
+      network: this.network,
+      baseUrl: options.endpoints?.rest,
+      maxRetries: options.maxRetries,
+      timeoutMs: options.timeoutMs,
+      fetch: options.fetch,
+      onResponseMeta: options.onResponseMeta
+    });
+  }
+  /** Rate-limit/credit info from the most recent REST response. */
+  get lastResponseMeta() {
+    return this.http.lastResponseMeta;
+  }
+  /**
+   * Sui gRPC client (@mysten/sui) over Inodra's authenticated gateway.
+   * Uses a fetch-based gRPC-Web transport — works in browsers, edge
+   * runtimes, and Node. For native HTTP/2 gRPC on Node, use
+   * `@inodra/sui/node`.
+   */
+  get grpc() {
+    return this.lazy("grpc", () => this.createGrpcClient());
+  }
+  /** Sui GraphQL client (@mysten/sui) over Inodra's authenticated gateway. */
+  get graphql() {
+    return this.lazy(
+      "graphql",
+      () => createInodraGraphQLClient({
+        auth: this.auth,
+        network: this.network,
+        url: this.options.endpoints?.graphql
+      })
+    );
+  }
+  /** Warp streams: subscription CRUD + live SSE/WebSocket delivery. */
+  get warp() {
+    return this.lazy(
+      "warp",
+      () => new WarpNamespace({
+        http: this.http,
+        auth: this.auth,
+        network: this.network,
+        restBaseUrl: this.options.endpoints?.rest,
+        warpWsBaseUrl: this.options.endpoints?.warpWs,
+        fetch: this.options.fetch
+      })
+    );
+  }
+  /** Webhooks: subscription CRUD + delivery signature verification. */
+  get webhooks() {
+    return this.lazy("webhooks", () => new WebhooksNamespace(this.http));
+  }
+  /** Indexer-backed data: accounts, coins, packages, validators, SuiNS, …. */
+  get data() {
+    return this.lazy("data", () => new DataNamespace(this.http));
+  }
+  /** Curated protocol event catalog (live view). */
+  get catalog() {
+    return this.lazy("catalog", () => new CatalogNamespace(this.http));
+  }
+  /** The authenticated principal: key introspection + usage stats. */
+  get account() {
+    return this.lazy("account", () => new AccountNamespace(this.http));
+  }
+  /** Reflection-based typed payloads for arbitrary (uncataloged) events. */
+  get events() {
+    return this.lazy(
+      "events",
+      () => new EventsNamespace({
+        auth: this.auth,
+        network: this.network,
+        graphqlUrl: this.options.endpoints?.graphql,
+        fetch: this.options.fetch
+      })
+    );
+  }
+  /** Default endpoints for this client's network. */
+  get endpoints() {
+    return INODRA_ENDPOINTS[this.network];
+  }
+  createGrpcClient() {
+    return createInodraGrpcWebClient({
+      auth: this.auth,
+      network: this.network,
+      baseUrl: this.options.endpoints?.grpcWeb
+    });
+  }
+  lazy(key, create) {
+    let value = this.memo.get(key);
+    if (value === void 0) {
+      value = create();
+      this.memo.set(key, value);
+    }
+    return value;
+  }
+};
+
+// src/index.ts
+init_auth();
+init_network();
+init_version();
+
+// src/manage/index.ts
+var InodraManagementClient = class {
+  http;
+  constructor(options) {
+    this.http = new InodraHttpClient(options);
+  }
+  webhooks = {
+    createEvent: (input) => this.http.request("POST", "/webhooks/events", {
+      body: input
+    }),
+    createAddress: (input) => this.http.request("POST", "/webhooks/addresses", {
+      body: input
+    }),
+    createCoin: (input) => this.http.request("POST", "/webhooks/coins", {
+      body: input
+    }),
+    createObject: (input) => this.http.request("POST", "/webhooks/objects", {
+      body: input
+    }),
+    list: () => this.http.request("GET", "/webhooks"),
+    get: (id) => this.http.request("GET", `/webhooks/${encodeURIComponent(id)}`),
+    update: (id, input) => this.http.request(
+      "PUT",
+      `/webhooks/${encodeURIComponent(id)}`,
+      { body: input }
+    ),
+    delete: (id) => this.http.request(
+      "DELETE",
+      `/webhooks/${encodeURIComponent(id)}`
+    )
+  };
+  warp = {
+    createEventStream: (input) => this.http.request("POST", "/warp/events", {
+      body: input
+    }),
+    createAddressStream: (input) => this.http.request("POST", "/warp/addresses", {
+      body: input
+    }),
+    createCoinStream: (input) => this.http.request("POST", "/warp/coins", {
+      body: input
+    }),
+    createObjectStream: (input) => this.http.request("POST", "/warp/objects", {
+      body: input
+    }),
+    list: () => this.http.request("GET", "/warp"),
+    get: (id) => this.http.request("GET", `/warp/${encodeURIComponent(id)}`),
+    update: (id, input) => this.http.request(
+      "PUT",
+      `/warp/${encodeURIComponent(id)}`,
+      { body: input }
+    ),
+    delete: (id) => this.http.request(
+      "DELETE",
+      `/warp/${encodeURIComponent(id)}`
+    )
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccountNamespace,
+  CatalogNamespace,
+  DataNamespace,
+  EventsNamespace,
+  INODRA_ENDPOINTS,
+  Inodra,
+  InodraAuthenticationError,
+  InodraError,
+  InodraHttpClient,
+  InodraManagementClient,
+  InodraRateLimitError,
+  InodraTimeoutError,
+  InodraWebhookSignatureError,
+  SDK_VERSION,
+  WarpNamespace,
+  WarpSseStream,
+  WarpWebSocketStream,
+  WebhooksNamespace,
+  iterateStream,
+  paginate,
+  resolveAuth,
+  verifyWebhookSignature
+});
+//# sourceMappingURL=index.cjs.map