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

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

@@ -0,0 +1,309 @@
+import { IGrantUpdateBase } from "core/shared/types";
+export type Hex = `0x${string}`;
+export type JSONStr = string;
+export type ExternalLink = {
+    type: string;
+    url: string;
+};
+export type ExternalCustomLink = {
+    type: 'custom';
+    url: string;
+    name: 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: "MilestoneStatus";
+    data: {
+        type: "approved" | "rejected" | "completed";
+        reason?: string;
+        proofOfWork?: string;
+    };
+}
+export interface IMilestoneResponse extends IAttestationResponse {
+    type: "Milestone";
+    completed?: IMilestoneCompleted;
+    approved?: IMilestoneCompleted;
+    rejected?: IMilestoneCompleted;
+    verified?: IMilestoneCompleted[];
+    data: {
+        title: string;
+        description: string;
+        endsAt: number;
+        startsAt?: number;
+        type: "milestone";
+        priority?: number;
+    };
+}
+export interface IGrantUpdateStatus extends IAttestationResponse {
+    type: `grant-update-${IStatus}`;
+    reason?: string;
+    data: {
+        type: "approved" | "rejected" | "completed";
+        reason?: string;
+        pitchDeck?: string;
+        demoVideo?: string;
+        trackExplanations?: Array<{
+            trackId: string;
+            trackName: string;
+            explanation: string;
+        }>;
+    };
+}
+export interface IGrantUpdate extends IAttestationResponse {
+    data: IGrantUpdateBase & {
+        type: "grant-update";
+    };
+    verified?: IGrantUpdateStatus[];
+}
+export interface IProjectUpdateStatus extends IAttestationResponse {
+    type: `project-update-${IStatus}`;
+    reason?: string;
+    data: {
+        type: "approved" | "rejected" | "completed";
+        reason?: string;
+    };
+}
+export interface IProjectUpdate extends IAttestationResponse {
+    data: {
+        title: string;
+        text: string;
+        startDate?: Date;
+        endDate?: Date;
+        grants?: string[];
+        indicators?: {
+            name: string;
+            indicatorId: string;
+        }[];
+        deliverables?: {
+            name: string;
+            proof: string;
+            description: string;
+        }[];
+        type: "project-update";
+    };
+    verified?: IProjectUpdateStatus[];
+}
+export interface IProjectMilestoneStatus extends IAttestationResponse {
+    type: `project-milestone-verified`;
+    reason?: string;
+    data: {
+        type: "approved" | "rejected" | "completed";
+        reason?: string;
+    };
+}
+export interface IProjectMilestoneResponse extends IAttestationResponse {
+    data: {
+        text: string;
+        title: string;
+        type: "project-milestone";
+    };
+    verified?: IProjectMilestoneStatus[];
+    completed?: IMilestoneCompleted;
+}
+export interface IProjectPointer extends IAttestationResponse {
+    data: {
+        ogProjectUID: string;
+        type: "project-pointer";
+    };
+}
+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;
+        programId?: string;
+        type: "grant-details";
+        fundUsage?: string;
+        selectedTrackIds?: string[];
+    };
+}
+export interface IGrantResponse extends IAttestationResponse {
+    type: "Grant";
+    data: {
+        communityUID: Hex;
+    };
+    details?: IGrantDetails;
+    milestones: IMilestoneResponse[];
+    completed?: IGrantUpdate;
+    project: IProjectResponse;
+    updates: IGrantUpdate[];
+    community: ICommunityResponse;
+    members: Hex[];
+    categories?: string[];
+    externalAddresses?: {
+        [key: string]: string;
+    };
+    external?: {
+        [key: string]: string[];
+    };
+    amount?: Hex;
+}
+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;
+        problem?: string;
+        solution?: string;
+        missionSummary?: string;
+        locationOfImpact?: string;
+        imageURL: string;
+        links?: Array<ExternalLink | ExternalCustomLink>;
+        tags?: ITag[];
+        slug?: string;
+        type: "project-details";
+        businessModel?: string;
+        stageIn?: string;
+        raisedMoney?: string;
+        pathToTake?: string;
+    };
+}
+type IStatus = "verified";
+export interface IProjectImpactStatus extends IAttestationResponse {
+    type: `project-impact-${IStatus}`;
+    reason?: string;
+}
+export interface IProjectImpact extends IAttestationResponse {
+    type: "ProjectImpact";
+    data: {
+        work: string;
+        impact: string;
+        proof: string;
+        startedAt?: number;
+        completedAt: number;
+        type: "project-impact";
+    };
+    verified: IProjectImpactStatus[];
+}
+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: IGrantResponse[];
+    grantee: any;
+    impacts: IProjectImpact[];
+    updates: IProjectUpdate[];
+    pointers: IProjectPointer[];
+    symlinks: Hex[];
+    endorsements: IProjectEndorsement[];
+    milestones: IProjectMilestoneResponse[];
+    payoutAddress?: Hex;
+}
+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[];
+}
+export interface ICommunityAdminsResponse {
+    id: string;
+    admins: {
+        user: {
+            id: string;
+        };
+    }[];
+}
+export interface ISearchResponse {
+    projects: IProjectResponse[];
+    communities: ICommunityResponse[];
+}
+export interface ITrackResponse {
+    id: string;
+    name: string;
+    description?: string;
+    communityUID: string;
+    isArchived: boolean;
+    createdAt: string;
+    updatedAt: string;
+    programId?: string;
+    isActive?: boolean;
+    chainID?: number;
+}
+export interface ITrackAssignmentResponse {
+    id: string;
+    programId: string;
+    chainID: number;
+    trackId: string;
+    track: ITrackResponse;
+}
+export interface IProjectTrackResponse {
+    projectUID: string;
+    chainID: number;
+    programId: string;
+    track: ITrackResponse;
+    project: {
+        uid: string;
+        chainID: number;
+        details: any;
+    };
+}
+export {};

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

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

package/core/class/remote-storage/IpfsStorage.d.ts

@@ -0,0 +1,23 @@
+import { RemoteStorage } from "./RemoteStorage";
+import { TRemoteStorageOutput } from "core/types";
+export interface IpfsStorageOptions {
+    token: string;
+}
+export declare class IpfsStorage extends RemoteStorage {
+    private pinataJWTToken;
+    constructor(opts: IpfsStorageOptions, 
+    /**
+     * If set, will send request to another server instead of
+     * using the local instance
+     */
+    sponsor?: RemoteStorage["sponsor"]);
+    private assert;
+    save<T = unknown>(data: T): Promise<string>;
+    encode(data: string): TRemoteStorageOutput<string>;
+    get<T = unknown>(args: {
+        cid: string;
+    }): Promise<T>;
+    saveAndGetCID(data: any, pinataMetadata?: {
+        name: string;
+    }): Promise<any>;
+}

package/core/class/remote-storage/IpfsStorage.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IpfsStorage = void 0;
+const RemoteStorage_1 = require("./RemoteStorage");
+const SchemaError_1 = require("../SchemaError");
+const utils_1 = require("../../utils");
+const axios_1 = __importDefault(require("axios"));
+class IpfsStorage extends RemoteStorage_1.RemoteStorage {
+    constructor(opts, 
+    /**
+     * If set, will send request to another server instead of
+     * using the local instance
+     */
+    sponsor) {
+        super(0 /* STORAGE_TYPE.IPFS */, sponsor);
+        this.assert(opts);
+        this.pinataJWTToken = opts.token;
+    }
+    assert(opts) { }
+    async save(data) {
+        try {
+            const cid = await this.saveAndGetCID(data);
+            return cid;
+        }
+        catch (error) {
+            throw new SchemaError_1.RemoteStorageError("REMOTE_STORAGE_UPLOAD", `Error adding data to IPFS`);
+        }
+    }
+    encode(data) {
+        return { hash: data, storageType: this.storageType };
+    }
+    async get(args) {
+        return (0, utils_1.getIPFSData)(args.cid);
+    }
+    async saveAndGetCID(data, pinataMetadata = { name: "via karma-gap-sdk" }) {
+        try {
+            const res = await axios_1.default.post("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+                pinataContent: data,
+                pinataMetadata: pinataMetadata,
+            }, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.pinataJWTToken}`,
+                },
+            });
+            return res.data.IpfsHash;
+        }
+        catch (error) {
+            throw new SchemaError_1.RemoteStorageError("REMOTE_STORAGE_UPLOAD", `Error adding data to IPFS`);
+        }
+    }
+}
+exports.IpfsStorage = IpfsStorage;

package/core/class/remote-storage/RemoteStorage.d.ts

@@ -0,0 +1,41 @@
+import { STORAGE_TYPE, TRemoteStorageOutput } from 'core/types';
+interface SponsoredRemote {
+    url: string;
+    responseParser: (response: any) => string;
+}
+export declare abstract class RemoteStorage<C = unknown> {
+    protected client: C;
+    readonly storageType: number;
+    readonly sponsor?: SponsoredRemote;
+    constructor(storageType: STORAGE_TYPE, 
+    /**
+     * If set, will try to POST request to another server instead of
+     * using the local instance.
+     *
+     * > If a response parser is not set, it will try to get { cid: string }.
+     */
+    sponsor: SponsoredRemote);
+    /**
+     * Try to save data to remote storage and return the CID.
+     * IF sponsorUrl is set, this method will be automatically
+     * intercepted and will send a POST request to the sponsorUrl
+     * with the contents: `{ data: T, type: "<AttestationType>" }`
+     */
+    abstract save<T = unknown>(data: T, schemaName: string): Promise<string>;
+    /**
+     * Encodes the data according to the remote storage type parameters
+     * OR returns the data as is if no encoding is required
+     */
+    abstract encode(data: unknown): TRemoteStorageOutput;
+    /**
+     * Get data from Remote Storage
+     */
+    abstract get<T = unknown>(args: unknown): Promise<T>;
+    /**
+     * If sponsorUrl is set, intercept the save method and send a POST request
+     * to the sponsorUrl instead of using the local instance.
+     * @returns
+     */
+    private interceptRemoteStorage;
+}
+export {};

package/core/class/remote-storage/RemoteStorage.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteStorage = void 0;
+const axios_1 = __importDefault(require("axios"));
+class RemoteStorage {
+    constructor(storageType, 
+    /**
+     * If set, will try to POST request to another server instead of
+     * using the local instance.
+     *
+     * > If a response parser is not set, it will try to get { cid: string }.
+     */
+    sponsor) {
+        this.storageType = storageType;
+        this.sponsor = sponsor;
+        this.interceptRemoteStorage();
+    }
+    /**
+     * If sponsorUrl is set, intercept the save method and send a POST request
+     * to the sponsorUrl instead of using the local instance.
+     * @returns
+     */
+    interceptRemoteStorage() {
+        if (!this.sponsor?.url)
+            return;
+        this.save = async (data, schemaName) => {
+            const { data: response } = await axios_1.default.post(this.sponsor.url, {
+                data: data,
+                type: schemaName,
+            });
+            return this.sponsor.responseParser?.(response) || response.cid;
+        };
+    }
+}
+exports.RemoteStorage = RemoteStorage;

package/core/class/types/allo.d.ts

@@ -0,0 +1,78 @@
+export type RoundMetadata = {
+    name: string;
+    support: {
+        info: string;
+        type: string;
+    };
+    roundType: "public" | string;
+    eligibility: {
+        description: string;
+        requirements: Array<{
+            requirement: string;
+        }>;
+    };
+    feesAddress: string;
+    feesPercentage: number;
+    programContractAddress: string;
+    quadraticFundingConfig?: {
+        matchingCap: boolean;
+        sybilDefense: boolean;
+        matchingCapAmount: number;
+        minDonationThreshold: boolean;
+        matchingFundsAvailable: number;
+        minDonationThresholdAmount: number;
+    };
+    category: string;
+    source: string;
+};
+export type Address = `0x${string}`;
+export type GrantArgs = {
+    profileId: Address;
+    roundMetadata: RoundMetadata;
+    applicationStart: number;
+    applicationEnd: number;
+    roundStart: number;
+    roundEnd: number;
+    matchingFundAmt: number;
+    applicationMetadata: ApplicationMetadata;
+    managers: Address[];
+    strategy: Address;
+    payoutToken: Address;
+};
+export type ApplicationMetadata = {
+    version: string;
+    lastUpdatedOn: number;
+    applicationSchema: {
+        questions: Array<{
+            id: number;
+            info: string;
+            type: "email" | "short-answer" | "link" | "number" | "paragraph" | "address" | "checkbox" | "multiple-choice";
+            title: string;
+            hidden: boolean;
+            choices?: string[];
+            required: boolean;
+            encrypted: boolean;
+        }>;
+        requirements: {
+            github: {
+                required: boolean;
+                verification: boolean;
+            };
+            twitter: {
+                required: boolean;
+                verification: boolean;
+            };
+        };
+    };
+};
+export type ProfileMetadata = {
+    title: string;
+    description: string;
+    website: string;
+    projectTwitter: string;
+    logoImg: string;
+    bannerImg: string;
+    logoImgData: any;
+    bannerImgData: any;
+    createdAt: number;
+};

package/core/class/types/allo.js

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