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

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

@@ -0,0 +1,92 @@
+import { Hex, MultiAttestPayload, SignerOrProvider, TNetwork } from "core/types";
+import { Attestation } from "../Attestation";
+import { IProjectResponse } from "../karma-indexer/api/types";
+import { AttestationWithTx, Grantee, MemberDetails, ProjectDetails, ProjectEndorsement } from "../types/attestations";
+import { Grant } from "./Grant";
+import { MemberOf } from "./MemberOf";
+import { IProjectImpact, ProjectImpact } from "./ProjectImpact";
+import { ProjectMilestone } from "./ProjectMilestone";
+import { ProjectPointer } from "./ProjectPointer";
+import { ProjectUpdate } from "./ProjectUpdate";
+export interface IProject {
+    project: true;
+}
+export declare class Project extends Attestation<IProject> {
+    details?: ProjectDetails;
+    members: MemberOf[];
+    grants: Grant[];
+    grantee: Grantee;
+    impacts: ProjectImpact[];
+    endorsements: ProjectEndorsement[];
+    updates: ProjectUpdate[];
+    pointers: ProjectPointer[];
+    milestones: ProjectMilestone[];
+    /**
+     * 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 communityIdx
+     */
+    multiAttestPayload(currentPayload?: MultiAttestPayload, communityIdx?: number): Promise<MultiAttestPayload>;
+    attest(signer: SignerOrProvider, callback?: Function): Promise<AttestationWithTx>;
+    transferOwnership(signer: SignerOrProvider, newOwner: Hex, callback?: Function): Promise<AttestationWithTx>;
+    isOwner(signer: SignerOrProvider, publicAddress?: string): Promise<boolean>;
+    isAdmin(signer: SignerOrProvider, publicAddress?: string): Promise<boolean>;
+    /**
+     * Add new members to the project.
+     * If any member in the array already exists in the project
+     * it'll be ignored.
+     * @param members
+     */
+    pushMembers(...members: Hex[]): void;
+    /**
+     * Add new members to the project.
+     * If any member in the array already exists in the project
+     * it'll be ignored.
+     *
+     * __To modify member details, use `addMemberDetails(signer, MemberDetails[])` instead.__
+     * @param signer
+     * @param members
+     */
+    attestMembers(signer: SignerOrProvider, members: MemberDetails[], callback?: Function): Promise<void>;
+    /**
+     * Add new details to the members of a project. Note that it will overwrite
+     * any existing details.
+     *
+     * @param signer
+     * @param entities
+     */
+    private addMemberDetails;
+    /**
+     * Clean member details.
+     * @param signer
+     * @param uids
+     */
+    cleanDetails(signer: SignerOrProvider, uids: Hex[]): Promise<void>;
+    /**
+     * Remove members from the project.
+     * @param signer
+     * @param uids
+     * @returns
+     */
+    removeMembers(signer: SignerOrProvider, uids: Hex[]): Promise<void>;
+    /**
+     * Remove all members from the project.
+     * @param signer
+     */
+    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: IProjectImpact, targetChainId?: number, callback?: Function): Promise<AttestationWithTx>;
+    private attestGhostProjectImpact;
+    attestEndorsement(signer: SignerOrProvider, data?: ProjectEndorsement): Promise<void>;
+    attestGhostProject(signer: SignerOrProvider, targetChainId: number): Promise<AttestationWithTx>;
+    addAdmin(signer: SignerOrProvider, newAdmin: Hex, callback?: Function): Promise<AttestationWithTx>;
+    removeAdmin(signer: SignerOrProvider, oldAdmin: Hex, callback?: Function): Promise<AttestationWithTx>;
+}

package/core/class/entities/Project.js

@@ -0,0 +1,418 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = void 0;
+const consts_1 = require("../../consts");
+const utils_1 = require("../../utils");
+const AllGapSchemas_1 = require("../AllGapSchemas");
+const Attestation_1 = require("../Attestation");
+const GapContract_1 = require("../contract/GapContract");
+const SchemaError_1 = require("../SchemaError");
+const attestations_1 = require("../types/attestations");
+const Grant_1 = require("./Grant");
+const MemberOf_1 = require("./MemberOf");
+const ProjectImpact_1 = require("./ProjectImpact");
+const ProjectMilestone_1 = require("./ProjectMilestone");
+const ProjectPointer_1 = require("./ProjectPointer");
+const ProjectUpdate_1 = require("./ProjectUpdate");
+class Project extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.members = [];
+        this.grants = [];
+        this.impacts = [];
+        this.endorsements = [];
+        this.updates = [];
+        this.pointers = [];
+        this.milestones = [];
+    }
+    /**
+     * 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 communityIdx
+     */
+    async multiAttestPayload(currentPayload = [], communityIdx = 0) {
+        const payload = [...currentPayload];
+        const projectIdx = payload.push([this, await this.payloadFor(communityIdx)]) - 1;
+        if (this.details) {
+            payload.push([this.details, await this.details.payloadFor(projectIdx)]);
+        }
+        if (this.members?.length) {
+            await Promise.all(this.members.map(async (m) => payload.push(...(await m.multiAttestPayload(payload, projectIdx)))));
+        }
+        if (this.grants?.length) {
+            await Promise.all(this.grants.map(async (g) => payload.push(...(await g.multiAttestPayload(payload, projectIdx)))));
+        }
+        return payload.slice(currentPayload.length, payload.length);
+    }
+    async attest(signer, callback) {
+        const payload = await this.multiAttestPayload();
+        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");
+        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, publicAddress) {
+        return GapContract_1.GapContract.isProjectOwner(signer, this.uid, this.chainID, publicAddress);
+    }
+    isAdmin(signer, publicAddress) {
+        return GapContract_1.GapContract.isProjectAdmin(signer, this.uid, this.chainID, publicAddress);
+    }
+    /**
+     * Add new members to the project.
+     * If any member in the array already exists in the project
+     * it'll be ignored.
+     * @param members
+     */
+    pushMembers(...members) {
+        this.members.push(...(0, utils_1.mapFilter)(members, (member) => !!this.members.find((m) => m.recipient === member), (member) => new MemberOf_1.MemberOf({
+            data: { memberOf: true },
+            refUID: this.uid,
+            schema: this.schema.gap.findSchema("MemberOf"),
+            recipient: member,
+            uid: consts_1.nullRef,
+        })));
+    }
+    /**
+     * Add new members to the project.
+     * If any member in the array already exists in the project
+     * it'll be ignored.
+     *
+     * __To modify member details, use `addMemberDetails(signer, MemberDetails[])` instead.__
+     * @param signer
+     * @param members
+     */
+    async attestMembers(signer, members, callback) {
+        const newMembers = (0, utils_1.mapFilter)(members, (member) => !this.members.find((m) => m.recipient === member.recipient), 
+        // (member) => !!member,
+        (details) => {
+            const member = new MemberOf_1.MemberOf({
+                data: { memberOf: true },
+                refUID: this.uid,
+                schema: this.schema.gap.findSchema("MemberOf"),
+                createdAt: Date.now(),
+                recipient: details.recipient,
+                uid: consts_1.nullRef,
+            });
+            return { member, details };
+        });
+        if (!newMembers.length) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "No new members to add.");
+        }
+        console.log(`Creating ${newMembers.length} new members`);
+        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] });
+            if (!details)
+                return;
+            Object.assign(details, { refUID: attestedMembers[idx] });
+        });
+        this.members.push(...newMembers.map((m) => m.member));
+        await this.addMemberDetails(signer, newMembers.map((m) => m.details));
+    }
+    /**
+     * Add new details to the members of a project. Note that it will overwrite
+     * any existing details.
+     *
+     * @param signer
+     * @param entities
+     */
+    async addMemberDetails(signer, entities, callback) {
+        // Check if any of members should be revoked (details modified)
+        const toRevoke = (0, utils_1.mapFilter)(this.members, (member) => !!entities.find((entity) => member.uid === entity.refUID &&
+            member.details &&
+            member.details?.refUID !== entity.refUID), (member) => member.uid);
+        if (toRevoke.length) {
+            console.log("Revoking details");
+            await this.cleanDetails(signer, toRevoke);
+        }
+        console.log(`Creating ${entities.length} new member details`);
+        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);
+            if (!member)
+                return;
+            Object.assign(entity, { uid: attestedEntities[idx] });
+            member.details = entity;
+        });
+    }
+    /**
+     * Clean member details.
+     * @param signer
+     * @param uids
+     */
+    async cleanDetails(signer, uids) {
+        if (!uids.length) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "No details to clean.");
+        }
+        const memberDetails = this.schema.gap.findSchema("MemberDetails");
+        await this.schema.multiRevoke(signer, uids.map((uid) => ({ schemaId: memberDetails.uid, uid })));
+        this.members.forEach((member) => {
+            if (!member.details)
+                return;
+            if (uids.includes(member.details.uid)) {
+                member.details = undefined;
+            }
+        });
+    }
+    /**
+     * Remove members from the project.
+     * @param signer
+     * @param uids
+     * @returns
+     */
+    async removeMembers(signer, uids) {
+        if (!uids.length) {
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "No members to remove.");
+        }
+        const memberOf = this.schema.gap.findSchema("MemberOf");
+        const details = (0, utils_1.mapFilter)(this.members, (m) => uids.includes(m.uid) && !!m.details, (m) => m.details?.uid);
+        if (details.length) {
+            await this.cleanDetails(signer, details);
+        }
+        await this.schema.multiRevoke(signer, uids.map((uid) => ({ schemaId: memberOf.uid, uid })));
+        this.members = this.members.filter((m) => !uids.includes(m.uid));
+    }
+    /**
+     * Remove all members from the project.
+     * @param signer
+     */
+    async removeAllMembers(signer) {
+        const members = (0, utils_1.mapFilter)(this.members, (m) => !!m.uid, (m) => m.uid);
+        if (!members.length) {
+            throw new SchemaError_1.AttestationError("REVOKATION_ERROR", "No members to revoke.");
+        }
+        const details = (0, utils_1.mapFilter)(this.members, (m) => !!m.details, (m) => m.details?.uid);
+        if (details.length) {
+            await this.cleanDetails(signer, details);
+        }
+        await this.removeMembers(signer, members);
+        this.members.splice(0, this.members.length);
+    }
+    static from(attestations, network) {
+        const allSchemas = new AllGapSchemas_1.AllGapSchemas();
+        return attestations.map((attestation) => {
+            const project = new Project({
+                ...attestation,
+                data: {
+                    project: true,
+                },
+                schema: allSchemas.findSchema("Project", consts_1.chainIdToNetwork[attestation.chainID]),
+                chainID: attestation.chainID,
+            });
+            if (attestation.details) {
+                const { details } = attestation;
+                project.details = new attestations_1.ProjectDetails({
+                    ...details,
+                    data: {
+                        ...details.data,
+                    },
+                    schema: allSchemas.findSchema("ProjectDetails", consts_1.chainIdToNetwork[attestation.chainID]),
+                    chainID: attestation.chainID,
+                });
+                project.details.links = details.data.links || [];
+                project.details.tags = details.data.tags || [];
+                if (attestation.data.links) {
+                    project.details.links = attestation.data.links;
+                }
+                if (attestation.data.tags) {
+                    project.details.tags = attestation.tags;
+                }
+            }
+            if (attestation.members) {
+                project.members = attestation.members.map((m) => {
+                    const member = new MemberOf_1.MemberOf({
+                        ...m,
+                        data: {
+                            memberOf: true,
+                        },
+                        schema: allSchemas.findSchema("MemberOf", consts_1.chainIdToNetwork[attestation.chainID]),
+                        chainID: attestation.chainID,
+                    });
+                    if (m.details) {
+                        const { details } = m;
+                        member.details = new attestations_1.MemberDetails({
+                            ...details,
+                            data: {
+                                ...details.data,
+                            },
+                            schema: allSchemas.findSchema("MemberDetails", consts_1.chainIdToNetwork[attestation.chainID]),
+                            chainID: attestation.chainID,
+                        });
+                    }
+                    return member;
+                });
+            }
+            if (attestation.grants) {
+                project.grants = Grant_1.Grant.from(attestation.grants, network);
+            }
+            if (attestation.impacts) {
+                project.impacts = ProjectImpact_1.ProjectImpact.from(attestation.impacts, network);
+            }
+            if (attestation.pointers) {
+                project.pointers = ProjectPointer_1.ProjectPointer.from(attestation.pointers, network);
+            }
+            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({
+                        ...pi,
+                        data: {
+                            ...pi.data,
+                        },
+                        schema: allSchemas.findSchema("ProjectDetails", consts_1.chainIdToNetwork[attestation.chainID]),
+                        chainID: attestation.chainID,
+                    });
+                    return endorsement;
+                });
+            }
+            return project;
+        });
+    }
+    async attestUpdate(signer, data, callback) {
+        const projectUpdate = new ProjectUpdate_1.ProjectUpdate({
+            data: {
+                ...data,
+                type: "project-update",
+            },
+            recipient: this.recipient,
+            refUID: this.uid,
+            schema: this.schema.gap.findSchema("ProjectUpdate"),
+        });
+        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: {
+                ...data,
+                type: "project-pointer",
+            },
+            recipient: this.recipient,
+            refUID: this.uid,
+            schema: this.schema.gap.findSchema("ProjectPointer"),
+        });
+        await projectPointer.attest(signer, callback);
+        this.pointers.push(projectPointer);
+    }
+    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,
+                type: "project-impact",
+            },
+            recipient: this.recipient,
+            refUID: this.uid,
+            schema: this.schema.gap.findSchema("ProjectDetails"),
+        });
+        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({
+            data: {
+                ...data,
+                type: "project-endorsement",
+            },
+            recipient: this.recipient,
+            refUID: this.uid,
+            schema: this.schema.gap.findSchema("ProjectDetails"),
+        });
+        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;
+    }
+    async addAdmin(signer, newAdmin, callback) {
+        callback?.("preparing");
+        const tx = await GapContract_1.GapContract.addProjectAdmin(signer, this.uid, newAdmin);
+        callback?.("confirmed");
+        const txArray = [tx].flat();
+        return { tx: txArray, uids: [this.uid] };
+    }
+    async removeAdmin(signer, oldAdmin, callback) {
+        callback?.("preparing");
+        const tx = await GapContract_1.GapContract.removeProjectAdmin(signer, this.uid, oldAdmin);
+        callback?.("confirmed");
+        const txArray = [tx].flat();
+        return { tx: txArray, uids: [this.uid] };
+    }
+}
+exports.Project = Project;

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

@@ -0,0 +1,50 @@
+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}`;
+    reason?: string;
+}
+export declare 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 declare 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>);
+    /**
+     * Attest Project Impact.
+     */
+    private attestStatus;
+    /**
+     * Verify this ProjectImpact. If the ProjectImpact is not already verified,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectImpact = exports.ProjectImpactStatus = void 0;
+const Attestation_1 = require("../Attestation");
+const SchemaError_1 = require("../SchemaError");
+const AllGapSchemas_1 = require("../AllGapSchemas");
+const consts_1 = require("../../consts");
+class ProjectImpactStatus extends Attestation_1.Attestation {
+}
+exports.ProjectImpactStatus = ProjectImpactStatus;
+class ProjectImpact extends Attestation_1.Attestation {
+    constructor(data) {
+        data.data.type = "project-impact";
+        super(data);
+        this.verified = [];
+    }
+    /**
+     * Attest Project Impact.
+     */
+    async attestStatus(signer, schema, callback) {
+        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,
+                    },
+                ],
+                uids: [uid],
+            };
+        }
+        catch (error) {
+            console.error(error);
+            throw new SchemaError_1.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, data, callback) {
+        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, network) {
+        return attestations.map((attestation) => {
+            const projectImpact = new ProjectImpact({
+                ...attestation,
+                data: {
+                    ...attestation.data,
+                },
+                schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectImpact", consts_1.chainIdToNetwork[attestation.chainID]),
+                chainID: attestation.chainID,
+            });
+            if (attestation.verified?.length > 0) {
+                projectImpact.verified = attestation.verified.map((m) => new ProjectImpactStatus({
+                    ...m,
+                    data: {
+                        ...m.data,
+                    },
+                    schema: new AllGapSchemas_1.AllGapSchemas().findSchema("GrantUpdateStatus", consts_1.chainIdToNetwork[attestation.chainID]),
+                    chainID: attestation.chainID,
+                }));
+            }
+            return projectImpact;
+        });
+    }
+}
+exports.ProjectImpact = ProjectImpact;