@show-karma/karma-gap-sdk 0.4.14 → 0.4.16

package/core/class/karma-indexer/api/types.ts

@@ -0,0 +1,313 @@
+import { IGrantUpdateBase } from "core/shared/types";
+
+export type Hex = `0x${string}`;
+export type JSONStr = string;
+export type ExternalLink = { type: string; url: string };
+export type ExternalCustomLink = { 
+  type: 'custom';
+  url: string;
+  name: string
+};
+export interface ITag {
+  name: string;
+}
+
+export interface IAttestationResponse {
+  id: string;
+  uid: Hex;
+  schemaUID: Hex;
+  refUID: Hex;
+  attester: Hex;
+  recipient: Hex;
+  revoked: boolean;
+  revocationTime?: number;
+  createdAt: any;
+  updatedAt: any;
+  chainID: number;
+  type: string;
+  data: any;
+  decodedDataJson: JSONStr;
+  isOffchain: any;
+  revocable: any;
+  schemaId: Hex;
+}
+
+export interface ISummaryProject {
+  title: string;
+  slug?: string;
+  uid: Hex;
+}
+
+export interface IMilestoneCompleted extends IAttestationResponse {
+  type: "MilestoneStatus";
+  data: {
+    type: "approved" | "rejected" | "completed";
+    reason?: string;
+    proofOfWork?: string;
+  };
+}
+
+export interface IMilestoneResponse extends IAttestationResponse {
+  type: "Milestone";
+  completed?: IMilestoneCompleted;
+  approved?: IMilestoneCompleted;
+  rejected?: IMilestoneCompleted;
+  verified?: IMilestoneCompleted[];
+  data: {
+    title: string;
+    description: string;
+    endsAt: number;
+    startsAt?: number;
+    type: "milestone";
+    priority?: number;
+  };
+}
+
+export interface IGrantUpdateStatus extends IAttestationResponse {
+  type: `grant-update-${IStatus}`;
+  reason?: string;
+  data: {
+    type: "approved" | "rejected" | "completed";
+    reason?: string;
+    pitchDeck?: string;
+    demoVideo?: string;
+    trackExplanations?: Array<{
+      trackId: string;
+      trackName: string;
+      explanation: string;
+    }>;
+  };
+}
+export interface IGrantUpdate extends IAttestationResponse {
+  data: IGrantUpdateBase & {
+    type: "grant-update";
+  };
+  verified?: IGrantUpdateStatus[];
+}
+
+export interface IProjectUpdateStatus extends IAttestationResponse {
+  type: `project-update-${IStatus}`;
+  reason?: string;
+  data: {
+    type: "approved" | "rejected" | "completed";
+    reason?: string;
+  };
+}
+export interface IProjectUpdate extends IAttestationResponse {
+  data: {
+    title: string;
+    text: string;
+    startDate?: Date;
+    endDate?: Date;
+    grants?: string[];
+    indicators?: {
+      name: string;
+      indicatorId: string;
+    }[];
+    deliverables?: {
+      name: string;
+      proof: string;
+      description: string;
+    }[];
+    type: "project-update";
+  };
+  verified?: IProjectUpdateStatus[];
+}
+
+export interface IProjectMilestoneStatus extends IAttestationResponse {
+  type: `project-milestone-verified`;
+  reason?: string;
+  data: {
+    type: "approved" | "rejected" | "completed";
+    reason?: string;
+  };
+}
+
+export interface IProjectMilestoneResponse extends IAttestationResponse {
+  data: {
+    text: string;
+    title: string;
+    type: "project-milestone";
+  };
+  verified?: IProjectMilestoneStatus[];
+  completed?: IMilestoneCompleted;
+}
+
+export interface IProjectPointer extends IAttestationResponse {
+  data: {
+    ogProjectUID: string;
+    type: "project-pointer";
+  };
+}
+
+export interface IGrantDetails extends IAttestationResponse {
+  type: "GrantDetails";
+  data: {
+    title: string;
+    amount: string;
+    description: string;
+    proposalURL: string;
+    assetAndChainId?: [Hex, number];
+    payoutAddress: Hex;
+    questions: { type: string; query: string; explanation: string }[];
+    startDate: number;
+    programId?: string;
+    type: "grant-details";
+    fundUsage?: string;
+    selectedTrackIds?: string[];
+  };
+}
+
+export interface IGrantResponse extends IAttestationResponse {
+  type: "Grant";
+  data: { communityUID: Hex };
+  details?: IGrantDetails;
+  milestones: IMilestoneResponse[];
+  completed?: IGrantUpdate;
+  project: IProjectResponse;
+  updates: IGrantUpdate[];
+  community: ICommunityResponse;
+  members: Hex[];
+  categories?: string[];
+  externalAddresses?: {
+    [key: string]: string;
+  };
+  external?: {
+    [key: string]: string[];
+  };
+  amount?: Hex;
+}
+
+export interface IMemberDetails extends IAttestationResponse {
+  name: string;
+  profilePictureURL: string;
+}
+
+export interface IMemberOf extends IAttestationResponse {
+  type: "MemberOf";
+  data: { memberOf: true };
+  details?: IMemberDetails;
+}
+
+export interface IProjectDetails extends IAttestationResponse {
+  type: "ProjectDetails";
+  data: {
+    title: string;
+    description: string;
+    problem?: string;
+    solution?: string;
+    missionSummary?: string;
+    locationOfImpact?: string;
+    imageURL: string;
+    links?: Array<ExternalLink | ExternalCustomLink>;
+    tags?: ITag[];
+    slug?: string;
+    type: "project-details";
+    businessModel?: string;
+    stageIn?: string;
+    raisedMoney?: string;
+    pathToTake?: string;
+  };
+}
+
+type IStatus = "verified";
+export interface IProjectImpactStatus extends IAttestationResponse {
+  type: `project-impact-${IStatus}`;
+  reason?: string;
+}
+export interface IProjectImpact extends IAttestationResponse {
+  type: "ProjectImpact";
+  data: {
+    work: string;
+    impact: string;
+    proof: string;
+    startedAt?: number;
+    completedAt: number;
+    type: "project-impact";
+  };
+  verified: IProjectImpactStatus[];
+}
+export interface IProjectEndorsement extends IAttestationResponse {
+  type: "ProjectEndorsement";
+  data: {
+    comment?: string;
+    type?: "project-endorsement";
+  };
+}
+
+export interface IProjectResponse extends IAttestationResponse {
+  type: "Project";
+  data: { project: true };
+  details?: IProjectDetails;
+  members: IMemberOf[];
+  grants: IGrantResponse[];
+  grantee: any;
+  impacts: IProjectImpact[];
+  updates: IProjectUpdate[];
+  pointers: IProjectPointer[];
+  symlinks: Hex[];
+  endorsements: IProjectEndorsement[];
+  milestones: IProjectMilestoneResponse[];
+  payoutAddress?: Hex;
+}
+
+export interface ICommunityDetails extends IAttestationResponse {
+  type: "CommunityDetails";
+  data: {
+    name: string;
+    description: string;
+    imageURL: string;
+    links: ExternalLink[];
+    slug?: string;
+  };
+}
+
+export interface ICommunityResponse extends IAttestationResponse {
+  type: "Community";
+  data: { community: true };
+  details?: ICommunityDetails;
+  grants: IGrantResponse[];
+}
+
+export interface ICommunityAdminsResponse {
+  id: string;
+  admins: { user: { id: string } }[];
+}
+
+export interface ISearchResponse {
+  projects: IProjectResponse[];
+  communities: ICommunityResponse[];
+}
+
+export interface ITrackResponse {
+  id: string;
+  name: string;
+  description?: string;
+  communityUID: string;
+  isArchived: boolean;
+  createdAt: string;
+  updatedAt: string;
+  programId?: string;
+  isActive?: boolean;
+  chainID?: number;
+}
+
+export interface ITrackAssignmentResponse {
+  id: string;
+  programId: string;
+  chainID: number;
+  trackId: string;
+  track: ITrackResponse;
+}
+
+export interface IProjectTrackResponse {
+  projectUID: string;
+  chainID: number;
+  programId: string;
+  track: ITrackResponse;
+  project: {
+    uid: string;
+    chainID: number;
+    details: any;
+  };
+}

package/core/class/remote-storage/IpfsStorage.ts

@@ -0,0 +1,76 @@
+import { RemoteStorage } from "./RemoteStorage";
+import { RemoteStorageError } from "../SchemaError";
+import { getIPFSData } from "../../utils";
+import { STORAGE_TYPE, TRemoteStorageOutput } from "core/types";
+import axios from "axios";
+
+export interface IpfsStorageOptions {
+  token: string;
+}
+
+export class IpfsStorage extends RemoteStorage {
+  private pinataJWTToken: string;
+
+  constructor(
+    opts: IpfsStorageOptions,
+    /**
+     * If set, will send request to another server instead of
+     * using the local instance
+     */
+    sponsor?: RemoteStorage["sponsor"]
+  ) {
+    super(STORAGE_TYPE.IPFS, sponsor);
+
+    this.assert(opts);
+    this.pinataJWTToken = opts.token;
+  }
+
+  private assert(opts: IpfsStorageOptions) {}
+
+  async save<T = unknown>(data: T): Promise<string> {
+    try {
+      const cid = await this.saveAndGetCID(data);
+      return cid;
+    } catch (error) {
+      throw new RemoteStorageError(
+        "REMOTE_STORAGE_UPLOAD",
+        `Error adding data to IPFS`
+      );
+    }
+  }
+
+  encode(data: string): TRemoteStorageOutput<string> {
+    return { hash: data, storageType: this.storageType };
+  }
+
+  async get<T = unknown>(args: { cid: string }): Promise<T> {
+    return getIPFSData<T>(args.cid);
+  }
+
+  async saveAndGetCID(
+    data: any,
+    pinataMetadata = { name: "via karma-gap-sdk" }
+  ) {
+    try {
+      const res = await axios.post(
+        "https://api.pinata.cloud/pinning/pinJSONToIPFS",
+        {
+          pinataContent: data,
+          pinataMetadata: pinataMetadata,
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.pinataJWTToken}`,
+          },
+        }
+      );
+      return res.data.IpfsHash;
+    } catch (error) {
+      throw new RemoteStorageError(
+        "REMOTE_STORAGE_UPLOAD",
+        `Error adding data to IPFS`
+      );
+    }
+  }
+}

package/core/class/remote-storage/RemoteStorage.ts

@@ -0,0 +1,65 @@
+import axios from 'axios';
+import { STORAGE_TYPE, TRemoteStorageOutput, TSchemaName } from 'core/types';
+
+interface SponsoredRemote {
+  url: string;
+  responseParser: (response: any) => string;
+}
+
+export abstract class RemoteStorage<C = unknown> {
+  protected client: C;
+  readonly storageType: number;
+
+  readonly sponsor?: SponsoredRemote;
+
+  constructor(
+    storageType: STORAGE_TYPE,
+    /**
+     * If set, will try to POST request to another server instead of
+     * using the local instance.
+     *
+     * > If a response parser is not set, it will try to get { cid: string }.
+     */
+    sponsor: SponsoredRemote
+  ) {
+    this.storageType = storageType;
+    this.sponsor = sponsor;
+    this.interceptRemoteStorage();
+  }
+
+  /**
+   * Try to save data to remote storage and return the CID.
+   * IF sponsorUrl is set, this method will be automatically
+   * intercepted and will send a POST request to the sponsorUrl
+   * with the contents: `{ data: T, type: "<AttestationType>" }`
+   */
+  abstract save<T = unknown>(data: T, schemaName: string): Promise<string>;
+
+  /**
+   * Encodes the data according to the remote storage type parameters
+   * OR returns the data as is if no encoding is required
+   */
+  abstract encode(data: unknown): TRemoteStorageOutput;
+
+  /**
+   * Get data from Remote Storage
+   */
+  abstract get<T = unknown>(args: unknown): Promise<T>;
+
+  /**
+   * If sponsorUrl is set, intercept the save method and send a POST request
+   * to the sponsorUrl instead of using the local instance.
+   * @returns
+   */
+  private interceptRemoteStorage() {
+    if (!this.sponsor?.url) return;
+    this.save = async (data: unknown, schemaName: TSchemaName) => {
+      const { data: response } = await axios.post(this.sponsor.url, {
+        data: data,
+        type: schemaName,
+      });
+
+      return this.sponsor.responseParser?.(response) || response.cid;
+    };
+  }
+}

package/core/class/types/allo.ts

@@ -0,0 +1,93 @@
+export type RoundMetadata = {
+  name: string;
+  support: {
+    info: string;
+    type: string;
+  };
+  roundType: "public" | string; // Could be extended to include other round types
+  eligibility: {
+    description: string;
+    requirements: Array<{
+      requirement: string;
+    }>;
+  };
+  feesAddress: string;
+  feesPercentage: number;
+  programContractAddress: string;
+  quadraticFundingConfig?: {
+    matchingCap: boolean;
+    sybilDefense: boolean;
+    matchingCapAmount: number;
+    minDonationThreshold: boolean;
+    matchingFundsAvailable: number;
+    minDonationThresholdAmount: number;
+  };
+  category: string;
+  source: string;
+};
+
+export type Address = `0x${string}`;
+
+export type GrantArgs = {
+  profileId: Address;
+  roundMetadata: RoundMetadata;
+  applicationStart: number;
+  applicationEnd: number;
+  roundStart: number;
+  roundEnd: number;
+  // Use available payout tokens from this file:
+  // https://github.dev/gitcoinco/grants-stack-indexer/blob/main/src/database/schema.ts
+  matchingFundAmt: number;
+  applicationMetadata: ApplicationMetadata;
+  managers: Address[];
+  strategy: Address;
+  payoutToken: Address;
+};
+
+export type ApplicationMetadata = {
+  version: string;
+  lastUpdatedOn: number;
+  applicationSchema: {
+    questions: Array<{
+      id: number;
+      info: string;
+      type:
+        | "email"
+        | "short-answer"
+        | "link"
+        | "number"
+        | "paragraph"
+        | "address"
+        | "checkbox"
+        | "multiple-choice";
+      title: string;
+      hidden: boolean;
+      choices?: string[];
+      required: boolean;
+      encrypted: boolean;
+    }>;
+    requirements: {
+      github: {
+        required: boolean;
+        verification: boolean;
+      };
+      twitter: {
+        required: boolean;
+        verification: boolean;
+      };
+      // Potentially add more requirements here if they exist in the data
+    };
+  };
+};
+
+export type ProfileMetadata = {
+  title: string;
+  description: string;
+  website: string;
+  projectTwitter: string;
+  logoImg: string; // Assuming it's a URL to the logo image
+  bannerImg: string; // Assuming it's a URL to the banner image
+  logoImgData: any; // Could be object with image data or left as type 'any' if not used
+  bannerImgData: any; // Could be object with image data or left as type 'any' if not used
+  createdAt: number; // Timestamp in milliseconds
+};