@show-karma/karma-gap-sdk 0.3.22 → 0.3.24

package/core/class/Attestation.js

@@ -194,7 +194,7 @@ class Attestation {
                 this._data.type = this.type;
                 this.schema.setValue('json', JSON.stringify(this._data));
             }
-            if (remoteClient) {
+            if (remoteClient && JSON.stringify(this._data)?.length > 1500) {
                 const cid = await remoteClient.save(this._data, this.schema.name);
                 const encodedData = remoteClient.encode(cid);
                 this.schema.setValue('json', JSON.stringify(encodedData));

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

@@ -3,8 +3,7 @@ import { CommunityDetails, ICommunityDetails } from '../types/attestations';
 import { Project } from './Project';
 import { MultiAttestPayload, SignerOrProvider, TNetwork } from 'core/types';
 import { Grant } from './Grant';
-interface _Community extends Community {
-}
+import { ICommunityResponse } from '../karma-indexer/api/types';
 export interface ICommunity {
     community: true;
 }
@@ -31,6 +30,5 @@ export declare class Community extends Attestation<ICommunity> {
      * @param details
      */
     attest(signer: SignerOrProvider, details?: ICommunityDetails): Promise<void>;
-    static from(attestations: _Community[], network: TNetwork): Community[];
+    static from(attestations: ICommunityResponse[], network: TNetwork): Community[];
 }
-export {};

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

@@ -4,9 +4,8 @@ import { IMilestone, Milestone } from './Milestone';
 import { GapSchema } from '../GapSchema';
 import { Hex, MultiAttestPayload, SignerOrProvider, TNetwork } from 'core/types';
 import { Community } from './Community';
+import { IGrantResponse } from '../karma-indexer/api/types';
 import { GrantUpdate, IGrantUpdate } from './GrantUpdate';
-interface _Grant extends Grant {
-}
 export interface IGrant {
     communityUID: Hex;
 }
@@ -56,6 +55,5 @@ export declare class Grant extends Attestation<IGrant> {
      * Validate if the grant has a valid reference to a community.
      */
     protected assertPayload(): boolean;
-    static from(attestations: _Grant[], network: TNetwork): Grant[];
+    static from(attestations: IGrantResponse[], network: TNetwork): Grant[];
 }
-export {};

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

@@ -1,6 +1,6 @@
 import { SignerOrProvider, TNetwork } from '../../../core/types';
 import { Attestation } from '../Attestation';
-interface _IGrantUpdate extends GrantUpdate {
+export interface _IGrantUpdate extends GrantUpdate {
 }
 export interface IGrantUpdate {
     title: string;

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

@@ -1,9 +1,8 @@
 import { MultiAttestPayload, SignerOrProvider, TNetwork } from '../../types';
 import { Attestation } from '../Attestation';
 import { GapSchema } from '../GapSchema';
+import { IMilestoneResponse } from '../karma-indexer/api/types';
 import { MilestoneCompleted } from '../types/attestations';
-interface _Milestone extends Milestone {
-}
 export interface IMilestone {
     title: string;
     startsAt?: number;
@@ -79,7 +78,7 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
      * Attest the status of the milestone as approved, rejected or completed.
      */
     private attestStatus;
-    static from(attestations: _Milestone[], network: TNetwork): Milestone[];
+    static from(attestations: IMilestoneResponse[], network: TNetwork): Milestone[];
     /**
    * Verify this milestone. If the milestone is not completed or already verified,
    * it will throw an error.
@@ -88,4 +87,3 @@ export declare class Milestone extends Attestation<IMilestone> implements IMiles
    */
     verify(signer: SignerOrProvider, reason?: string): Promise<void>;
 }
-export {};

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

@@ -3,8 +3,7 @@ import { Grantee, MemberDetails, ProjectDetails, ProjectEndorsement, ProjectImpa
 import { Hex, MultiAttestPayload, SignerOrProvider, TNetwork } from 'core/types';
 import { Grant } from './Grant';
 import { MemberOf } from './MemberOf';
-interface _Project extends Project {
-}
+import { IProjectResponse } from '../karma-indexer/api/types';
 export interface IProject {
     project: true;
 }
@@ -72,8 +71,7 @@ export declare class Project extends Attestation<IProject> {
      * @param signer
      */
     removeAllMembers(signer: SignerOrProvider): Promise<void>;
-    static from(attestations: _Project[], network: TNetwork): Project[];
+    static from(attestations: IProjectResponse[], network: TNetwork): Project[];
     attestImpact(signer: SignerOrProvider, data: ProjectImpact): Promise<void>;
     attestEndorsement(signer: SignerOrProvider, data?: ProjectEndorsement): Promise<void>;
 }
-export {};

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

@@ -5,6 +5,8 @@ import { Fetcher } from '../Fetcher';
 import { Community, Project, Grant, Milestone, MemberOf } from '../entities';
 import { Grantee } from '../types/attestations';
 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[]>;

package/core/class/karma-indexer/GapIndexerClient.js

@@ -4,6 +4,7 @@ exports.GapIndexerClient = void 0;
 const Attestation_1 = require("../Attestation");
 const Fetcher_1 = require("../Fetcher");
 const entities_1 = require("../entities");
+const GapIndexerApi_1 = require("./api/GapIndexerApi");
 const Endpoints = {
     attestations: {
         all: () => '/attestations',
@@ -35,43 +36,35 @@ const Endpoints = {
     },
 };
 class GapIndexerClient extends Fetcher_1.Fetcher {
+    constructor(params) {
+        super(params);
+        this.apiClient = new GapIndexerApi_1.GapIndexerApi(params);
+    }
     async attestation(uid) {
-        const { data } = await this.client.get(Endpoints.attestations.byUid(uid));
+        const { data } = await this.apiClient.attestation(uid);
         if (!data)
             throw new Error('Attestation not found');
         return Attestation_1.Attestation.fromInterface([data], this.gap.network)[0];
     }
     async attestations(schemaName, search) {
-        const { data } = await this.client.get(Endpoints.attestations.all(), {
-            params: {
-                'filter[schemaUID]': this.gap.findSchema(schemaName).uid,
-                'filter[data]': search,
-            },
-        });
+        const schemaUID = this.gap.findSchema(schemaName).uid;
+        const { data } = await this.apiClient.attestations(schemaUID, search);
         return data || [];
     }
     async attestationsOf(schemaName, attester) {
-        const { data } = await this.client.get(Endpoints.attestations.all(), {
-            params: {
-                'filter[schemaUID]': this.gap.findSchema(schemaName).uid,
-                'filter[recipient]': attester,
-            },
-        });
+        const schemaUID = this.gap.findSchema(schemaName).uid;
+        const { data } = await this.apiClient.attestationsOf(schemaUID, attester);
         return data || [];
     }
     attestationsTo(schemaName, recipient) {
         return this.attestationsOf(schemaName, recipient);
     }
     async communities(search) {
-        const { data } = await this.client.get(Endpoints.communities.all(), {
-            params: {
-                'filter[name]': search,
-            },
-        });
+        const { data } = await this.apiClient.communities(search);
         return entities_1.Community.from(data, this.gap.network);
     }
     async communitiesOf(address, withGrants) {
-        const { data } = await this.client.get(Endpoints.grantees.communities(address, withGrants));
+        const { data } = await this.apiClient.communitiesOf(address, withGrants);
         return entities_1.Community.from(data, this.gap.network);
     }
     async communitiesAdminOf(address, withGrants) {
@@ -82,78 +75,64 @@ class GapIndexerClient extends Fetcher_1.Fetcher {
         throw new Error('Method not implemented.');
     }
     async communityBySlug(slug) {
-        const { data } = await this.client.get(Endpoints.communities.byUidOrSlug(slug));
+        const { data } = await this.apiClient.communityBySlug(slug);
         return entities_1.Community.from([data], this.gap.network)[0];
     }
     communityById(uid) {
         return this.communityBySlug(uid);
     }
     async projectBySlug(slug) {
-        const { data } = await this.client.get(Endpoints.project.byUidOrSlug(slug));
+        const { data } = await this.apiClient.projectBySlug(slug);
         return entities_1.Project.from([data], this.gap.network)[0];
     }
     projectById(uid) {
         return this.projectBySlug(uid);
     }
     async searchProjects(query) {
-        const { data } = await this.client.get(Endpoints.project.all(), {
-            params: {
-                q: query,
-            },
-        });
+        const { data } = await this.apiClient.searchProjects(query);
         return entities_1.Project.from(data, this.gap.network);
     }
     async projects(name) {
-        const { data } = await this.client.get(Endpoints.project.all(), {
-            params: {
-                'filter[title]': name,
-            },
-        });
+        const { data } = await this.apiClient.projects(name);
         return entities_1.Project.from(data, this.gap.network);
     }
     async projectsOf(grantee) {
-        const { data } = await this.client.get(Endpoints.grantees.projects(grantee));
+        const { data } = await this.apiClient.projectsOf(grantee);
         return entities_1.Project.from(data, this.gap.network);
     }
     async grantee(address) {
-        const { data } = await this.client.get(Endpoints.grantees.byAddress(address));
+        const { data } = await this.apiClient.grantee(address);
         return data;
     }
     async grantees() {
-        const { data } = await this.client.get(Endpoints.grantees.all());
-        return data;
+        const { data } = await this.apiClient.grantees();
+        return data; // TODO: Remove this casting after the api is fixed
     }
     async grantsOf(grantee, withCommunity) {
-        const { data } = await this.client.get(Endpoints.grantees.grants(grantee));
+        const { data } = await this.apiClient.grantsOf(grantee, withCommunity);
         return entities_1.Grant.from(data, this.gap.network);
     }
     async grantsFor(projects, withCommunity) {
-        const { data } = await this.client.get(Endpoints.project.grants(projects[0].uid));
+        const { data } = await this.apiClient.grantsFor(projects[0].uid, withCommunity);
         return entities_1.Grant.from(data, this.gap.network);
     }
     async grantsForExtProject(projectExtId) {
-        const { data } = await this.client.get(Endpoints.grants.byExternalId(projectExtId));
+        const { data } = await this.apiClient.grantsForExtProject(projectExtId);
         return entities_1.Grant.from(data, this.gap.network);
     }
     async grantsByCommunity(uid) {
-        const { data } = await this.client.get(Endpoints.communities.grants(uid));
+        const { data } = await this.apiClient.grantsByCommunity(uid);
         return entities_1.Grant.from(data, this.gap.network);
     }
     async milestonesOf(grants) {
-        const { data } = await this.client.get(Endpoints.project.milestones(grants[0].uid));
+        const { data } = await this.apiClient.milestonesOf(grants[0].uid);
         return entities_1.Milestone.from(data, this.gap.network);
     }
     async membersOf(projects) {
         throw new Error('Method not implemented.');
     }
     async slugExists(slug) {
-        try {
-            await this.client.get(Endpoints.project.byUidOrSlug(slug));
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return await this.apiClient.slugExists(slug);
     }
 }
 exports.GapIndexerClient = GapIndexerClient;

package/core/class/karma-indexer/api/GapIndexerApi.d.ts

@@ -0,0 +1,43 @@
+import { AxiosGQL } from "../../GraphQL/AxiosGQL";
+import { Hex, IAttestationResponse, ICommunityResponse, IGrantResponse, IProjectResponse } from "./types";
+export declare class GapIndexerApi extends AxiosGQL {
+    constructor(url: string);
+    attestation(uid: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse, any>>;
+    attestations(schemaUID: string, search?: string): Promise<import("axios").AxiosResponse<IAttestationResponse[], any>>;
+    attestationsOf(schemaUID: string, attester: Hex): Promise<import("axios").AxiosResponse<IAttestationResponse[], any>>;
+    /**
+     * Community
+     */
+    communities(search?: string): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
+    communitiesOf(address: Hex, withGrants: boolean): Promise<import("axios").AxiosResponse<ICommunityResponse[], any>>;
+    communityBySlug(slug: string): Promise<import("axios").AxiosResponse<ICommunityResponse, any>>;
+    /**
+     * Project
+     */
+    projectBySlug(slug: string): Promise<import("axios").AxiosResponse<IProjectResponse, any>>;
+    searchProjects(query: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
+    projects(name?: string): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
+    projectsOf(grantee: Hex): Promise<import("axios").AxiosResponse<IProjectResponse[], any>>;
+    /**
+     * Grantee
+     */
+    grantee(address: Hex): Promise<import("axios").AxiosResponse<any, any>>;
+    grantees(): Promise<import("axios").AxiosResponse<{
+        [key: `0x${string}`]: {
+            grants: number;
+            projects: number;
+        };
+    }, any>>;
+    /**
+     * Grant
+     */
+    grantsOf(grantee: Hex, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
+    grantsFor(uid: string, withCommunity?: boolean): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
+    grantsForExtProject(projectExtId: string): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
+    grantsByCommunity(uid: Hex): Promise<import("axios").AxiosResponse<IGrantResponse[], any>>;
+    /**
+     * Milestone
+     */
+    milestonesOf(uid: Hex): Promise<import("axios").AxiosResponse<any, any>>;
+    slugExists(slug: string): Promise<boolean>;
+}

package/core/class/karma-indexer/api/GapIndexerApi.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapIndexerApi = void 0;
+const AxiosGQL_1 = require("../../GraphQL/AxiosGQL");
+const Endpoints = {
+    attestations: {
+        all: () => "/attestations",
+        byUid: (uid) => `/attestations/${uid}`,
+    },
+    communities: {
+        all: () => "/communities",
+        byUidOrSlug: (uidOrSlug) => `/communities/${uidOrSlug}`,
+        grants: (uidOrSlug) => `/communities/${uidOrSlug}/grants`,
+    },
+    grantees: {
+        all: () => "/grantees",
+        byAddress: (address) => `/grantees/${address}`,
+        grants: (address) => `/grantees/${address}/grants`,
+        projects: (address) => `/grantees/${address}/projects`,
+        communities: (address, withGrants) => `/grantees/${address}/communities${withGrants ? "?withGrants=true" : ""}`,
+    },
+    grants: {
+        all: () => "/grants",
+        byUid: (uid) => `/grants/${uid}`,
+        byExternalId: (id) => `/grants/external-id/${id}`,
+    },
+    project: {
+        all: () => "/projects",
+        byUidOrSlug: (uidOrSlug) => `/projects/${uidOrSlug}`,
+        grants: (uidOrSlug) => `/projects/${uidOrSlug}/grants`,
+        milestones: (uidOrSlug) => `/projects/${uidOrSlug}/milestones`,
+    },
+};
+class GapIndexerApi extends AxiosGQL_1.AxiosGQL {
+    constructor(url) {
+        super(url);
+    }
+    async attestation(uid) {
+        const response = await this.client.get(Endpoints.attestations.byUid(uid));
+        return response;
+    }
+    async attestations(schemaUID, search) {
+        const response = await this.client.get(Endpoints.attestations.all(), {
+            params: {
+                "filter[schemaUID]": schemaUID,
+                "filter[data]": search,
+            },
+        });
+        return response;
+    }
+    async attestationsOf(schemaUID, attester) {
+        const response = await this.client.get(Endpoints.attestations.all(), {
+            params: {
+                "filter[schemaUID]": schemaUID,
+                "filter[recipient]": attester,
+            },
+        });
+        return response;
+    }
+    /**
+     * Community
+     */
+    async communities(search) {
+        const response = await this.client.get(Endpoints.communities.all(), {
+            params: {
+                "filter[name]": search,
+            },
+        });
+        return response;
+    }
+    async communitiesOf(address, withGrants) {
+        const response = await this.client.get(Endpoints.grantees.communities(address, withGrants));
+        return response;
+    }
+    async communityBySlug(slug) {
+        const response = await this.client.get(Endpoints.communities.byUidOrSlug(slug));
+        return response;
+    }
+    /**
+     * Project
+     */
+    async projectBySlug(slug) {
+        const response = await this.client.get(Endpoints.project.byUidOrSlug(slug));
+        return response;
+    }
+    async searchProjects(query) {
+        const response = await this.client.get(Endpoints.project.all(), {
+            params: {
+                q: query,
+            },
+        });
+        return response;
+    }
+    async projects(name) {
+        const response = await this.client.get(Endpoints.project.all(), {
+            params: {
+                "filter[title]": name,
+            },
+        });
+        return response;
+    }
+    async projectsOf(grantee) {
+        const response = await this.client.get(Endpoints.grantees.projects(grantee));
+        return response;
+    }
+    /**
+     * Grantee
+     */
+    async grantee(address) {
+        // TODO: update response type when the endpoint works
+        const response = await this.client.get(Endpoints.grantees.byAddress(address));
+        return response;
+    }
+    async grantees() {
+        const response = await this.client.get(Endpoints.grantees.all());
+        return response;
+    }
+    /**
+     * Grant
+     */
+    async grantsOf(grantee, withCommunity) {
+        const response = await this.client.get(Endpoints.grantees.grants(grantee));
+        return response;
+    }
+    async grantsFor(uid, withCommunity) {
+        const response = await this.client.get(Endpoints.project.grants(uid));
+        return response;
+    }
+    async grantsForExtProject(projectExtId) {
+        const response = await this.client.get(Endpoints.grants.byExternalId(projectExtId));
+        return response;
+    }
+    async grantsByCommunity(uid) {
+        const response = await this.client.get(Endpoints.communities.grants(uid));
+        return response;
+    }
+    /**
+     * Milestone
+     */
+    async milestonesOf(uid) {
+        const response = await this.client.get(Endpoints.project.milestones(uid));
+        return response;
+    }
+    async slugExists(slug) {
+        try {
+            await this.client.get(Endpoints.project.byUidOrSlug(slug));
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+}
+exports.GapIndexerApi = GapIndexerApi;

package/core/class/karma-indexer/api/types.d.ts

@@ -0,0 +1,159 @@
+export type Hex = `0x${string}`;
+export type JSONStr = string;
+export type ExternalLink = {
+    type: string;
+    url: string;
+};
+export interface ITag {
+    name: string;
+}
+export interface IAttestationResponse {
+    id: string;
+    uid: Hex;
+    schemaUID: Hex;
+    refUID: Hex;
+    attester: Hex;
+    recipient: Hex;
+    revoked: boolean;
+    revocationTime?: number;
+    createdAt: any;
+    updatedAt: any;
+    chainID: number;
+    type: string;
+    data: any;
+    decodedDataJson: JSONStr;
+    isOffchain: any;
+    revocable: any;
+    schemaId: Hex;
+}
+export interface ISummaryProject {
+    title: string;
+    slug?: string;
+    uid: Hex;
+}
+export interface IMilestoneCompleted extends IAttestationResponse {
+    type: "approved" | "rejected" | "completed";
+    reason?: string;
+}
+export interface IMilestoneResponse extends IAttestationResponse {
+    type: "Milestone";
+    completed?: IMilestoneCompleted;
+    approved?: IMilestoneCompleted;
+    rejected?: IMilestoneCompleted;
+    verified?: IMilestoneCompleted[];
+    data: {
+        title: string;
+        description: string;
+        endsAt: number;
+        type: "milestone";
+    };
+}
+export interface IGrantUpdate extends IAttestationResponse {
+    data: {
+        text: string;
+        title: string;
+        type: "grant-update";
+    };
+}
+export interface IGrantDetails extends IAttestationResponse {
+    type: "GrantDetails";
+    data: {
+        title: string;
+        amount: string;
+        description: string;
+        proposalURL: string;
+        assetAndChainId?: [Hex, number];
+        payoutAddress: Hex;
+        questions: {
+            type: string;
+            query: string;
+            explanation: string;
+        }[];
+        startDate: number;
+        type: "grant-details";
+    };
+}
+export interface IGrantResponse extends IAttestationResponse {
+    type: "Grant";
+    data: {
+        communityUID: Hex;
+    };
+    details?: IGrantDetails;
+    milestones: IMilestoneResponse[];
+    completed?: IGrantUpdate;
+    project: ISummaryProject;
+    updates: IGrantUpdate[];
+    community: ICommunityResponse;
+    members: Hex[];
+    categories?: string[];
+}
+export interface IMemberDetails extends IAttestationResponse {
+    name: string;
+    profilePictureURL: string;
+}
+export interface IMemberOf extends IAttestationResponse {
+    type: "MemberOf";
+    data: {
+        memberOf: true;
+    };
+    details?: IMemberDetails;
+}
+export interface IProjectDetails extends IAttestationResponse {
+    type: "ProjectDetails";
+    data: {
+        title: string;
+        description: string;
+        imageURL: string;
+        links?: ExternalLink[];
+        tags?: ITag[];
+        slug?: string;
+        type: "project-details";
+    };
+}
+export interface IProjectImpact extends IAttestationResponse {
+    type: "ProjectImpact";
+    data: {
+        work: string;
+        impact: string;
+        proof: string;
+        completedAt: number;
+        type: "project-impact";
+    };
+}
+export interface IProjectEndorsement extends IAttestationResponse {
+    type: "ProjectEndorsement";
+    data: {
+        comment?: string;
+        type?: 'project-endorsement';
+    };
+}
+export interface IProjectResponse extends IAttestationResponse {
+    type: "Project";
+    data: {
+        project: true;
+    };
+    details?: IProjectDetails;
+    members: IMemberOf[];
+    grants: any[];
+    grantee: any;
+    impacts: IProjectImpact[];
+    endorsements: IProjectEndorsement[];
+}
+export interface ICommunityDetails extends IAttestationResponse {
+    type: "CommunityDetails";
+    data: {
+        name: string;
+        description: string;
+        imageURL: string;
+        links: ExternalLink[];
+        slug?: string;
+    };
+}
+export interface ICommunityResponse extends IAttestationResponse {
+    type: "Community";
+    data: {
+        community: true;
+    };
+    details?: ICommunityDetails;
+    grants: IGrantResponse[];
+}

package/core/class/karma-indexer/api/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -3,7 +3,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.3.22",
+    "version": "0.3.24",
     "description": "Simple and easy interface between EAS and Karma GAP.",
     "main": "./index.js",
     "author": "KarmaHQ",