Add Fundraising API endpoints SDK with examples (#10)

danielkhoo · web-flow · commit 0be0a5d42008 · 2025-03-05T00:29:33.000+08:00
* Add fundraising yaml

* Update client for fund raising

* Add initial fund raising examples

* Add m&amp;a endpoint

* Extend example

* Gen types

* Lint
diff --git a/packages/api/src/client/base.ts b/packages/api/src/client/base.ts
@@ -30,6 +30,7 @@ import type {
   getProjectRecapResponse,
   getAssetListResponse,
   getAssetListParameters,
+  APIResponseWithMetadata,
   getPreviewsResponse,
   getReportByAssetIDParameters,
   getReportByAssetIDResponse,
@@ -38,6 +39,12 @@ import type {
   getResearchReportByIdParameters,
   getResearchReportByIdResponse,
   getResearchReportTagsResponse,
+  getFundingRoundsParameters,
+  FundingRound,
+  getFundingRoundsInvestorsParameters,
+  Investors,
+  getAcquisitionDealsParameters,
+  AcquisitionDeal,
 } from "@messari-kit/types";
 import { LogLevel, type Logger, makeConsoleLogger, createFilteredLogger, noOpLogger } from "../logging";
 import type { PaginatedResult, RequestOptions, ClientEventMap, ClientEventType, ClientEventHandler } from "./types";
@@ -249,6 +256,29 @@ export interface DiligenceAPIInterface {
   getDiligenceReport(params: getReportByAssetIDParameters): Promise<getReportByAssetIDResponse>;
 }
 
+/**
+ * Interface for the Fundraising API methods
+ */
+export interface FundraisingAPIInterface {
+  /**
+   * Gets a list of all fundraising rounds based on provided filters
+   * @param params Query parameters for filtering funding rounds
+   */
+  getFundingRounds(params?: getFundingRoundsParameters): Promise<APIResponseWithMetadata<FundingRound[]>>;
+
+  /**
+   * Gets a list of all investors for a given fundraising round
+   * @param params Query parameters for filtering investors
+   */
+  getFundingRoundsInvestors(params?: getFundingRoundsInvestorsParameters): Promise<APIResponseWithMetadata<Investors[]>>;
+
+  /**
+   * Gets a list of all acquisition deals based on provided filters
+   * @param params Query parameters for filtering acquisition deals
+   */
+  getAcquisitionDeals(params?: getAcquisitionDealsParameters): Promise<APIResponseWithMetadata<AcquisitionDeal[]>>;
+}
+
 /**
  * Abstract base class for the Messari client
  * Defines the structure and common functionality that all client implementations must provide
diff --git a/packages/api/src/client/client.ts b/packages/api/src/client/client.ts
@@ -21,6 +21,9 @@ import {
   getResearchReports,
   getResearchReportById,
   getResearchReportTags,
+  getFundingRounds,
+  getFundingRoundsInvestors,
+  getAcquisitionDeals,
 } from "@messari-kit/types";
 import type {
   createChatCompletionParameters,
@@ -63,6 +66,12 @@ import type {
   getResearchReportByIdParameters,
   getResearchReportByIdResponse,
   getResearchReportTagsResponse,
+  getFundingRoundsParameters,
+  getFundingRoundsResponse,
+  getFundingRoundsInvestorsParameters,
+  getFundingRoundsInvestorsResponse,
+  getAcquisitionDealsParameters,
+  getAcquisitionDealsResponse,
 } from "@messari-kit/types";
 import type { Agent } from "node:http";
 import { pick } from "../utils";
@@ -82,6 +91,7 @@ import type {
 import type {
   AIInterface,
   AssetInterface,
+  FundraisingAPIInterface,
   DiligenceAPIInterface,
   IntelInterface,
   MarketsInterface,
@@ -774,4 +784,30 @@ export class MessariClient extends MessariClientBase {
       });
     },
   };
+
+  public readonly fundraising: FundraisingAPIInterface = {
+    getFundingRounds: async (params: getFundingRoundsParameters) => {
+      return this.requestWithMetadata<getFundingRoundsResponse, PaginationMetadata>({
+        method: getFundingRounds.method,
+        path: getFundingRounds.path(),
+        queryParams: pick(params, getFundingRounds.queryParams),
+      });
+    },
+
+    getFundingRoundsInvestors: async (params: getFundingRoundsInvestorsParameters) => {
+      return this.requestWithMetadata<getFundingRoundsInvestorsResponse, PaginationMetadata>({
+        method: getFundingRoundsInvestors.method,
+        path: getFundingRoundsInvestors.path(),
+        queryParams: pick(params, getFundingRoundsInvestors.queryParams),
+      });
+    },
+
+    getAcquisitionDeals: async (params: getAcquisitionDealsParameters) => {
+      return this.requestWithMetadata<getAcquisitionDealsResponse, PaginationMetadata>({
+        method: getAcquisitionDeals.method,
+        path: getAcquisitionDeals.path(),
+        queryParams: pick(params, getAcquisitionDeals.queryParams),
+      });
+    },
+  };
 }
diff --git a/packages/examples/package.json b/packages/examples/package.json
@@ -14,7 +14,8 @@
 		"start:marketdata": "tsx src/marketData.ts",
 		"start:recaps": "tsx src/recaps.ts",
 		"start:diligence": "tsx src/diligence.ts",
-		"start:research": "tsx src/research.ts"
+		"start:research": "tsx src/research.ts",
+		"start:fundraising": "tsx src/fundraising.ts"
 	},
 	"dependencies": {
 		"@messari-kit/api": "workspace:*",
diff --git a/packages/examples/src/fundraising.ts b/packages/examples/src/fundraising.ts
@@ -0,0 +1,114 @@
+import { MessariClient } from "@messari-kit/api";
+import { printTable } from "console-table-printer";
+import type { getAcquisitionDealsParameters, getFundingRoundsInvestorsParameters, getFundingRoundsParameters } from "@messari-kit/types";
+import dotenv from "dotenv";
+
+// Load environment variables from .env file
+dotenv.config();
+
+// Get API key from environment variable
+const API_KEY = process.env.MESSARI_API_KEY;
+
+// Check if API key is available
+if (!API_KEY) {
+  console.error("Error: MESSARI_API_KEY environment variable is not set.");
+  console.error("Please create a .env file with your API key or set it in your environment.");
+  process.exit(1);
+}
+
+// Initialize the Messari client
+const client = new MessariClient({
+  apiKey: API_KEY,
+  // Optional: Override the base URL if needed
+  // baseUrl: "https://api.messari.io",
+});
+
+async function main() {
+  const roundMap: Record<string, { entityName: string; type: string }> = {};
+  // Get the latest funding rounds filter by type and announcedAfter date
+  try {
+    const roundsParams: getFundingRoundsParameters = { page: 1, limit: 10, type: "Seed,Series A", announcedAfter: "2025-01-01T00:00:00Z" };
+    const resp = await client.fundraising.getFundingRounds(roundsParams);
+
+    console.log("\n--------------------------------");
+    console.log("Funding Rounds");
+    console.log("--------------------------------");
+    const rounds = resp.data;
+    if (rounds.length > 0) {
+      for (const round of rounds) {
+        if (round.id && round.fundedEntity?.name) {
+          roundMap[round.id] = { entityName: round.fundedEntity?.name, type: round.type ?? "" };
+        }
+      }
+      const rows = rounds.map((r) => ({
+        "Id": r.id,
+        "Date": r.announcementDate,
+        "Entity": r.fundedEntity?.name,
+        "Type": r.type,
+        "Amount Raised": r.amountRaisedUSD,
+      }));
+      printTable(rows);
+    }
+  } catch (error) {
+    console.error("Error calling getProjectRecap:", error);
+  }
+
+  // Get the funding round investors
+  try {
+    const investorsParams: getFundingRoundsInvestorsParameters = { page: 1, limit: 10, type: "Seed,Series A", announcedAfter: "2025-01-01T00:00:00Z" };
+    const resp = await client.fundraising.getFundingRoundsInvestors(investorsParams);
+
+    console.log("\n--------------------------------");
+    console.log("Funding Round - Investors");
+    console.log("--------------------------------");
+
+    const rounds = resp.data;
+    if (rounds.length > 0) {
+      for (const round of rounds) {
+        const roundName = roundMap[round.fundingRoundId ?? ""];
+        if (!roundName) {
+          continue;
+        }
+
+        console.log("Round Id:", round.fundingRoundId);
+        console.log(roundName.entityName, "-", roundName.type);
+        if (round.organizations) {
+          const rows = round.organizations.map((o) => ({
+            "Id": o.id,
+            "Name": o.name,
+            "Location": o.location,
+          }));
+          printTable(rows);
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Error calling getProjectRecap:", error);
+  }
+
+  // Get the acquisition deals
+  try {
+    const dealsParams: getAcquisitionDealsParameters = { page: 1, limit: 10 };
+    const resp = await client.fundraising.getAcquisitionDeals(dealsParams);
+
+    console.log("\n--------------------------------");
+    console.log("M&A Deals");
+    console.log("--------------------------------");
+
+    const deals = resp.data;
+    if (deals.length > 0) {
+      const rows = deals.map((d) => ({
+        "Date": d.announcementDate,
+        "Entity": d.acquiredEntity?.name,
+        "Acquirer": d.acquiringEntity?.name,
+        "Type": d.status,
+        "Amount Raised": d.transactionAmountUSD,
+      }));
+      printTable(rows);
+    }
+  } catch (error) {
+    console.error("Error calling getAcquisitionDeals:", error);
+  }
+}
+
+main().catch(console.error);
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
@@ -346,5 +346,50 @@ export const getReportByAssetID = {
   path: (p: PathParams) => `/diligence/v1/report/asset/${p.assetId}`
 } as const;
 
+
+export type getFundingRoundsResponse = components['schemas']['FundingRound'][];
+export type getFundingRoundsError = components['schemas']['APIError'];
+
+export type getFundingRoundsParameters = { fundedEntityId?: string; investorId?: string; type?: string; stage?: string; raisedAmountMax?: number; raisedAmountMin?: number; isTokenFunded?: boolean; announcedBefore?: string; announcedAfter?: string; page?: number; limit?: number };
+
+
+export const getFundingRounds = {
+  method: 'GET' as const,
+  pathParams: [] as const,
+  queryParams: ['fundedEntityId', 'investorId', 'type', 'stage', 'raisedAmountMax', 'raisedAmountMin', 'isTokenFunded', 'announcedBefore', 'announcedAfter', 'page', 'limit'] as const,
+  bodyParams: [] as const,
+  path: () => '/funding/v1/rounds'
+} as const;
+
+
+export type getFundingRoundsInvestorsResponse = components['schemas']['Investors'][];
+export type getFundingRoundsInvestorsError = components['schemas']['APIError'];
+
+export type getFundingRoundsInvestorsParameters = { fundedEntityId?: string; investorId?: string; type?: string; stage?: string; raisedAmountMax?: number; raisedAmountMin?: number; isTokenFunded?: boolean; announcedBefore?: string; announcedAfter?: string; page?: number; limit?: number };
+
+
+export const getFundingRoundsInvestors = {
+  method: 'GET' as const,
+  pathParams: [] as const,
+  queryParams: ['fundedEntityId', 'investorId', 'type', 'stage', 'raisedAmountMax', 'raisedAmountMin', 'isTokenFunded', 'announcedBefore', 'announcedAfter', 'page', 'limit'] as const,
+  bodyParams: [] as const,
+  path: () => '/funding/v1/rounds/investors'
+} as const;
+
+
+export type getAcquisitionDealsResponse = components['schemas']['AcquisitionDeal'][];
+export type getAcquisitionDealsError = components['schemas']['APIError'];
+
+export type getAcquisitionDealsParameters = { acquiringEntityId?: string; acquiredEntityId?: string; transactionAmountMin?: number; transactionAmountMax?: number; announcedBefore?: string; announcedAfter?: string; page?: number; limit?: number };
+
+
+export const getAcquisitionDeals = {
+  method: 'GET' as const,
+  pathParams: [] as const,
+  queryParams: ['acquiringEntityId', 'acquiredEntityId', 'transactionAmountMin', 'transactionAmountMax', 'announcedBefore', 'announcedAfter', 'page', 'limit'] as const,
+  bodyParams: [] as const,
+  path: () => '/funding/v1/mergers-and-acquisitions'
+} as const;
+
 // Re-export schema types
 export * from './schema';
diff --git a/packages/types/src/schema.ts b/packages/types/src/schema.ts
@@ -13,6 +13,12 @@ export type APIResponse = components['schemas']['APIResponse'];
 
 export type APIResponseWithMetadata = components['schemas']['APIResponseWithMetadata'];
 
+export type AcquisitionDeal = components['schemas']['AcquisitionDeal'];
+
+export type AcquisitionDealStatus = components['schemas']['AcquisitionDealStatus'];
+
+export type Announcement = components['schemas']['Announcement'];
+
 export type Asset = components['schemas']['Asset'];
 
 export type AssetList = components['schemas']['AssetList'];
@@ -73,6 +79,14 @@ export type ExtractResponse = components['schemas']['ExtractResponse'];
 
 export type ExtractResponseMetadata = components['schemas']['ExtractResponseMetadata'];
 
+export type FundingEntity = components['schemas']['FundingEntity'];
+
+export type FundingRound = components['schemas']['FundingRound'];
+
+export type FundingRoundStage = components['schemas']['FundingRoundStage'];
+
+export type FundingRoundType = components['schemas']['FundingRoundType'];
+
 export type GetAllEventsRequest = components['schemas']['GetAllEventsRequest'];
 
 export type GetEventResponse = components['schemas']['GetEventResponse'];
@@ -85,6 +99,8 @@ export type GroupedEntity = components['schemas']['GroupedEntity'];
 
 export type IntelResponse = components['schemas']['IntelResponse'];
 
+export type Investors = components['schemas']['Investors'];
+
 export type NetworkMetrics = components['schemas']['NetworkMetrics'];
 
 export type NewsAsset = components['schemas']['NewsAsset'];
@@ -93,10 +109,16 @@ export type NewsResponse = components['schemas']['NewsResponse'];
 
 export type OHLCV = components['schemas']['OHLCV'];
 
+export type Organization = components['schemas']['Organization'];
+
 export type PaginationResult = components['schemas']['PaginationResult'];
 
+export type Person = components['schemas']['Person'];
+
 export type PlatformContract = components['schemas']['PlatformContract'];
 
+export type Project = components['schemas']['Project'];
+
 export type ProjectRecapResponse = components['schemas']['ProjectRecapResponse'];
 
 export type PropositionResponse = components['schemas']['PropositionResponse'];
diff --git a/packages/types/src/types.ts b/packages/types/src/types.ts
diff --git a/typegen/openapi/index.yaml b/typegen/openapi/index.yaml
diff --git a/typegen/openapi/services/fundraising/openapi.yaml b/typegen/openapi/services/fundraising/openapi.yaml
