@neus/sdk 1.0.0 → 1.0.1

package/cjs/errors.cjs

@@ -0,0 +1,202 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// errors.js
+var errors_exports = {};
+__export(errors_exports, {
+  ApiError: () => ApiError,
+  AuthenticationError: () => AuthenticationError,
+  ConfigurationError: () => ConfigurationError,
+  NetworkError: () => NetworkError,
+  SDKError: () => SDKError,
+  ValidationError: () => ValidationError,
+  VerificationError: () => VerificationError,
+  createErrorFromGeneric: () => createErrorFromGeneric,
+  default: () => errors_default
+});
+module.exports = __toCommonJS(errors_exports);
+var SDKError = class _SDKError extends Error {
+  constructor(message, code = "SDK_ERROR", details = {}) {
+    super(message);
+    this.name = "SDKError";
+    this.code = code;
+    this.details = details;
+    this.timestamp = Date.now();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _SDKError);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      details: this.details,
+      timestamp: this.timestamp
+    };
+  }
+};
+var ApiError = class _ApiError extends SDKError {
+  constructor(message, statusCode = 500, code = "API_ERROR", response = null) {
+    super(message, code);
+    this.name = "ApiError";
+    this.statusCode = statusCode;
+    this.response = response;
+    this.isClientError = statusCode >= 400 && statusCode < 500;
+    this.isServerError = statusCode >= 500;
+    this.isRetryable = this.isServerError || statusCode === 429;
+  }
+  static fromResponse(response, responseData) {
+    const statusCode = response.status;
+    const message = responseData?.error?.message || responseData?.message || `API request failed with status ${statusCode}`;
+    const code = responseData?.error?.code || "API_ERROR";
+    return new _ApiError(message, statusCode, code, responseData);
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      statusCode: this.statusCode,
+      isClientError: this.isClientError,
+      isServerError: this.isServerError,
+      isRetryable: this.isRetryable
+    };
+  }
+};
+var ValidationError = class extends SDKError {
+  constructor(message, field = null, value = null) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.field = field;
+    this.value = value;
+    this.isRetryable = false;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      field: this.field,
+      value: this.value,
+      isRetryable: this.isRetryable
+    };
+  }
+};
+var NetworkError = class _NetworkError extends SDKError {
+  constructor(message, code = "NETWORK_ERROR", originalError = null) {
+    super(message, code);
+    this.name = "NetworkError";
+    this.originalError = originalError;
+    this.isRetryable = true;
+  }
+  static isNetworkError(error) {
+    return error instanceof _NetworkError || error.name === "TypeError" && error.message.includes("fetch") || error.name === "AbortError" || error.code === "ENOTFOUND" || error.code === "ECONNREFUSED" || error.code === "ETIMEDOUT";
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      isRetryable: this.isRetryable,
+      originalError: this.originalError ? {
+        name: this.originalError.name,
+        message: this.originalError.message,
+        code: this.originalError.code
+      } : null
+    };
+  }
+};
+var ConfigurationError = class extends SDKError {
+  constructor(message, configKey = null) {
+    super(message, "CONFIGURATION_ERROR");
+    this.name = "ConfigurationError";
+    this.configKey = configKey;
+    this.isRetryable = false;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      configKey: this.configKey,
+      isRetryable: this.isRetryable
+    };
+  }
+};
+var VerificationError = class extends SDKError {
+  constructor(message, verifierId = null, code = "VERIFICATION_ERROR") {
+    super(message, code);
+    this.name = "VerificationError";
+    this.verifierId = verifierId;
+    this.isRetryable = true;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      verifierId: this.verifierId,
+      isRetryable: this.isRetryable
+    };
+  }
+};
+var AuthenticationError = class extends SDKError {
+  constructor(message, code = "AUTHENTICATION_ERROR") {
+    super(message, code);
+    this.name = "AuthenticationError";
+    this.isRetryable = false;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      isRetryable: this.isRetryable
+    };
+  }
+};
+function createErrorFromGeneric(error, context = {}) {
+  if (error instanceof SDKError) {
+    return error;
+  }
+  if (NetworkError.isNetworkError(error)) {
+    return new NetworkError(
+      error.message || "Network error occurred",
+      error.code || "NETWORK_ERROR",
+      error
+    );
+  }
+  if (error.name === "AbortError" || error.message.includes("timeout")) {
+    return new NetworkError("Request timeout", "TIMEOUT", error);
+  }
+  return new SDKError(
+    error.message || "Unknown error occurred",
+    error.code || "UNKNOWN_ERROR",
+    { originalError: error, context }
+  );
+}
+var errors_default = {
+  SDKError,
+  ApiError,
+  ValidationError,
+  NetworkError,
+  ConfigurationError,
+  VerificationError,
+  AuthenticationError,
+  createErrorFromGeneric
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  AuthenticationError,
+  ConfigurationError,
+  NetworkError,
+  SDKError,
+  ValidationError,
+  VerificationError,
+  createErrorFromGeneric
+});

package/cjs/gates.cjs

@@ -0,0 +1,140 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// gates.js
+var gates_exports = {};
+__export(gates_exports, {
+  DAY: () => DAY,
+  GATE_AGENT_DELEGATION: () => GATE_AGENT_DELEGATION,
+  GATE_AGENT_IDENTITY: () => GATE_AGENT_IDENTITY,
+  GATE_CONTENT_MODERATION: () => GATE_CONTENT_MODERATION,
+  GATE_CONTRACT_ADMIN: () => GATE_CONTRACT_ADMIN,
+  GATE_DOMAIN_OWNER: () => GATE_DOMAIN_OWNER,
+  GATE_LINKED_WALLETS: () => GATE_LINKED_WALLETS,
+  GATE_NFT_HOLDER: () => GATE_NFT_HOLDER,
+  GATE_PSEUDONYM: () => GATE_PSEUDONYM,
+  GATE_TOKEN_HOLDER: () => GATE_TOKEN_HOLDER,
+  GATE_WALLET_RISK: () => GATE_WALLET_RISK,
+  HOUR: () => HOUR,
+  MONTH: () => MONTH,
+  WEEK: () => WEEK,
+  YEAR: () => YEAR,
+  combineGates: () => combineGates,
+  createGate: () => createGate,
+  default: () => gates_default
+});
+module.exports = __toCommonJS(gates_exports);
+var HOUR = 60 * 60 * 1e3;
+var DAY = 24 * HOUR;
+var WEEK = 7 * DAY;
+var MONTH = 30 * DAY;
+var YEAR = 365 * DAY;
+var GATE_NFT_HOLDER = [
+  { verifierId: "nft-ownership" }
+];
+var GATE_TOKEN_HOLDER = [
+  { verifierId: "token-holding" }
+];
+var GATE_CONTRACT_ADMIN = [
+  { verifierId: "contract-ownership", maxAgeMs: HOUR }
+];
+var GATE_DOMAIN_OWNER = [
+  { verifierId: "ownership-dns-txt" }
+];
+var GATE_LINKED_WALLETS = [
+  { verifierId: "wallet-link" }
+];
+var GATE_AGENT_IDENTITY = [
+  { verifierId: "agent-identity" }
+];
+var GATE_AGENT_DELEGATION = [
+  { verifierId: "agent-delegation", maxAgeMs: 7 * DAY }
+];
+var GATE_CONTENT_MODERATION = [
+  { verifierId: "ai-content-moderation" }
+];
+var GATE_WALLET_RISK = [
+  { verifierId: "wallet-risk" }
+];
+var GATE_PSEUDONYM = [
+  { verifierId: "ownership-pseudonym" }
+];
+function createGate(requirements) {
+  return requirements.map((req) => {
+    if (typeof req === "string") {
+      return { verifierId: req };
+    }
+    return req;
+  });
+}
+function combineGates(...gates) {
+  const combined = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const gate of gates) {
+    for (const req of gate) {
+      const key = req.verifierId + JSON.stringify(req.match || {});
+      if (!seen.has(key)) {
+        seen.add(key);
+        combined.push(req);
+      }
+    }
+  }
+  return combined;
+}
+var gates_default = {
+  // Time constants
+  HOUR,
+  DAY,
+  WEEK,
+  MONTH,
+  YEAR,
+  // Recipe gates
+  GATE_NFT_HOLDER,
+  GATE_TOKEN_HOLDER,
+  GATE_CONTRACT_ADMIN,
+  GATE_DOMAIN_OWNER,
+  GATE_LINKED_WALLETS,
+  GATE_AGENT_IDENTITY,
+  GATE_AGENT_DELEGATION,
+  GATE_CONTENT_MODERATION,
+  GATE_WALLET_RISK,
+  GATE_PSEUDONYM,
+  // Helpers
+  createGate,
+  combineGates
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DAY,
+  GATE_AGENT_DELEGATION,
+  GATE_AGENT_IDENTITY,
+  GATE_CONTENT_MODERATION,
+  GATE_CONTRACT_ADMIN,
+  GATE_DOMAIN_OWNER,
+  GATE_LINKED_WALLETS,
+  GATE_NFT_HOLDER,
+  GATE_PSEUDONYM,
+  GATE_TOKEN_HOLDER,
+  GATE_WALLET_RISK,
+  HOUR,
+  MONTH,
+  WEEK,
+  YEAR,
+  combineGates,
+  createGate
+});