@show-karma/karma-gap-sdk 0.1.29

package/core/class/entities/Milestone.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Milestone = void 0;
+const Attestation_1 = require("../Attestation");
+const GAP_1 = require("../GAP");
+const GapSchema_1 = require("../GapSchema");
+const SchemaError_1 = require("../SchemaError");
+const attestations_1 = require("../types/attestations");
+class Milestone extends Attestation_1.Attestation {
+    /**
+     * Approves this milestone. If the milestone is not completed or already approved,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    async approve(signer, reason = "") {
+        if (!this.completed)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
+        const schema = GapSchema_1.GapSchema.find("MilestoneCompleted");
+        schema.setValue("type", "approved");
+        schema.setValue("reason", reason);
+        await this.attestStatus(signer, schema);
+        this.approved = new attestations_1.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) {
+        if (!this.approved)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not approved");
+        await this.approved.revoke(signer);
+    }
+    /**
+     * 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, reason = "") {
+        if (!this.completed)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
+        const schema = GapSchema_1.GapSchema.find("MilestoneCompleted");
+        schema.setValue("type", "rejected");
+        schema.setValue("reason", reason);
+        await this.attestStatus(signer, schema);
+        this.rejected = new attestations_1.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) {
+        if (!this.rejected)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not rejected");
+        await this.rejected.revoke(signer);
+    }
+    /**
+     * Marks a milestone as completed. If the milestone is already completed,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    async complete(signer, reason = "") {
+        const schema = GapSchema_1.GapSchema.find("MilestoneCompleted");
+        schema.setValue("type", "completed");
+        schema.setValue("reason", reason);
+        await this.attestStatus(signer, schema);
+        this.completed = new attestations_1.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) {
+        if (!this.completed)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
+        await this.completed.revoke(signer);
+    }
+    /**
+     * Attest the status of the milestone as approved, rejected or completed.
+     */
+    async attestStatus(signer, schema) {
+        const eas = GAP_1.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) {
+            console.error(error);
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", error.message);
+        }
+    }
+    static from(attestations) {
+        return attestations.map((attestation) => {
+            const milestone = new Milestone({
+                ...attestation,
+                data: {
+                    ...attestation.data,
+                },
+                schema: GapSchema_1.GapSchema.find("Milestone"),
+            });
+            if (attestation.completed) {
+                milestone.completed = new attestations_1.MilestoneCompleted({
+                    ...attestation.completed,
+                    data: {
+                        ...attestation.completed.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find("MilestoneCompleted"),
+                });
+            }
+            if (attestation.approved) {
+                milestone.approved = new attestations_1.MilestoneCompleted({
+                    ...attestation.approved,
+                    data: {
+                        ...attestation.completed.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find("MilestoneCompleted"),
+                });
+            }
+            if (attestation.rejected) {
+                milestone.rejected = new attestations_1.MilestoneCompleted({
+                    ...attestation.rejected,
+                    data: {
+                        ...attestation.completed.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find("MilestoneCompleted"),
+                });
+            }
+            return milestone;
+        });
+    }
+}
+exports.Milestone = Milestone;

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

@@ -0,0 +1,73 @@
+import { Attestation } from "../Attestation";
+import { Grantee, MemberDetails, ProjectDetails } from "../types/attestations";
+import { Hex, MultiAttestPayload, SignerOrProvider } from "core/types";
+import { Grant } from "./Grant";
+import { MemberOf } from "./MemberOf";
+interface _Project extends Project {
+}
+export interface IProject {
+    project: true;
+}
+export declare class Project extends Attestation<IProject> {
+    details?: ProjectDetails;
+    members: MemberOf[];
+    grants: Grant[];
+    grantee: Grantee;
+    /**
+     * 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): MultiAttestPayload;
+    attest(signer: SignerOrProvider): Promise<void>;
+    /**
+     * 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[]): 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: _Project[]): Project[];
+}
+export {};

package/core/class/entities/Project.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Project = void 0;
+const Attestation_1 = require("../Attestation");
+const attestations_1 = require("../types/attestations");
+const GapSchema_1 = require("../GapSchema");
+const SchemaError_1 = require("../SchemaError");
+const utils_1 = require("../../utils");
+const Grant_1 = require("./Grant");
+const consts_1 = require("../../consts");
+const MemberOf_1 = require("./MemberOf");
+const GapContract_1 = require("../contract/GapContract");
+class Project extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.members = [];
+        this.grants = [];
+    }
+    /**
+     * 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 = [], communityIdx = 0) {
+        const payload = [...currentPayload];
+        const projectIdx = payload.push([this, this.payloadFor(communityIdx)]) - 1;
+        if (this.details) {
+            payload.push([this.details, this.details.payloadFor(projectIdx)]);
+        }
+        if (this.members?.length) {
+            this.members.forEach((m) => {
+                payload.push(...m.multiAttestPayload(payload, projectIdx));
+            });
+        }
+        if (this.grants?.length) {
+            this.grants.forEach((g) => {
+                payload.push(...g.multiAttestPayload(payload, projectIdx));
+            });
+        }
+        return payload.slice(currentPayload.length, payload.length);
+    }
+    async attest(signer) {
+        const payload = this.multiAttestPayload();
+        const uids = await GapContract_1.GapContract.multiAttest(signer, payload.map((p) => p[1]));
+        uids.forEach((uid, index) => {
+            payload[index][0].uid = uid;
+        });
+    }
+    /**
+     * 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: GapSchema_1.GapSchema.find("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) {
+        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: GapSchema_1.GapSchema.find("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 attestedMembers = await this.schema.multiAttest(signer, newMembers.map((m) => m.member));
+        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) {
+        // 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 attestedEntities = (await this.schema.multiAttest(signer, entities));
+        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 = GapSchema_1.GapSchema.find("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 = GapSchema_1.GapSchema.find("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) {
+        return attestations.map((attestation) => {
+            const project = new Project({
+                ...attestation,
+                data: {
+                    project: true,
+                },
+                schema: GapSchema_1.GapSchema.find("Project"),
+            });
+            if (attestation.details) {
+                const { details } = attestation;
+                project.details = new attestations_1.ProjectDetails({
+                    ...details,
+                    data: {
+                        ...details.data,
+                    },
+                    schema: GapSchema_1.GapSchema.find("ProjectDetails"),
+                });
+                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: GapSchema_1.GapSchema.find("MemberOf"),
+                    });
+                    if (m.details) {
+                        const { details } = m;
+                        member.details = new attestations_1.MemberDetails({
+                            ...details,
+                            data: {
+                                ...details.data,
+                            },
+                            schema: GapSchema_1.GapSchema.find("MemberDetails"),
+                        });
+                    }
+                    return member;
+                });
+            }
+            if (attestation.grants) {
+                project.grants = Grant_1.Grant.from(attestation.grants);
+            }
+            return project;
+        });
+    }
+}
+exports.Project = Project;

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

@@ -0,0 +1,5 @@
+export * from "./Grant";
+export * from "./Milestone";
+export * from "./Project";
+export * from "./Community";
+export * from "./MemberOf";

package/core/class/entities/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Grant"), exports);
+__exportStar(require("./Milestone"), exports);
+__exportStar(require("./Project"), exports);
+__exportStar(require("./Community"), exports);
+__exportStar(require("./MemberOf"), exports);

package/core/class/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Attestation";
+export * from "./GAP";
+export * from "./GapSchema";
+export * from "./Schema";
+export * from "./SchemaError";
+export * from "./entities";
+export * from "./karma-indexer/GapIndexerClient";

package/core/class/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Attestation"), exports);
+__exportStar(require("./GAP"), exports);
+__exportStar(require("./GapSchema"), exports);
+__exportStar(require("./Schema"), exports);
+__exportStar(require("./SchemaError"), exports);
+__exportStar(require("./entities"), exports);
+__exportStar(require("./karma-indexer/GapIndexerClient"), exports);

package/core/class/karma-indexer/GapIndexerClient.d.ts

@@ -0,0 +1,28 @@
+import { TSchemaName, IAttestation } from "core/types";
+import { Attestation } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { Fetcher } from "../Fetcher";
+import { Community, Project, Grant, Milestone, MemberOf } from "../entities";
+import { Grantee } from "../types/attestations";
+export declare class GapIndexerClient extends Fetcher {
+    attestation<T = unknown>(uid: `0x${string}`): Promise<Attestation<T, GapSchema>>;
+    attestations(schemaName: TSchemaName, search?: string): Promise<IAttestation[]>;
+    attestationsOf(schemaName: TSchemaName, attester: `0x${string}`): Promise<IAttestation[]>;
+    attestationsTo(schemaName: TSchemaName, recipient: `0x${string}`): Promise<IAttestation[]>;
+    communities(search?: string): Promise<Community[]>;
+    communitiesByIds(uids: `0x${string}`[]): Promise<Community[]>;
+    communityBySlug(slug: string): Promise<Community>;
+    communityById(uid: `0x${string}`): Promise<Community>;
+    projectBySlug(slug: string): Promise<Project>;
+    projectById(uid: `0x${string}`): Promise<Project>;
+    projects(name?: string): Promise<Project[]>;
+    projectsOf(grantee: `0x${string}`): Promise<Project[]>;
+    grantee(address: `0x${string}`): Promise<Grantee>;
+    grantees(): Promise<Grantee[]>;
+    grantsOf(grantee: `0x${string}`, withCommunity?: boolean): Promise<Grant[]>;
+    grantsFor(projects: Project[], withCommunity?: boolean): Promise<Grant[]>;
+    grantsByCommunity(uid: `0x${string}`): Promise<Grant[]>;
+    milestonesOf(grants: Grant[]): Promise<Milestone[]>;
+    membersOf(projects: Project[]): Promise<MemberOf[]>;
+    slugExists(slug: string): Promise<boolean>;
+}