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

package/core/class/entities/Grant.ts

@@ -0,0 +1,321 @@
+import { Attestation } from "../Attestation";
+import {
+  GrantDetails,
+  GrantRound,
+  GrantCompleted,
+  AttestationWithTx,
+} from "../types/attestations";
+import { IMilestone, Milestone } from "./Milestone";
+import { GapSchema } from "../GapSchema";
+import { GAP } from "../GAP";
+import { AttestationError } from "../SchemaError";
+import { chainIdToNetwork, nullRef } from "../../consts";
+import {
+  Hex,
+  MultiAttestPayload,
+  SignerOrProvider,
+  TNetwork,
+} from "core/types";
+import { GapContract } from "../contract/GapContract";
+import { Community } from "./Community";
+import { Project } from "./Project";
+import { AllGapSchemas } from "../AllGapSchemas";
+import {
+  IGrantResponse,
+  IProjectResponse,
+  ISummaryProject,
+} from "../karma-indexer/api/types";
+import { GrantUpdate, IGrantUpdate, _IGrantUpdate } from "./GrantUpdate";
+
+interface _Grant extends Grant {}
+
+export interface IGrant {
+  communityUID: Hex;
+}
+
+export class Grant extends Attestation<IGrant> {
+  details?: GrantDetails;
+  communityUID: Hex;
+  verified?: boolean = false;
+  round?: GrantRound;
+  milestones: Milestone[] = [];
+  community: Community;
+  updates: GrantUpdate[] = [];
+  members: string[] = [];
+  completed?: GrantCompleted;
+  project?: IProjectResponse | ISummaryProject;
+  categories?: string[] = [];
+
+  async verify(signer: SignerOrProvider) {
+    const eas = this.schema.gap.eas.connect(signer);
+    const schema = this.schema.gap.findSchema("MilestoneApproved");
+    schema.setValue("approved", true);
+
+    try {
+      await eas.attest({
+        schema: schema.raw,
+        data: {
+          recipient: this.recipient,
+          data: schema.encode(),
+          refUID: this.uid,
+          expirationTime: 0n,
+          revocable: schema.revocable,
+        },
+      });
+      this.verified = true;
+    } catch (error) {
+      console.error(error);
+      throw new AttestationError("ATTEST_ERROR", error.message, error);
+    }
+  }
+
+  /**
+   * Add milestones to the grant.
+   * @param signer
+   * @param milestones
+   */
+  addMilestones(milestones: IMilestone[]) {
+    const schema = this.schema.gap.findSchema("Milestone");
+
+    const newMilestones = milestones.map((milestone) => {
+      const m = new Milestone({
+        data: milestone,
+        refUID: this.uid,
+        schema,
+        createdAt: Date.now(),
+        recipient: this.recipient,
+        uid: nullRef,
+      });
+      return m;
+    });
+    this.milestones.push(...newMilestones);
+  }
+
+  /**
+   * Creates the payload for a multi-attestation.
+   *
+   * > if Current payload is set, it'll be used as the base payload
+   * and the project should refer to an index of the current payload,
+   * usually the community position.
+   *
+   * @param payload
+   * @param projectIdx
+   */
+  async multiAttestPayload(
+    currentPayload: MultiAttestPayload = [],
+    projectIdx = 0
+  ) {
+    this.assertPayload();
+    const payload = [...currentPayload];
+    const grantIdx =
+      payload.push([this, await this.payloadFor(projectIdx)]) - 1;
+    if (this.details) {
+      payload.push([this.details, await this.details.payloadFor(grantIdx)]);
+    }
+
+    if (this.milestones.length) {
+      await Promise.all(
+        this.milestones.map(async (m) =>
+          payload.push(...(await m.multiAttestPayload(payload, grantIdx)))
+        )
+      );
+    }
+    if (this.updates.length) {
+      await Promise.all(
+        this.updates.map(async (u) =>
+          payload.push([u, await u.payloadFor(grantIdx)])
+        )
+      );
+    }
+
+    return payload.slice(currentPayload.length, payload.length);
+  }
+
+  async attestProject(
+    signer: SignerOrProvider,
+    originalProjectChainId: number
+  ) {
+    const project = new Project({
+      data: { project: true },
+      schema: this.schema.gap.findSchema("Project"),
+      recipient: this.recipient,
+      chainID: this.chainID,
+    });
+
+    (project.details as Attestation) = new Attestation({
+      data: {
+        originalProjectChainId,
+        uid: this.refUID,
+      },
+      chainID: this.chainID,
+      recipient: this.recipient,
+      schema: this.schema.gap.findSchema("ProjectDetails"),
+    });
+
+    // Overwrite refuid
+    Object.assign(this, { refUID: nullRef });
+    project.grants = [this];
+
+    const attestation = await project.attest(signer);
+    return attestation;
+  }
+
+  /**
+   * @inheritdoc
+   */
+  async attest(
+    signer: SignerOrProvider,
+    projectChainId: number,
+    callback?: Function
+  ): Promise<AttestationWithTx> {
+    if (projectChainId !== this.chainID) {
+      return this.attestProject(signer, projectChainId);
+    }
+    this.assertPayload();
+    const payload = await this.multiAttestPayload();
+
+    const { tx, uids } = await GapContract.multiAttest(
+      signer,
+      payload.map((p) => p[1]),
+      callback
+    );
+
+    if (Array.isArray(uids)) {
+      uids.forEach((uid, index) => {
+        payload[index][0].uid = uid;
+      });
+    }
+    return { tx, uids };
+  }
+
+  async attestUpdate(
+    signer: SignerOrProvider,
+    data: IGrantUpdate,
+    callback?: Function
+  ) {
+    const grantUpdate = new GrantUpdate({
+      data: {
+        ...data,
+        type: "grant-update",
+      },
+      recipient: this.recipient,
+      refUID: this.uid,
+      schema: this.schema.gap.findSchema("GrantDetails"),
+    });
+
+    await grantUpdate.attest(signer, callback);
+    this.updates.push(grantUpdate);
+  }
+
+  /**
+   * Validate if the grant has a valid reference to a community.
+   */
+  protected assertPayload() {
+    if (!this.details || !this.communityUID) {
+      throw new AttestationError(
+        "INVALID_REFERENCE",
+        "Grant should include a valid reference to a community on its details."
+      );
+    }
+    return true;
+  }
+
+  async complete(
+    signer: SignerOrProvider,
+    data: IGrantUpdate,
+    callback?: Function
+  ): Promise<AttestationWithTx> {
+    const completed = new GrantCompleted({
+      data: {
+        ...data,
+        type: "grant-completed",
+      },
+      recipient: this.recipient,
+      refUID: this.uid,
+      schema: this.schema.gap.findSchema("GrantDetails"),
+    });
+
+    const { tx, uids } = await completed.attest(signer, callback);
+    this.completed = completed;
+    return { tx, uids };
+  }
+
+  static from(attestations: IGrantResponse[], network: TNetwork): Grant[] {
+    return attestations.map((attestation) => {
+      const grant = new Grant({
+        ...attestation,
+        data: {
+          communityUID: attestation.data.communityUID,
+        },
+        schema: new AllGapSchemas().findSchema(
+          "Grant",
+          chainIdToNetwork[attestation.chainID] as TNetwork
+        ),
+        chainID: attestation.chainID,
+      });
+
+      if (attestation.details) {
+        const { details } = attestation;
+        grant.details = new GrantDetails({
+          ...details,
+          data: {
+            ...details.data,
+          },
+          schema: new AllGapSchemas().findSchema(
+            "GrantDetails",
+            chainIdToNetwork[attestation.chainID] as TNetwork
+          ),
+          chainID: attestation.chainID,
+        });
+      }
+
+      if (attestation.milestones) {
+        const { milestones } = attestation;
+        grant.milestones = Milestone.from(milestones, network);
+      }
+
+      if (attestation.updates) {
+        const { updates } = attestation;
+        grant.updates = GrantUpdate.from(
+          updates as any as _IGrantUpdate[],
+          network
+        );
+      }
+
+      if (attestation.completed) {
+        const { completed } = attestation;
+        grant.completed = new GrantCompleted({
+          ...completed,
+          data: {
+            ...completed.data,
+          },
+          schema: new AllGapSchemas().findSchema(
+            "GrantDetails",
+            chainIdToNetwork[attestation.chainID] as TNetwork
+          ),
+          chainID: attestation.chainID,
+        });
+      }
+
+      if (attestation.project) {
+        const { project } = attestation;
+        grant.project = project;
+      }
+
+      if (attestation.community) {
+        const { community } = attestation;
+        grant.community = Community.from([community], network)[0];
+      }
+
+      if (attestation.members) {
+        grant.members = attestation.members;
+      }
+
+      if (attestation.categories) {
+        grant.categories = attestation.categories;
+      }
+
+      return grant;
+    });
+  }
+}

package/core/class/entities/GrantUpdate.ts

@@ -0,0 +1,187 @@
+import { IGrantUpdateBase } from "core/shared/types";
+import { Transaction } from "ethers";
+import { chainIdToNetwork } from "../../../core/consts";
+import { SignerOrProvider, TNetwork } from "../../../core/types";
+import { AllGapSchemas } from "../AllGapSchemas";
+import { Attestation } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { Hex } from "../karma-indexer/api/types";
+import { AttestationError } from "../SchemaError";
+
+export interface _IGrantUpdate extends GrantUpdate {}
+export interface IGrantUpdate extends IGrantUpdateBase {
+  type?: string;
+  proofOfWork?: string;
+  pitchDeck?: string;
+  demoVideo?: string;
+  trackExplanations?: Array<{
+    trackId: string;
+    trackName: string;
+    explanation: string;
+  }>;
+}
+
+type IStatus = "verified";
+
+export interface IGrantUpdateStatus {
+  type?: `grant-update-${IStatus}`;
+  reason?: string;
+}
+
+export class GrantUpdateStatus
+  extends Attestation<IGrantUpdateStatus>
+  implements IGrantUpdateStatus
+{
+  type: `grant-update-${IStatus}`;
+  reason?: string;
+  pitchDeck?: string;
+  demoVideo?: string;
+  trackExplanations?: Array<{
+    trackId: string;
+    trackName: string;
+    explanation: string;
+  }>;
+}
+
+export class GrantUpdate
+  extends Attestation<IGrantUpdate>
+  implements IGrantUpdate
+{
+  title: string;
+  text: string;
+  proofOfWork: string;
+  pitchDeck?: string;
+  demoVideo?: string;
+  trackExplanations?: Array<{
+    trackId: string;
+    trackName: string;
+    explanation: string;
+  }>;
+  verified: GrantUpdateStatus[] = [];
+
+  /**
+   * Attest the status of the milestone as approved, rejected or completed.
+   */
+  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 GrantUpdate. If the GrantUpdate is not already verified,
+   * it will throw an error.
+   * @param signer
+   * @param reason
+   */
+  async verify(
+    signer: SignerOrProvider,
+    data?: IGrantUpdateStatus,
+    callback?: Function
+  ) {
+    console.log("Verifying");
+
+    const schema = this.schema.gap.findSchema("GrantUpdateStatus");
+
+    if (this.schema.isJsonSchema()) {
+      schema.setValue(
+        "json",
+        JSON.stringify({
+          type: "grant-update-verified",
+          ...data,
+        })
+      );
+    } else {
+      schema.setValue("type", "grant-update-verified");
+      schema.setValue("reason", data?.reason || "");
+    }
+
+    console.log("Before attest grant update verified");
+    const { tx, uids } = await this.attestStatus(signer, schema, callback);
+    console.log("After attest grant update verified");
+
+    this.verified.push(
+      new GrantUpdateStatus({
+        data: {
+          type: "grant-update-verified",
+          ...data,
+        },
+        refUID: this.uid,
+        schema: schema,
+        recipient: this.recipient,
+      })
+    );
+
+    return {
+      tx,
+      uids,
+    };
+  }
+
+  static from(attestations: _IGrantUpdate[], network: TNetwork): GrantUpdate[] {
+    return attestations.map((attestation) => {
+      const grantUpdate = new GrantUpdate({
+        ...attestation,
+        data: {
+          ...attestation.data,
+        },
+        schema: new AllGapSchemas().findSchema(
+          "GrantUpdate",
+          chainIdToNetwork[attestation.chainID] as TNetwork
+        ),
+        chainID: attestation.chainID,
+      });
+
+      if (attestation.verified?.length > 0) {
+        grantUpdate.verified = attestation.verified.map(
+          (m) =>
+            new GrantUpdateStatus({
+              ...m,
+              data: {
+                ...m.data,
+              },
+              schema: new AllGapSchemas().findSchema(
+                "GrantUpdateStatus",
+                chainIdToNetwork[attestation.chainID] as TNetwork
+              ),
+              chainID: attestation.chainID,
+            })
+        );
+      }
+
+      return grantUpdate;
+    });
+  }
+}

package/core/class/entities/MemberOf.ts

@@ -0,0 +1,52 @@
+import { Hex, MultiAttestPayload, SignerOrProvider } from "core/types";
+import { Attestation } from "../Attestation";
+import { AttestationWithTx, MemberDetails } from "../types/attestations";
+import { AttestationError } from "../SchemaError";
+import { GapContract } from "../contract/GapContract";
+
+export interface IMemberOf {
+  memberOf: true;
+}
+
+export class MemberOf extends Attestation<IMemberOf> {
+  details?: MemberDetails;
+
+  async multiAttestPayload(
+    currentPayload: MultiAttestPayload = [],
+    projectIdx = 0
+  ) {
+    const payload = [...currentPayload];
+    const memberIdx =
+      payload.push([this, await this.payloadFor(projectIdx)]) - 1;
+
+    if (this.details) {
+      payload.push([this.details, await this.details.payloadFor(memberIdx)]);
+    }
+
+    return payload.slice(currentPayload.length, payload.length);
+  }
+
+  async attest(
+    signer: SignerOrProvider,
+    callback?: Function
+  ): Promise<AttestationWithTx> {
+    const payload = await this.multiAttestPayload();
+    try {
+      const { uids, tx } = await GapContract.multiAttest(
+        signer,
+        payload.map((p) => p[1]),
+        callback
+      );
+      const [memberUID, detailsUID] = uids;
+
+      this.uid = memberUID as Hex;
+      if (this.details && detailsUID) {
+        this.details.uid = detailsUID as Hex;
+      }
+      return { tx, uids };
+    } catch (error) {
+      console.error(error);
+      throw new AttestationError("ATTEST_ERROR", error.message, error);
+    }
+  }
+}