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

package/core/class/entities/Grant.ts

@@ -1,321 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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);
-    }
-  }
-}