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

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

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

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

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

@@ -1,112 +0,0 @@
-"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;