@nexusmutual/sdk 2.1.1 → 3.0.0-rc.0

package/dist/index.js

@@ -6507,6 +6507,7 @@ __export(src_exports, {
   COMMISSION_DENOMINATOR: () => COMMISSION_DENOMINATOR,
   ContentType: () => ContentType,
   CoverAsset: () => CoverAsset,
+  CoverData: () => CoverData,
   DEFAULT_SLIPPAGE: () => DEFAULT_SLIPPAGE,
   Ipfs: () => Ipfs,
   MAXIMUM_COVER_PERIOD: () => MAXIMUM_COVER_PERIOD,
@@ -6520,6 +6521,8 @@ __export(src_exports, {
   SLIPPAGE_DENOMINATOR: () => SLIPPAGE_DENOMINATOR,
   Swap: () => Swap,
   TARGET_PRICE_DENOMINATOR: () => TARGET_PRICE_DENOMINATOR,
+  buildAuthTypedData: () => buildAuthTypedData,
+  buildCoverMetadataAuthMessage: () => buildCoverMetadataAuthMessage,
   categoryLabelByEnum: () => categoryLabelByEnum,
   default: () => src_default,
   productCategoryMap: () => productCategoryMap
@@ -6527,6 +6530,38 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var deployments = __toESM(require("@nexusmutual/deployments"));
 
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  buildAuthTypedData: () => buildAuthTypedData,
+  buildCoverMetadataAuthMessage: () => buildCoverMetadataAuthMessage
+});
+var SIGNING_DOMAIN = {
+  name: "Nexus Mutual App",
+  version: "1.0.0"
+};
+var SIGNING_TYPES = {
+  Authentication: [
+    { name: "timestamp", type: "uint256" },
+    { name: "message", type: "string" }
+  ]
+};
+function buildAuthTypedData(message) {
+  return {
+    domain: SIGNING_DOMAIN,
+    types: SIGNING_TYPES,
+    primaryType: "Authentication",
+    value: {
+      timestamp: BigInt(Math.floor(Date.now() / 1e3)),
+      message
+    }
+  };
+}
+var COVER_METADATA_AUTH_MESSAGE = "Nexus Mutual (app.nexusmutual.io) wants you to sign in to manage your proof of loss data";
+function buildCoverMetadataAuthMessage() {
+  return buildAuthTypedData(COVER_METADATA_AUTH_MESSAGE);
+}
+
 // src/constants/index.ts
 var constants_exports = {};
 __export(constants_exports, {
@@ -7343,6 +7378,159 @@ var productCategoryMap = {
   // Venus Flux
 };
 
+// src/cover/index.ts
+var cover_exports = {};
+__export(cover_exports, {
+  CoverData: () => CoverData
+});
+
+// src/nexus-sdk-base.ts
+var ApiError = class extends Error {
+  status;
+  data;
+  constructor(status, data, message) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.data = data;
+  }
+};
+var NexusSDKBase = class {
+  apiUrl;
+  /**
+   * Create a new instance of NexusSDKBase
+   * @param config SDK configuration
+   */
+  constructor(config = {}) {
+    this.apiUrl = config.apiUrl ?? "https://api.nexusmutual.io/v2";
+  }
+  /**
+   * Sends an HTTP request to the specified endpoint
+   * @param endpoint API endpoint to send the request to
+   * @param options Request configuration
+   * @returns Promise resolving to the response data
+   */
+  async sendRequest(endpoint, options = {}) {
+    const { method = "GET", headers, params, data } = options;
+    const url = new URL(this.apiUrl + endpoint);
+    if (params) {
+      for (const [key2, value] of Object.entries(params)) {
+        if (value != null) {
+          url.searchParams.append(key2, String(value));
+        }
+      }
+    }
+    const init2 = { method };
+    if (data !== void 0) {
+      init2.body = JSON.stringify(data);
+      init2.headers = { "Content-Type": "application/json", ...headers };
+    } else if (headers) {
+      init2.headers = headers;
+    }
+    let response;
+    try {
+      response = await fetch(url.toString(), init2);
+    } catch (err) {
+      throw new ApiError(0, void 0, err.message ?? "Network Error");
+    }
+    if (!response.ok) {
+      const errorData = await this.parseResponseBody(response);
+      const apiErrorMessage = errorData?.error || response.statusText || "Unknown error";
+      const message = apiErrorMessage.includes("Not enough capacity") ? apiErrorMessage : `API request failed: ${response.status} ${apiErrorMessage}`;
+      throw new ApiError(response.status, errorData, message);
+    }
+    return await this.parseResponseBody(response);
+  }
+  async parseResponseBody(response) {
+    if (response.status === 204 || response.status === 205) {
+      return void 0;
+    }
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+};
+
+// src/cover/Cover.ts
+var CoverData = class extends NexusSDKBase {
+  constructor(config = {}) {
+    super(config);
+  }
+  async getCover(coverId) {
+    if (!coverId || coverId <= 0) {
+      return { result: void 0, error: { message: "Invalid coverId: must be a positive number" } };
+    }
+    try {
+      const response = await this.sendRequest(`/cover/${coverId}`);
+      return { result: response, error: void 0 };
+    } catch (error) {
+      return { result: void 0, error: { message: error.message || "Failed to fetch cover" } };
+    }
+  }
+  async viewCoverMetadata(params) {
+    const { coverMetadataId, signature: signature2 } = params;
+    if (!coverMetadataId || typeof coverMetadataId !== "string") {
+      return { result: void 0, error: { message: "Invalid coverMetadataId: must be a non-empty string" } };
+    }
+    const options = { method: "GET" };
+    if (signature2) {
+      options.headers = this.buildAuthHeaders(signature2);
+    }
+    try {
+      const response = await this.sendRequest(`/cover-metadata/${coverMetadataId}`, options);
+      return { result: response, error: void 0 };
+    } catch (error) {
+      return { result: void 0, error: { message: error.message || "Failed to fetch cover metadata" } };
+    }
+  }
+  async editCoverMetadata(params) {
+    const { coverMetadataId, proofOfLoss, signature: signature2 } = params;
+    if (!coverMetadataId || typeof coverMetadataId !== "string") {
+      return { result: void 0, error: { message: "Invalid coverMetadataId: must be a non-empty string" } };
+    }
+    if (!proofOfLoss || proofOfLoss.length === 0) {
+      return { result: void 0, error: { message: "At least one proof of loss entry is required" } };
+    }
+    if (!signature2?.signature || !signature2?.payload) {
+      return { result: void 0, error: { message: "Signature is required to edit cover metadata" } };
+    }
+    const options = {
+      method: "PUT",
+      headers: this.buildAuthHeaders(signature2),
+      data: { proofOfLoss }
+    };
+    try {
+      const response = await this.sendRequest(`/cover-metadata/${coverMetadataId}`, options);
+      return { result: response, error: void 0 };
+    } catch (error) {
+      return { result: void 0, error: { message: error.message || "Failed to update cover metadata" } };
+    }
+  }
+  async createCoverMetadata(input) {
+    const options = {
+      method: "POST",
+      data: input
+    };
+    const response = await this.sendRequest("/cover-metadata", options);
+    return response.cid;
+  }
+  buildAuthHeaders(auth) {
+    return {
+      "x-auth-signature": auth.signature,
+      "x-auth-payload": JSON.stringify(
+        auth.payload,
+        (_key, value) => typeof value === "bigint" ? String(value) : value
+      )
+    };
+  }
+};
+
 // src/ipfs/index.ts
 var ipfs_exports = {};
 __export(ipfs_exports, {
@@ -23170,50 +23358,6 @@ var import_zod = require("zod");
 var VERSION_1_0 = "1.0";
 var VERSION_2_0 = "2.0";
 var ethereumAddressRegex = /^0x[a-f0-9]{40}$/i;
-var coverValidatorsSchema = import_zod.z.object({
-  version: import_zod.z.literal(VERSION_1_0),
-  validators: import_zod.z.array(import_zod.z.string().regex(ethereumAddressRegex, "Invalid Ethereum address")).min(1, "At least one validator address is required")
-});
-var coverQuotaShareSchema = import_zod.z.object({
-  version: import_zod.z.literal(VERSION_1_0),
-  quotaShare: import_zod.z.number().min(0).max(100)
-});
-var coverAumCoverAmountPercentageSchema = import_zod.z.object({
-  version: import_zod.z.literal(VERSION_1_0),
-  aumCoverAmountPercentage: import_zod.z.number().min(0).max(100)
-});
-var coverWalletAddressSchema = import_zod.z.object({
-  version: import_zod.z.literal(VERSION_1_0),
-  walletAddress: import_zod.z.string().regex(ethereumAddressRegex, "Invalid Ethereum address")
-});
-var coverWalletAddressesSchema = import_zod.z.discriminatedUnion("version", [
-  import_zod.z.object({
-    version: import_zod.z.literal(VERSION_1_0),
-    walletAddresses: import_zod.z.string().refine((val) => {
-      const addresses = val.split(",").map((addr) => addr.trim());
-      return addresses.every((addr) => ethereumAddressRegex.test(addr));
-    }, "Invalid Ethereum address(es)")
-  }),
-  import_zod.z.object({
-    version: import_zod.z.literal(VERSION_2_0),
-    walletAddresses: import_zod.z.array(import_zod.z.string().regex(ethereumAddressRegex, "Invalid Ethereum address")).min(1, "At least one wallet address is required")
-  })
-]);
-var coverFreeTextSchema = import_zod.z.object({
-  version: import_zod.z.literal(VERSION_1_0),
-  freeText: import_zod.z.string().min(1, "Free text cannot be empty")
-});
-var coverDesignatedWalletsSchema = import_zod.z.object({
-  version: import_zod.z.literal(VERSION_1_0),
-  wallets: import_zod.z.array(
-    import_zod.z.object({
-      wallet: import_zod.z.string().regex(ethereumAddressRegex, "Invalid Ethereum address"),
-      amount: import_zod.z.string().regex(/^(?!,$)[\d,.]+$/, "Amount must be a valid number"),
-      currency: import_zod.z.string().min(1, "Currency cannot be empty")
-    })
-  ).min(1, "At least one wallet object is required")
-});
-var defiPassContentSchema = import_zod.z.union([coverWalletAddressSchema, coverDesignatedWalletsSchema]);
 var stakingPoolDetailsSchema = import_zod.z.object({
   version: import_zod.z.literal(VERSION_1_0),
   poolName: import_zod.z.string().min(1, "Pool name cannot be empty"),
@@ -23281,89 +23425,8 @@ var coverMetadataRefSchema = import_zod.z.object({
 // generated/version.json
 var version27 = "2.1.1";
 
-// src/nexus-sdk-base.ts
-var ApiError = class extends Error {
-  status;
-  data;
-  constructor(status, data, message) {
-    super(message);
-    this.name = "ApiError";
-    this.status = status;
-    this.data = data;
-  }
-};
-var NexusSDKBase = class {
-  apiUrl;
-  /**
-   * Create a new instance of NexusSDKBase
-   * @param config SDK configuration
-   */
-  constructor(config = {}) {
-    this.apiUrl = config.apiUrl ?? "https://api.nexusmutual.io/v2";
-  }
-  /**
-   * Sends an HTTP request to the specified endpoint
-   * @param endpoint API endpoint to send the request to
-   * @param options Request configuration
-   * @returns Promise resolving to the response data
-   */
-  async sendRequest(endpoint, options = {}) {
-    const { method = "GET", headers, params, data } = options;
-    const url = new URL(this.apiUrl + endpoint);
-    if (params) {
-      for (const [key2, value] of Object.entries(params)) {
-        if (value != null) {
-          url.searchParams.append(key2, String(value));
-        }
-      }
-    }
-    const init2 = { method };
-    if (data !== void 0) {
-      init2.body = JSON.stringify(data);
-      init2.headers = { "Content-Type": "application/json", ...headers };
-    } else if (headers) {
-      init2.headers = headers;
-    }
-    let response;
-    try {
-      response = await fetch(url.toString(), init2);
-    } catch (err) {
-      throw new ApiError(0, void 0, err.message ?? "Network Error");
-    }
-    if (!response.ok) {
-      const errorData = await this.parseResponseBody(response);
-      const apiErrorMessage = errorData?.error || response.statusText || "Unknown error";
-      const message = apiErrorMessage.includes("Not enough capacity") ? apiErrorMessage : `API request failed: ${response.status} ${apiErrorMessage}`;
-      throw new ApiError(response.status, errorData, message);
-    }
-    return await this.parseResponseBody(response);
-  }
-  async parseResponseBody(response) {
-    if (response.status === 204 || response.status === 205) {
-      return void 0;
-    }
-    const text = await response.text();
-    if (!text) {
-      return void 0;
-    }
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
-    }
-  }
-};
-
 // src/types/ipfs.ts
 var ContentType = /* @__PURE__ */ ((ContentType2) => {
-  ContentType2["coverValidators"] = "coverValidators";
-  ContentType2["coverQuotaShare"] = "coverQuotaShare";
-  ContentType2["coverAumCoverAmountPercentage"] = "coverAumCoverAmountPercentage";
-  ContentType2["coverWalletAddress"] = "coverWalletAddress";
-  ContentType2["coverWalletAddresses"] = "coverWalletAddresses";
-  ContentType2["coverFreeText"] = "coverFreeText";
-  ContentType2["coverDesignatedWallets"] = "coverDesignatedWallets";
-  ContentType2["defiPassContent"] = "defiPassContent";
   ContentType2["stakingPoolDetails"] = "stakingPoolDetails";
   ContentType2["claimProof"] = "claimProof";
   ContentType2["assessmentCriteriaAnswers"] = "assessmentCriteriaAnswers";
@@ -23429,22 +23492,6 @@ var Ipfs = class extends NexusSDKBase {
       throw new Error("Content cannot be empty");
     }
     switch (type) {
-      case "coverValidators" /* coverValidators */:
-        return coverValidatorsSchema.parse(content);
-      case "coverQuotaShare" /* coverQuotaShare */:
-        return coverQuotaShareSchema.parse(content);
-      case "coverAumCoverAmountPercentage" /* coverAumCoverAmountPercentage */:
-        return coverAumCoverAmountPercentageSchema.parse(content);
-      case "coverWalletAddress" /* coverWalletAddress */:
-        return coverWalletAddressSchema.parse(content);
-      case "coverWalletAddresses" /* coverWalletAddresses */:
-        return coverWalletAddressesSchema.parse(content);
-      case "coverFreeText" /* coverFreeText */:
-        return coverFreeTextSchema.parse(content);
-      case "coverDesignatedWallets" /* coverDesignatedWallets */:
-        return coverDesignatedWalletsSchema.parse(content);
-      case "defiPassContent" /* defiPassContent */:
-        return defiPassContentSchema.parse(content);
       case "stakingPoolDetails" /* stakingPoolDetails */:
         return stakingPoolDetailsSchema.parse(content);
       case "claimProof" /* claimProof */:
@@ -23508,10 +23555,11 @@ var ProductAPI = class extends NexusSDKBase {
   /**
    * Get product type details by ID
    * @param productTypeId ID of the product type
+   * @param params Optional attributes to include
    * @returns Product type details
    */
-  async getProductTypeById(productTypeId) {
-    const productTypeEndpoint = `/product-types/${productTypeId}`;
+  async getProductTypeById(productTypeId, params) {
+    const productTypeEndpoint = `/product-types/${productTypeId}${params ? `?${new URLSearchParams({ withAttributes: params.join(",") }).toString()}` : ""}`;
     return this.sendRequest(productTypeEndpoint);
   }
   /**
@@ -23527,8 +23575,8 @@ var ProductAPI = class extends NexusSDKBase {
    * @param productId ID of the product
    * @returns Product details
    */
-  async getProductById(productId) {
-    const productEndpoint = `/products/${productId}`;
+  async getProductById(productId, params) {
+    const productEndpoint = `/products/${productId}${params ? `?${new URLSearchParams({ withAttributes: params.join(",") }).toString()}` : ""}`;
     return this.sendRequest(productEndpoint);
   }
   /**
@@ -23545,15 +23593,16 @@ var ProductAPI = class extends NexusSDKBase {
 var Quote = class extends NexusSDKBase {
   ipfs;
   productAPI;
+  coverData;
   /**
    * Create a new Quote instance
    * @param config SDK configuration
-   * @param ipfs IPFS instance for content upload and validation
    */
-  constructor(config = {}, ipfs) {
+  constructor(config = {}) {
     super(config);
-    this.ipfs = ipfs || new Ipfs(config);
+    this.ipfs = new Ipfs(config);
     this.productAPI = new ProductAPI(config);
+    this.coverData = new CoverData(config);
   }
   /**
    * Get quote and buy cover inputs
@@ -23568,7 +23617,8 @@ var Quote = class extends NexusSDKBase {
       coverAsset,
       buyerAddress,
       slippage = DEFAULT_SLIPPAGE / SLIPPAGE_DENOMINATOR,
-      ipfsCidOrContent = "",
+      ipfsCid,
+      coverMetadata,
       paymentAsset = coverAsset,
       coverId = 0,
       commissionRatio,
@@ -23612,26 +23662,10 @@ var Quote = class extends NexusSDKBase {
         error: { message: "Invalid slippage: must be a number between 0 and 1" }
       };
     }
-    const isString = typeof ipfsCidOrContent === "string";
-    const isObject = typeof ipfsCidOrContent === "object" && ipfsCidOrContent !== null;
-    if (!isString && !isObject) {
-      return {
-        result: void 0,
-        error: { message: "Invalid ipfsCidOrContent: must be a string CID or content object" }
-      };
-    }
-    if (isString && ipfsCidOrContent !== "") {
-      const isValidCID = this.ipfs.validateIPFSCid(ipfsCidOrContent);
-      if (!isValidCID) {
-        return {
-          result: void 0,
-          error: { message: "Invalid ipfsCid: must be a valid IPFS CID" }
-        };
-      }
-    }
+    let product;
     let productType;
     try {
-      const product = await this.productAPI.getProductById(productId);
+      product = await this.productAPI.getProductById(productId);
       const productTypeId = product?.productType;
       if (productTypeId === void 0) {
         return {
@@ -23639,7 +23673,7 @@ var Quote = class extends NexusSDKBase {
           error: { message: `Invalid product` }
         };
       }
-      productType = await this.productAPI.getProductTypeById(productTypeId);
+      productType = await this.productAPI.getProductTypeById(productTypeId, ["buyCoverForm"]);
       if (!productType) {
         return {
           result: void 0,
@@ -23652,27 +23686,59 @@ var Quote = class extends NexusSDKBase {
         error: { message: error.message || "Failed to fetch product data" }
       };
     }
-    if (productType.ipfsContentType !== void 0 && !ipfsCidOrContent) {
-      return {
-        result: void 0,
-        error: {
-          message: `Missing IPFS content. 
-
-          ${productType.name} requires ${productType.ipfsContentType} content type.`
-        }
-      };
-    }
-    let ipfsData = ipfsCidOrContent;
-    const contentType = productType.ipfsContentType;
-    if (!isString && contentType !== void 0 && ipfsCidOrContent) {
-      try {
-        ipfsData = await this.ipfs.uploadIPFSContent([contentType, ipfsCidOrContent]);
-      } catch (error) {
+    let ipfsData = "";
+    if (ipfsCid) {
+      const isValidCID = this.ipfs.validateIPFSCid(ipfsCid);
+      if (!isValidCID) {
+        return {
+          result: void 0,
+          error: { message: "Invalid ipfsCid: must be a valid IPFS CID" }
+        };
+      }
+      ipfsData = ipfsCid;
+    } else {
+      if (product.proofOfLossInputTypes?.length && (!coverMetadata?.proofOfLoss || coverMetadata.proofOfLoss.length === 0)) {
+        return {
+          result: void 0,
+          error: {
+            message: `Missing cover metadata. ${productType.name} requires proof of loss data.`
+          }
+        };
+      }
+      const contentType = productType.buyCoverForm;
+      if (contentType === "withAUM" && !coverMetadata?.publicData?.aumCoverAmountPercentage) {
         return {
           result: void 0,
-          error: { message: error.message || "Failed to upload IPFS content" }
+          error: { message: "Missing AUM cover amount percentage data" }
         };
       }
+      if (contentType === "withQuotaShare" && !coverMetadata?.publicData?.quotaShare) {
+        return {
+          result: void 0,
+          error: { message: "Missing quota share data" }
+        };
+      }
+      const requiredTypes = product.proofOfLossInputTypes;
+      if (requiredTypes && requiredTypes.length > 0 && coverMetadata?.proofOfLoss) {
+        const providedTypes = new Set(coverMetadata.proofOfLoss.map((e) => e.type));
+        if (!requiredTypes.every((t) => providedTypes.has(t))) {
+          return {
+            result: void 0,
+            error: { message: `Missing required proof of loss types. Required: ${requiredTypes.join(", ")}` }
+          };
+        }
+      }
+      const hasCoverMetadata = coverMetadata?.proofOfLoss?.length || coverMetadata?.publicData && Object.keys(coverMetadata.publicData).length > 0;
+      if (hasCoverMetadata) {
+        try {
+          ipfsData = await this.coverData.createCoverMetadata(coverMetadata);
+        } catch (error) {
+          return {
+            result: void 0,
+            error: { message: error.message || "Failed to create cover metadata" }
+          };
+        }
+      }
     }
     const slippageValue = slippage * SLIPPAGE_DENOMINATOR;
     const quoteParams = {
@@ -23941,14 +24007,16 @@ var Swap = class {
 
 // src/nexus-sdk.ts
 var NexusSDK = class extends NexusSDKBase {
+  cover;
   quote;
   swap;
   ipfs;
   constructor(config = {}) {
     super(config);
+    this.cover = new CoverData(config);
     this.swap = new Swap();
     this.ipfs = new Ipfs(config);
-    this.quote = new Quote(config, this.ipfs);
+    this.quote = new Quote(config);
   }
 };
 
@@ -23980,6 +24048,8 @@ var nexusSdk = {
   ...ipfs_exports,
   ...product_api_exports,
   ...constants_exports,
+  ...cover_exports,
+  ...auth_exports,
   NexusSDK,
   ApiError
 };
@@ -23990,6 +24060,7 @@ var src_default = nexusSdk;
   COMMISSION_DENOMINATOR,
   ContentType,
   CoverAsset,
+  CoverData,
   DEFAULT_SLIPPAGE,
   Ipfs,
   MAXIMUM_COVER_PERIOD,
@@ -24003,6 +24074,8 @@ var src_default = nexusSdk;
   SLIPPAGE_DENOMINATOR,
   Swap,
   TARGET_PRICE_DENOMINATOR,
+  buildAuthTypedData,
+  buildCoverMetadataAuthMessage,
   categoryLabelByEnum,
   productCategoryMap,
   ...require("@nexusmutual/deployments")