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

package/core/class/GrantProgramRegistry/AlloRegistry.d.ts

@@ -0,0 +1,15 @@
+import { ethers } from "ethers";
+import { ProfileMetadata } from "../types/allo";
+export declare class AlloRegistry {
+    private contract;
+    private pinataJWTToken;
+    constructor(signer: ethers.Signer, pinataJWTToken: string);
+    saveAndGetCID(data: any, pinataMetadata?: {
+        name: string;
+    }): Promise<any>;
+    createProgram(nonce: number, name: string, profileMetadata: ProfileMetadata, owner: string, members: string[]): Promise<{
+        profileId: any;
+        txHash: any;
+    }>;
+    updateProgramMetadata(profileId: string, profileMetadata: ProfileMetadata): Promise<any>;
+}

package/core/class/GrantProgramRegistry/AlloRegistry.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlloRegistry = void 0;
+const ethers_1 = require("ethers");
+const AlloRegistry_json_1 = __importDefault(require("../../abi/AlloRegistry.json"));
+const consts_1 = require("../../consts");
+const axios_1 = __importDefault(require("axios"));
+class AlloRegistry {
+    constructor(signer, pinataJWTToken) {
+        this.contract = new ethers_1.ethers.Contract(consts_1.AlloContracts.registry, AlloRegistry_json_1.default, signer);
+        this.pinataJWTToken = pinataJWTToken;
+    }
+    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) {
+            console.log(error);
+        }
+    }
+    async createProgram(nonce, name, profileMetadata, owner, members) {
+        console.log("Creating program...");
+        try {
+            const metadata_cid = await this.saveAndGetCID(profileMetadata);
+            const metadata = {
+                protocol: 1,
+                pointer: metadata_cid,
+            };
+            const tx = await this.contract.createProfile(nonce, name, metadata, owner, members);
+            const receipt = await tx.wait();
+            // Get ProfileCreated event
+            const profileCreatedEvent = receipt.logs.find((event) => event.eventName === "ProfileCreated");
+            return {
+                profileId: profileCreatedEvent.args[0],
+                txHash: receipt.hash,
+            };
+        }
+        catch (error) {
+            console.error(`Failed to register program: ${error}`);
+        }
+    }
+    async updateProgramMetadata(profileId, profileMetadata) {
+        try {
+            const metadata_cid = await this.saveAndGetCID(profileMetadata);
+            const metadata = {
+                protocol: 1,
+                pointer: metadata_cid,
+            };
+            const tx = await this.contract.updateProfileMetadata(profileId, metadata);
+            const receipt = await tx.wait();
+            return receipt;
+        }
+        catch (error) {
+            console.error(`Failed to update profile metadata: ${error}`);
+        }
+    }
+}
+exports.AlloRegistry = AlloRegistry;

package/core/class/GraphQL/AxiosGQL.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosInstance } from "axios";
+export declare abstract class AxiosGQL {
+    protected client: AxiosInstance;
+    constructor(url: string);
+    protected query<R = unknown, T = unknown>(query: string, variables?: T): Promise<R>;
+}

package/core/class/GraphQL/AxiosGQL.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxiosGQL = void 0;
+const axios_1 = __importDefault(require("axios"));
+class AxiosGQL {
+    constructor(url) {
+        this.client = axios_1.default.create({
+            baseURL: url,
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+    }
+    async query(query, variables) {
+        const { data: { data }, } = await this.client.post("", {
+            query,
+            variables,
+        });
+        return data;
+    }
+}
+exports.AxiosGQL = AxiosGQL;

package/core/class/GraphQL/EASClient.d.ts

@@ -0,0 +1,16 @@
+import { TNetwork } from "../../types";
+import { AxiosGQL } from "./AxiosGQL";
+interface EASClientProps {
+    network: TNetwork;
+}
+export declare class EASClient extends AxiosGQL implements EASClientProps {
+    private readonly _network;
+    constructor(args: EASClientProps);
+    /**
+     * Validate the constructor arguments
+     * @param args
+     */
+    private assert;
+    get network(): TNetwork;
+}
+export {};

package/core/class/GraphQL/EASClient.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EASClient = void 0;
+const consts_1 = require("../../consts");
+const AxiosGQL_1 = require("./AxiosGQL");
+class EASClient extends AxiosGQL_1.AxiosGQL {
+    constructor(args) {
+        const { network } = args;
+        super(consts_1.Networks[network].url);
+        this.assert(args);
+        this._network = { ...consts_1.Networks[network], name: network };
+    }
+    /**
+     * Validate the constructor arguments
+     * @param args
+     */
+    assert(args) {
+        if (!consts_1.Networks[args.network]) {
+            throw new Error("Invalid network");
+        }
+    }
+    get network() {
+        return this._network.name;
+    }
+}
+exports.EASClient = EASClient;

package/core/class/GraphQL/GapEasClient.d.ts

@@ -0,0 +1,71 @@
+import { Attestation } from "../Attestation";
+import { EASNetworkConfig, Hex, IAttestation, TNetwork, TSchemaName } from "../../types";
+import { Grantee } from "../types/attestations";
+import { GapSchema } from "../GapSchema";
+import { Grant, Milestone, Project, MemberOf } from "../entities";
+import { Community } from "../entities/Community";
+import { Fetcher } from "../Fetcher";
+interface EASClientProps {
+    network: TNetwork;
+}
+export declare class GapEasClient extends Fetcher {
+    network: EASNetworkConfig & {
+        name: TNetwork;
+    };
+    constructor(args: EASClientProps);
+    /**
+     * Fetches all the schemas deployed by an owner
+     * @param owner
+     */
+    schemas(owner: Hex): Promise<GapSchema[]>;
+    attestation<T = unknown>(uid: Hex): Promise<Attestation<T, GapSchema>>;
+    attestations(schemaName: TSchemaName, search?: string): Promise<IAttestation[]>;
+    attestationsOf(schemaName: TSchemaName, recipient: Hex): Promise<IAttestation[]>;
+    attestationsTo(schemaName: TSchemaName, recipient: Hex): Promise<IAttestation[]>;
+    /**
+     * Fetch all dependent attestations of a parent schema.
+     * @param parentSchema the schema name to get dependents of.
+     * @param parentUid the parent uid to get dependents of.
+     */
+    dependentsOf(parentSchema: TSchemaName, parentUid: Hex): Promise<Attestation[]>;
+    communities(search?: string): Promise<Community[]>;
+    communitiesOf(address?: Hex): Promise<Community[]>;
+    communitiesAdminOf(address?: Hex): Promise<Community[]>;
+    communitiesByIds(uids: Hex[]): Promise<Community[]>;
+    communitiesDetails(communities: Community[]): Promise<Community[]>;
+    communityBySlug(slug: string): Promise<Community>;
+    communityById(uid: Hex): Promise<Community>;
+    /**
+     * Fetch the details for a set of
+     * projects with project grants,
+     * members, milestones, and tags.
+     * @param projects
+     */
+    projectsDetails(projects: Project[]): Promise<Project[]>;
+    projectById(uid: Hex): Promise<Project>;
+    projectBySlug(slug: string): Promise<Project>;
+    slugExists(slug: string): Promise<boolean>;
+    search(query: string): Promise<{
+        projects: Project[];
+        communities: Community[];
+    }>;
+    searchProjects(query: string): Promise<Project[]>;
+    projects(name?: string): Promise<Project[]>;
+    projectsOf(grantee: Hex): Promise<Project[]>;
+    grantee(address: Hex): Promise<Grantee>;
+    grantees(): Promise<Grantee[]>;
+    grantsOf(grantee: Hex, withCommunity?: boolean): Promise<Grant[]>;
+    grantsUpdates(grants: Grant[]): Promise<Grant[]>;
+    grantsByCommunity(uid: Hex): Promise<Grant[]>;
+    grantsFor(projects: Project[], withCommunity?: boolean): Promise<Grant[]>;
+    milestonesOf(grants: Grant[]): Promise<Milestone[]>;
+    membersOf(projects: Project[]): Promise<MemberOf[]>;
+    /**
+     * Returns a string to be used to search by a value in `decodedDataJson`.
+     * @param field
+     * @param value
+     */
+    private getSearchFieldString;
+    grantsForExtProject(projectExtId: string): Promise<Grant[]>;
+}
+export {};