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

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 {};

package/core/class/entities/ProjectMilestone.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectMilestone = exports.ProjectMilestoneStatus = void 0;
+const Attestation_1 = require("../Attestation");
+const SchemaError_1 = require("../SchemaError");
+const AllGapSchemas_1 = require("../AllGapSchemas");
+const consts_1 = require("../../../core/consts");
+const attestations_1 = require("../types/attestations");
+class ProjectMilestoneStatus extends Attestation_1.Attestation {
+}
+exports.ProjectMilestoneStatus = ProjectMilestoneStatus;
+class ProjectMilestone extends Attestation_1.Attestation {
+    constructor(data) {
+        data.data.type = "project-milestone";
+        super(data);
+        this.verified = [];
+    }
+    /**
+     * Attest the status of the update as approved, rejected or completed.
+     */
+    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 ProjectUpdate. If the ProjectUpdate is not already verified,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    async verify(signer, data, callback) {
+        console.log("Verifying");
+        const schema = this.schema.gap.findSchema("ProjectMilestoneStatus");
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "verified",
+                reason: data?.reason || "",
+            }));
+        }
+        else {
+            schema.setValue("type", "project-milestone-verified");
+            schema.setValue("reason", data?.reason || "");
+        }
+        console.log("Before attest project milestone verified");
+        await this.attestStatus(signer, schema, callback);
+        console.log("After attest project milestone verified");
+        this.verified.push(new ProjectMilestoneStatus({
+            data: {
+                type: "project-milestone-verified",
+                reason: data?.reason || "",
+            },
+            refUID: this.uid,
+            schema: schema,
+            recipient: this.recipient,
+        }));
+    }
+    /**
+     * Marks a milestone as completed. If the milestone is already completed,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    async complete(signer, data, callback) {
+        console.log("Completing");
+        const schema = this.schema.gap.findSchema("ProjectMilestoneStatus");
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "project-milestone-completed",
+                ...data,
+            }));
+        }
+        else {
+            schema.setValue("type", "project-milestone-completed");
+            schema.setValue("proofOfWork", data?.proofOfWork || "");
+            schema.setValue("reason", data?.reason || "");
+        }
+        console.log("Before attest project milestone completed");
+        const { tx, uids } = await this.attestStatus(signer, schema, callback);
+        console.log("After attest project milestone completed");
+        this.completed = new attestations_1.MilestoneCompleted({
+            data: {
+                reason: data?.reason || "",
+            },
+            refUID: this.uid,
+            schema: schema,
+            recipient: this.recipient,
+        });
+        return { tx, uids };
+    }
+    /**
+     * Revokes the completed status of the milestone. If the milestone is not completed,
+     * it will throw an error.
+     * @param signer
+     */
+    async revokeCompletion(signer, callback) {
+        if (!this.completed)
+            throw new SchemaError_1.AttestationError("ATTEST_ERROR", "Milestone is not completed");
+        const { tx, uids } = await this.completed.schema.multiRevoke(signer, [
+            {
+                schemaId: this.completed.schema.uid,
+                uid: this.completed.uid,
+            },
+        ], callback);
+        return { tx, uids };
+    }
+    static from(attestations, network) {
+        return attestations.map((attestation) => {
+            const projectMilestone = new ProjectMilestone({
+                ...attestation,
+                data: {
+                    ...attestation.data,
+                },
+                schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectMilestone", consts_1.chainIdToNetwork[attestation.chainID]),
+                chainID: attestation.chainID,
+            });
+            if (attestation.verified?.length > 0) {
+                projectMilestone.verified = attestation.verified.map((m) => new ProjectMilestoneStatus({
+                    ...m,
+                    data: {
+                        ...m.data,
+                        type: m.data.type === "completed"
+                            ? "project-milestone-completed"
+                            : "project-milestone-verified",
+                    },
+                    schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectMilestoneStatus", consts_1.chainIdToNetwork[attestation.chainID]),
+                    chainID: attestation.chainID,
+                }));
+            }
+            if (attestation.completed) {
+                projectMilestone.completed = new attestations_1.MilestoneCompleted({
+                    ...attestation.completed,
+                    data: {
+                        ...attestation.completed.data,
+                    },
+                    schema: new AllGapSchemas_1.AllGapSchemas().findSchema("MilestoneCompleted", consts_1.chainIdToNetwork[attestation.chainID]),
+                    chainID: attestation.chainID,
+                });
+            }
+            return projectMilestone;
+        });
+    }
+}
+exports.ProjectMilestone = ProjectMilestone;

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

@@ -0,0 +1,12 @@
+import { TNetwork } from "../../../core/types";
+import { Attestation } from "../Attestation";
+export interface _IProjectPointer extends ProjectPointer {
+}
+export interface IProjectPointer {
+    ogProjectUID: string;
+    type?: string;
+}
+export declare class ProjectPointer extends Attestation<IProjectPointer> implements IProjectPointer {
+    ogProjectUID: string;
+    static from(attestations: _IProjectPointer[], network: TNetwork): ProjectPointer[];
+}

package/core/class/entities/ProjectPointer.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectPointer = void 0;
+const Attestation_1 = require("../Attestation");
+const AllGapSchemas_1 = require("../AllGapSchemas");
+const consts_1 = require("../../../core/consts");
+class ProjectPointer extends Attestation_1.Attestation {
+    static from(attestations, network) {
+        return attestations.map((attestation) => {
+            const projectUpdate = new ProjectPointer({
+                ...attestation,
+                data: {
+                    ...attestation.data,
+                },
+                schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectUpdate", consts_1.chainIdToNetwork[attestation.chainID]),
+                chainID: attestation.chainID,
+            });
+            return projectUpdate;
+        });
+    }
+}
+exports.ProjectPointer = ProjectPointer;

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

@@ -0,0 +1,50 @@
+import { SignerOrProvider, TNetwork } from "../../../core/types";
+import { Attestation } from "../Attestation";
+export interface _IProjectUpdate extends ProjectUpdate {
+}
+export interface IProjectUpdate {
+    title: string;
+    text: string;
+    startDate?: Date;
+    endDate?: Date;
+    type?: string;
+    grants?: string[];
+    indicators?: {
+        name: string;
+        indicatorId: string;
+    }[];
+    deliverables?: {
+        name: string;
+        proof: string;
+        description: string;
+    }[];
+}
+type IStatus = "verified";
+export interface IProjectUpdateStatus {
+    type?: `project-update-${IStatus}`;
+    reason?: string;
+    proofOfWork?: string;
+}
+export declare class ProjectUpdateStatus extends Attestation<IProjectUpdateStatus> implements IProjectUpdateStatus {
+    type: `project-update-${IStatus}`;
+    reason?: string;
+    proofOfWork?: string;
+}
+export declare class ProjectUpdate extends Attestation<IProjectUpdate> implements IProjectUpdate {
+    title: string;
+    text: string;
+    verified: ProjectUpdateStatus[];
+    /**
+     * 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?: IProjectUpdateStatus, callback?: Function): Promise<void>;
+    static from(attestations: _IProjectUpdate[], network: TNetwork): ProjectUpdate[];
+}
+export {};

package/core/class/entities/ProjectUpdate.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectUpdate = exports.ProjectUpdateStatus = void 0;
+const Attestation_1 = require("../Attestation");
+const SchemaError_1 = require("../SchemaError");
+const AllGapSchemas_1 = require("../AllGapSchemas");
+const consts_1 = require("../../../core/consts");
+class ProjectUpdateStatus extends Attestation_1.Attestation {
+}
+exports.ProjectUpdateStatus = ProjectUpdateStatus;
+class ProjectUpdate extends Attestation_1.Attestation {
+    constructor() {
+        super(...arguments);
+        this.verified = [];
+    }
+    /**
+     * Attest the status of the update as approved, rejected or completed.
+     */
+    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 ProjectUpdate. If the ProjectUpdate is not already verified,
+     * it will throw an error.
+     * @param signer
+     * @param reason
+     */
+    async verify(signer, data, callback) {
+        console.log("Verifying");
+        const schema = this.schema.gap.findSchema("ProjectUpdateStatus");
+        if (this.schema.isJsonSchema()) {
+            schema.setValue("json", JSON.stringify({
+                type: "verified",
+                reason: data?.reason || "",
+            }));
+        }
+        else {
+            schema.setValue("type", "project-update-verified");
+            schema.setValue("reason", data?.reason || "");
+        }
+        console.log("Before attest project update verified");
+        await this.attestStatus(signer, schema, callback);
+        console.log("After attest project update verified");
+        this.verified.push(new ProjectUpdateStatus({
+            data: {
+                type: "project-update-verified",
+                reason: data?.reason || "",
+            },
+            refUID: this.uid,
+            schema: schema,
+            recipient: this.recipient,
+        }));
+    }
+    static from(attestations, network) {
+        return attestations.map((attestation) => {
+            const projectUpdate = new ProjectUpdate({
+                ...attestation,
+                data: {
+                    ...attestation.data,
+                },
+                schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectUpdate", consts_1.chainIdToNetwork[attestation.chainID]),
+                chainID: attestation.chainID,
+            });
+            if (attestation.verified?.length > 0) {
+                projectUpdate.verified = attestation.verified.map((m) => new ProjectUpdateStatus({
+                    ...m,
+                    data: {
+                        ...m.data,
+                    },
+                    schema: new AllGapSchemas_1.AllGapSchemas().findSchema("ProjectUpdateStatus", consts_1.chainIdToNetwork[attestation.chainID]),
+                    chainID: attestation.chainID,
+                }));
+            }
+            return projectUpdate;
+        });
+    }
+}
+exports.ProjectUpdate = ProjectUpdate;

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

@@ -0,0 +1,16 @@
+import { TNetwork } from "core/types";
+import { ITrackResponse } from "../karma-indexer/api/types";
+export declare class Track {
+    id: string;
+    name: string;
+    description?: string;
+    communityUID: string;
+    isArchived: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    programId?: string;
+    isActive?: boolean;
+    network: TNetwork;
+    constructor(data: any, network: TNetwork);
+    static from(data: ITrackResponse[], network: TNetwork): Track[];
+}

package/core/class/entities/Track.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Track = void 0;
+class Track {
+    constructor(data, network) {
+        this.id = data.id;
+        this.name = data.name;
+        this.description = data.description;
+        this.communityUID = data.communityUID;
+        this.isArchived = data.isArchived ?? false;
+        this.createdAt = new Date(data.createdAt);
+        this.updatedAt = new Date(data.updatedAt);
+        this.programId = data.programId;
+        this.isActive = data.isActive;
+        this.network = network;
+    }
+    static from(data, network) {
+        return data.map((item) => new Track(item, network));
+    }
+}
+exports.Track = Track;

package/core/class/entities/index.js

@@ -0,0 +1,26 @@
+"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);
+__exportStar(require("./GrantUpdate"), exports);
+__exportStar(require("./ProjectUpdate"), exports);
+__exportStar(require("./ProjectPointer"), exports);
+__exportStar(require("./ContributorProfile"), exports);
+__exportStar(require("./Track"), exports);

package/core/class/index.js

@@ -0,0 +1,26 @@
+"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("./Fetcher"), exports);
+__exportStar(require("./karma-indexer/GapIndexerClient"), exports);
+__exportStar(require("./remote-storage/IpfsStorage"), exports);
+__exportStar(require("./remote-storage/RemoteStorage"), exports);

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

@@ -0,0 +1,66 @@
+import { TSchemaName, IAttestation, Hex } from "core/types";
+import { Attestation } from "../Attestation";
+import { GapSchema } from "../GapSchema";
+import { Fetcher } from "../Fetcher";
+import { Community, Project, Grant, Milestone, MemberOf, Track } from "../entities";
+import { Grantee } from "../types/attestations";
+import { ICommunityAdminsResponse } from "./api/types";
+import { ProjectMilestone } from "../entities/ProjectMilestone";
+export declare class GapIndexerClient extends Fetcher {
+    private apiClient;
+    constructor(params: any);
+    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[]>;
+    communitiesOf(address: Hex, withGrants: boolean): Promise<Community[]>;
+    adminOf(address: Hex): Promise<Community[]>;
+    communitiesAdminOf(address: Hex, withGrants: boolean): Promise<Community[]>;
+    communitiesByIds(uids: `0x${string}`[]): Promise<Community[]>;
+    communityBySlug(slug: string): Promise<Community>;
+    communityById(uid: `0x${string}`): Promise<Community>;
+    communityAdmins(uid: `0x${string}`): Promise<ICommunityAdminsResponse>;
+    projectBySlug(slug: string): Promise<Project>;
+    projectById(uid: `0x${string}`): Promise<Project>;
+    search(query: string): Promise<{
+        projects: Project[];
+        communities: Community[];
+    }>;
+    searchProjects(query: string): Promise<Project[]>;
+    projects(name?: string): Promise<Project[]>;
+    projectsOf(grantee: `0x${string}`): Promise<Project[]>;
+    projectMilestones(uidOrSlug: string): Promise<ProjectMilestone[]>;
+    grantee(address: `0x${string}`): Promise<Grantee>;
+    grantees(): Promise<Grantee[]>;
+    grantsOf(grantee: `0x${string}`, withCommunity?: boolean): Promise<Grant[]>;
+    grantsFor(projects: Project[], withCommunity?: boolean): Promise<Grant[]>;
+    grantsForExtProject(projectExtId: string): Promise<Grant[]>;
+    grantsByCommunity(uid: `0x${string}`, page?: number, pageLimit?: number): Promise<Grant[]>;
+    milestonesOf(grants: Grant[]): Promise<Milestone[]>;
+    membersOf(projects: Project[]): Promise<MemberOf[]>;
+    slugExists(slug: string): Promise<boolean>;
+    /**
+     * Track related methods
+     */
+    getTracks(communityUID: string, includeArchived?: boolean): Promise<Track[]>;
+    getTrackById(id: string): Promise<Track>;
+    createTrack(trackData: {
+        name: string;
+        description?: string;
+        communityUID: string;
+    }): Promise<Track>;
+    updateTrack(id: string, trackData: {
+        name?: string;
+        description?: string;
+        communityUID?: string;
+    }): Promise<Track>;
+    archiveTrack(id: string): Promise<Track>;
+    assignTracksToProgram(programId: string, trackIds: string[]): Promise<any[]>;
+    unassignTrackFromProgram(programId: string, trackId: string): Promise<any>;
+    getTracksForProgram(programId: string): Promise<Track[]>;
+    getTracksForProject(projectId: string, programId: string, activeOnly?: boolean): Promise<Track[]>;
+    assignTracksToProject(projectId: string, programId: string, trackIds: string[]): Promise<any[]>;
+    unassignTracksFromProject(projectId: string, programId: string, trackIds: string[]): Promise<any[]>;
+    getProjectsByTrack(communityId: string, programId: string, trackId?: string): Promise<any[]>;
+}