@show-karma/karma-gap-sdk 0.3.4 → 0.3.5

package/core/class/entities/Grant.ts

@@ -1,309 +0,0 @@
-import { Attestation } from '../Attestation';
-import {
-  GrantDetails,
-  GrantRound,
-  GrantUpdate,
-  IGrantUpdate,
-  GrantCompleted,
-  ProjectDetails,
-} from '../types/attestations';
-import { IMilestone, Milestone } from './Milestone';
-import { GapSchema } from '../GapSchema';
-import { GAP } from '../GAP';
-import { AttestationError } from '../SchemaError';
-import { nullRef } from '../../consts';
-import {
-  Hex,
-  MultiAttestPayload,
-  SignerOrProvider,
-  TNetwork,
-} from 'core/types';
-import { GapContract } from '../contract/GapContract';
-import { Community } from './Community';
-import { Project } from './Project';
-
-interface _Grant extends Grant {}
-
-export interface IGrant {
-  communityUID: Hex;
-}
-
-export interface ISummaryProject {
-  title: string;
-  slug?: string;
-  uid: 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?: 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);
-    }
-  }
-
-  /**
-   * 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(currentPayload, 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];
-
-    await project.attest(signer);
-  }
-
-  /**
-   * @inheritdoc
-   */
-  async attest(
-    signer: SignerOrProvider,
-    projectChainId: number
-  ): Promise<void> {
-    if (projectChainId !== this.chainID) {
-      return this.attestProject(signer, projectChainId);
-    }
-    this.assertPayload();
-    const payload = await this.multiAttestPayload();
-
-    const uids = await GapContract.multiAttest(
-      signer,
-      payload.map((p) => p[1])
-    );
-
-    uids.forEach((uid, index) => {
-      payload[index][0].uid = uid;
-    });
-
-    console.log(uids);
-  }
-
-  async attestUpdate(signer: SignerOrProvider, data: IGrantUpdate) {
-    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);
-    this.updates.push(grantUpdate);
-  }
-
-  async complete(signer: SignerOrProvider, data: IGrantUpdate) {
-    const completed = new GrantCompleted({
-      data: {
-        ...data,
-        type: 'grant-completed',
-      },
-      recipient: this.recipient,
-      refUID: this.uid,
-      schema: this.schema.gap.findSchema('GrantDetails'),
-    });
-
-    await completed.attest(signer);
-    this.completed = completed;
-  }
-
-  /**
-   * 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;
-  }
-
-  static from(attestations: _Grant[], network: TNetwork): Grant[] {
-    return attestations.map((attestation) => {
-      const grant = new Grant({
-        ...attestation,
-        data: {
-          communityUID: attestation.data.communityUID,
-        },
-        schema: GapSchema.find('Grant', network),
-        chainID: attestation.chainID,
-      });
-
-      if (attestation.details) {
-        const { details } = attestation;
-        grant.details = new GrantDetails({
-          ...details,
-          data: {
-            ...details.data,
-          },
-          schema: GapSchema.find('GrantDetails', network),
-          chainID: attestation.chainID,
-        });
-      }
-
-      if (attestation.milestones) {
-        const { milestones } = attestation;
-        grant.milestones = Milestone.from(milestones, network);
-      }
-
-      if (attestation.updates) {
-        const { updates } = attestation;
-        grant.updates = updates.map(
-          (u) =>
-            new GrantUpdate({
-              ...u,
-              data: {
-                ...u.data,
-              },
-              schema: GapSchema.find('GrantDetails', network),
-              chainID: attestation.chainID,
-            })
-        );
-      }
-
-      if (attestation.completed) {
-        const { completed } = attestation;
-        grant.completed = new GrantCompleted({
-          ...completed,
-          data: {
-            ...completed.data,
-          },
-          schema: GapSchema.find('GrantDetails', network),
-          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/MemberOf.ts

@@ -1,42 +0,0 @@
-import { MultiAttestPayload, SignerOrProvider } from "core/types";
-import { Attestation } from "../Attestation";
-import { 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) {
-    const payload = await this.multiAttestPayload();
-    try {
-      const [memberUID, detailsUID] = await GapContract.multiAttest(
-        signer,
-        payload.map((p) => p[1])
-      );
-
-      this.uid = memberUID;
-      if (this.details && detailsUID) {
-        this.details.uid = detailsUID;
-      }
-    } catch (error) {
-      console.error(error);
-      throw new AttestationError("ATTEST_ERROR", error.message);
-    }
-  }
-}

package/core/class/entities/Milestone.ts

@@ -1,269 +0,0 @@
-import { MultiAttestPayload, SignerOrProvider, TNetwork } from '../../types';
-import { Attestation } from '../Attestation';
-import { GAP } from '../GAP';
-import { GapSchema } from '../GapSchema';
-import { AttestationError } from '../SchemaError';
-import { GapContract } from '../contract/GapContract';
-import { MilestoneCompleted } from '../types/attestations';
-
-interface _Milestone extends Milestone {}
-
-export interface IMilestone {
-  title: string;
-  endsAt: number;
-  description: string;
-}
-export class Milestone extends Attestation<IMilestone> implements IMilestone {
-  title: string;
-  endsAt: number;
-  description: string;
-  completed: MilestoneCompleted;
-  approved: MilestoneCompleted;
-  rejected: MilestoneCompleted;
-
-  /**
-   * Approves this milestone. If the milestone is not completed or already approved,
-   * it will throw an error.
-   * @param signer
-   * @param reason
-   */
-  async approve(signer: SignerOrProvider, reason = '') {
-    if (!this.completed)
-      throw new AttestationError('ATTEST_ERROR', 'Milestone is not completed');
-
-    const schema = this.schema.gap.findSchema('MilestoneCompleted');
-    schema.setValue('type', 'approved');
-    schema.setValue('reason', reason);
-
-    await this.attestStatus(signer, schema);
-
-    this.approved = new MilestoneCompleted({
-      data: {
-        type: 'approved',
-        reason,
-      },
-      refUID: this.uid,
-      schema: schema,
-      recipient: this.recipient,
-    });
-  }
-
-  /**
-   * Revokes the approved status of the milestone. If the milestone is not approved,
-   * it will throw an error.
-   * @param signer
-   */
-  async revokeApproval(signer: SignerOrProvider) {
-    if (!this.approved)
-      throw new AttestationError('ATTEST_ERROR', 'Milestone is not approved');
-
-    await this.approved.schema.multiRevoke(signer, [
-      {
-        schemaId: this.completed.schema.uid,
-        uid: this.completed.uid,
-      },
-    ]);
-  }
-
-  /**
-   * Reject a completed milestone. If the milestone is not completed or already rejected,
-   * it will throw an error.
-   * @param signer
-   * @param reason
-   */
-  async reject(signer: SignerOrProvider, reason = '') {
-    if (!this.completed)
-      throw new AttestationError('ATTEST_ERROR', 'Milestone is not completed');
-
-    const schema = this.schema.gap.findSchema('MilestoneCompleted');
-    schema.setValue('type', 'rejected');
-    schema.setValue('reason', reason);
-    await this.attestStatus(signer, schema);
-
-    this.rejected = new MilestoneCompleted({
-      data: {
-        type: 'rejected',
-        reason,
-      },
-      refUID: this.uid,
-      schema: schema,
-      recipient: this.recipient,
-    });
-  }
-
-  /**
-   * Revokes the rejected status of the milestone. If the milestone is not rejected,
-   * it will throw an error.
-   * @param signer
-   */
-  async revokeRejection(signer: SignerOrProvider) {
-    if (!this.rejected)
-      throw new AttestationError('ATTEST_ERROR', 'Milestone is not rejected');
-
-    await this.rejected.schema.multiRevoke(signer, [
-      {
-        schemaId: this.completed.schema.uid,
-        uid: this.completed.uid,
-      },
-    ]);
-  }
-
-  /**
-   * Marks a milestone as completed. If the milestone is already completed,
-   * it will throw an error.
-   * @param signer
-   * @param reason
-   */
-  async complete(signer: SignerOrProvider, reason = '') {
-    const schema = this.schema.gap.findSchema('MilestoneCompleted');
-    schema.setValue('type', 'completed');
-    schema.setValue('reason', reason);
-
-    await this.attestStatus(signer, schema);
-    this.completed = new MilestoneCompleted({
-      data: {
-        type: 'completed',
-        reason,
-      },
-      refUID: this.uid,
-      schema,
-      recipient: this.recipient,
-    });
-  }
-
-  /**
-   * Revokes the completed status of the milestone. If the milestone is not completed,
-   * it will throw an error.
-   * @param signer
-   */
-  async revokeCompletion(signer: SignerOrProvider) {
-    if (!this.completed)
-      throw new AttestationError('ATTEST_ERROR', 'Milestone is not completed');
-
-    await this.completed.schema.multiRevoke(signer, [
-      {
-        schemaId: this.completed.schema.uid,
-        uid: this.completed.uid,
-      },
-    ]);
-  }
-
-  /**
-   * 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 grantIdx
-   */
-  async multiAttestPayload(
-    currentPayload: MultiAttestPayload = [],
-    grantIdx = 0
-  ) {
-    this.assertPayload();
-    const payload = [...currentPayload];
-    const milestoneIdx =
-      payload.push([this, await this.payloadFor(grantIdx)]) - 1;
-    if (this.completed) {
-      payload.push([
-        this.completed,
-        await this.completed.payloadFor(milestoneIdx),
-      ]);
-    }
-    return payload.slice(currentPayload.length, payload.length);
-  }
-
-  /**
-   * @inheritdoc
-   */
-  async attest(signer: SignerOrProvider): Promise<void> {
-    this.assertPayload();
-    const payload = await this.multiAttestPayload();
-
-    const uids = await GapContract.multiAttest(
-      signer,
-      payload.map((p) => p[1])
-    );
-
-    uids.forEach((uid, index) => {
-      payload[index][0].uid = uid;
-    });
-
-    console.log(uids);
-  }
-
-  /**
-   * Attest the status of the milestone as approved, rejected or completed.
-   */
-  private async attestStatus(signer: SignerOrProvider, schema: GapSchema) {
-    const eas = this.schema.gap.eas.connect(signer);
-    try {
-      const tx = await eas.attest({
-        schema: schema.uid,
-        data: {
-          recipient: this.recipient,
-          data: schema.encode(),
-          refUID: this.uid,
-          expirationTime: 0n,
-          revocable: schema.revocable,
-        },
-      });
-
-      const uid = await tx.wait();
-      console.log(uid);
-    } catch (error: any) {
-      console.error(error);
-      throw new AttestationError('ATTEST_ERROR', error.message);
-    }
-  }
-
-  static from(attestations: _Milestone[], network: TNetwork): Milestone[] {
-    return attestations.map((attestation) => {
-      const milestone = new Milestone({
-        ...attestation,
-        data: {
-          ...attestation.data,
-        },
-        schema: GapSchema.find('Milestone', network),
-        chainID: attestation.chainID,
-      });
-
-      if (attestation.completed) {
-        milestone.completed = new MilestoneCompleted({
-          ...attestation.completed,
-          data: {
-            ...attestation.completed.data,
-          },
-          schema: GapSchema.find('MilestoneCompleted', network),
-          chainID: attestation.chainID,
-        });
-      }
-
-      if (attestation.approved) {
-        milestone.approved = new MilestoneCompleted({
-          ...attestation.approved,
-          data: {
-            ...attestation.completed.data,
-          },
-          schema: GapSchema.find('MilestoneCompleted', network),
-          chainID: attestation.chainID,
-        });
-      }
-
-      if (attestation.rejected) {
-        milestone.rejected = new MilestoneCompleted({
-          ...attestation.rejected,
-          data: {
-            ...attestation.completed.data,
-          },
-          schema: GapSchema.find('MilestoneCompleted', network),
-          chainID: attestation.chainID,
-        });
-      }
-
-      return milestone;
-    });
-  }
-}