@show-karma/karma-gap-sdk 0.3.43 → 0.3.45

package/core/class/entities/Milestone.js

@@ -19,17 +19,26 @@ class Milestone extends Attestation_1.Attestation {
      * @param signer
      * @param reason
      */
-    async approve(signer, reason = "", callback) {
+    async approve(signer, data, callback) {
         if (!this.completed)
             throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
         const schema = this.schema.gap.findSchema("MilestoneCompleted");
-        schema.setValue("type", "approved");
-        schema.setValue("reason", reason);
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "approved",
+                ...data,
+            }));
+        }
+        else {
+            schema.setValue("type", "approved");
+            schema.setValue("reason", data?.reason || "");
+            schema.setValue("proofOfWork", data?.proofOfWork || "");
+        }
         await this.attestStatus(signer, schema, callback);
         this.approved = new attestations_1.MilestoneCompleted({
             data: {
                 type: "approved",
-                reason,
+                reason: data?.reason || "",
             },
             refUID: this.uid,
             schema: schema,
@@ -82,12 +91,13 @@ class Milestone extends Attestation_1.Attestation {
     async revokeRejection(signer) {
         if (!this.rejected)
             throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not rejected");
-        await this.rejected.schema.multiRevoke(signer, [
+        const { tx, uids } = await this.rejected.schema.multiRevoke(signer, [
             {
                 schemaId: this.completed.schema.uid,
                 uid: this.completed.uid,
             },
         ]);
+        return { tx, uids };
     }
     /**
      * Marks a milestone as completed. If the milestone is already completed,
@@ -95,20 +105,30 @@ class Milestone extends Attestation_1.Attestation {
      * @param signer
      * @param reason
      */
-    async complete(signer, reason = "", callback) {
+    async complete(signer, data, callback) {
         const schema = this.schema.gap.findSchema("MilestoneCompleted");
-        schema.setValue("type", "completed");
-        schema.setValue("reason", reason);
-        await this.attestStatus(signer, schema, callback);
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "completed",
+                ...data,
+            }));
+        }
+        else {
+            schema.setValue("type", "completed");
+            schema.setValue("reason", data?.reason || "");
+            schema.setValue("proofOfWork", data?.proofOfWork || "");
+        }
+        const { tx, uids } = await this.attestStatus(signer, schema, callback);
         this.completed = new attestations_1.MilestoneCompleted({
             data: {
                 type: "completed",
-                reason,
+                ...data,
             },
             refUID: this.uid,
             schema,
             recipient: this.recipient,
         });
+        return { tx, uids };
     }
     /**
      * Revokes the completed status of the milestone. If the milestone is not completed,
@@ -118,12 +138,13 @@ class Milestone extends Attestation_1.Attestation {
     async revokeCompletion(signer, callback) {
         if (!this.completed)
             throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
-        await this.completed.schema.multiRevoke(signer, [
+        const { tx, uids } = await this.completed.schema.multiRevoke(signer, [
             {
                 schemaId: this.completed.schema.uid,
                 uid: this.completed.uid,
             },
         ], callback);
+        return { tx, uids };
     }
     /**
      * Creates the payload for a multi-attestation.
@@ -161,11 +182,14 @@ class Milestone extends Attestation_1.Attestation {
     async attest(signer, callback) {
         this.assertPayload();
         const payload = await this.multiAttestPayload();
-        const uids = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]), callback);
-        uids.forEach((uid, index) => {
-            payload[index][0].uid = uid;
-        });
+        const { uids, tx } = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]), callback);
+        if (Array.isArray(uids)) {
+            uids.forEach((uid, index) => {
+                payload[index][0].uid = uid;
+            });
+        }
         console.log(uids);
+        return { tx, uids };
     }
     /**
      * Attest the status of the milestone as approved, rejected or completed.
@@ -191,10 +215,18 @@ class Milestone extends Attestation_1.Attestation {
             if (callback)
                 callback("confirmed");
             console.log(uid);
+            return {
+                tx: [
+                    {
+                        hash: tx.tx.hash,
+                    },
+                ],
+                uids: [uid],
+            };
         }
         catch (error) {
             console.error(error);
-            throw new SchemaError_1.AttestationError("ATTEST_ERROR", error.message);
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", error.message, error);
         }
     }
     static from(attestations, network) {
@@ -256,25 +288,35 @@ class Milestone extends Attestation_1.Attestation {
      * @param signer
      * @param reason
      */
-    async verify(signer, reason = "", callback) {
+    async verify(signer, data, callback) {
         console.log("Verifying");
         if (!this.completed)
             throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
         const schema = this.schema.gap.findSchema("MilestoneCompleted");
-        schema.setValue("type", "verified");
-        schema.setValue("reason", reason);
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "verified",
+                ...data,
+            }));
+        }
+        else {
+            schema.setValue("type", "verified");
+            schema.setValue("reason", data?.reason || "");
+            schema.setValue("proofOfWork", data?.proofOfWork || "");
+        }
         console.log("Before attestStatus");
-        await this.attestStatus(signer, schema, callback);
+        const { tx, uids } = await this.attestStatus(signer, schema, callback);
         console.log("After attestStatus");
         this.verified.push(new attestations_1.MilestoneCompleted({
             data: {
                 type: "verified",
-                reason,
+                ...data,
             },
             refUID: this.uid,
             schema: schema,
             recipient: this.recipient,
         }));
+        return { tx, uids };
     }
 }
 exports.Milestone = Milestone;

package/core/class/entities/Project.d.ts

@@ -1,12 +1,13 @@
 import { Attestation } from "../Attestation";
-import { Grantee, MemberDetails, ProjectDetails, ProjectEndorsement } from "../types/attestations";
+import { AttestationWithTx, Grantee, MemberDetails, ProjectDetails, ProjectEndorsement } from "../types/attestations";
 import { Hex, MultiAttestPayload, SignerOrProvider, TNetwork } from "core/types";
 import { Grant } from "./Grant";
 import { MemberOf } from "./MemberOf";
 import { IProjectResponse } from "../karma-indexer/api/types";
-import { ProjectImpact } from "./ProjectImpact";
+import { IProjectImpact, ProjectImpact } from "./ProjectImpact";
 import { ProjectUpdate } from "./ProjectUpdate";
 import { ProjectPointer } from "./ProjectPointer";
+import { ProjectMilestone } from "./ProjectMilestone";
 export interface IProject {
     project: true;
 }
@@ -19,6 +20,7 @@ export declare class Project extends Attestation<IProject> {
     endorsements: ProjectEndorsement[];
     updates: ProjectUpdate[];
     pointers: ProjectPointer[];
+    milestones: ProjectMilestone[];
     /**
      * Creates the payload for a multi-attestation.
      *
@@ -30,8 +32,8 @@ export declare class Project extends Attestation<IProject> {
      * @param communityIdx
      */
     multiAttestPayload(currentPayload?: MultiAttestPayload, communityIdx?: number): Promise<MultiAttestPayload>;
-    attest(signer: SignerOrProvider, callback?: Function): Promise<void>;
-    transferOwnership(signer: SignerOrProvider, newOwner: Hex, callback?: Function): Promise<void>;
+    attest(signer: SignerOrProvider, callback?: Function): Promise<AttestationWithTx>;
+    transferOwnership(signer: SignerOrProvider, newOwner: Hex, callback?: Function): Promise<AttestationWithTx>;
     isOwner(signer: SignerOrProvider): Promise<boolean>;
     /**
      * Add new members to the project.
@@ -78,7 +80,10 @@ export declare class Project extends Attestation<IProject> {
     removeAllMembers(signer: SignerOrProvider): Promise<void>;
     static from(attestations: IProjectResponse[], network: TNetwork): Project[];
     attestUpdate(signer: SignerOrProvider, data: ProjectUpdate, callback?: Function): Promise<void>;
+    attestMilestone(signer: SignerOrProvider, data: ProjectUpdate, callback?: Function): Promise<void>;
     attestPointer(signer: SignerOrProvider, data: ProjectPointer, callback?: Function): Promise<void>;
-    attestImpact(signer: SignerOrProvider, data: ProjectImpact): Promise<void>;
+    attestImpact(signer: SignerOrProvider, data: IProjectImpact, targetChainId?: number, callback?: Function): Promise<AttestationWithTx>;
+    private attestGhostProjectImpact;
     attestEndorsement(signer: SignerOrProvider, data?: ProjectEndorsement): Promise<void>;
+    attestGhostProject(signer: SignerOrProvider, targetChainId: number): Promise<AttestationWithTx>;
 }

package/core/class/entities/Project.js

@@ -13,6 +13,7 @@ const AllGapSchemas_1 = require("../AllGapSchemas");
 const ProjectImpact_1 = require("./ProjectImpact");
 const ProjectUpdate_1 = require("./ProjectUpdate");
 const ProjectPointer_1 = require("./ProjectPointer");
+const ProjectMilestone_1 = require("./ProjectMilestone");
 class Project extends Attestation_1.Attestation {
     constructor() {
         super(...arguments);
@@ -22,6 +23,7 @@ class Project extends Attestation_1.Attestation {
         this.endorsements = [];
         this.updates = [];
         this.pointers = [];
+        this.milestones = [];
     }
     /**
      * Creates the payload for a multi-attestation.
@@ -49,15 +51,20 @@ class Project extends Attestation_1.Attestation {
     }
     async attest(signer, callback) {
         const payload = await this.multiAttestPayload();
-        const uids = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]), callback);
-        uids.forEach((uid, index) => {
-            payload[index][0].uid = uid;
-        });
+        const { tx, uids } = await GapContract_1.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 transferOwnership(signer, newOwner, callback) {
         callback?.("preparing");
-        await GapContract_1.GapContract.transferProjectOwnership(signer, this.uid, newOwner);
+        const tx = await GapContract_1.GapContract.transferProjectOwnership(signer, this.uid, newOwner);
         callback?.("confirmed");
+        const txArray = [tx].flat();
+        return { tx: txArray, uids: [this.uid] };
     }
     isOwner(signer) {
         return GapContract_1.GapContract.isProjectOwner(signer, this.uid, this.chainID);
@@ -104,7 +111,7 @@ class Project extends Attestation_1.Attestation {
             throw new SchemaError_1.AttestationError("ATTEST_ERROR", "No new members to add.");
         }
         console.log(`Creating ${newMembers.length} new members`);
-        const attestedMembers = await this.schema.multiAttest(signer, newMembers.map((m) => m.member), callback);
+        const { uids: attestedMembers } = await this.schema.multiAttest(signer, newMembers.map((m) => m.member), callback);
         console.log("attested-members", attestedMembers);
         newMembers.forEach(({ member, details }, idx) => {
             Object.assign(member, { uid: attestedMembers[idx] });
@@ -132,7 +139,7 @@ class Project extends Attestation_1.Attestation {
             await this.cleanDetails(signer, toRevoke);
         }
         console.log(`Creating ${entities.length} new member details`);
-        const attestedEntities = await this.schema.multiAttest(signer, entities, callback);
+        const { uids: attestedEntities } = await this.schema.multiAttest(signer, entities, callback);
         console.log("attested-entities", attestedEntities);
         entities.forEach((entity, idx) => {
             const member = this.members.find((member) => member.uid === entity.refUID);
@@ -260,6 +267,9 @@ class Project extends Attestation_1.Attestation {
             if (attestation.updates) {
                 project.updates = ProjectUpdate_1.ProjectUpdate.from(attestation.updates, network);
             }
+            if (attestation.milestones) {
+                project.milestones = ProjectMilestone_1.ProjectMilestone.from(attestation.milestones, network);
+            }
             if (attestation.endorsements) {
                 project.endorsements = attestation.endorsements.map((pi) => {
                     const endorsement = new attestations_1.ProjectEndorsement({
@@ -289,6 +299,19 @@ class Project extends Attestation_1.Attestation {
         await projectUpdate.attest(signer, callback);
         this.updates.push(projectUpdate);
     }
+    async attestMilestone(signer, data, callback) {
+        const projectMilestone = new ProjectMilestone_1.ProjectMilestone({
+            data: {
+                ...data,
+                type: "project-milestone",
+            },
+            recipient: this.recipient,
+            refUID: this.uid,
+            schema: this.schema.gap.findSchema("ProjectMilestone"),
+        });
+        await projectMilestone.attest(signer, callback);
+        this.milestones.push(projectMilestone);
+    }
     async attestPointer(signer, data, callback) {
         const projectPointer = new ProjectPointer_1.ProjectPointer({
             data: {
@@ -302,7 +325,10 @@ class Project extends Attestation_1.Attestation {
         await projectPointer.attest(signer, callback);
         this.pointers.push(projectPointer);
     }
-    async attestImpact(signer, data) {
+    async attestImpact(signer, data, targetChainId, callback) {
+        if (targetChainId && targetChainId !== this.chainID) {
+            return this.attestGhostProjectImpact(signer, data, targetChainId, callback);
+        }
         const projectImpact = new ProjectImpact_1.ProjectImpact({
             data: {
                 ...data,
@@ -312,8 +338,30 @@ class Project extends Attestation_1.Attestation {
             refUID: this.uid,
             schema: this.schema.gap.findSchema("ProjectDetails"),
         });
-        await projectImpact.attest(signer);
+        const { tx, uids } = await projectImpact.attest(signer, callback);
+        this.impacts.push(projectImpact);
+        return { tx, uids };
+    }
+    async attestGhostProjectImpact(signer, data, targetChainId, callback) {
+        const { tx, uids } = await this.attestGhostProject(signer, targetChainId);
+        const ghostProjectUid = uids[0];
+        const allGapSchemas = new AllGapSchemas_1.AllGapSchemas();
+        const projectImpact = new ProjectImpact_1.ProjectImpact({
+            data: {
+                ...data,
+                type: "project-impact",
+            },
+            recipient: this.recipient,
+            refUID: ghostProjectUid,
+            schema: allGapSchemas.findSchema("ProjectDetails", consts_1.chainIdToNetwork[targetChainId]),
+            chainID: targetChainId,
+        });
+        const impactAttestation = await projectImpact.attest(signer, callback);
         this.impacts.push(projectImpact);
+        return {
+            tx: impactAttestation.tx,
+            uids: [...uids, impactAttestation.uids[0]],
+        };
     }
     async attestEndorsement(signer, data) {
         const projectEndorsement = new attestations_1.ProjectEndorsement({
@@ -328,5 +376,25 @@ class Project extends Attestation_1.Attestation {
         await projectEndorsement.attest(signer);
         this.endorsements.push(projectEndorsement);
     }
+    async attestGhostProject(signer, targetChainId) {
+        const allGapSchemas = new AllGapSchemas_1.AllGapSchemas();
+        const project = new Project({
+            data: { project: true },
+            schema: allGapSchemas.findSchema("Project", consts_1.chainIdToNetwork[targetChainId]),
+            recipient: this.recipient,
+            chainID: targetChainId,
+        });
+        project.details = new Attestation_1.Attestation({
+            data: {
+                originalProjectChainId: this.chainID,
+                uid: this.uid,
+            },
+            chainID: targetChainId,
+            recipient: this.recipient,
+            schema: allGapSchemas.findSchema("ProjectDetails", consts_1.chainIdToNetwork[targetChainId]),
+        });
+        const attestation = await project.attest(signer);
+        return attestation;
+    }
 }
 exports.Project = Project;

package/core/class/entities/ProjectImpact.d.ts

@@ -1,11 +1,12 @@
 import { SignerOrProvider, TNetwork } from "../../types";
 import { Attestation, AttestationArgs } from "../Attestation";
 import { GapSchema } from "../GapSchema";
+import { Transaction } from "ethers";
 export interface _IProjectImpact extends ProjectImpact {
 }
 type IStatus = "verified";
 export interface IProjectImpactStatus {
-    type: `project-impact-${IStatus}`;
+    type?: `project-impact-${IStatus}`;
     reason?: string;
 }
 export declare class ProjectImpactStatus extends Attestation<IProjectImpactStatus> implements IProjectImpactStatus {
@@ -19,7 +20,7 @@ export interface IProjectImpact {
     startedAt?: number;
     completedAt: number;
     type?: string;
-    verified: ProjectImpactStatus[];
+    verified?: ProjectImpactStatus[];
 }
 export declare class ProjectImpact extends Attestation<IProjectImpact> implements IProjectImpact {
     work: string;
@@ -40,7 +41,10 @@ export declare class ProjectImpact extends Attestation<IProjectImpact> implement
      * @param signer
      * @param reason
      */
-    verify(signer: SignerOrProvider, reason?: string, callback?: Function): Promise<void>;
+    verify(signer: SignerOrProvider, data?: IProjectImpactStatus, callback?: Function): Promise<{
+        tx: Transaction[];
+        uids: `0x${string}`[];
+    }>;
     static from(attestations: ProjectImpact[], network: TNetwork): ProjectImpact[];
 }
 export {};

package/core/class/entities/ProjectImpact.js

@@ -38,10 +38,18 @@ class ProjectImpact extends Attestation_1.Attestation {
             if (callback)
                 callback("confirmed");
             console.log(uid);
+            return {
+                tx: [
+                    {
+                        hash: tx.tx.hash,
+                    },
+                ],
+                uids: [uid],
+            };
         }
         catch (error) {
             console.error(error);
-            throw new SchemaError_1.AttestationError("ATTEST_ERROR", error.message);
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", error.message, error);
         }
     }
     /**
@@ -50,23 +58,32 @@ class ProjectImpact extends Attestation_1.Attestation {
      * @param signer
      * @param reason
      */
-    async verify(signer, reason = "", callback) {
+    async verify(signer, data, callback) {
         console.log("Verifying ProjectImpact");
         const schema = this.schema.gap.findSchema("GrantUpdateStatus");
-        schema.setValue("type", "project-impact-verified");
-        schema.setValue("reason", reason);
+        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");
-        await this.attestStatus(signer, schema, callback);
+        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,
+                reason: data?.reason || '',
             },
             refUID: this.uid,
             schema: schema,
             recipient: this.recipient,
         }));
+        return { tx, uids };
     }
     static from(attestations, network) {
         return attestations.map((attestation) => {

package/core/class/entities/ProjectMilestone.d.ts

@@ -0,0 +1,60 @@
+import { SignerOrProvider, TNetwork } from "../../../core/types";
+import { Attestation, AttestationArgs } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { Transaction } from "ethers";
+import { IProjectMilestoneResponse } from "../karma-indexer/api/types";
+import { 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 declare class ProjectMilestoneStatus extends Attestation<IProjectMilestoneStatus> implements IProjectMilestoneStatus {
+    type: `project-milestone-${IStatus}`;
+    reason?: string;
+}
+export declare class ProjectMilestone extends Attestation<IProjectMilestone> implements IProjectMilestone {
+    title: string;
+    text: string;
+    verified: ProjectMilestoneStatus[];
+    completed: ProjectMilestoneCompleted;
+    constructor(data: AttestationArgs<IProjectMilestone, GapSchema>);
+    /**
+     * Attest the status of the update as approved, rejected or completed.
+     */
+    private attestStatus;
+    /**
+     * Verify this ProjectUpdate. If the ProjectUpdate is not already verified,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    verify(signer: SignerOrProvider, data?: IProjectMilestoneStatus, callback?: Function): Promise<void>;
+    /**
+     * Marks a milestone as completed. If the milestone is already completed,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    complete(signer: SignerOrProvider, data?: IProjectMilestoneStatus, callback?: Function): Promise<{
+        tx: Transaction[];
+        uids: `0x${string}`[];
+    }>;
+    /**
+     * Revokes the completed status of the milestone. If the milestone is not completed,
+     * it will throw an error.
+     * @param signer
+     */
+    revokeCompletion(signer: SignerOrProvider, callback?: Function): Promise<{
+        tx: Transaction[];
+        uids: `0x${string}`[];
+    }>;
+    static from(attestations: IProjectMilestoneResponse[], network: TNetwork): ProjectMilestone[];
+}
+export {};