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

package/core/class/entities/ProjectImpact.ts

@@ -0,0 +1,170 @@
+import { Hex, SignerOrProvider, TNetwork } from "../../types";
+import { Attestation, AttestationArgs } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { AttestationError } from "../SchemaError";
+import { AllGapSchemas } from "../AllGapSchemas";
+import { chainIdToNetwork } from "../../consts";
+import { Transaction } from "ethers";
+
+export interface _IProjectImpact extends ProjectImpact {}
+
+type IStatus = "verified";
+
+export interface IProjectImpactStatus {
+  type?: `project-impact-${IStatus}`;
+  reason?: string;
+}
+
+export class ProjectImpactStatus
+  extends Attestation<IProjectImpactStatus>
+  implements IProjectImpactStatus
+{
+  type: `project-impact-${IStatus}`;
+  reason?: string;
+}
+
+export interface IProjectImpact {
+  work: string;
+  impact: string;
+  proof: string;
+  startedAt?: number;
+  completedAt: number;
+  type?: string;
+  verified?: ProjectImpactStatus[];
+}
+
+export class ProjectImpact
+  extends Attestation<IProjectImpact>
+  implements IProjectImpact
+{
+  work: string;
+  impact: string;
+  proof: string;
+  startedAt?: number;
+  completedAt: number;
+  type?: string;
+  verified: ProjectImpactStatus[] = [];
+
+  constructor(data: AttestationArgs<IProjectImpact, GapSchema>) {
+    (data.data as any).type = "project-impact";
+    super(data);
+  }
+
+  /**
+   * Attest Project Impact.
+   */
+  private async attestStatus(
+    signer: SignerOrProvider,
+    schema: GapSchema,
+    callback?: Function
+  ) {
+    const eas = this.schema.gap.eas.connect(signer);
+    try {
+      if (callback) callback("preparing");
+      const tx = await eas.attest({
+        schema: schema.uid,
+        data: {
+          recipient: this.recipient,
+          data: schema.encode(),
+          refUID: this.uid,
+          expirationTime: 0n,
+          revocable: schema.revocable,
+        },
+      });
+
+      if (callback) callback("pending");
+      const uid = await tx.wait();
+      if (callback) callback("confirmed");
+
+      console.log(uid);
+      return {
+        tx: [
+          {
+            hash: tx.tx.hash as Hex,
+          } as Transaction,
+        ],
+        uids: [uid as `0x${string}`],
+      };
+    } catch (error: any) {
+      console.error(error);
+      throw new AttestationError("ATTEST_ERROR", error.message, error);
+    }
+  }
+
+  /**
+   * Verify this ProjectImpact. If the ProjectImpact is not already verified,
+   * it will throw an error.
+   * @param signer
+   * @param reason
+   */
+  async verify(signer: SignerOrProvider, data?: IProjectImpactStatus, callback?: Function) {
+    console.log("Verifying ProjectImpact");
+
+    const schema = this.schema.gap.findSchema("GrantUpdateStatus");
+    if (this.schema.isJsonSchema()) {
+      schema.setValue("json", JSON.stringify({
+        type: "project-impact-verified",
+        reason: data?.reason || '',
+      }))
+    } else {
+      schema.setValue("type", "project-impact-verified");
+      schema.setValue("reason", data?.reason || '');
+    }
+
+    console.log("Before attest project impact verified");
+    const { tx, uids } = await this.attestStatus(signer, schema, callback);
+    console.log("After attest project impact verified");
+
+    this.verified.push(
+      new ProjectImpactStatus({
+        data: {
+          type: "project-impact-verified",
+          reason: data?.reason || '',
+        },
+        refUID: this.uid,
+        schema: schema,
+        recipient: this.recipient,
+      })
+    );
+
+    return { tx, uids };
+  }
+
+  static from(
+    attestations: ProjectImpact[],
+    network: TNetwork
+  ): ProjectImpact[] {
+    return attestations.map((attestation) => {
+      const projectImpact = new ProjectImpact({
+        ...attestation,
+        data: {
+          ...attestation.data,
+        },
+        schema: new AllGapSchemas().findSchema(
+          "ProjectImpact",
+          chainIdToNetwork[attestation.chainID] as TNetwork
+        ),
+        chainID: attestation.chainID,
+      });
+
+      if (attestation.verified?.length > 0) {
+        projectImpact.verified = attestation.verified.map(
+          (m) =>
+            new ProjectImpactStatus({
+              ...m,
+              data: {
+                ...m.data,
+              },
+              schema: new AllGapSchemas().findSchema(
+                "GrantUpdateStatus",
+                chainIdToNetwork[attestation.chainID] as TNetwork
+              ),
+              chainID: attestation.chainID,
+            })
+        );
+      }
+
+      return projectImpact;
+    });
+  }
+}

package/core/class/entities/ProjectMilestone.ts

@@ -0,0 +1,254 @@
+import { SignerOrProvider, TNetwork } from "../../../core/types";
+import { Attestation, AttestationArgs } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { AttestationError } from "../SchemaError";
+import { AllGapSchemas } from "../AllGapSchemas";
+import { chainIdToNetwork } from "../../../core/consts";
+import { Transaction } from "ethers";
+import { Hex, IProjectMilestoneResponse } from "../karma-indexer/api/types";
+import {
+  AttestationWithTx,
+  IMilestoneCompleted as IProjectMilestoneCompleted,
+  MilestoneCompleted as ProjectMilestoneCompleted,
+} from "../types/attestations";
+
+export interface IProjectMilestone {
+  title: string;
+  text: string;
+  type?: string;
+}
+
+type IStatus = "verified" | "completed";
+
+export interface IProjectMilestoneStatus {
+  type?: `project-milestone-${IStatus}`;
+  proofOfWork?: string;
+  reason?: string;
+}
+
+export class ProjectMilestoneStatus
+  extends Attestation<IProjectMilestoneStatus>
+  implements IProjectMilestoneStatus
+{
+  type: `project-milestone-${IStatus}`;
+  reason?: string;
+}
+
+export class ProjectMilestone
+  extends Attestation<IProjectMilestone>
+  implements IProjectMilestone
+{
+  title: string;
+  text: string;
+  verified: ProjectMilestoneStatus[] = [];
+  completed: ProjectMilestoneCompleted;
+
+  constructor(data: AttestationArgs<IProjectMilestone, GapSchema>) {
+    (data.data as any).type = "project-milestone";
+    super(data);
+  }
+
+  /**
+   * Attest the status of the update as approved, rejected or completed.
+   */
+  private async attestStatus(
+    signer: SignerOrProvider,
+    schema: GapSchema,
+    callback?: Function
+  ): Promise<AttestationWithTx> {
+    const eas = this.schema.gap.eas.connect(signer);
+    try {
+      if (callback) callback("preparing");
+      const tx = await eas.attest({
+        schema: schema.uid,
+        data: {
+          recipient: this.recipient,
+          data: schema.encode(),
+          refUID: this.uid,
+          expirationTime: 0n,
+          revocable: schema.revocable,
+        },
+      });
+
+      if (callback) callback("pending");
+      const uid = await tx.wait();
+      if (callback) callback("confirmed");
+
+      console.log(uid);
+      return {
+        tx: [
+          {
+            hash: tx.tx.hash as Hex,
+          } as Transaction,
+        ],
+        uids: [uid as `0x${string}`],
+      };
+    } catch (error: any) {
+      console.error(error);
+      throw new AttestationError("ATTEST_ERROR", error.message, error);
+    }
+  }
+
+  /**
+   * Verify this ProjectUpdate. If the ProjectUpdate is not already verified,
+   * it will throw an error.
+   * @param signer
+   * @param reason
+   */
+  async verify(
+    signer: SignerOrProvider,
+    data?: IProjectMilestoneStatus,
+    callback?: Function
+  ) {
+    console.log("Verifying");
+
+    const schema = this.schema.gap.findSchema("ProjectMilestoneStatus");
+    if (this.schema.isJsonSchema()) {
+      schema.setValue(
+        "json",
+        JSON.stringify({
+          type: "verified",
+          reason: data?.reason || "",
+        })
+      );
+    } else {
+      schema.setValue("type", "project-milestone-verified");
+      schema.setValue("reason", data?.reason || "");
+    }
+    console.log("Before attest project milestone verified");
+    await this.attestStatus(signer, schema, callback);
+    console.log("After attest project milestone verified");
+
+    this.verified.push(
+      new ProjectMilestoneStatus({
+        data: {
+          type: "project-milestone-verified",
+          reason: data?.reason || "",
+        },
+        refUID: this.uid,
+        schema: schema,
+        recipient: this.recipient,
+      })
+    );
+  }
+
+  /**
+   * Marks a milestone as completed. If the milestone is already completed,
+   * it will throw an error.
+   * @param signer
+   * @param reason
+   */
+  async complete(
+    signer: SignerOrProvider,
+    data?: IProjectMilestoneStatus,
+    callback?: Function
+  ) {
+    console.log("Completing");
+
+    const schema = this.schema.gap.findSchema("ProjectMilestoneStatus");
+    if (this.schema.isJsonSchema()) {
+      schema.setValue(
+        "json",
+        JSON.stringify({
+          type: "project-milestone-completed",
+          ...data,
+        })
+      );
+    } else {
+      schema.setValue("type", "project-milestone-completed");
+      schema.setValue("proofOfWork", data?.proofOfWork || "");
+      schema.setValue("reason", data?.reason || "");
+    }
+    console.log("Before attest project milestone completed");
+    const { tx, uids } = await this.attestStatus(signer, schema, callback);
+    console.log("After attest project milestone completed");
+
+    this.completed = new ProjectMilestoneCompleted({
+      data: {
+        reason: data?.reason || "",
+      },
+      refUID: this.uid,
+      schema: schema,
+      recipient: this.recipient,
+    });
+    return { tx, uids };
+  }
+
+  /**
+   * Revokes the completed status of the milestone. If the milestone is not completed,
+   * it will throw an error.
+   * @param signer
+   */
+  async revokeCompletion(signer: SignerOrProvider, callback?: Function) {
+    if (!this.completed)
+      throw new AttestationError("ATTEST_ERROR", "Milestone is not completed");
+
+    const { tx, uids } = await this.completed.schema.multiRevoke(
+      signer,
+      [
+        {
+          schemaId: this.completed.schema.uid,
+          uid: this.completed.uid,
+        },
+      ],
+      callback
+    );
+    return { tx, uids };
+  }
+
+  static from(
+    attestations: IProjectMilestoneResponse[],
+    network: TNetwork
+  ): ProjectMilestone[] {
+    return attestations.map((attestation) => {
+      const projectMilestone = new ProjectMilestone({
+        ...attestation,
+        data: {
+          ...attestation.data,
+        },
+        schema: new AllGapSchemas().findSchema(
+          "ProjectMilestone",
+          chainIdToNetwork[attestation.chainID] as TNetwork
+        ),
+        chainID: attestation.chainID,
+      });
+
+      if (attestation.verified?.length > 0) {
+        projectMilestone.verified = attestation.verified.map(
+          (m) =>
+            new ProjectMilestoneStatus({
+              ...m,
+              data: {
+                ...m.data,
+                type:
+                  m.data.type === "completed"
+                    ? "project-milestone-completed"
+                    : "project-milestone-verified",
+              },
+              schema: new AllGapSchemas().findSchema(
+                "ProjectMilestoneStatus",
+                chainIdToNetwork[attestation.chainID] as TNetwork
+              ),
+              chainID: attestation.chainID,
+            })
+        );
+      }
+
+      if (attestation.completed) {
+        projectMilestone.completed = new ProjectMilestoneCompleted({
+          ...attestation.completed,
+          data: {
+            ...attestation.completed.data,
+          },
+          schema: new AllGapSchemas().findSchema(
+            "MilestoneCompleted",
+            chainIdToNetwork[attestation.chainID] as TNetwork
+          ),
+          chainID: attestation.chainID,
+        });
+      }
+
+      return projectMilestone;
+    });
+  }
+}

package/core/class/entities/ProjectPointer.ts

@@ -0,0 +1,39 @@
+import { TNetwork } from "../../../core/types";
+import { Attestation } from "../Attestation";
+import { AllGapSchemas } from "../AllGapSchemas";
+import { chainIdToNetwork } from "../../../core/consts";
+
+export interface _IProjectPointer extends ProjectPointer {}
+
+export interface IProjectPointer {
+  ogProjectUID: string;
+  type?: string;
+}
+
+export class ProjectPointer
+  extends Attestation<IProjectPointer>
+  implements IProjectPointer
+{
+  ogProjectUID: string;
+
+  static from(
+    attestations: _IProjectPointer[],
+    network: TNetwork
+  ): ProjectPointer[] {
+    return attestations.map((attestation) => {
+      const projectUpdate = new ProjectPointer({
+        ...attestation,
+        data: {
+          ...attestation.data,
+        },
+        schema: new AllGapSchemas().findSchema(
+          "ProjectUpdate",
+          chainIdToNetwork[attestation.chainID] as TNetwork
+        ),
+        chainID: attestation.chainID,
+      });
+
+      return projectUpdate;
+    });
+  }
+}

package/core/class/entities/ProjectUpdate.ts

@@ -0,0 +1,176 @@
+import { SignerOrProvider, TNetwork } from "../../../core/types";
+import { Attestation } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { AttestationError } from "../SchemaError";
+import { AllGapSchemas } from "../AllGapSchemas";
+import { chainIdToNetwork } from "../../../core/consts";
+import { Transaction } from "ethers";
+import { Hex } from "../karma-indexer/api/types";
+import { AttestationWithTx } from "../types/attestations";
+
+export interface _IProjectUpdate extends ProjectUpdate {}
+export interface IProjectUpdate {
+  title: string;
+  text: string;
+  startDate?: Date;
+  endDate?: Date;
+  type?: string;
+  grants?: string[];
+  indicators?: {
+    name: string;
+    indicatorId: string;
+  }[];
+  deliverables?: {
+    name: string;
+    proof: string;
+    description: string;
+  }[];
+}
+
+type IStatus = "verified";
+
+export interface IProjectUpdateStatus {
+  type?: `project-update-${IStatus}`;
+  reason?: string;
+  proofOfWork?: string;
+}
+
+export class ProjectUpdateStatus
+  extends Attestation<IProjectUpdateStatus>
+  implements IProjectUpdateStatus
+{
+  type: `project-update-${IStatus}`;
+  reason?: string;
+  proofOfWork?: string;
+}
+
+export class ProjectUpdate
+  extends Attestation<IProjectUpdate>
+  implements IProjectUpdate
+{
+  title: string;
+  text: string;
+  verified: ProjectUpdateStatus[] = [];
+
+  /**
+   * Attest the status of the update as approved, rejected or completed.
+   */
+  private async attestStatus(
+    signer: SignerOrProvider,
+    schema: GapSchema,
+    callback?: Function
+  ): Promise<AttestationWithTx> {
+    const eas = this.schema.gap.eas.connect(signer);
+    try {
+      if (callback) callback("preparing");
+      const tx = await eas.attest({
+        schema: schema.uid,
+        data: {
+          recipient: this.recipient,
+          data: schema.encode(),
+          refUID: this.uid,
+          expirationTime: 0n,
+          revocable: schema.revocable,
+        },
+      });
+
+      if (callback) callback("pending");
+      const uid = await tx.wait();
+      if (callback) callback("confirmed");
+
+      console.log(uid);
+      return {
+        tx: [
+          {
+            hash: tx.tx.hash as Hex,
+          } as Transaction,
+        ],
+        uids: [uid as `0x${string}`],
+      };
+    } catch (error: any) {
+      console.error(error);
+      throw new AttestationError("ATTEST_ERROR", error.message, error);
+    }
+  }
+
+  /**
+   * Verify this ProjectUpdate. If the ProjectUpdate is not already verified,
+   * it will throw an error.
+   * @param signer
+   * @param reason
+   */
+  async verify(
+    signer: SignerOrProvider,
+    data?: IProjectUpdateStatus,
+    callback?: Function
+  ) {
+    console.log("Verifying");
+
+    const schema = this.schema.gap.findSchema("ProjectUpdateStatus");
+    if (this.schema.isJsonSchema()) {
+      schema.setValue(
+        "json",
+        JSON.stringify({
+          type: "verified",
+          reason: data?.reason || "",
+        })
+      );
+    } else {
+      schema.setValue("type", "project-update-verified");
+      schema.setValue("reason", data?.reason || "");
+    }
+    console.log("Before attest project update verified");
+    await this.attestStatus(signer, schema, callback);
+    console.log("After attest project update verified");
+
+    this.verified.push(
+      new ProjectUpdateStatus({
+        data: {
+          type: "project-update-verified",
+          reason: data?.reason || "",
+        },
+        refUID: this.uid,
+        schema: schema,
+        recipient: this.recipient,
+      })
+    );
+  }
+
+  static from(
+    attestations: _IProjectUpdate[],
+    network: TNetwork
+  ): ProjectUpdate[] {
+    return attestations.map((attestation) => {
+      const projectUpdate = new ProjectUpdate({
+        ...attestation,
+        data: {
+          ...attestation.data,
+        },
+        schema: new AllGapSchemas().findSchema(
+          "ProjectUpdate",
+          chainIdToNetwork[attestation.chainID] as TNetwork
+        ),
+        chainID: attestation.chainID,
+      });
+
+      if (attestation.verified?.length > 0) {
+        projectUpdate.verified = attestation.verified.map(
+          (m) =>
+            new ProjectUpdateStatus({
+              ...m,
+              data: {
+                ...m.data,
+              },
+              schema: new AllGapSchemas().findSchema(
+                "ProjectUpdateStatus",
+                chainIdToNetwork[attestation.chainID] as TNetwork
+              ),
+              chainID: attestation.chainID,
+            })
+        );
+      }
+
+      return projectUpdate;
+    });
+  }
+}

package/core/class/entities/Track.ts

@@ -0,0 +1,32 @@
+import { TNetwork } from "core/types";
+import { ITrackResponse } from "../karma-indexer/api/types";
+
+export class Track {
+  id: string;
+  name: string;
+  description?: string;
+  communityUID: string;
+  isArchived: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+  programId?: string;
+  isActive?: boolean;
+  network: TNetwork;
+
+  constructor(data: any, network: TNetwork) {
+    this.id = data.id;
+    this.name = data.name;
+    this.description = data.description;
+    this.communityUID = data.communityUID;
+    this.isArchived = data.isArchived ?? false;
+    this.createdAt = new Date(data.createdAt);
+    this.updatedAt = new Date(data.updatedAt);
+    this.programId = data.programId;
+    this.isActive = data.isActive;
+    this.network = network;
+  }
+
+  static from(data: ITrackResponse[], network: TNetwork): Track[] {
+    return data.map((item) => new Track(item, network));
+  }
+}